什么是在事件发生后将在C＃中运行的方法延迟一定时间，同时又让原始线程运行的“正确”方法？

Question

I have a project in C# (using WPF) which involves a user placing 2d markers on a canvas to generate 3d geometry. When the 2d arrangement changes there's a fair amount of math that happens, and then a new 3d view is created. Performing this computation takes a short but noticeable amount of time.

Using events and properties I've set the program up such that it can update itself. I have a class that represents a project as a whole, and it has a property I've named "Is3dViewValid". Any one of several objects stored in the project can set this property to false when their own properties change, triggering an event which regenerates the 3d data.

However, since the regeneration takes a noticeable amount of time, it causes the UI to lag when the user is performing an action that is constantly updating one of the child objects (specifically dragging a marker across the canvas). The delay isn't long enough for me to want to move the regeneration to a separate thread and deal with the monumental task of trying to make everything thread-safe with my limited skills... but it's too long to just let it be.

So, what I would like to do is wait until a finite amount of time (say 1 second) has passed since the last time Is3dViewValid is set to false before actually committing to the computation. If the user makes several changes in short succession I want it to wait until 1s after the last change before it regenerates the 3d data.

Is there a "right" way to do this in C#? I'm assuming, perhaps incorrectly, that accomplishing this will require a second thread waiting and watching a shared DateTime object, then attempting to invoke a method on the original thread when a certain amount of time has passed since the last time Is3dViewValid was set to false. Is this right, or is there a better way to do it?

Edit: I didn't think of this while I was writing the original question, but what I'm trying to accomplish is that if the event is fired at t=0.1s, t=0.2s, and t=0.3s, I want the regenerate method to run once at t=1.3s

Answer 1

I'd start by looking into the Reactive Extensions for .NET, a framework for working with a stream of events (typically user interaction events in the examples) and then manipulating those events as a stream. The most useful thing to you will be the http://msdn.microsoft.com/en-us/library/hh229400(v=vs.103).aspx Observable.Throttle method on the stream which will allow you to specify an amount of time to wait before propagating any change into the rest of the stream where you can take action on it through event subscription.

Further Resources:

• Beginner's Guide to the Reactive Extensions
• 101 RX Examples if you want to just jump into code
• A great tutorial going soup to nuts

Listed here is a more concise way of expressing the same thing as previously written but also including execution of the needed code asynchronously.

public class ApplicationPresenterRX
{
    private DateTime started;
    public Project Project { get; set; }

    public ApplicationPresenterRX()
    {
        // Create the project and subscribe to the invalidation event
        Project = new Project();

        // Convert events into observable stream of events based on custom event.
        Observable.FromEvent(ev => { this.Project.Invalidated += () => ev(); },
                         ev => { this.Project.Invalidated -= () => ev();})
            // Only propagate a maximum of 1 event per second (dropping others) 
            .Throttle(TimeSpan.FromSeconds(1))
            // Finally execute the task needed asynchronously
            // The only caveat is that if the code in Project.HeftyComputation updates UI components in WPF you may need to marshal the UI updates onto the correct thread to make it work.
            .Subscribe(e => { Task.Run(Project.HeftyComputation); });

        // Simulate the user doing stuff
        started = DateTime.Now;
        Project.SimulateUserDoingStuff();
    }
}

Answer 2

If you're using .NET 4.5, you can do this in your event handler:

Task.Delay(TimeSpan.FromSeconds(5))
    .ContinueWith(t => { /* do whatever it is that you want delayed */ });

Task.Delay will create a Task that does absolutely nothing except for wait a certain amount of time before completing. ContinueWith(Action<Task> action) means "when this task is done, only then do this second task, specified by this action .

If you're additionally using C# 5.0, then you can potentially use the async / await tools and an async event handler to do await Task.Delay(TimeSpan.FromSeconds(5)); followed by the code you want delayed.

---

I second Norman H's suggestion to investigate the Reactive Extensions. They're a really powerful toolset, but it might be more than you're looking for.

Answer 3

Ok, I've done some research on Reactive Extensions, I've put together code, and I have two potential answers. I don't know if one of these is the "right" way, but both seem to work. RX seems very powerful, but using it stretches the limits of my C# abilities.

1. The Problem

First, to restate the problem, imagine I have this class:

public class Project
{
    public delegate void InvalidateEventHandler();
    public event InvalidateEventHandler Invalidated;

    private void InvalidateMyself() { if (Invalidated != null) Invalidated(); }

    public void HeftyComputation() { Thread.Sleep(2000); }

    public void SimulateUserDoingStuff()
    {
        Thread.Sleep(100);
        InvalidateMyself();
        Thread.Sleep(100);
        InvalidateMyself();
        Thread.Sleep(100);
        InvalidateMyself();
    }

    public Project() { }
}

It holds data and it's NOT thread safe. It has three methods. One performs a hefty computation based on its internal data to update itself whenever the data changes. This is accomplished by having internal properties (not demonstrated) that call the InvalidateMyself() function, firing an event to be handled by a parent class, which will at some point decide to tell the object to update itself. Finally, I have a "simulate user input" method which calls InvalidateMyself() at t=0.1s, t=0.2s, and t=0.3s.

Now, the easiest way to make this class update itself is to take the parent object, an application presenter in this case, listen for the Invalidate event and directly fire the HeftyComputation() method when it comes. Observe the following class:

public class ApplicationPresenterBasic
{
    private DateTime started;
    public Project Project { get; set; }

    public ApplicationPresenterBasic()
    {
        // Create the project and subscribe to the invalidation event
        Project = new Project();
        Project.Invalidated += Project_Invalidated;

        // Simulate the user doing stuff
        started = DateTime.Now;
        Project.SimulateUserDoingStuff();
    }

