I want a way where every one gets equal chance how do i do it in C#?

Question

I have a function, like this,

private void Step()
{
    foreach (A a in aList)
        a.Act();
    foreach (B b in bList)
        b.Act();
    foreach (C c in cList)
        c.Act();
}

where "a" gets the first chance "b" next and "c" gets the last chance,

I want a way where every one gets equal chance how do i do it in C#?

Thanks a lot for all the help!!!

Answer 1

I would define an interface IActable (pick your name) which defines Act().

public interface IActable
{
  void Act();
}

Make A, B, and C implement IActable. Then, change your function to do the following.

private void Step()
{
    var all = new List<IActable>();
    all.AddRange(aList);
    all.AddRange(bList);
    all.AddRange(cList);
    all = all.Shuffle(new Random());

    foreach (IActable a in all)
    {
        a.Act();
    }
}

Shuffle method, stolen from here

public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> source, Random rng)
{
    T[] elements = source.ToArray();
    // Note i > 0 to avoid final pointless iteration
    for (int i = elements.Length-1; i > 0; i--)
    {
        // Swap element "i" with a random earlier element it (or itself)
        int swapIndex = rng.Next(i + 1);
        T tmp = elements[i];
        elements[i] = elements[swapIndex];
        elements[swapIndex] = tmp;
    }
    // Lazily yield (avoiding aliasing issues etc)
    foreach (T element in elements)
    {
        yield return element;
    }
}

A parallel implementation using plinq. (order not preserved)

private void Step()
    {
        var all = new List<IActable>();
        all.AddRange(aList);
        all.AddRange(bList);
        all.AddRange(cList);

        all.AsParallel().ForAll(a=>a.Act());
    }

Answer 2

ThreadPool.QueueUserWorkItem

Example from the documentation page:

using System;
using System.Threading;
public class Example {
    public static void Main() {
        // Queue the task.
        ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc));

        Console.WriteLine("Main thread does some work, then sleeps.");

        // If you comment out the Sleep, the main thread exits, and
        // therefore the application ends, before the work item 
        // runs on the thread pool thread.  The thread pool uses background
        // threads, which do not keep the application running.  (This
        // is a simple example of a race condition.)
        Thread.Sleep(1000);

        Console.WriteLine("Main thread exits.");
    }

    // This method performs the work. It will be invoked in a thread
    // running in the .NET threadpool.
    static void ThreadProc(Object stateInfo) {
        // No state object was passed to QueueUserWorkItem, so 
        // stateInfo is null.
        Console.WriteLine("Hello from the thread pool.");
    }
}

In your scenario you could simply queue all the workitems from the various lists. There is no guarantee of order-of-processing with the threadpool. However, if the work to be done is fairly "short" - that is to say if the time required for thread dispatch is "about the same as" the time required performing actual work - then you may want to shuffle the actions, so as to provide a fairer chance among all the threadpool threads.

If your actions run for a longish time - let's say tens of seconds or more - then the threadpool will provide good fairness anyway, and assuming no contention among the threads, you probably won't need to shuffle the workitems before queuing them.

Answer 3

You can run all of them in parallel using multiple threads (Cheeso's answer) - note that there are absolutely no guarantees that all methods will run at the same time in this case. You should define what "equal chance" actually means in your case befor jumping into multithreaded approach.

Or you need to decide what order you want you function to be executed and make appropriate ordering. I.e. assign priorities put all of the in the same list (see Brook's answer) and sort them by priority.