Migrated IAsyncCollection and IBatchAsyncCollection to ValueTask

HellBrick · HellBrick · commit 56daefad8037 · 2016-07-24T20:53:18.000+03:00
diff --git a/AsyncCollections.Benchmark/BlockingCollectionAdapter.cs b/AsyncCollections.Benchmark/BlockingCollectionAdapter.cs
@@ -29,10 +29,10 @@ public void Add( T item )
 			_collection.Add( item );
 		}
 
-		public Task<T> TakeAsync( System.Threading.CancellationToken cancellationToken )
+		public ValueTask<T> TakeAsync( System.Threading.CancellationToken cancellationToken )
 		{
 			T item = _collection.Take( cancellationToken );
-			return Task.FromResult( item );
+			return new ValueTask<T>( item );
 		}
 
 		#endregion
diff --git a/AsyncCollections.Benchmark/NitoAsyncCollectionAdapter.cs b/AsyncCollections.Benchmark/NitoAsyncCollectionAdapter.cs
@@ -28,9 +28,9 @@ public void Add( T item )
 			_collection.Add( item );
 		}
 
-		public Task<T> TakeAsync( System.Threading.CancellationToken cancellationToken )
+		public ValueTask<T> TakeAsync( System.Threading.CancellationToken cancellationToken )
 		{
-			return _collection.TakeAsync( cancellationToken );
+			return new ValueTask<T>( _collection.TakeAsync( cancellationToken ) );
 		}
 
 		#endregion
diff --git a/AsyncCollections.Benchmark/TplBatchBlockAdapter.cs b/AsyncCollections.Benchmark/TplBatchBlockAdapter.cs
@@ -23,7 +23,8 @@ public TplBatchBlockAdapter( int batchSize )
 		public int Count => _batchBlock.OutputCount;
 
 		public void Add( T item ) => _batchBlock.Post( item );
-		public async Task<IReadOnlyList<T>> TakeAsync( CancellationToken cancellationToken ) => await _batchBlock.ReceiveAsync( cancellationToken );
+		public ValueTask<IReadOnlyList<T>> TakeAsync( CancellationToken cancellationToken ) => new ValueTask<IReadOnlyList<T>>( RecieveAsync( cancellationToken ) );
+		private async Task<IReadOnlyList<T>> RecieveAsync( CancellationToken cancellationToken ) => await _batchBlock.ReceiveAsync( cancellationToken ).ConfigureAwait( false );
 		public void Flush() => _batchBlock.TriggerBatch();
 
 		public IEnumerator<IReadOnlyList<T>> GetEnumerator()
diff --git a/AsyncCollections.Benchmark/TplDataflowAdapter.cs b/AsyncCollections.Benchmark/TplDataflowAdapter.cs
@@ -21,9 +21,9 @@ public void Add( T item )
 			buffer.Post( item );
 		}
 
-		public Task<T> TakeAsync( CancellationToken cancellationToken )
+		public ValueTask<T> TakeAsync( CancellationToken cancellationToken )
 		{
-			return buffer.ReceiveAsync( cancellationToken );
+			return new ValueTask<T>( buffer.ReceiveAsync( cancellationToken ) );
 		}
 
 		public IEnumerator<T> GetEnumerator()
diff --git a/AsyncCollections.Test/AsyncCollectionTest.cs b/AsyncCollections.Test/AsyncCollectionTest.cs
@@ -49,7 +49,7 @@ public void TakeWithCanceledTokenReturnsCanceledTask()
 			cancelSource.Cancel();
 			Collection.Add( 42 );
 
-			Task<int> itemTask = Collection.TakeAsync( cancelSource.Token );
+			ValueTask<int> itemTask = Collection.TakeAsync( cancelSource.Token );
 			itemTask.IsCanceled.Should().BeTrue( "The task should have been canceled." );
 		}
 
@@ -60,7 +60,7 @@ public void CancelledTakeCancelsTask()
 			var itemTask = Collection.TakeAsync( cancelSource.Token );
 			cancelSource.Cancel();
 
