Merge pull request #1312 from dotnet/dev/bartde/scheduler_value_task

bartdesmet · web-flow · commit 612f64605ecc · 2020-09-27T23:31:58.000-07:00
Use ValueTask on schedulers.
diff --git a/AsyncRx.NET/System.Reactive.Async.Concurrency/System/Reactive/Concurrency/AsyncScheduler.cs b/AsyncRx.NET/System.Reactive.Async.Concurrency/System/Reactive/Concurrency/AsyncScheduler.cs
@@ -90,7 +90,7 @@ public static async ValueTask Delay(this IAsyncScheduler scheduler, TimeSpan due
                     tcs.SetResult(true);
                 }
 
-                return Task.CompletedTask;
+                return default;
             }, dueTime);
 
             using (token.Register(() => task.DisposeAsync()))
@@ -117,7 +117,7 @@ public static async ValueTask Delay(this IAsyncScheduler scheduler, DateTimeOffs
                     tcs.SetResult(true);
                 }
 
-                return Task.CompletedTask;
+                return default;
             }, dueTime);
 
             using (token.Register(() => task.DisposeAsync()))
diff --git a/AsyncRx.NET/System.Reactive.Async.Concurrency/System/Reactive/Concurrency/AsyncSchedulerBase.cs b/AsyncRx.NET/System.Reactive.Async.Concurrency/System/Reactive/Concurrency/AsyncSchedulerBase.cs
@@ -11,15 +11,15 @@ public abstract class AsyncSchedulerBase : IAsyncScheduler
     {
         public virtual DateTimeOffset Now => DateTimeOffset.Now;
 
-        public virtual ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, Task> action)
+        public virtual ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, ValueTask> action)
         {
             if (action == null)
                 throw new ArgumentNullException(nameof(action));
 
             return ScheduleAsyncCore(action);
         }
 
-        public virtual ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, Task> action, TimeSpan dueTime)
+        public virtual ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, ValueTask> action, TimeSpan dueTime)
         {
             if (action == null)
                 throw new ArgumentNullException(nameof(action));
@@ -34,7 +34,7 @@ public virtual ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken,
             });
         }
 
-        public virtual ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, Task> action, DateTimeOffset dueTime)
+        public virtual ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, ValueTask> action, DateTimeOffset dueTime)
         {
             if (action == null)
                 throw new ArgumentNullException(nameof(action));
@@ -49,7 +49,7 @@ public virtual ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken,
             });
         }
 
-        protected virtual async ValueTask<IAsyncDisposable> ScheduleAsyncCore(Func<CancellationToken, Task> action)
+        protected virtual async ValueTask<IAsyncDisposable> ScheduleAsyncCore(Func<CancellationToken, ValueTask> action)
         {
             var cad = new CancellationAsyncDisposable();
 
@@ -58,9 +58,9 @@ protected virtual async ValueTask<IAsyncDisposable> ScheduleAsyncCore(Func<Cance
             return cad;
         }
 
-        protected abstract Task ScheduleAsyncCore(Func<CancellationToken, Task> action, CancellationToken token);
+        protected abstract ValueTask ScheduleAsyncCore(Func<CancellationToken, ValueTask> action, CancellationToken token);
 
-        protected abstract Task Delay(TimeSpan dueTime, CancellationToken token);
+        protected abstract ValueTask Delay(TimeSpan dueTime, CancellationToken token);
 
         protected static TimeSpan Normalize(TimeSpan timeSpan) => timeSpan < TimeSpan.Zero ? TimeSpan.Zero : timeSpan;
 
diff --git a/AsyncRx.NET/System.Reactive.Async.Concurrency/System/Reactive/Concurrency/ImmediateAsyncScheduler.cs b/AsyncRx.NET/System.Reactive.Async.Concurrency/System/Reactive/Concurrency/ImmediateAsyncScheduler.cs
@@ -13,8 +13,8 @@ public sealed class ImmediateAsyncScheduler : AsyncSchedulerBase
 
         private ImmediateAsyncScheduler() { }
 
-        protected override Task Delay(TimeSpan dueTime, CancellationToken token) => Task.Delay(dueTime);
+        protected override ValueTask Delay(TimeSpan dueTime, CancellationToken token) => new ValueTask(Task.Delay(dueTime));
 
-        protected override Task ScheduleAsyncCore(Func<CancellationToken, Task> action, CancellationToken token) => action(token);
+        protected override ValueTask ScheduleAsyncCore(Func<CancellationToken, ValueTask> action, CancellationToken token) => action(token);
     }
 }
