通过后台工作者进行枚举

Question

Is there a way to enumerate through all background workers? Currently, I've written a small method that I add to as I create new workers. Only one worker should run at a time, so the check method is:

    private bool CheckForWorkers()  // returns true if any background workers are currently running
    {
        bool ret = false;

        if (bgWorkerFoo.IsBusy || bgWorkerMeh.IsBusy || bgWorkerHmpf.IsBusy || bgWorkerWorkyWorky.IsBusy || bgWorkerOMGStahp.IsBusy)
        {
            ret = true;
        }

        return ret;
    }

At the time a button is clicked that would start a worker, the click method does this:

        if (CheckForWorkers())
        {
            MessageBox.Show("File generation already in progress.  Please wait.", "Message");
            return;
        }

        else
        {
            bgWorkerFoo.RunWorkerAsync();
        }

I'd like to clean up my CheckForWorkers() method so that I don't need to add to it anytime a new worker is created for a different task, but I can't seem to find any way to run through each worker associated with the app. Maybe there isn't a way? Do all of the workers exist (are instantiated) prior to being used?

Answer 1

Why not do something similar to this?

Worker[] Workers => new[] { bgWorkerFoo, bgWorkerMeh, bgWorkerHmpf, bgWorkerWorkyWorky, bgWorkerOMGStahp };
private bool CheckForWorkers() 
{
    return Workers.Any(w => w != null && w.IsBusy);
}

It's likely you'll need to refer to the collection of workers in the future as well, so it makes sense to put them into a collection anyway

Or, for non-C#6 syntax, a bit uglier:

private Worker[] Workers { get { return new[] { bgWorkerFoo, bgWorkerMeh, bgWorkerHmpf, bgWorkerWorkyWorky, bgWorkerOMGStahp }; } }
private bool CheckForWorkers() 
{
    return Workers.Any(w => w != null && w.IsBusy);
}

To dynamically get all fields/properties in your class, you can do this:

private IEnumerable<Worker> GetWorkers()
{
    var flags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public;
    var fields = GetType().GetFields(flags);
    var fieldValues = fields.Select(f => f.GetValue(this)).OfType<Worker>();

    var properties = GetType().GetProperties(flags);
    var propertyValues = properties.Select(f => f.GetValue(this)).OfType<Worker>();

    return fieldValues.Concat(propertyValues).Where(w => w != null);
}

private bool CheckForWorkers() 
{
    return GetWorkers().Any(w => w.IsBusy);
}

Might be a good idea to cache GetWorkers() , but it depends on your use-case.

Answer 2

I'm going to suggest an alternative approach that may be appealing. The Microsoft Reactive Framework introduced aa lot of very useful functionality for dealing with concurrency and threads. Primarily the framework is used to deal with event sources in terms of IObservable<T> , but the framework also provides a lot of schedulers for dealing with processing on different threads.

One of the schedulers is called EventLoopScheduler and this allows you to create a scheduler that runs on a background thread and only allows one operation to occur at any one time. Any thread can schedule tasks and tasks can be scheduled immediately or in the future, or even recurringly.

The key point here is that you don't need to track multiple background workers as it doesn't matter how many operations you schedule they'll only run in series .

When using Windows Forms you can use a scheduler called ControlScheduler that allows you to set up a scheduler that will post operations to the UI thread.

Once you have these two set up they become very easy to use.

Try this code:

var form1 = new Form();
var label1 = new Label();
label1.AutoSize = true;
form1.Controls.Add(label1);
form1.Show();

var background = new EventLoopScheduler();
var ui = new ControlScheduler(form1);

var someValue = -1;
background.Schedule(() =>
{
    var z = 42 * someValue;
    var bgTid = System.Threading.Thread.CurrentThread.ManagedThreadId;
    ui.Schedule(() =>
    {
        var uiTid = System.Threading.Thread.CurrentThread.ManagedThreadId;
        label1.Text = $"{z} calc on {bgTid} updated on {uiTid}";
    });
});

When I run this code I get this form showing on screen:

Clearly the calculation is correct and it can be seen that the thread ids are different.

You can even do more powerful things like this:

var booking =
    background.SchedulePeriodic(0, TimeSpan.FromSeconds(1.0), state =>
    {
        var copy = state;
        if (copy % 2 == 0)
        {
            ui.Schedule(() => label1.Text = copy.ToString());
        }
        else
        {
            background.Schedule(() => ui.Schedule(() => label1.Text = "odd"));
        }
        return ++state;
    });

form1.FormClosing += (s, e) => booking.Dispose();

This code is creating a timer to run every second on the background thread. It uses the state variable to keep track of the number of times that it ran and updates the UI with the value of state when it is even, and otherwise, schedules on its own scheduler some code that will schedule on the UI to update label1.Text with the value "odd" . It can get quite sophisticated, but everything is serialized and synchronized for you. Since this created a timer there is a mechanism to shut the timer down and that is calling booking.Dispose() .

Of course, since this is using the Reactive Framework you could just use standard observables to do the above, like this:

var query =
    from n in Observable.Interval(TimeSpan.FromSeconds(1.0), background)
    select n % 2 == 0 ? n.ToString() : "odd";

var booking = query.ObserveOn(ui).Subscribe(x => label1.Text = x);

Notice that the same schedulers are used.

Answer 3

If you need to perform the same task for a (potentially large or unlimited) number of variables, this likely means that they are "homogenious" in some manner and thus should probably be combined into some kind of a "registry" container instead.

Eg I used to do something like this:

var thread = new BgWorker();
pool.Add(thread);
<...>
foreach (var thread in pool) {
    do_something();
}

The specific implementation of the registry van be anything, depending on what you need to do with your objects (eg a dictionary if you need to get a specific one in other scope than the one it was created in).