Replace more usages of Disposable.Utils.

Rx.NET/Source/src/System.Reactive/Concurrency/DefaultScheduler.cs

@@ -161,7 +161,7 @@ namespace System.Reactive.Concurrency
                 private readonly TState _state;
                 private readonly Action<TState, ICancelable> _action;
 
-                private IDisposable? _cancel;
+                private SingleAssignmentDisposableValue _cancel;
 
                 public LongScheduledWorkItem(TState state, Action<TState, ICancelable> action)
                 {
@@ -186,10 +186,10 @@ namespace System.Reactive.Concurrency
 
                 public void Dispose()
                 {
-                    Disposable.Dispose(ref _cancel);
+                    _cancel.Dispose();
                 }
 
-                public bool IsDisposed => Disposable.GetIsDisposed(ref _cancel);
+                public bool IsDisposed => _cancel.IsDisposed;
             }
 
             public static readonly ISchedulerLongRunning Instance = new LongRunning();

Rx.NET/Source/src/System.Reactive/Concurrency/Scheduler.Services.Emulation.cs

@@ -367,7 +367,7 @@ namespace System.Reactive.Concurrency
             private const int Suspended = 2;
             private const int Disposed = 3;
 
-            private IDisposable? _task;
+            private SingleAssignmentDisposableValue _task;
 
             public IDisposable Start()
             {
@@ -377,13 +377,13 @@ namespace System.Reactive.Concurrency
                 _nextDue = _period;
                 _runState = Running;
 
-                Disposable.SetSingle(ref _task, _scheduler.Schedule(this, _nextDue, static (@this, a) => @this.Tick(a)));
+                _task.Disposable = _scheduler.Schedule(this, _nextDue, static (@this, a) => @this.Tick(a));
                 return this;
             }
 
             void IDisposable.Dispose()
             {
-                Disposable.Dispose(ref _task);
+                _task.Dispose();
                 Cancel();
             }
 

Rx.NET/Source/src/System.Reactive/Concurrency/TaskPoolScheduler.cs

@@ -116,7 +116,7 @@ namespace System.Reactive.Concurrency
             private readonly TState _state;
             private readonly Action<TState, ICancelable> _action;
 
-            private IDisposable? _cancel;
+            private SingleAssignmentDisposableValue _cancel;
 
             public LongScheduledWorkItem(TaskPoolScheduler scheduler, TState state, Action<TState, ICancelable> action)
             {
@@ -141,10 +141,10 @@ namespace System.Reactive.Concurrency
 
             public void Dispose()
             {
-                Disposable.Dispose(ref _cancel);
+                _cancel.Dispose();
             }
 
-            public bool IsDisposed => Disposable.GetIsDisposed(ref _cancel);
+            public bool IsDisposed => _cancel.IsDisposed;
         }
 
         private static readonly Lazy<TaskPoolScheduler> LazyInstance = new Lazy<TaskPoolScheduler>(static () => new TaskPoolScheduler(new TaskFactory(TaskScheduler.Default)));

Rx.NET/Source/src/System.Reactive/Disposables/StableCompositeDisposable.cs

@@ -90,21 +90,21 @@ namespace System.Reactive.Disposables
 
         private sealed class Binary : StableCompositeDisposable
         {
-            private IDisposable? _disposable1;
-            private IDisposable? _disposable2;
+            private SingleAssignmentDisposableValue _disposable1;
+            private SingleAssignmentDisposableValue _disposable2;
 
             public Binary(IDisposable disposable1, IDisposable disposable2)
             {
-                Volatile.Write(ref _disposable1, disposable1);
-                Volatile.Write(ref _disposable2, disposable2);
+                _disposable1.Disposable = disposable1;
+                _disposable2.Disposable = disposable2;
             }
 
-            public override bool IsDisposed => Disposable.GetIsDisposed(ref _disposable1);
+            public override bool IsDisposed => _disposable1.IsDisposed;
 
             public override void Dispose()
             {
-                Disposable.Dispose(ref _disposable1);
-                Disposable.Dispose(ref _disposable2);
+                _disposable1.Dispose();
+                _disposable2.Dispose();
             }
         }
 

Rx.NET/Source/src/System.Reactive/Linq/Observable/AppendPrepend.cs

