Use Wait without wait handle

sakno · sakno · commit 7cdfbaeb7236 · 2024-12-31T22:50:39.000+02:00
diff --git a/src/DotNext/IO/AsyncWriterStream.cs b/src/DotNext/IO/AsyncWriterStream.cs
@@ -1,5 +1,7 @@
 namespace DotNext.IO;
 
+using static Threading.Tasks.Synchronization;
+
 internal sealed class AsyncWriterStream<TOutput>(TOutput output) : WriterStream<TOutput>(output)
     where TOutput : ISupplier<ReadOnlyMemory<byte>, CancellationToken, ValueTask>, IFlushable
 {
@@ -25,24 +27,23 @@ public override void Write(ReadOnlySpan<byte> buffer)
     {
         if (!buffer.IsEmpty)
         {
-            using var rental = buffer.Copy();
-
+            var rental = buffer.Copy();
             timeoutSource ??= new();
             timeoutSource.CancelAfter(timeout);
-            var task = WriteAsync(rental.Memory, timeoutSource.Token).AsTask();
+            var task = WriteAsync(rental.Memory, timeoutSource.Token);
             try
             {
                 task.Wait();
             }
             finally
             {
-                task.Dispose();
-
                 if (!timeoutSource.TryReset())
                 {
                     timeoutSource.Dispose();
                     timeoutSource = null;
                 }
+                
+                rental.Dispose();
             }
         }
     }
diff --git a/src/DotNext/IO/ReadOnlyStream.cs b/src/DotNext/IO/ReadOnlyStream.cs
@@ -2,6 +2,9 @@
 
 namespace DotNext.IO;
 
+using Buffers;
+using static Threading.Tasks.Synchronization;
+
 internal abstract class ReadOnlyStream : Stream
 {
     public sealed override bool CanRead => true;
@@ -84,7 +87,6 @@ internal sealed class ReadOnlyStream<TArg>(Func<Memory<byte>, TArg, Cancellation
 {
     private const int DefaultTimeout = 4000;
     private int timeout = DefaultTimeout;
-    private byte[]? synchronousBuffer;
     private CancellationTokenSource? timeoutSource;
 
     public override int ReadTimeout
@@ -121,40 +123,30 @@ public override int Read(Span<byte> buffer)
         }
         else
         {
-            var tempBuffer = RentBuffer(buffer.Length);
+            var tempBuffer = Memory.AllocateExactly<byte>(buffer.Length);
             timeoutSource ??= new();
             timeoutSource.CancelAfter(timeout);
-            var task = ReadAsync(tempBuffer, timeoutSource.Token).AsTask();
+            var task = ReadAsync(tempBuffer.Memory, timeoutSource.Token);
             try
             {
-                task.Wait();
-                writtenCount = task.Result;
+                writtenCount = task.Wait();
+                tempBuffer.Span.Slice(0, writtenCount).CopyTo(buffer);
             }
             finally
             {
-                task.Dispose();
-
                 if (!timeoutSource.TryReset())
                 {
                     timeoutSource.Dispose();
                     timeoutSource = null;
                 }
+                
+                tempBuffer.Dispose();
             }
-
-            tempBuffer.AsSpan(0, writtenCount).CopyTo(buffer);
         }
 
         return writtenCount;
     }
 
-    private ArraySegment<byte> RentBuffer(int length)
-    {
-        if (synchronousBuffer is null || synchronousBuffer.Length < length)
-            synchronousBuffer = GC.AllocateUninitializedArray<byte>(length);
-
-        return new(synchronousBuffer, 0, length);
-    }
-
     protected override void Dispose(bool disposing)
     {
         if (disposing)
diff --git a/src/DotNext/Runtime/CompilerServices/Scope.cs b/src/DotNext/Runtime/CompilerServices/Scope.cs
@@ -4,6 +4,7 @@
 
 namespace DotNext.Runtime.CompilerServices;
 
+using static Threading.Tasks.Synchronization;
 using ExceptionAggregator = ExceptionServices.ExceptionAggregator;
 
 /// <summary>
@@ -114,8 +115,6 @@ public void Dispose()
 
         static void ExecuteCallbacks(ReadOnlySpan<object?> callbacks, ref ExceptionAggregator aggregator)
         {
-            Task t;
-
             foreach (var cb in callbacks)
             {
                 try
@@ -128,22 +127,14 @@ static void ExecuteCallbacks(ReadOnlySpan<object?> callbacks, ref ExceptionAggre
                             callback();
                             break;
                         case Func<ValueTask> callback:
-                            using (t = callback().AsTask())
-                            {
-                                t.Wait();
-                            }
-
+                            callback().Wait();
                             break;
                         case IDisposable disposable:
                             // IDisposable in synchronous implementation has higher priority than IAsyncDisposable
                             disposable.Dispose();
                             break;
                         case IAsyncDisposable disposable:
-                            using (t = disposable.DisposeAsync().AsTask())
-                            {
-                                t.Wait();
-                            }
-
+                            disposable.DisposeAsync().Wait();
                             break;
                     }
                 }
diff --git a/src/DotNext/Threading/Tasks/Synchronization.cs b/src/DotNext/Threading/Tasks/Synchronization.cs
@@ -22,9 +22,9 @@ public static Result<TResult> GetResult<TResult>(this Task<TResult> task, TimeSp
         {
             result = task.Wait(timeout) ? new(task.Result) : new(new TimeoutException());
         }
-        catch (AggregateException e) when (e.InnerExceptions.Count == 1)
+        catch (AggregateException e) when (e.InnerExceptions is [var innerEx])
         {
-            result = new(e.InnerExceptions[0]);
+            result = new(innerEx);
         }
         catch (Exception e)
         {
@@ -49,9 +49,9 @@ public static Result<TResult> GetResult<TResult>(this Task<TResult> task, Cancel
             task.Wait(token);
             result = task.Result;
         }
-        catch (AggregateException e) when (e.InnerExceptions.Count == 1)
+        catch (AggregateException e) when (e.InnerExceptions is [var innerEx])
         {
-            result = new(e.InnerExceptions[0]);
+            result = new(innerEx);
         }
         catch (Exception e)
         {
@@ -87,9 +87,9 @@ public static Result<TResult> GetResult<TResult>(this Task<TResult> task, Cancel
             var awaiter = new DynamicTaskAwaitable.Awaiter(task, ConfigureAwaitOptions.None);
             result = new(awaiter.GetRawResult());
         }
-        catch (AggregateException e) when (e.InnerExceptions.Count is 1)
+        catch (AggregateException e) when (e.InnerExceptions is [var innerEx])
         {
-            result = new(e.InnerExceptions[0]);
+            result = new(innerEx);
         }
         catch (Exception e)
         {
@@ -119,9 +119,9 @@ public static Result<TResult> GetResult<TResult>(this Task<TResult> task, Cancel
             var awaiter = new DynamicTaskAwaitable.Awaiter(task, ConfigureAwaitOptions.None);
             result = new(awaiter.GetRawResult());
         }
-        catch (AggregateException e) when (e.InnerExceptions.Count is 1)
+        catch (AggregateException e) when (e.InnerExceptions is [var innerEx])
         {
-            result = new(e.InnerExceptions[0]);
+            result = new(innerEx);
         }
         catch (Exception e)
         {

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,7 @@`
`1`	`1`	`namespace DotNext.IO;`
`2`	`2`
	`3`	`+using static Threading.Tasks.Synchronization;`
	`4`	`+`
`3`	`5`	`internal sealed class AsyncWriterStream<TOutput>(TOutput output) : WriterStream<TOutput>(output)`
`4`	`6`	`where TOutput : ISupplier<ReadOnlyMemory<byte>, CancellationToken, ValueTask>, IFlushable`
`5`	`7`	`{`
`@@ -25,24 +27,23 @@ public override void Write(ReadOnlySpan<byte> buffer)`
`25`	`27`	`{`
`26`	`28`	`if (!buffer.IsEmpty)`
`27`	`29`	`{`
`28`		`- using var rental = buffer.Copy();`
`29`		`-`
	`30`	`+ var rental = buffer.Copy();`
`30`	`31`	`timeoutSource ??= new();`
`31`	`32`	`timeoutSource.CancelAfter(timeout);`
`32`		`- var task = WriteAsync(rental.Memory, timeoutSource.Token).AsTask();`
	`33`	`+ var task = WriteAsync(rental.Memory, timeoutSource.Token);`
`33`	`34`	`try`
`34`	`35`	`{`
`35`	`36`	`task.Wait();`
`36`	`37`	`}`
`37`	`38`	`finally`
`38`	`39`	`{`
`39`		`- task.Dispose();`
`40`		`-`
`41`	`40`	`if (!timeoutSource.TryReset())`
`42`	`41`	`{`
`43`	`42`	`timeoutSource.Dispose();`
`44`	`43`	`timeoutSource = null;`
`45`	`44`	`}`
	`45`	`+`
	`46`	`+ rental.Dispose();`
`46`	`47`	`}`
`47`	`48`	`}`
`48`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,9 @@`
`2`	`2`
`3`	`3`	`namespace DotNext.IO;`
`4`	`4`
	`5`	`+using Buffers;`
	`6`	`+using static Threading.Tasks.Synchronization;`
	`7`	`+`
`5`	`8`	`internal abstract class ReadOnlyStream : Stream`
`6`	`9`	`{`
`7`	`10`	`public sealed override bool CanRead => true;`
`@@ -84,7 +87,6 @@ internal sealed class ReadOnlyStream<TArg>(Func<Memory<byte>, TArg, Cancellation`
`84`	`87`	`{`
`85`	`88`	`private const int DefaultTimeout = 4000;`
`86`	`89`	`private int timeout = DefaultTimeout;`
`87`		`- private byte[]? synchronousBuffer;`
`88`	`90`	`private CancellationTokenSource? timeoutSource;`
`89`	`91`
`90`	`92`	`public override int ReadTimeout`
`@@ -121,40 +123,30 @@ public override int Read(Span<byte> buffer)`
`121`	`123`	`}`
`122`	`124`	`else`
`123`	`125`	`{`
`124`		`- var tempBuffer = RentBuffer(buffer.Length);`
	`126`	`+ var tempBuffer = Memory.AllocateExactly<byte>(buffer.Length);`
`125`	`127`	`timeoutSource ??= new();`
`126`	`128`	`timeoutSource.CancelAfter(timeout);`
`127`		`- var task = ReadAsync(tempBuffer, timeoutSource.Token).AsTask();`
	`129`	`+ var task = ReadAsync(tempBuffer.Memory, timeoutSource.Token);`
`128`	`130`	`try`
`129`	`131`	`{`
`130`		`- task.Wait();`
`131`		`- writtenCount = task.Result;`
	`132`	`+ writtenCount = task.Wait();`
	`133`	`+ tempBuffer.Span.Slice(0, writtenCount).CopyTo(buffer);`
`132`	`134`	`}`
`133`	`135`	`finally`
`134`	`136`	`{`
`135`		`- task.Dispose();`
`136`		`-`
`137`	`137`	`if (!timeoutSource.TryReset())`
`138`	`138`	`{`
`139`	`139`	`timeoutSource.Dispose();`
`140`	`140`	`timeoutSource = null;`
`141`	`141`	`}`
	`142`	`+`
	`143`	`+ tempBuffer.Dispose();`
`142`	`144`	`}`
`143`		`-`
`144`		`- tempBuffer.AsSpan(0, writtenCount).CopyTo(buffer);`
`145`	`145`	`}`
`146`	`146`
`147`	`147`	`return writtenCount;`
`148`	`148`	`}`
`149`	`149`
`150`		`- private ArraySegment<byte> RentBuffer(int length)`
`151`		`- {`
`152`		`- if (synchronousBuffer is null \|\| synchronousBuffer.Length < length)`
`153`		`- synchronousBuffer = GC.AllocateUninitializedArray<byte>(length);`
`154`		`-`
`155`		`- return new(synchronousBuffer, 0, length);`
`156`		`- }`
`157`		`-`
`158`	`150`	`protected override void Dispose(bool disposing)`
`159`	`151`	`{`
`160`	`152`	`if (disposing)`
Original file line number	Diff line number	Diff line change
`@@ -22,9 +22,9 @@ public static Result<TResult> GetResult<TResult>(this Task<TResult> task, TimeSp`
`22`	`22`	`{`
`23`	`23`	`result = task.Wait(timeout) ? new(task.Result) : new(new TimeoutException());`
`24`	`24`	`}`
`25`		`- catch (AggregateException e) when (e.InnerExceptions.Count == 1)`
	`25`	`+ catch (AggregateException e) when (e.InnerExceptions is [var innerEx])`
`26`	`26`	`{`
`27`		`- result = new(e.InnerExceptions[0]);`
	`27`	`+ result = new(innerEx);`
`28`	`28`	`}`
`29`	`29`	`catch (Exception e)`
`30`	`30`	`{`
`@@ -49,9 +49,9 @@ public static Result<TResult> GetResult<TResult>(this Task<TResult> task, Cancel`
`49`	`49`	`task.Wait(token);`
`50`	`50`	`result = task.Result;`
`51`	`51`	`}`
`52`		`- catch (AggregateException e) when (e.InnerExceptions.Count == 1)`
	`52`	`+ catch (AggregateException e) when (e.InnerExceptions is [var innerEx])`
`53`	`53`	`{`
`54`		`- result = new(e.InnerExceptions[0]);`
	`54`	`+ result = new(innerEx);`
`55`	`55`	`}`
`56`	`56`	`catch (Exception e)`
`57`	`57`	`{`
`@@ -87,9 +87,9 @@ public static Result<TResult> GetResult<TResult>(this Task<TResult> task, Cancel`
`87`	`87`	`var awaiter = new DynamicTaskAwaitable.Awaiter(task, ConfigureAwaitOptions.None);`
`88`	`88`	`result = new(awaiter.GetRawResult());`
`89`	`89`	`}`
`90`		`- catch (AggregateException e) when (e.InnerExceptions.Count is 1)`
	`90`	`+ catch (AggregateException e) when (e.InnerExceptions is [var innerEx])`
`91`	`91`	`{`
`92`		`- result = new(e.InnerExceptions[0]);`
	`92`	`+ result = new(innerEx);`
`93`	`93`	`}`
`94`	`94`	`catch (Exception e)`
`95`	`95`	`{`
`@@ -119,9 +119,9 @@ public static Result<TResult> GetResult<TResult>(this Task<TResult> task, Cancel`
`119`	`119`	`var awaiter = new DynamicTaskAwaitable.Awaiter(task, ConfigureAwaitOptions.None);`
`120`	`120`	`result = new(awaiter.GetRawResult());`
`121`	`121`	`}`
`122`		`- catch (AggregateException e) when (e.InnerExceptions.Count is 1)`
	`122`	`+ catch (AggregateException e) when (e.InnerExceptions is [var innerEx])`
`123`	`123`	`{`
`124`		`- result = new(e.InnerExceptions[0]);`
	`124`	`+ result = new(innerEx);`
`125`	`125`	`}`
`126`	`126`	`catch (Exception e)`
`127`	`127`	`{`