-			Func<Task> asyncAct = () => itemTask;
+			Func<Task> asyncAct = async () => await itemTask;
 			asyncAct.ShouldThrow<TaskCanceledException>();
 
 			Collection.Add( 42 );
diff --git a/AsyncCollections.Test/AsyncQueueTest.cs b/AsyncCollections.Test/AsyncQueueTest.cs
@@ -88,7 +88,7 @@ public void CountsAreCorrectIfTailsMatch()
 		public async Task EverythingWorksIfSegmentIsFilledByOneKindOfItems( Order insertionOrder )
 		{
 			int[] items = Enumerable.Range( 0, _itemsToOverflowSegment ).ToArray();
-			Task<int>[] tasks = null;
+			ValueTask<int>[] tasks = null;
 
 			switch ( insertionOrder )
 			{
@@ -104,7 +104,7 @@ public async Task EverythingWorksIfSegmentIsFilledByOneKindOfItems( Order insert
 			}
 
 			tasks.Should().OnlyContain( t => t.IsCompleted );
-			int[] values = await Task.WhenAll( tasks ).ConfigureAwait( true );
+			int[] values = await Task.WhenAll( tasks.Select( t => t.AsTask() ) ).ConfigureAwait( true );
 			values.Should().BeEquivalentTo( items ).And.BeInAscendingOrder();
 		}
 
@@ -132,7 +132,7 @@ public void EnumeratorDoesNotReturnItemsThatHaveBeenRemovedBetweenMoveNextCalls(
 			}
 		}
 
-		private Task<int>[] InsertAwaiters( int awaiterCount ) => Enumerable.Repeat( 0, awaiterCount ).Select( _ => Collection.TakeAsync() ).ToArray();
+		private ValueTask<int>[] InsertAwaiters( int awaiterCount ) => Enumerable.Repeat( 0, awaiterCount ).Select( _ => Collection.TakeAsync() ).ToArray();
 
 		private void InsertItems( params int[] items )
 		{
diff --git a/AsyncCollections/AsyncBatchQueue.cs b/AsyncCollections/AsyncBatchQueue.cs
@@ -54,12 +54,12 @@ public void Add( T item )
 		/// <summary>
 		/// Removes and returns a batch from the collection in an asynchronous manner.
 		/// </summary>
-		public Task<IReadOnlyList<T>> TakeAsync() => TakeAsync( CancellationToken.None );
+		public ValueTask<IReadOnlyList<T>> TakeAsync() => TakeAsync( CancellationToken.None );
 
 		/// <summary>
 		/// Removes and returns a batch from the collection in an asynchronous manner.
 		/// </summary>
-		public Task<IReadOnlyList<T>> TakeAsync( CancellationToken cancellationToken ) => _batchQueue.TakeAsync( cancellationToken );
+		public ValueTask<IReadOnlyList<T>> TakeAsync( CancellationToken cancellationToken ) => _batchQueue.TakeAsync( cancellationToken );
 
 		/// <summary>
 		/// <para>Forces a new batch to be created and made available for consuming even if amount of the pending items has not reached <see cref="BatchSize"/> yet.</para>
diff --git a/AsyncCollections/AsyncBoundedPriorityQueue.cs b/AsyncCollections/AsyncBoundedPriorityQueue.cs
@@ -80,15 +80,21 @@ public void Add( T item, int priority )
 		/// <summary>
 		/// Removes and returns an item with the highest priority from the collection in an asynchronous manner.
 		/// </summary>
-		public Task<PrioritizedItem<T>> TakeAsync() => TakeAsync( CancellationToken.None );
+		public ValueTask<PrioritizedItem<T>> TakeAsync() => TakeAsync( CancellationToken.None );
 
 		/// <summary>
 		/// Removes and returns an item with the highest priority from the collection in an asynchronous manner.
 		/// </summary>
-		async Task<T> IAsyncCollection<T>.TakeAsync( System.Threading.CancellationToken cancellationToken )
+		ValueTask<T> IAsyncCollection<T>.TakeAsync( System.Threading.CancellationToken cancellationToken )
 		{
-			PrioritizedItem<T> prioritizedItem = await base.TakeAsync( cancellationToken ).ConfigureAwait( false );
-			return prioritizedItem.Item;
+			ValueTask<PrioritizedItem<T>> prioritizedItemTask = TakeAsync( cancellationToken );
+			return prioritizedItemTask.IsCompletedSuccessfully ? new ValueTask<T>( prioritizedItemTask.Result.Item ) : new ValueTask<T>( UnwrapAsync( prioritizedItemTask ) );
+		}
+
+		private async Task<T> UnwrapAsync( ValueTask<PrioritizedItem<T>> prioritizedItemTask )
+		{
+			PrioritizedItem<T> result = await prioritizedItemTask.ConfigureAwait( false );
+			return result.Item;
 		}
 
 		IEnumerator<T> IEnumerable<T>.GetEnumerator() => ( this as IEnumerable<PrioritizedItem<T>> ).Select( prioritizedItem => prioritizedItem.Item ).GetEnumerator();
diff --git a/AsyncCollections/AsyncCollection.cs b/AsyncCollections/AsyncCollection.cs
@@ -85,12 +85,12 @@ private bool TryAdd( T item )
 		/// <summary>
 		/// Removes and returns an item from the collection in an asynchronous manner.
 		/// </summary>
-		public Task<T> TakeAsync( CancellationToken cancellationToken )
+		public ValueTask<T> TakeAsync( CancellationToken cancellationToken )
 			=> cancellationToken.IsCancellationRequested
-			? CanceledTask<T>.Value
+			? CanceledValueTask<T>.Value
 			: TakeAsync( new CompletionSourceAwaiterFactory<T>( cancellationToken ) );
 
-		private Task<T> TakeAsync<TAwaiterFactory>( TAwaiterFactory awaiterFactory ) where TAwaiterFactory : IAwaiterFactory<T>
+		private ValueTask<T> TakeAsync<TAwaiterFactory>( TAwaiterFactory awaiterFactory ) where TAwaiterFactory : IAwaiterFactory<T>
 		{
 			long balanceAfterCurrentAwaiter = Interlocked.Decrement( ref _queueBalance );
 
@@ -111,7 +111,7 @@ private Task<T> TakeAsync<TAwaiterFactory>( TAwaiterFactory awaiterFactory ) whe
 				while ( !_itemQueue.TryTake( out item ) )
 					spin.SpinOnce();
 
-				return Task.FromResult( item );
+				return new ValueTask<T>( item );
 			}
 		}
 