diff --git a/AsyncRx.NET/System.Reactive.Async.Concurrency/System/Reactive/Concurrency/SynchronizationContextAsyncScheduler.cs b/AsyncRx.NET/System.Reactive.Async.Concurrency/System/Reactive/Concurrency/SynchronizationContextAsyncScheduler.cs
@@ -16,9 +16,9 @@ public SynchronizationContextAsyncScheduler(SynchronizationContext context)
             _context = context ?? throw new ArgumentNullException(nameof(context));
         }
 
-        protected override Task Delay(TimeSpan dueTime, CancellationToken token) => Task.Delay(dueTime, token);
+        protected override ValueTask Delay(TimeSpan dueTime, CancellationToken token) => new ValueTask(Task.Delay(dueTime, token));
 
-        protected override Task ScheduleAsyncCore(Func<CancellationToken, Task> action, CancellationToken token)
+        protected override ValueTask ScheduleAsyncCore(Func<CancellationToken, ValueTask> action, CancellationToken token)
         {
             _context.Post(_ =>
             {
@@ -28,7 +28,7 @@ protected override Task ScheduleAsyncCore(Func<CancellationToken, Task> action,
                 }
             }, null);
 
-            return Task.CompletedTask;
+            return default;
         }
     }
 }
diff --git a/AsyncRx.NET/System.Reactive.Async.Concurrency/System/Reactive/Concurrency/TaskPoolAsyncScheduler.cs b/AsyncRx.NET/System.Reactive.Async.Concurrency/System/Reactive/Concurrency/TaskPoolAsyncScheduler.cs
@@ -27,11 +27,11 @@ public TaskPoolAsyncScheduler(TaskFactory factory)
             _factory = factory ?? throw new ArgumentNullException(nameof(factory));
         }
 
-        protected override Task Delay(TimeSpan dueTime, CancellationToken token) => Task.Delay(dueTime, token);
+        protected override ValueTask Delay(TimeSpan dueTime, CancellationToken token) => new ValueTask(Task.Delay(dueTime, token));
 
-        protected override Task ScheduleAsyncCore(Func<CancellationToken, Task> action, CancellationToken token)
+        protected override ValueTask ScheduleAsyncCore(Func<CancellationToken, ValueTask> action, CancellationToken token)
         {
-            var task = _factory.StartNew(() => action(token), token);
+            var task = _factory.StartNew(() => action(token).AsTask(), token);
 
             task.Unwrap().ContinueWith(t =>
             {
@@ -41,7 +41,7 @@ protected override Task ScheduleAsyncCore(Func<CancellationToken, Task> action,
                 }
             });
 
-            return Task.CompletedTask;
+            return default;
         }
     }
 }
diff --git a/AsyncRx.NET/System.Reactive.Async.Interfaces/System/Reactive/Concurrency/IAsyncScheduler.cs b/AsyncRx.NET/System.Reactive.Async.Interfaces/System/Reactive/Concurrency/IAsyncScheduler.cs
@@ -9,8 +9,8 @@ namespace System.Reactive.Concurrency
 {
     public interface IAsyncScheduler : IClock
     {
-        ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, Task> action);
-        ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, Task> action, TimeSpan dueTime);
-        ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, Task> action, DateTimeOffset dueTime);
+        ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, ValueTask> action);
+        ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, ValueTask> action, TimeSpan dueTime);
+        ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, ValueTask> action, DateTimeOffset dueTime);
     }
 }
diff --git a/AsyncRx.NET/System.Reactive.Async.Linq/System/Runtime/CompilerServices/AsyncObservableMethodBuilder.cs b/AsyncRx.NET/System.Reactive.Async.Linq/System/Runtime/CompilerServices/AsyncObservableMethodBuilder.cs
@@ -187,7 +187,7 @@ private static void Rethrow(Exception exception)
             {
                 ExceptionDispatchInfo.Capture(exception).Throw();
 
-                return System.Threading.Tasks.Task.CompletedTask;
+                return default;
             });
         }
 
diff --git a/AsyncRx.NET/System.Reactive.Async.Subjects/System/Reactive/FastImmediateAsyncObserver.cs b/AsyncRx.NET/System.Reactive.Async.Subjects/System/Reactive/FastImmediateAsyncObserver.cs
@@ -27,6 +27,6 @@ public FastImmediateAsyncObserver(IAsyncObserver<T> observer)
 
         protected override IAwaitable<R> RendezVous<R>(ValueTask<R> task) => new ValueTaskAwaitable<R>(task, false, null, CancellationToken.None);
 
