Use the helper methods for IDisposable-fields, avoid repeating code patterns. (#556)

danielcweber · web-flow · commit 389881c4f6f3 · 2018-05-31T11:55:20.000+02:00
diff --git a/Rx.NET/Source/src/System.Reactive/Disposables/ContextDisposable.cs b/Rx.NET/Source/src/System.Reactive/Disposables/ContextDisposable.cs
@@ -12,7 +12,7 @@ namespace System.Reactive.Disposables
     /// </summary>
     public sealed class ContextDisposable : ICancelable
     {
-        private volatile IDisposable _disposable;
+        private IDisposable _disposable;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ContextDisposable"/> class that uses the specified <see cref="SynchronizationContext"/> on which to dispose the specified disposable resource.
@@ -28,7 +28,7 @@ public ContextDisposable(SynchronizationContext context, IDisposable disposable)
                 throw new ArgumentNullException(nameof(disposable));
 
             Context = context;
-            _disposable = disposable;
+            Disposable.SetSingle(ref _disposable, disposable);
         }
 
         /// <summary>
@@ -39,19 +39,14 @@ public ContextDisposable(SynchronizationContext context, IDisposable disposable)
         /// <summary>
         /// Gets a value that indicates whether the object is disposed.
         /// </summary>
-        public bool IsDisposed => _disposable == BooleanDisposable.True;
+        public bool IsDisposed => Disposable.GetIsDisposed(ref _disposable);
 
         /// <summary>
         /// Disposes the underlying disposable on the provided <see cref="SynchronizationContext"/>.
         /// </summary>
         public void Dispose()
         {
-            var disposable = Interlocked.Exchange(ref _disposable, BooleanDisposable.True);
-
-            if (disposable != BooleanDisposable.True)
-            {
-                Context.PostWithStartComplete(d => d.Dispose(), disposable);
-            }
+            Disposable.TryRelease(ref _disposable, this.Context, (disposable, context) => context.PostWithStartComplete(d => d.Dispose(), disposable));
         }
     }
 }
diff --git a/Rx.NET/Source/src/System.Reactive/Disposables/Disposable.cs b/Rx.NET/Source/src/System.Reactive/Disposables/Disposable.cs
@@ -210,5 +210,16 @@ internal static bool TryDispose(ref IDisposable fieldRef)
             old?.Dispose();
             return true;
         }
+
+        internal static bool TryRelease<TState>(ref IDisposable fieldRef, TState state, Action<IDisposable, TState> disposeAction)
+        {
+            var old = Interlocked.Exchange(ref fieldRef, BooleanDisposable.True);
+
+            if (old == BooleanDisposable.True)
+                return false;
+
+            disposeAction(old, state);
+            return true;
+        }
     }
 }
diff --git a/Rx.NET/Source/src/System.Reactive/Disposables/ScheduledDisposable.cs b/Rx.NET/Source/src/System.Reactive/Disposables/ScheduledDisposable.cs
@@ -12,7 +12,7 @@ namespace System.Reactive.Disposables
     /// </summary>
     public sealed class ScheduledDisposable : ICancelable
     {
-        private volatile IDisposable _disposable;
+        private IDisposable _disposable;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ScheduledDisposable"/> class that uses an <see cref="IScheduler"/> on which to dispose the disposable.
@@ -28,7 +28,7 @@ public ScheduledDisposable(IScheduler scheduler, IDisposable disposable)
                 throw new ArgumentNullException(nameof(disposable));
 
             Scheduler = scheduler;
-            _disposable = disposable;
+            Disposables.Disposable.SetSingle(ref _disposable, disposable);
         }
 
         /// <summary>
@@ -39,39 +39,16 @@ public ScheduledDisposable(IScheduler scheduler, IDisposable disposable)
         /// <summary>
         /// Gets the underlying disposable. After disposal, the result is undefined.
         /// </summary>
-        public IDisposable Disposable
-        {
-            get
-            {
-                var current = _disposable;
-
-                if (current == BooleanDisposable.True)
-                {
-                    return Disposables.Disposable.Empty; // Don't leak the sentinel value.
-                }
-
-                return current;
-            }
-        }
+        public IDisposable Disposable => Disposables.Disposable.GetValueOrDefault(ref _disposable);
 
         /// <summary>
         /// Gets a value that indicates whether the object is disposed.
         /// </summary>
