Use Disposable helper methods were applicable (#568)

danielcweber · web-flow · commit d1a7ee2edf90 · 2018-06-04T17:07:20.000+02:00
diff --git a/Rx.NET/Source/src/System.Reactive/Disposables/StableCompositeDisposable.cs b/Rx.NET/Source/src/System.Reactive/Disposables/StableCompositeDisposable.cs
@@ -69,21 +69,21 @@ public abstract bool IsDisposed
 
         private sealed class Binary : StableCompositeDisposable
         {
-            private volatile IDisposable _disposable1;
-            private volatile IDisposable _disposable2;
+            private IDisposable _disposable1;
+            private IDisposable _disposable2;
 
             public Binary(IDisposable disposable1, IDisposable disposable2)
             {
-                _disposable1 = disposable1;
-                _disposable2 = disposable2;
+                Volatile.Write(ref _disposable1, disposable1);
+                Volatile.Write(ref _disposable2, disposable2);
             }
 
-            public override bool IsDisposed => _disposable1 == null;
+            public override bool IsDisposed => Disposable.GetIsDisposed(ref _disposable1);
 
             public override void Dispose()
             {
-                Interlocked.Exchange(ref _disposable1, null)?.Dispose();
-                Interlocked.Exchange(ref _disposable2, null)?.Dispose();
+                Disposable.TryDispose(ref _disposable1);
+                Disposable.TryDispose(ref _disposable2);
             }
         }
 
diff --git a/Rx.NET/Source/src/System.Reactive/Internal/ScheduledObserver.cs b/Rx.NET/Source/src/System.Reactive/Internal/ScheduledObserver.cs
@@ -328,7 +328,7 @@ protected override void Dispose(bool disposing)
 
             if (disposing)
             {
-                Interlocked.Exchange(ref _cancel, null)?.Dispose();
+                Disposable.TryDispose(ref _cancel);
             }
         }
     }
diff --git a/Rx.NET/Source/src/System.Reactive/Internal/Sink.cs b/Rx.NET/Source/src/System.Reactive/Internal/Sink.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information. 
 
+using System.Reactive.Disposables;
 using System.Threading;
 
 namespace System.Reactive
@@ -25,8 +26,7 @@ public void Dispose()
         protected virtual void Dispose(bool disposing)
         {
             _observer = NopObserver<TTarget>.Instance;
-
-            Interlocked.Exchange(ref _cancel, null)?.Dispose();
+            Disposable.TryDispose(ref _cancel);
         }
 
         protected void ForwardOnNext(TTarget value)
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable/Amb.cs b/Rx.NET/Source/src/System.Reactive/Linq/Observable/Amb.cs
@@ -95,10 +95,7 @@ public AmbObserver(IObserver<TSource> downstream, AmbCoordinator parent, bool is
 
                 internal void OnSubscribe(IDisposable d)
                 {
-                    if (Interlocked.CompareExchange(ref upstream, d, null) != null)
-                    {
-                        d?.Dispose();
-                    }
+                    Disposable.SetSingle(ref upstream, d);
                 }
 
                 public void Dispose()
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable/AmbMany.cs b/Rx.NET/Source/src/System.Reactive/Linq/Observable/AmbMany.cs
@@ -205,10 +205,7 @@ public void OnNext(T value)
 
             internal void OnSubscribe(IDisposable d)
             {
-                if (Interlocked.CompareExchange(ref upstream, d, null) != null)
-                {
-                    d?.Dispose();
-                }
+                Disposable.SetSingle(ref upstream, d);
             }
         }
 
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable/ConcatMany.cs b/Rx.NET/Source/src/System.Reactive/Linq/Observable/ConcatMany.cs
@@ -52,10 +52,7 @@ internal ConcatManyOuterObserver(IObserver<T> downstream)
 
             internal void OnSubscribe(IDisposable d)
             {
-                if (Interlocked.CompareExchange(ref upstream, d, null) != null)
-                {
-                    d?.Dispose();
-                }
+                Disposable.SetSingle(ref upstream, d);
             }
 
             public void Dispose()
