架构大更

Assets/Plugins/UniRx/Scripts/Operators/Take.cs

@@ -1,14 +1,13 @@
 using System;
-using UniRx.Operators;
 
 namespace UniRx.Operators
 {
     internal class TakeObservable<T> : OperatorObservableBase<T>
     {
-        readonly IObservable<T> source;
-        readonly int count;
-        readonly TimeSpan duration;
+        private readonly int count;
+        private readonly TimeSpan duration;
         internal readonly IScheduler scheduler; // public for optimization check
+        private readonly IObservable<T> source;
 
         public TakeObservable(IObservable<T> source, int count)
             : base(source.IsRequiredSubscribeOnCurrentThread())
@@ -34,7 +33,7 @@ namespace UniRx.Operators
             // xs.Take(5).Take(3) = 3 | xs.Take(3).Take(5) = 3
 
             // use minimum one
-            return (this.count <= count)
+            return this.count <= count
                 ? this
                 : new TakeObservable<T>(source, count);
         }
@@ -46,30 +45,25 @@ namespace UniRx.Operators
             // xs.Take(5s).Take(3s) = 3s | xs.Take(3s).Take(5s) = 3s
 
             // use minimum one
-            return (this.duration <= duration)
+            return this.duration <= duration
                 ? this
                 : new TakeObservable<T>(source, duration, scheduler);
         }
 
         protected override IDisposable SubscribeCore(IObserver<T> observer, IDisposable cancel)
         {
-            if (scheduler == null)
-            {
-                return source.Subscribe(new Take(this, observer, cancel));
-            }
-            else
-            {
-                return new Take_(this, observer, cancel).Run();
-            }
+            if (scheduler == null) return source.Subscribe(new Take(this, observer, cancel));
+
+            return new Take_(this, observer, cancel).Run();
         }
 
-        class Take : OperatorObserverBase<T, T>
+        private class Take : OperatorObserverBase<T, T>
         {
-            int rest;
+            private int rest;
 
             public Take(TakeObservable<T> parent, IObserver<T> observer, IDisposable cancel) : base(observer, cancel)
             {
-                this.rest = parent.count;
+                rest = parent.count;
             }
 
             public override void OnNext(T value)
@@ -77,29 +71,52 @@ namespace UniRx.Operators
                 if (rest > 0)
                 {
                     rest -= 1;
-                    base.observer.OnNext(value);
+                    observer.OnNext(value);
                     if (rest == 0)
                     {
-                        try { observer.OnCompleted(); } finally { Dispose(); };
+                        try
+                        {
+                            observer.OnCompleted();
+                        }
+                        finally
+                        {
+                            Dispose();
+                        }
+
+                        ;
                     }
                 }
             }
 
             public override void OnError(Exception error)
             {
-                try { observer.OnError(error); } finally { Dispose(); }
+                try
+                {
+                    observer.OnError(error);
+                }
+                finally
+                {
+                    Dispose();
+                }
             }
 
             public override void OnCompleted()
             {
-                try { observer.OnCompleted(); } finally { Dispose(); }
+                try
+                {
+                    observer.OnCompleted();
+                }
+                finally
+                {
+                    Dispose();
+                }
             }
         }
 
-        class Take_ : OperatorObserverBase<T, T>
+        private class Take_ : OperatorObserverBase<T, T>
         {
-            readonly TakeObservable<T> parent;
-            readonly object gate = new object();
+            private readonly object gate = new();
+            private readonly TakeObservable<T> parent;
 
             public Take_(TakeObservable<T> parent, IObserver<T> observer, IDisposable cancel) : base(observer, cancel)
             {
@@ -114,11 +131,20 @@ namespace UniRx.Operators
                 return StableCompositeDisposable.Create(d1, d2);
             }
 
-            void Tick()
+            private void Tick()
             {
                 lock (gate)
                 {
-                    try { observer.OnCompleted(); } finally { Dispose(); };
+                    try
+                    {
+                        observer.OnCompleted();
+                    }
+                    finally
+                    {
+                        Dispose();
+                    }
+
+                    ;
                 }
             }
 
@@ -126,7 +152,7 @@ namespace UniRx.Operators
             {
                 lock (gate)
                 {
-                    base.observer.OnNext(value);
+                    observer.OnNext(value);
                 }
             }
 
@@ -134,7 +160,16 @@ namespace UniRx.Operators
             {
                 lock (gate)
                 {
-                    try { observer.OnError(error); } finally { Dispose(); };
+                    try
+                    {
+                        observer.OnError(error);
+                    }
+                    finally
+                    {
+                        Dispose();
+                    }
+
+                    ;
                 }
             }
 
@@ -142,7 +177,16 @@ namespace UniRx.Operators
             {
                 lock (gate)
                 {
-                    try { observer.OnCompleted(); } finally { Dispose(); };
+                    try
+                    {
+                        observer.OnCompleted();
+                    }
+                    finally
+                    {
+                        Dispose();
+                    }
+
+                    ;
                 }
             }
         }