-        public bool IsDisposed => _disposable == BooleanDisposable.True;
+        public bool IsDisposed => Disposables.Disposable.GetIsDisposed(ref _disposable);
 
         /// <summary>
         /// Disposes the wrapped disposable on the provided scheduler.
         /// </summary>
-        public void Dispose() => Scheduler.Schedule(DisposeInner);
-
-        private void DisposeInner()
-        {
-            var disposable = Interlocked.Exchange(ref _disposable, BooleanDisposable.True);
-
-            if (disposable != BooleanDisposable.True)
-            {
-                disposable.Dispose();
-            }
-        }
+        public void Dispose() => Scheduler.Schedule(scheduler => Disposables.Disposable.TryDispose(ref scheduler._disposable), this);
     }
 }
diff --git a/Rx.NET/Source/src/System.Reactive/Internal/AutoDetachObserver.cs b/Rx.NET/Source/src/System.Reactive/Internal/AutoDetachObserver.cs
@@ -11,7 +11,7 @@ internal sealed class AutoDetachObserver<T> : ObserverBase<T>
     {
         private readonly IObserver<T> _observer;
 
-        private IDisposable disposable;
+        private IDisposable _disposable;
 
         public AutoDetachObserver(IObserver<T> observer)
         {
@@ -20,17 +20,7 @@ public AutoDetachObserver(IObserver<T> observer)
 
         public IDisposable Disposable
         {
-            set
-            {
-                if (Interlocked.CompareExchange(ref disposable, value, null) != null)
-                {
-                    value?.Dispose();
-                    if (Volatile.Read(ref disposable) != BooleanDisposable.True)
-                    {
-                        throw new InvalidOperationException(Strings_Core.DISPOSABLE_ALREADY_ASSIGNED);
-                    }
-                }
-            }
+            set => Disposables.Disposable.SetSingle(ref _disposable, value);
         }
 
         protected override void OnNextCore(T value)
@@ -111,7 +101,7 @@ protected override void Dispose(bool disposing)
 
             if (disposing)
             {
-                Interlocked.Exchange(ref disposable, BooleanDisposable.True)?.Dispose();
+                Disposables.Disposable.TryDispose(ref _disposable);
             }
         }
     }