@@ -176,7 +176,7 @@ public static Task<AnyResult<T>> TakeFromAnyAsync( AsyncCollection<T>[] collecti
 			if ( exclusiveSources.IsAwaiterCreated( index ) )
 				return null;
 
-			Task<T> collectionTask = collection.TakeAsync( exclusiveSources.CreateAwaiterFactory( index ) );
+			ValueTask<T> collectionTask = collection.TakeAsync( exclusiveSources.CreateAwaiterFactory( index ) );
 
 			//	One of the collections already had an item and returned it directly
 			if ( collectionTask != null && collectionTask.IsCompleted )
diff --git a/AsyncCollections/AsyncQueue.cs b/AsyncCollections/AsyncQueue.cs
@@ -83,20 +83,20 @@ public void Add( T item )
 				spin.SpinOnce();
 		}
 
-		public Task<T> TakeAsync( CancellationToken cancellationToken )
+		public ValueTask<T> TakeAsync( CancellationToken cancellationToken )
 			=> cancellationToken.IsCancellationRequested
-			? CanceledTask<T>.Value
+			? CanceledValueTask<T>.Value
 			: TakeWithoutValidationAsync( cancellationToken );
 
-		private Task<T> TakeWithoutValidationAsync( CancellationToken cancellationToken )
+		private ValueTask<T> TakeWithoutValidationAsync( CancellationToken cancellationToken )
 		{
 			SpinWait spin = new SpinWait();
 
 			while ( true )
 			{
-				Task<T> result = Volatile.Read( ref _awaiterTail ).TryTakeAsync( cancellationToken );
+				ValueTask<T>? result = Volatile.Read( ref _awaiterTail ).TryTakeAsync( cancellationToken );
 				if ( result != null )
-					return result;
+					return result.Value;
 
 				spin.SpinOnce();
 			}
@@ -260,17 +260,17 @@ private IAwaiter<T> SpinUntilAwaiterIsReady( int slot )
 				}
 			}
 
