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?"