    void Project_Invalidated()
    {
        UpdateProject();
    }

    void UpdateProject()
    {
        System.Diagnostics.Debug.WriteLine(string.Format("Running HeftyComputation() at {0}s", (DateTime.Now - started).TotalSeconds));
        Project.HeftyComputation();
    }
}

This essentially does that, except that it runs the HeftyComputation() method every time the object is "invalidated". Here's the output:

Running HeftyComputation() at 0.1010058s
Running HeftyComputation() at 2.203126s
Running HeftyComputation() at 4.3042462s

Fair enough? Now let's say the behavior I want is for the application presenter to wait for a 1s period of time with no invalidations before performing HeftyComputation(). This way all three updates are handled at one time at t=1.3s.

I've done this two ways, once using a listening thread and the System.Windows.Threading Dispatcher, and once using Reactive Extensions' IObservable.Throttle

2. Solution using Tasks and System.Windows.Dispatcher

The only advantage I can think of to using a background Task and the dispatcher is that you're not relying on any third party libraries. You are, however, locked into referencing the WindowsBase assembly, so I can't imagine this is going to work on Mono, if that's important to you.

public class ApplicationPresenterWindowsDispatcher
{
    private DateTime started;
    public Project Project { get; set; }

    /* Stuff necessary for this solution */
    private delegate void ComputationDelegate();
    private object Mutex = new object();
    private bool IsValid = true;
    private DateTime LastInvalidated;
    private Task ObservationTask;
    private Dispatcher MainThreadDispatcher;
    private CancellationTokenSource TokenSource;
    private CancellationToken Token;

    public void ObserveAndTriggerComputation(CancellationToken ctoken)
    {
        while (true)
        {
            ctoken.ThrowIfCancellationRequested();
            lock (Mutex)
            {
                if (!IsValid && (DateTime.Now - LastInvalidated).TotalSeconds > 1)
                {
                    IsValid = true;
                    ComputationDelegate compute = new ComputationDelegate(UpdateProject);
                    MainThreadDispatcher.BeginInvoke(compute);
                }
            }
        }
    }


    public ApplicationPresenterWindowsDispatcher()
    {
        // Create the project and subscribe to the invalidation event
        Project = new Project();
        Project.Invalidated += Project_Invalidated;

        // Set up observation task
        MainThreadDispatcher = Dispatcher.CurrentDispatcher;
        Mutex = new object();
        TokenSource = new CancellationTokenSource();
        Token = TokenSource.Token;
        ObservationTask = Task.Factory.StartNew(() => ObserveAndTriggerComputation(Token), Token);

        // Simulate the user doing stuff
        started = DateTime.Now;
        Project.SimulateUserDoingStuff();
    }

    void Project_Invalidated()
    {
        lock (Mutex)
        {
            IsValid = false;
            LastInvalidated = DateTime.Now;
        }
    }

    void UpdateProject()
    {
        System.Diagnostics.Debug.WriteLine(string.Format("Running HeftyComputation() at {0}s", (DateTime.Now - started).TotalSeconds));
        Project.HeftyComputation();
    }
}

Here's how it works: when created the application presenter spawns a Task which runs in the background. This task watches a bool that represents whether the Project object is still valid and a DateTime that represents the time of the last invalidation. When the bool is false and the last invalidation was more than 1 second ago, the Task invokes a method on the main thread using the Dispatcher which performs HeftyComputation(). The invalidation event handler now causes the main thread to simply update the bool and the DateTime and wait for the background thread to decide when to run the update.

The output:

Running HeftyComputation() at 1.3060747s

So this seems to work. It's probably not the best way, and I'm not great at concurrency, so if someone sees a mistake or a problem here please point it out.

3. Solution using Reactive Extensions

Here's the solution using Reactive Extensions. Fortunately, NuGet made adding it to the project trivial, but using it was a different story for someone of my skill level. Normon H mentioned it would only be a few lines of code, and that turned out to be true, but getting those few lines of code right took me much longer than writing the Dispatcher solution.

If you're good with delegates and lambdas Reactive Extensions looks amazing. I'm not, though, so I struggled.

public class ApplicationPresenterRX
{
    private DateTime started;
    public Project Project { get; set; }

    public ApplicationPresenterRX()
    {
        // Create the project and subscribe to the invalidation event
        Project = new Project();

        var invalidations = Observable.FromEvent(ev => { this.Project.Invalidated += () => ev(); },
                                                 ev => { this.Project.Invalidated -= () => ev(); });
        var throttledInvalidations = invalidations.Throttle(TimeSpan.FromSeconds(1));
        throttledInvalidations.Subscribe(e => { UpdateProject(); });

        // Simulate the user doing stuff
        started = DateTime.Now;
        Project.SimulateUserDoingStuff();
    }

    void UpdateProject()
    {
        System.Diagnostics.Debug.WriteLine(string.Format("Running HeftyComputation() at {0}s", (DateTime.Now - started).TotalSeconds));
        Project.HeftyComputation();
    }
}

And that's it, three lines. I create an IObservable source from the Project.Invalidated event, create a second IObservable source that throttles the first one, and then subscribe to it so that my UpdateProject() method is called when the throttled source activates. Figuring out how to properly call the Observable.FromEvent method with my event was the hardest part of the process.

The output:

Running HeftyComputation() at 1.3090749s

From reading this website: http://www.introtorx.com/uat/content/v1.0.10621.0/13_SchedulingAndThreading.html my takeaway is that while RX uses threads for timing and scheduling, it doesn't by default invoke code on a different thread. Thus the UpdateProject() method should be running on the main thread.