-        protected override Task ScheduleAsync() => RunAsync(_disposable.Token);
+        protected override ValueTask ScheduleAsync() => RunAsync(_disposable.Token);
     }
 }
diff --git a/AsyncRx.NET/System.Reactive.Async.Subjects/System/Reactive/ISchedulerAsyncObserver.cs b/AsyncRx.NET/System.Reactive.Async.Subjects/System/Reactive/ISchedulerAsyncObserver.cs
@@ -8,8 +8,8 @@ namespace System.Reactive
 {
     internal interface IScheduledAsyncObserver<T> : IAsyncObserver<T>, IAsyncDisposable
     {
-        Task EnsureActive();
+        ValueTask EnsureActive();
 
-        Task EnsureActive(int count);
+        ValueTask EnsureActive(int count);
     }
 }
diff --git a/AsyncRx.NET/System.Reactive.Async.Subjects/System/Reactive/ScheduledAsyncObserver.cs b/AsyncRx.NET/System.Reactive.Async.Subjects/System/Reactive/ScheduledAsyncObserver.cs
@@ -31,7 +31,7 @@ public ScheduledAsyncObserver(IAsyncObserver<T> observer, IAsyncScheduler schedu
 
         protected override IAwaitable<R> RendezVous<R>(ValueTask<R> task) => new ValueTaskAwaitable<R>(task, false, _scheduler, CancellationToken.None);
 
-        protected override async Task ScheduleAsync()
+        protected override async ValueTask ScheduleAsync()
         {
             var d = await _scheduler.ScheduleAsync(RunAsync).ConfigureAwait(false);
             await _disposable.AssignAsync(d).ConfigureAwait(false);
diff --git a/AsyncRx.NET/System.Reactive.Async.Subjects/System/Reactive/ScheduledAsyncObserverBase.cs b/AsyncRx.NET/System.Reactive.Async.Subjects/System/Reactive/ScheduledAsyncObserverBase.cs
@@ -25,9 +25,9 @@ public ScheduledAsyncObserverBase(IAsyncObserver<T> observer)
             _observer = observer;
         }
 
-        public Task EnsureActive() => EnsureActive(1);
+        public ValueTask EnsureActive() => EnsureActive(1);
 
-        public async Task EnsureActive(int count)
+        public async ValueTask EnsureActive(int count)
         {
             var shouldRun = false;
 
@@ -46,9 +46,9 @@ public async Task EnsureActive(int count)
             }
         }
 
-        protected abstract Task ScheduleAsync();
+        protected abstract ValueTask ScheduleAsync();
 
-        protected async Task RunAsync(CancellationToken token)
+        protected async ValueTask RunAsync(CancellationToken token)
         {
             while (!token.IsCancellationRequested)
             {
diff --git a/AsyncRx.NET/System.Reactive.Async.Subjects/System/Reactive/Subjects/ReplayAsyncSubject.cs b/AsyncRx.NET/System.Reactive.Async.Subjects/System/Reactive/Subjects/ReplayAsyncSubject.cs
@@ -230,11 +230,11 @@ public async ValueTask OnNextAsync(T value)
                 }
             }
 
