在引发所有事件（或组合事件）后，C＃做一些工作

Question

I'd like to subscribe to an event that will be raised when all of multiple other events are raised.

Suppose I have multiple tasks ( A ) to do first (for example animating multiple independent views), I can also subscribe to the event that the task is complete, and I'd like to do some other work ( B ) after all of these events are finished.

The amount of first tasks ( A ) can differ each time, so at the moment I set a counter to number of tasks A , subscribe to N events, and in the event handler for the task completion I decrement the counter, and when it's zero, I do the task B.

Is there a nicer way to combine these events than by using a counter?

Answer 1

If I understand the question correctly, you increment a counter when you start your A tasks and when each task is completed, you decrement the counter in the event handler. Also in the event handler, you check to see (after decrementing the counter) if the counter is zero. If so, you do task B.

I suggest you look at Tasks ( aka "Task Parallel Library (TPL)" ), which allows you to do something like this:

Task.WhenAll( new Task[] {
    Task.Run(()=> { //... do work A1... },
    Task.Run(()=> { //... do work A2... },
    Task.Run(()=> { //... do work A3... }})
    .ContinueWith(()=> {//... do work B... });

---

Update: Based on the mention of WPF animations in your comment below, Task.Run may NOT be a good fit here. If I remember correctly, you get a Completed event, and don't have a way to run animations synchronously in code (as in "...do work A1...").

However, instead of creating tasks via Task.Run , you can create them from the Completed event of a Storyboard via an extension method like:

public static Task<Storyboard> BeginAsync(this Storyboard sb)
{
   var tcs = new TaskCompletionSource<Storyboard>();
   sb.Completed += (s, a) => tcs.TrySetResult(sb);
   sb.Begin();
   return tcs.Task;
}

Note that this method creates a task which is completed in the storyboard's Completed event handler, and begins the storyboard animation before returning the task. Also note that you can write a similar extension method for other types and events.

You'd use this method like, for example:

var sb1 = (Storyboard)mainWindow.FindResource("Storyboard1");
var sb2 = (Storyboard)mainWindow.FindResource("Storyboard2");
var sb3 = (Storyboard)mainWindow.FindResource("Storyboard3");

Task.WhenAll( new Task[] {
    sb1.BeginAsync(),
    sb2.BeginAsync(),
    sb3.BeginAsync() })
    .ContinueWith(() => MessageBox.Show("All done!"),
        TaskScheduler.FromCurrentSynchronizationContext());

TaskScheduler.FromCurrentSynchronizationContext() basically schedules the continuation task to run on the UI thread (which is required if you will be accessing the UI elements).

Answer 2

I would have an identifier (based on an enum, for example) for each event and then add all the events you expect to be called to the list. Whenever the event is executed, I would remove it from the list.

In each event you call a method that will only actually do any work when the list is empty.