无法退订Rx

Question

Background

I am writing some software that does the following:

1. The user clicks on "start".
2. A task is started that performs some work and launches events to update the GUI.
3. An observable consumes the events from the task, and prints data to a rich-text-box in the GUI.

Everything works alright when I click on "START" the first time, but not after that. The first time I click on start, I get an output that looks like:

This looks alright, nothing wrong here. However, when I click on START the second time I get the following output.

Now, I believe I know why this might be happening. From what I can tell, my observer never unsubscribed from the first time I clicked on START and thus everything gets printed twice. When clicking on the start button, here is what happens:

    /// <summary>
    /// Starts the test.
    /// </summary>
    /// <param name="sender">The "start" button.</param>
    /// <param name="e">Clicking on the "start" button.</param>
    private void button_go_Click(object sender, RoutedEventArgs e)
    {
        var uiContext = SynchronizationContext.Current;
        var results = Observable.FromEventPattern<TestResultHandler, TestResultArgs>(
            handler => (s, a) => handler(s, a),
            handler => this.myTest.Results += handler,
            handler => this.myTest.Results -= handler)
            .ObserveOn(uiContext)
            .Subscribe(x => this.richTextBox_testResults.Document.Blocks.Add(new Paragraph(new Run(x.EventArgs.Results))));

        // start running the test
        this.runningTest = new Task(() => { this.myTest.Run(); });
        this.runningTest.Start();

        // block on purpose, wait for the task to finish
        this.runningTest.Wait();
    }

I am new to reactive extensions in .NET (have been using it for less than one hour). I am essentially using one of Stephen Cleary's examples from the Concurrency in C# cookbook in order to get started here. Despite all of this, I believe I sort of know what the problem is...

Proposed Plan

If I could just unsubscribe from the observable, then I think that this problem would go away. I think it's a little more complicated that that though, based on the reactive patterns used at ReactiveX.io it sounds like I should actually be smartly observing the task only for the during in which it actually exists then unsubscribing naturally. This is as far as I have come with debugging this problem, and I am not 100% sure that this unsubscribing thing would actually fix the problem.

Question

Is there some way to unsubscribe from the observable? Or, is there a way that I could observe my task only for the duration that it exists ?

Answer 1

Rx uses the IDisposable interface to enable you to unsubscribe from an observable subscription that hasn't yet naturally ended. If your observable sends a OnCompleted or OnError notification then the subscription is automatically disposed for you.

One clear advantage to this approach is that you can create a single CompositeDisposable to aggregate all of your subscriptions to enable a single unsubscribe. This is far better than hodge-podge of detaches required for removing event handlers.

In your code you're not ending the subscription so for each click on button_go you're creating a new subscription.

There are four solutions you can use, each somewhat different.

(1)

Remember, the key to needing to call .Dispose() is if your observable subsription hasn't naturally ended and you want it to end. So, you can simply add a .Take(1) to your query to make it naturally end after one value is produced.

private void button_go_Click(object sender, RoutedEventArgs e)
{
    var uiContext = SynchronizationContext.Current;
    var results = Observable.FromEventPattern<TestResultHandler, TestResultArgs>(
        handler => (s, a) => handler(s, a),
        handler => this.myTest.Results += handler,
        handler => this.myTest.Results -= handler)
        .Take(1)
        .ObserveOn(uiContext)
        .Subscribe(x => this.richTextBox_testResults.Document.Blocks.Add(new Paragraph(new Run(x.EventArgs.Results))));

    // start running the test
    this.runningTest = new Task(() => { this.myTest.Run(); });
    this.runningTest.Start();

    // block on purpose, wait for the task to finish
    this.runningTest.Wait();
}

The subscription is then automatically disposed for you.

(2)

You could use SerialDisposable to manage each subscription. The MSDN documentation describes it as:

Represents a disposable whose underlying disposable can be swapped for another disposable which causes the previous underlying disposable to be disposed.

Your code then would look like this:

private SerialDisposable _results = new SerialDisposable();

private void button_go_Click(object sender, RoutedEventArgs e)
{
    var uiContext = SynchronizationContext.Current;
    _results.Disposable = Observable.FromEventPattern<TestResultHandler, TestResultArgs>(
        handler => (s, a) => handler(s, a),
        handler => this.myTest.Results += handler,
        handler => this.myTest.Results -= handler)
        .ObserveOn(uiContext)
        .Subscribe(x => this.richTextBox_testResults.Document.Blocks.Add(new Paragraph(new Run(x.EventArgs.Results))));

    // start running the test
    this.runningTest = new Task(() => { this.myTest.Run(); });
    this.runningTest.Start();

    // block on purpose, wait for the task to finish
    this.runningTest.Wait();
}

(3)

You could always make sure that you only ever create the subscription once.

private IDisposable _results = null;

private void button_go_Click(object sender, RoutedEventArgs e)
{
    if (_results == null)
    {
        var uiContext = SynchronizationContext.Current;
        _results = Observable.FromEventPattern<TestResultHandler, TestResultArgs>(
            handler => (s, a) => handler(s, a),
            handler => this.myTest.Results += handler,
            handler => this.myTest.Results -= handler)
            .ObserveOn(uiContext)
            .Subscribe(x => this.richTextBox_testResults.Document.Blocks.Add(new Paragraph(new Run(x.EventArgs.Results))));
    }

    // start running the test
    this.runningTest = new Task(() => { this.myTest.Run(); });
    this.runningTest.Start();

    // block on purpose, wait for the task to finish
    this.runningTest.Wait();
}

(4)

The final approach is where the entire operation is wrapped up in an observable and is instigated for each new subscription. This is the correct way to work with Rx. Observables should hold their own state so that subscriptions can be 100% independent of each other.

Now, your code uses this.myTest & this.runningTest so it clearly has state. You should try to remove these. But without doing so your code would look like this:

private void button_go_Click(object sender, RoutedEventArgs e)
{
    var uiContext = SynchronizationContext.Current;
    Observable
        .Create<System.Reactive.EventPattern<TestResultArgs>>(o =>
        {
            var subscription =
                Observable
                    .FromEventPattern<TestResultHandler, TestResultArgs>(
                        h => this.myTest.Results += h,
                        h => this.myTest.Results -= h)
                    .Take(1)
                    .Subscribe(o);
            this.runningTest = new Task(() => { this.myTest.Run(); });
            this.runningTest.Start();
            return subscription;
        })
        .ObserveOn(uiContext)
        .Subscribe(x => this.richTextBox_testResults.Document.Blocks.Add(new Paragraph(new Run(x.EventArgs.Results))));

    // block on purpose, wait for the task to finish
    this.runningTest.Wait();
}

Ideally you should incorporate the creation and destruction of myTest inside the observable.

So, I would be inclined to do something like this:

private void button_go_Click(object sender, RoutedEventArgs e)
{
    var uiContext = SynchronizationContext.Current;
    Observable
        .Create<System.Reactive.EventPattern<TestResultArgs>>(o =>
        {
            var myTest = new MyTest();
            var subscription =
                Observable
                    .FromEventPattern<TestResultHandler, TestResultArgs>(
                        h => myTest.Results += h,
                        h => myTest.Results -= h)
                    .Take(1)
                    .Subscribe(o);
            myTest.Run();
            return subscription;
        })
        .ObserveOn(uiContext)
        .Subscribe(x => this.richTextBox_testResults.Document.Blocks.Add(new Paragraph(new Run(x.EventArgs.Results))));
}

This last one is really the answer to your question: "Or, is there a way that I could observe my task only for the duration that it exists?"