-            private async Task EnsureActive(IScheduledAsyncObserver<T>[] observers)
+            private async ValueTask EnsureActive(IScheduledAsyncObserver<T>[] observers)
             {
                 if (_concurrent)
                 {
-                    await Task.WhenAll(observers.Select(o => o.EnsureActive())).ConfigureAwait(false);
+                    await Task.WhenAll(observers.Select(o => o.EnsureActive().AsTask())).ConfigureAwait(false);
                 }
                 else
                 {
@@ -285,9 +285,9 @@ public async ValueTask<IAsyncDisposable> SubscribeAsync(IAsyncObserver<T> observ
 
             protected abstract IScheduledAsyncObserver<T> CreateScheduledObserver(IAsyncObserver<T> observer);
 
-            protected abstract Task NextAsync(T value);
+            protected abstract ValueTask NextAsync(T value);
 
-            protected abstract Task<int> ReplayAsync(IScheduledAsyncObserver<T> observer);
+            protected abstract ValueTask<int> ReplayAsync(IScheduledAsyncObserver<T> observer);
 
             protected abstract void Trim();
 
@@ -337,15 +337,15 @@ public ReplayOne(bool concurrent, Func<IAsyncObserver<T>, IScheduledAsyncObserve
             {
             }
 
-            protected override Task NextAsync(T value)
+            protected override ValueTask NextAsync(T value)
             {
                 _hasValue = true;
                 _value = value;
 
-                return Task.CompletedTask;
+                return default;
             }
 
-            protected override async Task<int> ReplayAsync(IScheduledAsyncObserver<T> observer)
+            protected override async ValueTask<int> ReplayAsync(IScheduledAsyncObserver<T> observer)
             {
                 if (_hasValue)
                 {
@@ -368,14 +368,14 @@ public ReplayManyBase(bool concurrent, Func<IAsyncObserver<T>, IScheduledAsyncOb
             {
             }
 
-            protected override Task NextAsync(T value)
+            protected override ValueTask NextAsync(T value)
             {
                 Values.Enqueue(value);
 
-                return Task.CompletedTask;
+                return default;
             }
 
-            protected override async Task<int> ReplayAsync(IScheduledAsyncObserver<T> observer)
+            protected override async ValueTask<int> ReplayAsync(IScheduledAsyncObserver<T> observer)
             {
                 var count = Values.Count;
 
@@ -432,14 +432,14 @@ public ReplayTime(bool concurrent, IAsyncScheduler scheduler, int bufferSize, Ti
                 _window = window;
             }
 
-            protected override Task NextAsync(T value)
+            protected override ValueTask NextAsync(T value)
             {
                 _values.Enqueue(new Timestamped<T>(value, _scheduler.Now));
 
-                return Task.CompletedTask;
+                return default;
             }
 
-            protected override async Task<int> ReplayAsync(IScheduledAsyncObserver<T> observer)
+            protected override async ValueTask<int> ReplayAsync(IScheduledAsyncObserver<T> observer)
             {
                 var count = _values.Count;
 
diff --git a/AsyncRx.NET/System.Reactive.Bcl/System/Threading/AsyncLock.cs b/AsyncRx.NET/System.Reactive.Bcl/System/Threading/AsyncLock.cs
@@ -13,7 +13,7 @@ public sealed class AsyncLock
         private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
         private readonly AsyncLocal<int> _recursionCount = new AsyncLocal<int>();
 
-        public Task<Releaser> LockAsync()
+        public ValueTask<Releaser> LockAsync()
         {
             var shouldAcquire = false;
 
@@ -32,10 +32,10 @@ public Task<Releaser> LockAsync()
 
             if (shouldAcquire)
             {
-                return _semaphore.WaitAsync().ContinueWith(_ => new Releaser(this));
+                return new ValueTask<Releaser>(_semaphore.WaitAsync().ContinueWith(_ => new Releaser(this)));
             }
 
-            return Task.FromResult(new Releaser(this));
+            return new ValueTask<Releaser>(new Releaser(this));
         }
 
         private void Release()

Original file line number	Diff line number	Diff line change
`@@ -90,7 +90,7 @@ public static async ValueTask Delay(this IAsyncScheduler scheduler, TimeSpan due`
`90`	`90`	`tcs.SetResult(true);`
`91`	`91`	`}`
`92`	`92`
`93`		`- return Task.CompletedTask;`
	`93`	`+ return default;`
`94`	`94`	`}, dueTime);`
`95`	`95`
`96`	`96`	`using (token.Register(() => task.DisposeAsync()))`
`@@ -117,7 +117,7 @@ public static async ValueTask Delay(this IAsyncScheduler scheduler, DateTimeOffs`
`117`	`117`	`tcs.SetResult(true);`
`118`	`118`	`}`
`119`	`119`
`120`		`- return Task.CompletedTask;`
	`120`	`+ return default;`
`121`	`121`	`}, dueTime);`
`122`	`122`
`123`	`123`	`using (token.Register(() => task.DisposeAsync()))`
Original file line number	Diff line number	Diff line change
`@@ -11,15 +11,15 @@ public abstract class AsyncSchedulerBase : IAsyncScheduler`
`11`	`11`	`{`
`12`	`12`	`public virtual DateTimeOffset Now => DateTimeOffset.Now;`
`13`	`13`
`14`		`- public virtual ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, Task> action)`
	`14`	`+ public virtual ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, ValueTask> action)`
`15`	`15`	`{`
`16`	`16`	`if (action == null)`
`17`	`17`	`throw new ArgumentNullException(nameof(action));`
`18`	`18`
`19`	`19`	`return ScheduleAsyncCore(action);`
`20`	`20`	`}`
`21`	`21`
`22`		`- public virtual ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, Task> action, TimeSpan dueTime)`
	`22`	`+ public virtual ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, ValueTask> action, TimeSpan dueTime)`
`23`	`23`	`{`
`24`	`24`	`if (action == null)`
`25`	`25`	`throw new ArgumentNullException(nameof(action));`
`@@ -34,7 +34,7 @@ public virtual ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken,`
`34`	`34`	`});`
`35`	`35`	`}`
`36`	`36`
`37`		`- public virtual ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, Task> action, DateTimeOffset dueTime)`
	`37`	`+ public virtual ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, ValueTask> action, DateTimeOffset dueTime)`
`38`	`38`	`{`
`39`	`39`	`if (action == null)`
`40`	`40`	`throw new ArgumentNullException(nameof(action));`
`@@ -49,7 +49,7 @@ public virtual ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken,`
`49`	`49`	`});`
`50`	`50`	`}`
`51`	`51`
`52`		`- protected virtual async ValueTask<IAsyncDisposable> ScheduleAsyncCore(Func<CancellationToken, Task> action)`
	`52`	`+ protected virtual async ValueTask<IAsyncDisposable> ScheduleAsyncCore(Func<CancellationToken, ValueTask> action)`
`53`	`53`	`{`
`54`	`54`	`var cad = new CancellationAsyncDisposable();`
`55`	`55`
`@@ -58,9 +58,9 @@ protected virtual async ValueTask<IAsyncDisposable> ScheduleAsyncCore(Func<Cance`
`58`	`58`	`return cad;`
`59`	`59`	`}`
`60`	`60`
`61`		`- protected abstract Task ScheduleAsyncCore(Func<CancellationToken, Task> action, CancellationToken token);`
	`61`	`+ protected abstract ValueTask ScheduleAsyncCore(Func<CancellationToken, ValueTask> action, CancellationToken token);`
`62`	`62`
`63`		`- protected abstract Task Delay(TimeSpan dueTime, CancellationToken token);`
	`63`	`+ protected abstract ValueTask Delay(TimeSpan dueTime, CancellationToken token);`
`64`	`64`
`65`	`65`	`protected static TimeSpan Normalize(TimeSpan timeSpan) => timeSpan < TimeSpan.Zero ? TimeSpan.Zero : timeSpan;`
`66`	`66`
Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,8 @@ public sealed class ImmediateAsyncScheduler : AsyncSchedulerBase`
`13`	`13`
`14`	`14`	`private ImmediateAsyncScheduler() { }`
`15`	`15`
`16`		`- protected override Task Delay(TimeSpan dueTime, CancellationToken token) => Task.Delay(dueTime);`
	`16`	`+ protected override ValueTask Delay(TimeSpan dueTime, CancellationToken token) => new ValueTask(Task.Delay(dueTime));`
`17`	`17`
`18`		`- protected override Task ScheduleAsyncCore(Func<CancellationToken, Task> action, CancellationToken token) => action(token);`
	`18`	`+ protected override ValueTask ScheduleAsyncCore(Func<CancellationToken, ValueTask> action, CancellationToken token) => action(token);`
`19`	`19`	`}`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,9 +16,9 @@ public SynchronizationContextAsyncScheduler(SynchronizationContext context)`
`16`	`16`	`_context = context ?? throw new ArgumentNullException(nameof(context));`
`17`	`17`	`}`
`18`	`18`
`19`		`- protected override Task Delay(TimeSpan dueTime, CancellationToken token) => Task.Delay(dueTime, token);`
	`19`	`+ protected override ValueTask Delay(TimeSpan dueTime, CancellationToken token) => new ValueTask(Task.Delay(dueTime, token));`
`20`	`20`
`21`		`- protected override Task ScheduleAsyncCore(Func<CancellationToken, Task> action, CancellationToken token)`
	`21`	`+ protected override ValueTask ScheduleAsyncCore(Func<CancellationToken, ValueTask> action, CancellationToken token)`
`22`	`22`	`{`
`23`	`23`	`_context.Post(_ =>`
`24`	`24`	`{`
`@@ -28,7 +28,7 @@ protected override Task ScheduleAsyncCore(Func<CancellationToken, Task> action,`
`28`	`28`	`}`
`29`	`29`	`}, null);`
`30`	`30`
`31`		`- return Task.CompletedTask;`
	`31`	`+ return default;`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,11 +27,11 @@ public TaskPoolAsyncScheduler(TaskFactory factory)`
`27`	`27`	`_factory = factory ?? throw new ArgumentNullException(nameof(factory));`
`28`	`28`	`}`
`29`	`29`
`30`		`- protected override Task Delay(TimeSpan dueTime, CancellationToken token) => Task.Delay(dueTime, token);`
	`30`	`+ protected override ValueTask Delay(TimeSpan dueTime, CancellationToken token) => new ValueTask(Task.Delay(dueTime, token));`
`31`	`31`
`32`		`- protected override Task ScheduleAsyncCore(Func<CancellationToken, Task> action, CancellationToken token)`
	`32`	`+ protected override ValueTask ScheduleAsyncCore(Func<CancellationToken, ValueTask> action, CancellationToken token)`
`33`	`33`	`{`
`34`		`- var task = _factory.StartNew(() => action(token), token);`
	`34`	`+ var task = _factory.StartNew(() => action(token).AsTask(), token);`
`35`	`35`
`36`	`36`	`task.Unwrap().ContinueWith(t =>`
`37`	`37`	`{`
`@@ -41,7 +41,7 @@ protected override Task ScheduleAsyncCore(Func<CancellationToken, Task> action,`
`41`	`41`	`}`
`42`	`42`	`});`
`43`	`43`
`44`		`- return Task.CompletedTask;`
	`44`	`+ return default;`
`45`	`45`	`}`
`46`	`46`	`}`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,8 +9,8 @@ namespace System.Reactive.Concurrency`
`9`	`9`	`{`
`10`	`10`	`public interface IAsyncScheduler : IClock`
`11`	`11`	`{`
`12`		`- ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, Task> action);`
`13`		`- ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, Task> action, TimeSpan dueTime);`
`14`		`- ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, Task> action, DateTimeOffset dueTime);`
	`12`	`+ ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, ValueTask> action);`
	`13`	`+ ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, ValueTask> action, TimeSpan dueTime);`
	`14`	`+ ValueTask<IAsyncDisposable> ScheduleAsync(Func<CancellationToken, ValueTask> action, DateTimeOffset dueTime);`
`15`	`15`	`}`
`16`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -187,7 +187,7 @@ private static void Rethrow(Exception exception)`
`187`	`187`	`{`
`188`	`188`	`ExceptionDispatchInfo.Capture(exception).Throw();`
`189`	`189`
`190`		`- return System.Threading.Tasks.Task.CompletedTask;`
	`190`	`+ return default;`
`191`	`191`	`});`
`192`	`192`	`}`
`193`	`193`
Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,6 @@ public FastImmediateAsyncObserver(IAsyncObserver<T> observer)`
`27`	`27`
`28`	`28`	`protected override IAwaitable<R> RendezVous<R>(ValueTask<R> task) => new ValueTaskAwaitable<R>(task, false, null, CancellationToken.None);`
`29`	`29`
`30`		`- protected override Task ScheduleAsync() => RunAsync(_disposable.Token);`
	`30`	`+ protected override ValueTask ScheduleAsync() => RunAsync(_disposable.Token);`
`31`	`31`	`}`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,8 +8,8 @@ namespace System.Reactive`
`8`	`8`	`{`
`9`	`9`	`internal interface IScheduledAsyncObserver<T> : IAsyncObserver<T>, IAsyncDisposable`
`10`	`10`	`{`
`11`		`- Task EnsureActive();`
	`11`	`+ ValueTask EnsureActive();`
`12`	`12`
`13`		`- Task EnsureActive(int count);`
	`13`	`+ ValueTask EnsureActive(int count);`
`14`	`14`	`}`
`15`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public ScheduledAsyncObserver(IAsyncObserver<T> observer, IAsyncScheduler schedu`
`31`	`31`
`32`	`32`	`protected override IAwaitable<R> RendezVous<R>(ValueTask<R> task) => new ValueTaskAwaitable<R>(task, false, _scheduler, CancellationToken.None);`
`33`	`33`
`34`		`- protected override async Task ScheduleAsync()`
	`34`	`+ protected override async ValueTask ScheduleAsync()`
`35`	`35`	`{`
`36`	`36`	`var d = await _scheduler.ScheduleAsync(RunAsync).ConfigureAwait(false);`
`37`	`37`	`await _disposable.AssignAsync(d).ConfigureAwait(false);`