@@ -178,15 +175,7 @@ internal sealed class InnerObserver : IObserver<T>, IDisposable
             {
                 readonly ConcatManyOuterObserver parent;
 
-                internal SingleAssignmentDisposable upstream;
-
-                static readonly SingleAssignmentDisposable DISPOSED;
-
-                static InnerObserver()
-                {
-                    DISPOSED = new SingleAssignmentDisposable();
-                    DISPOSED.Dispose();
-                }
+                internal IDisposable upstream;
 
                 internal InnerObserver(ConcatManyOuterObserver parent)
                 {
@@ -195,13 +184,13 @@ internal InnerObserver(ConcatManyOuterObserver parent)
 
                 internal bool SetDisposable(SingleAssignmentDisposable sad)
                 {
-                    return Interlocked.CompareExchange(ref upstream, sad, null) == null;
+                    return Disposable.TrySetSingle(ref upstream, sad) == TrySetSingleResult.Success;
                 }
 
                 internal bool Finish()
                 {
                     var sad = Volatile.Read(ref upstream);
-                    if (sad != DISPOSED)
+                    if (sad != BooleanDisposable.True)
                     {
                         if (Interlocked.CompareExchange(ref upstream, null, sad) == sad)
                         {
@@ -214,7 +203,7 @@ internal bool Finish()
 
                 public void Dispose()
                 {
-                    Interlocked.Exchange(ref upstream, DISPOSED)?.Dispose();
+                    Disposable.TryDispose(ref upstream);
                 }
 
                 public void OnCompleted()
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable/RetryWhen.cs b/Rx.NET/Source/src/System.Reactive/Linq/Observable/RetryWhen.cs
@@ -61,25 +61,17 @@ sealed class MainObserver : IObserver<T>, IDisposable
             readonly IObserver<Exception> errorSignal;
 
             internal readonly HandlerObserver handlerObserver;
-
+            
             readonly IObservable<T> source;
 
-            SingleAssignmentDisposable upstream;
+            IDisposable upstream;
 
             int trampoline;
 
             int halfSerializer;
 
             Exception error;
 
-            static readonly SingleAssignmentDisposable DISPOSED;
-
-            static MainObserver()
-            {
-                DISPOSED = new SingleAssignmentDisposable();
-                DISPOSED.Dispose();
-            }
-
             internal MainObserver(IObserver<T> downstream, IObservable<T> source, IObserver<Exception> errorSignal)
             {
                 this.downstream = downstream;
@@ -90,7 +82,7 @@ internal MainObserver(IObserver<T> downstream, IObservable<T> source, IObserver<
 
             public void Dispose()
             {
-                Interlocked.Exchange(ref upstream, DISPOSED)?.Dispose();
+                Disposable.TryDispose(ref upstream);
                 handlerObserver.Dispose();
             }
 
@@ -108,7 +100,7 @@ public void OnError(Exception error)
                 for (; ; )
                 {
                     var d = Volatile.Read(ref upstream);
-                    if (d == DISPOSED)
+                    if (d == BooleanDisposable.True)
                     {
                         break;
                     }
@@ -168,7 +160,7 @@ internal void HandlerNext()
                     do
                     {
                         var sad = new SingleAssignmentDisposable();
-                        if (Interlocked.CompareExchange(ref upstream, sad, null) != null)
+                        if (Disposable.TrySetSingle(ref upstream, sad) != TrySetSingleResult.Success)
                         {
                             return;
                         }
@@ -192,10 +184,7 @@ internal HandlerObserver(MainObserver main)
 
                 internal void OnSubscribe(IDisposable d)
                 {
-                    if (Interlocked.CompareExchange(ref upstream, d, null) != null)
-                    {
-                        d?.Dispose();
-                    }
+                    Disposable.SetSingle(ref upstream, d);
                 }
 
                 public void Dispose()
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Creation.cs b/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Creation.cs
@@ -178,10 +178,7 @@ public void OnError(Exception error)
 
                 public void OnNext(IDisposable value)
                 {
-                    if (Interlocked.CompareExchange(ref disposable, value, null) != null)
-                    {
-                        value?.Dispose();
-                    }
+                    Disposable.SetSingle(ref disposable, value);
                 }
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -69,21 +69,21 @@ public abstract bool IsDisposed`
`69`	`69`
`70`	`70`	`private sealed class Binary : StableCompositeDisposable`
`71`	`71`	`{`
`72`		`- private volatile IDisposable _disposable1;`
`73`		`- private volatile IDisposable _disposable2;`
	`72`	`+ private IDisposable _disposable1;`
	`73`	`+ private IDisposable _disposable2;`
`74`	`74`
`75`	`75`	`public Binary(IDisposable disposable1, IDisposable disposable2)`
`76`	`76`	`{`
`77`		`- _disposable1 = disposable1;`
`78`		`- _disposable2 = disposable2;`
	`77`	`+ Volatile.Write(ref _disposable1, disposable1);`
	`78`	`+ Volatile.Write(ref _disposable2, disposable2);`
`79`	`79`	`}`
`80`	`80`
`81`		`- public override bool IsDisposed => _disposable1 == null;`
	`81`	`+ public override bool IsDisposed => Disposable.GetIsDisposed(ref _disposable1);`
`82`	`82`
`83`	`83`	`public override void Dispose()`
`84`	`84`	`{`
`85`		`- Interlocked.Exchange(ref _disposable1, null)?.Dispose();`
`86`		`- Interlocked.Exchange(ref _disposable2, null)?.Dispose();`
	`85`	`+ Disposable.TryDispose(ref _disposable1);`
	`86`	`+ Disposable.TryDispose(ref _disposable2);`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`
Original file line number	Diff line number	Diff line change
`@@ -328,7 +328,7 @@ protected override void Dispose(bool disposing)`
`328`	`328`
`329`	`329`	`if (disposing)`
`330`	`330`	`{`
`331`		`- Interlocked.Exchange(ref _cancel, null)?.Dispose();`
	`331`	`+ Disposable.TryDispose(ref _cancel);`
`332`	`332`	`}`
`333`	`333`	`}`
`334`	`334`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`// The .NET Foundation licenses this file to you under the Apache 2.0 License.`
`3`	`3`	`// See the LICENSE file in the project root for more information.`
`4`	`4`
	`5`	`+using System.Reactive.Disposables;`
`5`	`6`	`using System.Threading;`
`6`	`7`
`7`	`8`	`namespace System.Reactive`
`@@ -25,8 +26,7 @@ public void Dispose()`
`25`	`26`	`protected virtual void Dispose(bool disposing)`
`26`	`27`	`{`
`27`	`28`	`_observer = NopObserver<TTarget>.Instance;`
`28`		`-`
`29`		`- Interlocked.Exchange(ref _cancel, null)?.Dispose();`
	`29`	`+ Disposable.TryDispose(ref _cancel);`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`protected void ForwardOnNext(TTarget value)`
Original file line number	Diff line number	Diff line change
`@@ -95,10 +95,7 @@ public AmbObserver(IObserver<TSource> downstream, AmbCoordinator parent, bool is`
`95`	`95`
`96`	`96`	`internal void OnSubscribe(IDisposable d)`
`97`	`97`	`{`
`98`		`- if (Interlocked.CompareExchange(ref upstream, d, null) != null)`
`99`		`- {`
`100`		`- d?.Dispose();`
`101`		`- }`
	`98`	`+ Disposable.SetSingle(ref upstream, d);`
`102`	`99`	`}`
`103`	`100`
`104`	`101`	`public void Dispose()`
Original file line number	Diff line number	Diff line change
`@@ -205,10 +205,7 @@ public void OnNext(T value)`
`205`	`205`
`206`	`206`	`internal void OnSubscribe(IDisposable d)`
`207`	`207`	`{`
`208`		`- if (Interlocked.CompareExchange(ref upstream, d, null) != null)`
`209`		`- {`
`210`		`- d?.Dispose();`
`211`		`- }`
	`208`	`+ Disposable.SetSingle(ref upstream, d);`
`212`	`209`	`}`
`213`	`210`	`}`
`214`	`211`
Original file line number	Diff line number	Diff line change
`@@ -52,10 +52,7 @@ internal ConcatManyOuterObserver(IObserver<T> downstream)`
`52`	`52`
`53`	`53`	`internal void OnSubscribe(IDisposable d)`
`54`	`54`	`{`
`55`		`- if (Interlocked.CompareExchange(ref upstream, d, null) != null)`
`56`		`- {`
`57`		`- d?.Dispose();`
`58`		`- }`
	`55`	`+ Disposable.SetSingle(ref upstream, d);`
`59`	`56`	`}`
`60`	`57`
`61`	`58`	`public void Dispose()`
`@@ -178,15 +175,7 @@ internal sealed class InnerObserver : IObserver<T>, IDisposable`
`178`	`175`	`{`
`179`	`176`	`readonly ConcatManyOuterObserver parent;`
`180`	`177`
`181`		`- internal SingleAssignmentDisposable upstream;`
`182`		`-`
`183`		`- static readonly SingleAssignmentDisposable DISPOSED;`
`184`		`-`
`185`		`- static InnerObserver()`
`186`		`- {`
`187`		`- DISPOSED = new SingleAssignmentDisposable();`
`188`		`- DISPOSED.Dispose();`
`189`		`- }`
	`178`	`+ internal IDisposable upstream;`
`190`	`179`
`191`	`180`	`internal InnerObserver(ConcatManyOuterObserver parent)`
`192`	`181`	`{`
`@@ -195,13 +184,13 @@ internal InnerObserver(ConcatManyOuterObserver parent)`
`195`	`184`
`196`	`185`	`internal bool SetDisposable(SingleAssignmentDisposable sad)`
`197`	`186`	`{`
`198`		`- return Interlocked.CompareExchange(ref upstream, sad, null) == null;`
	`187`	`+ return Disposable.TrySetSingle(ref upstream, sad) == TrySetSingleResult.Success;`
`199`	`188`	`}`
`200`	`189`
`201`	`190`	`internal bool Finish()`
`202`	`191`	`{`
`203`	`192`	`var sad = Volatile.Read(ref upstream);`
`204`		`- if (sad != DISPOSED)`
	`193`	`+ if (sad != BooleanDisposable.True)`
`205`	`194`	`{`
`206`	`195`	`if (Interlocked.CompareExchange(ref upstream, null, sad) == sad)`
`207`	`196`	`{`
`@@ -214,7 +203,7 @@ internal bool Finish()`
`214`	`203`
`215`	`204`	`public void Dispose()`
`216`	`205`	`{`
`217`		`- Interlocked.Exchange(ref upstream, DISPOSED)?.Dispose();`
	`206`	`+ Disposable.TryDispose(ref upstream);`
`218`	`207`	`}`
`219`	`208`
`220`	`209`	`public void OnCompleted()`
Original file line number	Diff line number	Diff line change
`@@ -61,25 +61,17 @@ sealed class MainObserver : IObserver<T>, IDisposable`
`61`	`61`	`readonly IObserver<Exception> errorSignal;`
`62`	`62`
`63`	`63`	`internal readonly HandlerObserver handlerObserver;`
`64`		`-`
	`64`	`+`
`65`	`65`	`readonly IObservable<T> source;`
`66`	`66`
`67`		`- SingleAssignmentDisposable upstream;`
	`67`	`+ IDisposable upstream;`
`68`	`68`
`69`	`69`	`int trampoline;`
`70`	`70`
`71`	`71`	`int halfSerializer;`
`72`	`72`
`73`	`73`	`Exception error;`
`74`	`74`
`75`		`- static readonly SingleAssignmentDisposable DISPOSED;`
`76`		`-`
`77`		`- static MainObserver()`
`78`		`- {`
`79`		`- DISPOSED = new SingleAssignmentDisposable();`
`80`		`- DISPOSED.Dispose();`
`81`		`- }`
`82`		`-`
`83`	`75`	`internal MainObserver(IObserver<T> downstream, IObservable<T> source, IObserver<Exception> errorSignal)`
`84`	`76`	`{`
`85`	`77`	`this.downstream = downstream;`
`@@ -90,7 +82,7 @@ internal MainObserver(IObserver<T> downstream, IObservable<T> source, IObserver<`
`90`	`82`
`91`	`83`	`public void Dispose()`
`92`	`84`	`{`
`93`		`- Interlocked.Exchange(ref upstream, DISPOSED)?.Dispose();`
	`85`	`+ Disposable.TryDispose(ref upstream);`
`94`	`86`	`handlerObserver.Dispose();`
`95`	`87`	`}`
`96`	`88`
`@@ -108,7 +100,7 @@ public void OnError(Exception error)`
`108`	`100`	`for (; ; )`
`109`	`101`	`{`
`110`	`102`	`var d = Volatile.Read(ref upstream);`
`111`		`- if (d == DISPOSED)`
	`103`	`+ if (d == BooleanDisposable.True)`
`112`	`104`	`{`
`113`	`105`	`break;`
`114`	`106`	`}`
`@@ -168,7 +160,7 @@ internal void HandlerNext()`
`168`	`160`	`do`
`169`	`161`	`{`
`170`	`162`	`var sad = new SingleAssignmentDisposable();`
`171`		`- if (Interlocked.CompareExchange(ref upstream, sad, null) != null)`
	`163`	`+ if (Disposable.TrySetSingle(ref upstream, sad) != TrySetSingleResult.Success)`
`172`	`164`	`{`
`173`	`165`	`return;`
`174`	`166`	`}`
`@@ -192,10 +184,7 @@ internal HandlerObserver(MainObserver main)`
`192`	`184`
`193`	`185`	`internal void OnSubscribe(IDisposable d)`
`194`	`186`	`{`
`195`		`- if (Interlocked.CompareExchange(ref upstream, d, null) != null)`
`196`		`- {`
`197`		`- d?.Dispose();`
`198`		`- }`
	`187`	`+ Disposable.SetSingle(ref upstream, d);`
`199`	`188`	`}`
`200`	`189`
`201`	`190`	`public void Dispose()`
Original file line number	Diff line number	Diff line change
`@@ -178,10 +178,7 @@ public void OnError(Exception error)`
`178`	`178`
`179`	`179`	`public void OnNext(IDisposable value)`
`180`	`180`	`{`
`181`		`- if (Interlocked.CompareExchange(ref disposable, value, null) != null)`
`182`		`- {`
`183`		`- value?.Dispose();`
`184`		`- }`
	`181`	`+ Disposable.SetSingle(ref disposable, value);`
`185`	`182`	`}`
`186`	`183`	`}`
`187`	`184`	`}`