diff --git a/Rx.NET/Source/src/System.Reactive/Internal/ScheduledObserver.cs b/Rx.NET/Source/src/System.Reactive/Internal/ScheduledObserver.cs
@@ -401,8 +401,8 @@ public ObserveOnObserverNew(IScheduler scheduler, IObserver<T> downstream, IDisp
         public void Dispose()
         {
             Volatile.Write(ref disposed, true);
-            Interlocked.Exchange(ref upstream, BooleanDisposable.True)?.Dispose();
-            Interlocked.Exchange(ref task, BooleanDisposable.True)?.Dispose();
+            Disposable.TryDispose(ref upstream);
+            Disposable.TryDispose(ref task);
             Clear();
         }
 
@@ -443,14 +443,10 @@ void Schedule()
         {
             if (Interlocked.Increment(ref wip) == 1)
             {
-                var oldTask = Volatile.Read(ref task);
-
                 var newTask = new SingleAssignmentDisposable();
 
-                if (oldTask != BooleanDisposable.True
-                    && Interlocked.CompareExchange(ref task, newTask, oldTask) == oldTask)
+                if (Disposable.TrySetMultiple(ref task, newTask))
                 {
-
                     var longRunning = this.longRunning;
                     if (longRunning != null)
                     {
diff --git a/Rx.NET/Source/src/System.Reactive/Internal/TailRecursiveSink.cs b/Rx.NET/Source/src/System.Reactive/Internal/TailRecursiveSink.cs
@@ -68,10 +68,8 @@ void Drain()
                         var enumerator = stack.Pop();
                         enumerator.Dispose();
                     }
-                    if (Volatile.Read(ref currentSubscription) != BooleanDisposable.True)
-                    {
-                        Interlocked.Exchange(ref currentSubscription, BooleanDisposable.True)?.Dispose();
-                    }
+
+                    Disposable.TryDispose(ref currentSubscription);
                 }
                 else
                 {
@@ -131,7 +129,8 @@ void Drain()
                             else
                             {
                                 var sad = new SingleAssignmentDisposable();
-                                if (Interlocked.CompareExchange(ref currentSubscription, sad, null) == null)
+
+                                if (Disposable.TrySetSingle(ref currentSubscription, sad) == TrySetSingleResult.Success)
                                 {
                                     sad.Disposable = next.SubscribeSafe(this);
                                 }
@@ -172,15 +171,8 @@ void DisposeAll()
 
         protected void Recurse()
         {
-            var d = Volatile.Read(ref currentSubscription);
-            if (d != BooleanDisposable.True)
-            {
-                d?.Dispose();
-                if (Interlocked.CompareExchange(ref currentSubscription, null, d) == d)
-                {
-                    Drain();
-                }
-            }
+            if (Disposable.TrySetSerial(ref currentSubscription, null))
+                Drain();
         }
 
         protected abstract IEnumerable<IObservable<TSource>> Extract(IObservable<TSource> source);
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable/Amb.cs b/Rx.NET/Source/src/System.Reactive/Linq/Observable/Amb.cs
@@ -103,7 +103,7 @@ internal void OnSubscribe(IDisposable d)
 
                 public void Dispose()
                 {
-                    Interlocked.Exchange(ref upstream, BooleanDisposable.True)?.Dispose();
+                    Disposable.TryDispose(ref upstream);
                 }
 
                 public void OnCompleted()
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable/AmbMany.cs b/Rx.NET/Source/src/System.Reactive/Linq/Observable/AmbMany.cs
@@ -153,7 +153,7 @@ public InnerObserver(AmbCoordinator<T> parent, int index)
 
             public void Dispose()
             {
-                Interlocked.Exchange(ref upstream, BooleanDisposable.True)?.Dispose();
+                Disposable.TryDispose(ref upstream);
             }
 
             public void OnCompleted()
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable/ConcatMany.cs b/Rx.NET/Source/src/System.Reactive/Linq/Observable/ConcatMany.cs
@@ -66,12 +66,12 @@ public void Dispose()
 
             void DisposeMain()
             {
-                Interlocked.Exchange(ref upstream, BooleanDisposable.True)?.Dispose();
+                Disposable.TryDispose(ref upstream);
             }
 
             bool IsDisposed()
             {
-                return Volatile.Read(ref upstream) == BooleanDisposable.True;
+                return Disposable.GetIsDisposed(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
@@ -200,7 +200,7 @@ internal void OnSubscribe(IDisposable d)
 
                 public void Dispose()
                 {
-                    Interlocked.Exchange(ref upstream, BooleanDisposable.True)?.Dispose();
+                    Disposable.TryDispose(ref upstream);
                 }
 
                 public void OnCompleted()
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Creation.cs b/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Creation.cs
@@ -163,7 +163,7 @@ public TaskDisposeCompletionObserver(IObserver<TResult> observer)
 
                 public void Dispose()
                 {
-                    Interlocked.Exchange(ref disposable, BooleanDisposable.True)?.Dispose();
+                    Disposable.TryDispose(ref disposable);
                 }
 
                 public void OnCompleted()

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ namespace System.Reactive.Disposables`
`12`	`12`	`/// </summary>`
`13`	`13`	`public sealed class ContextDisposable : ICancelable`
`14`	`14`	`{`
`15`		`- private volatile IDisposable _disposable;`
	`15`	`+ private IDisposable _disposable;`
`16`	`16`
`17`	`17`	`/// <summary>`
`18`	`18`	`/// Initializes a new instance of the <see cref="ContextDisposable"/> class that uses the specified <see cref="SynchronizationContext"/> on which to dispose the specified disposable resource.`
`@@ -28,7 +28,7 @@ public ContextDisposable(SynchronizationContext context, IDisposable disposable)`
`28`	`28`	`throw new ArgumentNullException(nameof(disposable));`
`29`	`29`
`30`	`30`	`Context = context;`
`31`		`- _disposable = disposable;`
	`31`	`+ Disposable.SetSingle(ref _disposable, disposable);`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`/// <summary>`
`@@ -39,19 +39,14 @@ public ContextDisposable(SynchronizationContext context, IDisposable disposable)`
`39`	`39`	`/// <summary>`
`40`	`40`	`/// Gets a value that indicates whether the object is disposed.`
`41`	`41`	`/// </summary>`
`42`		`- public bool IsDisposed => _disposable == BooleanDisposable.True;`
	`42`	`+ public bool IsDisposed => Disposable.GetIsDisposed(ref _disposable);`
`43`	`43`
`44`	`44`	`/// <summary>`
`45`	`45`	`/// Disposes the underlying disposable on the provided <see cref="SynchronizationContext"/>.`
`46`	`46`	`/// </summary>`
`47`	`47`	`public void Dispose()`
`48`	`48`	`{`
`49`		`- var disposable = Interlocked.Exchange(ref _disposable, BooleanDisposable.True);`
`50`		`-`
`51`		`- if (disposable != BooleanDisposable.True)`
`52`		`- {`
`53`		`- Context.PostWithStartComplete(d => d.Dispose(), disposable);`
`54`		`- }`
	`49`	`+ Disposable.TryRelease(ref _disposable, this.Context, (disposable, context) => context.PostWithStartComplete(d => d.Dispose(), disposable));`
`55`	`50`	`}`
`56`	`51`	`}`
`57`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -210,5 +210,16 @@ internal static bool TryDispose(ref IDisposable fieldRef)`
`210`	`210`	`old?.Dispose();`
`211`	`211`	`return true;`
`212`	`212`	`}`
	`213`	`+`
	`214`	`+ internal static bool TryRelease<TState>(ref IDisposable fieldRef, TState state, Action<IDisposable, TState> disposeAction)`
	`215`	`+ {`
	`216`	`+ var old = Interlocked.Exchange(ref fieldRef, BooleanDisposable.True);`
	`217`	`+`
	`218`	`+ if (old == BooleanDisposable.True)`
	`219`	`+ return false;`
	`220`	`+`
	`221`	`+ disposeAction(old, state);`
	`222`	`+ return true;`
	`223`	`+ }`
`213`	`224`	`}`
`214`	`225`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ internal sealed class AutoDetachObserver<T> : ObserverBase<T>`
`11`	`11`	`{`
`12`	`12`	`private readonly IObserver<T> _observer;`
`13`	`13`
`14`		`- private IDisposable disposable;`
	`14`	`+ private IDisposable _disposable;`
`15`	`15`
`16`	`16`	`public AutoDetachObserver(IObserver<T> observer)`
`17`	`17`	`{`
`@@ -20,17 +20,7 @@ public AutoDetachObserver(IObserver<T> observer)`
`20`	`20`
`21`	`21`	`public IDisposable Disposable`
`22`	`22`	`{`
`23`		`- set`
`24`		`- {`
`25`		`- if (Interlocked.CompareExchange(ref disposable, value, null) != null)`
`26`		`- {`
`27`		`- value?.Dispose();`
`28`		`- if (Volatile.Read(ref disposable) != BooleanDisposable.True)`
`29`		`- {`
`30`		`- throw new InvalidOperationException(Strings_Core.DISPOSABLE_ALREADY_ASSIGNED);`
`31`		`- }`
`32`		`- }`
`33`		`- }`
	`23`	`+ set => Disposables.Disposable.SetSingle(ref _disposable, value);`
`34`	`24`	`}`
`35`	`25`
`36`	`26`	`protected override void OnNextCore(T value)`
`@@ -111,7 +101,7 @@ protected override void Dispose(bool disposing)`
`111`	`101`
`112`	`102`	`if (disposing)`
`113`	`103`	`{`
`114`		`- Interlocked.Exchange(ref disposable, BooleanDisposable.True)?.Dispose();`
	`104`	`+ Disposables.Disposable.TryDispose(ref _disposable);`
`115`	`105`	`}`
`116`	`106`	`}`
`117`	`107`	`}`
Original file line number	Diff line number	Diff line change
`@@ -401,8 +401,8 @@ public ObserveOnObserverNew(IScheduler scheduler, IObserver<T> downstream, IDisp`
`401`	`401`	`public void Dispose()`
`402`	`402`	`{`
`403`	`403`	`Volatile.Write(ref disposed, true);`
`404`		`- Interlocked.Exchange(ref upstream, BooleanDisposable.True)?.Dispose();`
`405`		`- Interlocked.Exchange(ref task, BooleanDisposable.True)?.Dispose();`
	`404`	`+ Disposable.TryDispose(ref upstream);`
	`405`	`+ Disposable.TryDispose(ref task);`
`406`	`406`	`Clear();`
`407`	`407`	`}`
`408`	`408`
`@@ -443,14 +443,10 @@ void Schedule()`
`443`	`443`	`{`
`444`	`444`	`if (Interlocked.Increment(ref wip) == 1)`
`445`	`445`	`{`
`446`		`- var oldTask = Volatile.Read(ref task);`
`447`		`-`
`448`	`446`	`var newTask = new SingleAssignmentDisposable();`
`449`	`447`
`450`		`- if (oldTask != BooleanDisposable.True`
`451`		`- && Interlocked.CompareExchange(ref task, newTask, oldTask) == oldTask)`
	`448`	`+ if (Disposable.TrySetMultiple(ref task, newTask))`
`452`	`449`	`{`
`453`		`-`
`454`	`450`	`var longRunning = this.longRunning;`
`455`	`451`	`if (longRunning != null)`
`456`	`452`	`{`
Original file line number	Diff line number	Diff line change
`@@ -68,10 +68,8 @@ void Drain()`
`68`	`68`	`var enumerator = stack.Pop();`
`69`	`69`	`enumerator.Dispose();`
`70`	`70`	`}`
`71`		`- if (Volatile.Read(ref currentSubscription) != BooleanDisposable.True)`
`72`		`- {`
`73`		`- Interlocked.Exchange(ref currentSubscription, BooleanDisposable.True)?.Dispose();`
`74`		`- }`
	`71`	`+`
	`72`	`+ Disposable.TryDispose(ref currentSubscription);`
`75`	`73`	`}`
`76`	`74`	`else`
`77`	`75`	`{`
`@@ -131,7 +129,8 @@ void Drain()`
`131`	`129`	`else`
`132`	`130`	`{`
`133`	`131`	`var sad = new SingleAssignmentDisposable();`
`134`		`- if (Interlocked.CompareExchange(ref currentSubscription, sad, null) == null)`
	`132`	`+`
	`133`	`+ if (Disposable.TrySetSingle(ref currentSubscription, sad) == TrySetSingleResult.Success)`
`135`	`134`	`{`
`136`	`135`	`sad.Disposable = next.SubscribeSafe(this);`
`137`	`136`	`}`
`@@ -172,15 +171,8 @@ void DisposeAll()`
`172`	`171`
`173`	`172`	`protected void Recurse()`
`174`	`173`	`{`
`175`		`- var d = Volatile.Read(ref currentSubscription);`
`176`		`- if (d != BooleanDisposable.True)`
`177`		`- {`
`178`		`- d?.Dispose();`
`179`		`- if (Interlocked.CompareExchange(ref currentSubscription, null, d) == d)`
`180`		`- {`
`181`		`- Drain();`
`182`		`- }`
`183`		`- }`
	`174`	`+ if (Disposable.TrySetSerial(ref currentSubscription, null))`
	`175`	`+ Drain();`
`184`	`176`	`}`
`185`	`177`
`186`	`178`	`protected abstract IEnumerable<IObservable<TSource>> Extract(IObservable<TSource> source);`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ internal void OnSubscribe(IDisposable d)`
`103`	`103`
`104`	`104`	`public void Dispose()`
`105`	`105`	`{`
`106`		`- Interlocked.Exchange(ref upstream, BooleanDisposable.True)?.Dispose();`
	`106`	`+ Disposable.TryDispose(ref upstream);`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`public void OnCompleted()`
Original file line number	Diff line number	Diff line change
`@@ -153,7 +153,7 @@ public InnerObserver(AmbCoordinator<T> parent, int index)`
`153`	`153`
`154`	`154`	`public void Dispose()`
`155`	`155`	`{`
`156`		`- Interlocked.Exchange(ref upstream, BooleanDisposable.True)?.Dispose();`
	`156`	`+ Disposable.TryDispose(ref upstream);`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`public void OnCompleted()`
Original file line number	Diff line number	Diff line change
`@@ -66,12 +66,12 @@ public void Dispose()`
`66`	`66`
`67`	`67`	`void DisposeMain()`
`68`	`68`	`{`
`69`		`- Interlocked.Exchange(ref upstream, BooleanDisposable.True)?.Dispose();`
	`69`	`+ Disposable.TryDispose(ref upstream);`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`bool IsDisposed()`
`73`	`73`	`{`
`74`		`- return Volatile.Read(ref upstream) == BooleanDisposable.True;`
	`74`	`+ return Disposable.GetIsDisposed(ref upstream);`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`public void OnCompleted()`
Original file line number	Diff line number	Diff line change
`@@ -200,7 +200,7 @@ internal void OnSubscribe(IDisposable d)`
`200`	`200`
`201`	`201`	`public void Dispose()`
`202`	`202`	`{`
`203`		`- Interlocked.Exchange(ref upstream, BooleanDisposable.True)?.Dispose();`
	`203`	`+ Disposable.TryDispose(ref upstream);`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`public void OnCompleted()`