-			public Task<T> TryTakeAsync( CancellationToken cancellationToken )
+			public ValueTask<T>? TryTakeAsync( CancellationToken cancellationToken )
 				=> TryTakeAsync( cancellationToken, Interlocked.Increment( ref _awaiterIndex ) );
 
-			private Task<T> TryTakeAsync( CancellationToken cancellationToken, int slot )
+			private ValueTask<T>? TryTakeAsync( CancellationToken cancellationToken, int slot )
 				=> slot < SegmentSize
 				? TryTakeWithoutValidationAsync( cancellationToken, slot )
-				: null;
+				: (ValueTask<T>?) null;
 
-			private Task<T> TryTakeWithoutValidationAsync( CancellationToken cancellationToken, int slot )
+			private ValueTask<T> TryTakeWithoutValidationAsync( CancellationToken cancellationToken, int slot )
 			{
-				Task<T> result;
+				ValueTask<T> result;
 
 				/// The order here differs from what <see cref="TryAdd(T)"/> does: we capture the slot *before* inserting an awaiter.
 				/// We do it to avoid allocating an awaiter / registering the cancellation that we're not gonna need in case we lose.
@@ -284,7 +284,7 @@ private Task<T> TryTakeWithoutValidationAsync( CancellationToken cancellationTok
 				}
 				else
 				{
-					result = Task.FromResult( _items[ slot ] );
+					result = new ValueTask<T>( _items[ slot ] );
 					ClearSlot( slot );
 				}
 
diff --git a/AsyncCollections/IAsyncBatchCollection.cs b/AsyncCollections/IAsyncBatchCollection.cs
@@ -11,12 +11,12 @@ public interface IAsyncBatchCollection<T> : IReadOnlyCollection<IReadOnlyList<T>
 
 		void Add( T item );
 		void Flush();
-		Task<IReadOnlyList<T>> TakeAsync( CancellationToken cancellationToken );
+		ValueTask<IReadOnlyList<T>> TakeAsync( CancellationToken cancellationToken );
 	}
 
 	public static class AsyncBatchCollectionExtensions
 	{
-		public static Task<IReadOnlyList<T>> TakeAsync<T>( this IAsyncBatchCollection<T> collection ) => collection.TakeAsync( CancellationToken.None );
+		public static ValueTask<IReadOnlyList<T>> TakeAsync<T>( this IAsyncBatchCollection<T> collection ) => collection.TakeAsync( CancellationToken.None );
 		public static TimerAsyncBatchQueue<T> WithFlushEvery<T>( this IAsyncBatchCollection<T> collection, TimeSpan flushPeriod ) => new TimerAsyncBatchQueue<T>( collection, flushPeriod );
 	}
 }
diff --git a/AsyncCollections/IAsyncCollection.cs b/AsyncCollections/IAsyncCollection.cs
@@ -25,15 +25,15 @@ public interface IAsyncCollection<T> : IReadOnlyCollection<T>
 		/// <summary>
 		/// Removes and returns an item from the collection in an asynchronous manner.
 		/// </summary>
