An allocation in BasicProducer.SubscribeRaw can be saved in most cases. (#602)

Author: danielcweber

Rx.NET/Source/src/System.Reactive/Internal/Producer.cs

@@ -38,31 +38,35 @@ public IDisposable Subscribe(IObserver<TSource> observer)
 
         public IDisposable SubscribeRaw(IObserver<TSource> observer, bool enableSafeguard)
         {
-            var subscription = new SingleAssignmentDisposable();
+            IDisposable run;
+            ISafeObserver<TSource> safeObserver = null;
 
             //
             // See AutoDetachObserver.cs for more information on the safeguarding requirement and
             // its implementation aspects.
             //
             if (enableSafeguard)
             {
-                var safeObserver = SafeObserver<TSource>.Wrap(observer);
-                safeObserver.SetResource(subscription);
-                observer = safeObserver;
+                observer = safeObserver = SafeObserver<TSource>.Wrap(observer);
             }
 
             if (CurrentThreadScheduler.IsScheduleRequired)
             {
+                var runAssignable = new SingleAssignmentDisposable();
+                
                 CurrentThreadScheduler.Instance.ScheduleAction(
-                    (@this: this, subscription, observer),
-                    tuple => tuple.subscription.Disposable = tuple.@this.Run(tuple.observer));
+                    (@this: this, runAssignable, observer),
+                    tuple => tuple.runAssignable.Disposable = tuple.@this.Run(tuple.observer));
+
+                run = runAssignable;
             }
             else
             {
-                subscription.Disposable = Run(observer);
+                run = Run(observer);
             }
 
-            return subscription;
+            safeObserver?.SetResource(run);
+            return run;
         }
 
         /// <summary>