@@ -105,7 +105,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 private readonly TSource _value;
                 private readonly IScheduler _scheduler;
                 private readonly bool _append;
-                private IDisposable? _schedulerDisposable;
+                private SingleAssignmentDisposableValue _schedulerDisposable;
 
                 public _(SingleValue parent, IObserver<TSource> observer)
                     : base(observer)
@@ -136,7 +136,7 @@ namespace System.Reactive.Linq.ObservableImpl
                     if (_append)
                     {
                         var disposable = _scheduler.ScheduleAction(this, AppendValue);
-                        Disposable.SetSingle(ref _schedulerDisposable, disposable);
+                        _schedulerDisposable.Disposable = disposable;
                     }
                     else
                     {
@@ -154,7 +154,7 @@ namespace System.Reactive.Linq.ObservableImpl
                 {
                     if (disposing)
                     {
-                        Disposable.Dispose(ref _schedulerDisposable);
+                        _schedulerDisposable.Dispose();
                     }
                     base.Dispose(disposing);
                 }

Rx.NET/Source/src/System.Reactive/Linq/Observable/GetEnumerator.cs

@@ -17,7 +17,7 @@ namespace System.Reactive.Linq.ObservableImpl
         private Exception? _error;
         private bool _done;
         private bool _disposed;
-        private IDisposable? _subscription;
+        private SingleAssignmentDisposableValue _subscription;
 
         private readonly SemaphoreSlim _gate;
 
@@ -32,7 +32,7 @@ namespace System.Reactive.Linq.ObservableImpl
             //
             // [OK] Use of unsafe Subscribe: non-pretentious exact mirror with the dual GetEnumerator method.
             //
-            Disposable.SetSingle(ref _subscription, source.Subscribe/*Unsafe*/(this));
+            _subscription.Disposable = source.Subscribe/*Unsafe*/(this);
             return this;
         }
 
@@ -45,14 +45,14 @@ namespace System.Reactive.Linq.ObservableImpl
         public void OnError(Exception error)
         {
             _error = error;
-            Disposable.Dispose(ref _subscription);
+            _subscription.Dispose();
             _gate.Release();
         }
 
         public void OnCompleted()
         {
             _done = true;
-            Disposable.Dispose(ref _subscription);
+            _subscription.Dispose();
             _gate.Release();
         }
 
@@ -84,7 +84,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
         public void Dispose()
         {
-            Disposable.Dispose(ref _subscription);
+            _subscription.Dispose();
 
             _disposed = true;
             _gate.Release();

Rx.NET/Source/src/System.Reactive/Linq/Observable/SkipUntil.cs

@@ -24,7 +24,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
         internal sealed class _ : IdentitySink<TSource>
         {
-            private IDisposable? _otherDisposable;
+            private SingleAssignmentDisposableValue _otherDisposable;
             private bool _forward;
             private int _halfSerializer;
             private Exception? _error;
@@ -36,7 +36,7 @@ namespace System.Reactive.Linq.ObservableImpl
 
             public void Run(SkipUntil<TSource, TOther> parent)
             {
-                Disposable.SetSingle(ref _otherDisposable, parent._other.Subscribe(new OtherObserver(this)));
+                _otherDisposable.Disposable = parent._other.Subscribe(new OtherObserver(this));
                 Run(parent._source);
             }
 
@@ -44,9 +44,9 @@ namespace System.Reactive.Linq.ObservableImpl
             {
                 if (disposing)
                 {
-                    if (!Disposable.GetIsDisposed(ref _otherDisposable))
+                    if (!_otherDisposable.IsDisposed)
                     {
-                        Disposable.Dispose(ref _otherDisposable);
+                        _otherDisposable.Dispose();
                     }
                 }
 
@@ -94,9 +94,9 @@ namespace System.Reactive.Linq.ObservableImpl
 
                 public void Dispose()
                 {
-                    if (!Disposable.GetIsDisposed(ref _parent._otherDisposable))
+                    if (!_parent._otherDisposable.IsDisposed)
                     {
-                        Disposable.Dispose(ref _parent._otherDisposable);
+                        _parent._otherDisposable.Dispose();
                     }
                 }