-		Task<T> TakeAsync( CancellationToken cancellationToken );
+		ValueTask<T> TakeAsync( CancellationToken cancellationToken );
 	}
 
 	public static class AsyncCollectionExtensions
 	{
 		/// <summary>
 		/// Removes and returns an item from the collection in an asynchronous manner.
 		/// </summary>
-		public static Task<T> TakeAsync<T>( this IAsyncCollection<T> collection )
+		public static ValueTask<T> TakeAsync<T>( this IAsyncCollection<T> collection )
 		{
 			return collection.TakeAsync( CancellationToken.None );
 		}
diff --git a/AsyncCollections/Internal/CancelledTask.cs b/AsyncCollections/Internal/CancelledTask.cs
@@ -6,6 +6,11 @@
 
 namespace HellBrick.Collections.Internal
 {
+	internal static class CanceledValueTask<T>
+	{
+		public static readonly ValueTask<T> Value = new ValueTask<T>( CanceledTask<T>.Value );
+	}
+
 	internal static class CanceledTask<T>
 	{
 		static CanceledTask()
diff --git a/AsyncCollections/Internal/CompletionSourceAwaiterFactory.cs b/AsyncCollections/Internal/CompletionSourceAwaiterFactory.cs
@@ -29,7 +29,7 @@ private class CompletionSourceAwaiter : IAwaiter<T>
 			public CompletionSourceAwaiter( CancellationToken cancellationToken )
 			{
 				_completionSource = new TaskCompletionSource<T>();
-				Task = _completionSource.Task.WithYield();
+				Task = new ValueTask<T>( _completionSource.Task.WithYield() );
 
 				_registration = cancellationToken.Register(
 					state =>
@@ -47,7 +47,7 @@ public bool TrySetResult( T result )
 				return _completionSource.TrySetResult( result );
 			}
 
-			public Task<T> Task { get; }
+			public ValueTask<T> Task { get; }
 		}
 
 		#region IEquatable<CompletionSourceAwaiterFactory<T>>
diff --git a/AsyncCollections/Internal/ExclusiveCompletionSourceGroup.cs b/AsyncCollections/Internal/ExclusiveCompletionSourceGroup.cs
@@ -90,6 +90,7 @@ public CancellationRegistrationHolder( CancellationTokenRegistration registratio
 
 		private class ExclusiveCompletionSource : IAwaiter<T>
 		{
+			private static readonly ValueTask<T> _neverEndingTask = new ValueTask<T>( new TaskCompletionSource<T>().Task );
 			private readonly ExclusiveCompletionSourceGroup<T> _group;
 			private readonly int _id;
 
@@ -131,7 +132,7 @@ public bool TrySetResult( T result )
 			}
 
 			//	The value will never be actually used.
-			public Task<T> Task => null;
+			public ValueTask<T> Task => _neverEndingTask;
 		}
 
 		public struct Factory : IAwaiterFactory<T>, IEquatable<Factory>
diff --git a/AsyncCollections/Internal/IAwaiter.cs b/AsyncCollections/Internal/IAwaiter.cs
@@ -20,6 +20,6 @@ internal interface IAwaiter<T>
 		/// <summary>
 		/// The task that's completed when the awaiter gets the result.
 		/// </summary>
-		Task<T> Task { get; }
+		ValueTask<T> Task { get; }
 	}
 }
diff --git a/AsyncCollections/TimerAsyncBatchQueue.cs b/AsyncCollections/TimerAsyncBatchQueue.cs
@@ -22,7 +22,7 @@ public TimerAsyncBatchQueue( IAsyncBatchCollection<T> innerCollection, TimeSpan
 		public int BatchSize => _innerCollection.BatchSize;
 		public int Count => _innerCollection.Count;
 		public void Add( T item ) => _innerCollection.Add( item );
-		public Task<IReadOnlyList<T>> TakeAsync( CancellationToken cancellationToken ) => _innerCollection.TakeAsync( cancellationToken );
+		public ValueTask<IReadOnlyList<T>> TakeAsync( CancellationToken cancellationToken ) => _innerCollection.TakeAsync( cancellationToken );
 		public void Flush() => _innerCollection.Flush();
 		public IEnumerator<IReadOnlyList<T>> GetEnumerator() => _innerCollection.GetEnumerator();
 		IEnumerator IEnumerable.GetEnumerator() => ( _innerCollection as IEnumerable ).GetEnumerator();

Original file line number	Diff line number	Diff line change
`@@ -29,10 +29,10 @@ public void Add( T item )`
`29`	`29`	`_collection.Add( item );`
`30`	`30`	`}`
`31`	`31`
`32`		`- public Task<T> TakeAsync( System.Threading.CancellationToken cancellationToken )`
	`32`	`+ public ValueTask<T> TakeAsync( System.Threading.CancellationToken cancellationToken )`
`33`	`33`	`{`
`34`	`34`	`T item = _collection.Take( cancellationToken );`
`35`		`- return Task.FromResult( item );`
	`35`	`+ return new ValueTask<T>( item );`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -28,9 +28,9 @@ public void Add( T item )`
`28`	`28`	`_collection.Add( item );`
`29`	`29`	`}`
`30`	`30`
`31`		`- public Task<T> TakeAsync( System.Threading.CancellationToken cancellationToken )`
	`31`	`+ public ValueTask<T> TakeAsync( System.Threading.CancellationToken cancellationToken )`
`32`	`32`	`{`
`33`		`- return _collection.TakeAsync( cancellationToken );`
	`33`	`+ return new ValueTask<T>( _collection.TakeAsync( cancellationToken ) );`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -21,9 +21,9 @@ public void Add( T item )`
`21`	`21`	`buffer.Post( item );`
`22`	`22`	`}`
`23`	`23`
`24`		`- public Task<T> TakeAsync( CancellationToken cancellationToken )`
	`24`	`+ public ValueTask<T> TakeAsync( CancellationToken cancellationToken )`
`25`	`25`	`{`
`26`		`- return buffer.ReceiveAsync( cancellationToken );`
	`26`	`+ return new ValueTask<T>( buffer.ReceiveAsync( cancellationToken ) );`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`public IEnumerator<T> GetEnumerator()`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ public void CountsAreCorrectIfTailsMatch()`
`88`	`88`	`public async Task EverythingWorksIfSegmentIsFilledByOneKindOfItems( Order insertionOrder )`
`89`	`89`	`{`
`90`	`90`	`int[] items = Enumerable.Range( 0, _itemsToOverflowSegment ).ToArray();`
`91`		`- Task<int>[] tasks = null;`
	`91`	`+ ValueTask<int>[] tasks = null;`
`92`	`92`
`93`	`93`	`switch ( insertionOrder )`
`94`	`94`	`{`
`@@ -104,7 +104,7 @@ public async Task EverythingWorksIfSegmentIsFilledByOneKindOfItems( Order insert`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`tasks.Should().OnlyContain( t => t.IsCompleted );`
`107`		`- int[] values = await Task.WhenAll( tasks ).ConfigureAwait( true );`
	`107`	`+ int[] values = await Task.WhenAll( tasks.Select( t => t.AsTask() ) ).ConfigureAwait( true );`
`108`	`108`	`values.Should().BeEquivalentTo( items ).And.BeInAscendingOrder();`
`109`	`109`	`}`
`110`	`110`
`@@ -132,7 +132,7 @@ public void EnumeratorDoesNotReturnItemsThatHaveBeenRemovedBetweenMoveNextCalls(`
`132`	`132`	`}`
`133`	`133`	`}`
`134`	`134`
`135`		`- private Task<int>[] InsertAwaiters( int awaiterCount ) => Enumerable.Repeat( 0, awaiterCount ).Select( _ => Collection.TakeAsync() ).ToArray();`
	`135`	`+ private ValueTask<int>[] InsertAwaiters( int awaiterCount ) => Enumerable.Repeat( 0, awaiterCount ).Select( _ => Collection.TakeAsync() ).ToArray();`
`136`	`136`
`137`	`137`	`private void InsertItems( params int[] items )`
`138`	`138`	`{`
Original file line number	Diff line number	Diff line change
`@@ -83,20 +83,20 @@ public void Add( T item )`
`83`	`83`	`spin.SpinOnce();`
`84`	`84`	`}`
`85`	`85`
`86`		`- public Task<T> TakeAsync( CancellationToken cancellationToken )`
	`86`	`+ public ValueTask<T> TakeAsync( CancellationToken cancellationToken )`
`87`	`87`	`=> cancellationToken.IsCancellationRequested`
`88`		`- ? CanceledTask<T>.Value`
	`88`	`+ ? CanceledValueTask<T>.Value`
`89`	`89`	`: TakeWithoutValidationAsync( cancellationToken );`
`90`	`90`
`91`		`- private Task<T> TakeWithoutValidationAsync( CancellationToken cancellationToken )`
	`91`	`+ private ValueTask<T> TakeWithoutValidationAsync( CancellationToken cancellationToken )`
`92`	`92`	`{`
`93`	`93`	`SpinWait spin = new SpinWait();`
`94`	`94`
`95`	`95`	`while ( true )`
`96`	`96`	`{`
`97`		`- Task<T> result = Volatile.Read( ref _awaiterTail ).TryTakeAsync( cancellationToken );`
	`97`	`+ ValueTask<T>? result = Volatile.Read( ref _awaiterTail ).TryTakeAsync( cancellationToken );`
`98`	`98`	`if ( result != null )`
`99`		`- return result;`
	`99`	`+ return result.Value;`
`100`	`100`
`101`	`101`	`spin.SpinOnce();`
`102`	`102`	`}`
`@@ -260,17 +260,17 @@ private IAwaiter<T> SpinUntilAwaiterIsReady( int slot )`
`260`	`260`	`}`
`261`	`261`	`}`
`262`	`262`
`263`		`- public Task<T> TryTakeAsync( CancellationToken cancellationToken )`
	`263`	`+ public ValueTask<T>? TryTakeAsync( CancellationToken cancellationToken )`
`264`	`264`	`=> TryTakeAsync( cancellationToken, Interlocked.Increment( ref _awaiterIndex ) );`
`265`	`265`
`266`		`- private Task<T> TryTakeAsync( CancellationToken cancellationToken, int slot )`
	`266`	`+ private ValueTask<T>? TryTakeAsync( CancellationToken cancellationToken, int slot )`
`267`	`267`	`=> slot < SegmentSize`
`268`	`268`	`? TryTakeWithoutValidationAsync( cancellationToken, slot )`
`269`		`- : null;`
	`269`	`+ : (ValueTask<T>?) null;`
`270`	`270`
`271`		`- private Task<T> TryTakeWithoutValidationAsync( CancellationToken cancellationToken, int slot )`
	`271`	`+ private ValueTask<T> TryTakeWithoutValidationAsync( CancellationToken cancellationToken, int slot )`
`272`	`272`	`{`
`273`		`- Task<T> result;`
	`273`	`+ ValueTask<T> result;`
`274`	`274`
`275`	`275`	`/// The order here differs from what <see cref="TryAdd(T)"/> does: we capture the slot before inserting an awaiter.`
`276`	`276`	`/// We do it to avoid allocating an awaiter / registering the cancellation that we're not gonna need in case we lose.`
`@@ -284,7 +284,7 @@ private Task<T> TryTakeWithoutValidationAsync( CancellationToken cancellationTok`
`284`	`284`	`}`
`285`	`285`	`else`
`286`	`286`	`{`
`287`		`- result = Task.FromResult( _items[ slot ] );`
	`287`	`+ result = new ValueTask<T>( _items[ slot ] );`
`288`	`288`	`ClearSlot( slot );`
`289`	`289`	`}`
`290`	`290`
Original file line number	Diff line number	Diff line change
`@@ -11,12 +11,12 @@ public interface IAsyncBatchCollection<T> : IReadOnlyCollection<IReadOnlyList<T>`
`11`	`11`
`12`	`12`	`void Add( T item );`
`13`	`13`	`void Flush();`
`14`		`- Task<IReadOnlyList<T>> TakeAsync( CancellationToken cancellationToken );`
	`14`	`+ ValueTask<IReadOnlyList<T>> TakeAsync( CancellationToken cancellationToken );`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`public static class AsyncBatchCollectionExtensions`
`18`	`18`	`{`
`19`		`- public static Task<IReadOnlyList<T>> TakeAsync<T>( this IAsyncBatchCollection<T> collection ) => collection.TakeAsync( CancellationToken.None );`
	`19`	`+ public static ValueTask<IReadOnlyList<T>> TakeAsync<T>( this IAsyncBatchCollection<T> collection ) => collection.TakeAsync( CancellationToken.None );`
`20`	`20`	`public static TimerAsyncBatchQueue<T> WithFlushEvery<T>( this IAsyncBatchCollection<T> collection, TimeSpan flushPeriod ) => new TimerAsyncBatchQueue<T>( collection, flushPeriod );`
`21`	`21`	`}`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,15 +25,15 @@ public interface IAsyncCollection<T> : IReadOnlyCollection<T>`
`25`	`25`	`/// <summary>`
`26`	`26`	`/// Removes and returns an item from the collection in an asynchronous manner.`
`27`	`27`	`/// </summary>`
`28`		`- Task<T> TakeAsync( CancellationToken cancellationToken );`
	`28`	`+ ValueTask<T> TakeAsync( CancellationToken cancellationToken );`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`public static class AsyncCollectionExtensions`
`32`	`32`	`{`
`33`	`33`	`/// <summary>`
`34`	`34`	`/// Removes and returns an item from the collection in an asynchronous manner.`
`35`	`35`	`/// </summary>`
`36`		`- public static Task<T> TakeAsync<T>( this IAsyncCollection<T> collection )`
	`36`	`+ public static ValueTask<T> TakeAsync<T>( this IAsyncCollection<T> collection )`
`37`	`37`	`{`
`38`	`38`	`return collection.TakeAsync( CancellationToken.None );`
`39`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,11 @@`
`6`	`6`
`7`	`7`	`namespace HellBrick.Collections.Internal`
`8`	`8`	`{`
	`9`	`+ internal static class CanceledValueTask<T>`
	`10`	`+ {`
	`11`	`+ public static readonly ValueTask<T> Value = new ValueTask<T>( CanceledTask<T>.Value );`
	`12`	`+ }`
	`13`	`+`
`9`	`14`	`internal static class CanceledTask<T>`
`10`	`15`	`{`
`11`	`16`	`static CanceledTask()`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ private class CompletionSourceAwaiter : IAwaiter<T>`
`29`	`29`	`public CompletionSourceAwaiter( CancellationToken cancellationToken )`
`30`	`30`	`{`
`31`	`31`	`_completionSource = new TaskCompletionSource<T>();`
`32`		`- Task = _completionSource.Task.WithYield();`
	`32`	`+ Task = new ValueTask<T>( _completionSource.Task.WithYield() );`
`33`	`33`
`34`	`34`	`_registration = cancellationToken.Register(`
`35`	`35`	`state =>`
`@@ -47,7 +47,7 @@ public bool TrySetResult( T result )`
`47`	`47`	`return _completionSource.TrySetResult( result );`
`48`	`48`	`}`
`49`	`49`
`50`		`- public Task<T> Task { get; }`
	`50`	`+ public ValueTask<T> Task { get; }`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`#region IEquatable<CompletionSourceAwaiterFactory<T>>`
Original file line number	Diff line number	Diff line change
`@@ -90,6 +90,7 @@ public CancellationRegistrationHolder( CancellationTokenRegistration registratio`
`90`	`90`
`91`	`91`	`private class ExclusiveCompletionSource : IAwaiter<T>`
`92`	`92`	`{`
	`93`	`+ private static readonly ValueTask<T> _neverEndingTask = new ValueTask<T>( new TaskCompletionSource<T>().Task );`
`93`	`94`	`private readonly ExclusiveCompletionSourceGroup<T> _group;`
`94`	`95`	`private readonly int _id;`
`95`	`96`
`@@ -131,7 +132,7 @@ public bool TrySetResult( T result )`
`131`	`132`	`}`
`132`	`133`
`133`	`134`	`// The value will never be actually used.`
`134`		`- public Task<T> Task => null;`
	`135`	`+ public ValueTask<T> Task => _neverEndingTask;`
`135`	`136`	`}`
`136`	`137`
`137`	`138`	`public struct Factory : IAwaiterFactory<T>, IEquatable<Factory>`