From f154e3624f9a3a452438755f876990eeb649d7af Mon Sep 17 00:00:00 2001
From: forest93 <forest93@163.com>
Date: Sat, 14 Oct 2017 20:44:24 +0800
Subject: [PATCH] AsyncEnumerableBuffer throws ObjectDisposedException for
 access after disposal. Add docs.

---
 .../AsyncEnumerableExtensions.csproj          |  3 +-
 .../AsyncEnumerableFactory.cs                 | 30 +++++++++++++++++++
 .../IAsyncEnumerableSink.cs                   |  2 +-
 .../TaskAsyncEnumerable.cs                    | 18 +++++------
 4 files changed, 41 insertions(+), 12 deletions(-)

diff --git a/AsyncEnumerableExtensions/AsyncEnumerableExtensions.csproj b/AsyncEnumerableExtensions/AsyncEnumerableExtensions.csproj
index 7b87dd1..2550971 100644
--- a/AsyncEnumerableExtensions/AsyncEnumerableExtensions.csproj
+++ b/AsyncEnumerableExtensions/AsyncEnumerableExtensions.csproj
@@ -4,7 +4,7 @@
     <TargetFramework>netstandard1.1</TargetFramework>
     <PackageId>CXuesong.AsyncEnumerableExtensions</PackageId>
     <Authors>CXuesong</Authors>
-    <Version>0.1.3</Version>
+    <Version>0.1.4</Version>
     <Description>Some rudimentary utilities to flavor Ix.Async. Such as asynchronous generator methods.</Description>
     <RepositoryUrl>https://github.com/CXuesong/AsyncEnumerableExtensions</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
@@ -12,6 +12,7 @@
     <PackageLicenseUrl>https://github.com/CXuesong/AsyncEnumerableExtensions/blob/master/LICENSE.txt</PackageLicenseUrl>
     <PackageProjectUrl>https://github.com/CXuesong/AsyncEnumerableExtensions</PackageProjectUrl>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+    <GenerateDocumentationFile>True</GenerateDocumentationFile>
     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>../AsyncEnumerableExtensions.snk</AssemblyOriginatorKeyFile>
   </PropertyGroup>
diff --git a/AsyncEnumerableExtensions/AsyncEnumerableFactory.cs b/AsyncEnumerableExtensions/AsyncEnumerableFactory.cs
index 6b6d101..0c4585b 100644
--- a/AsyncEnumerableExtensions/AsyncEnumerableFactory.cs
+++ b/AsyncEnumerableExtensions/AsyncEnumerableFactory.cs
@@ -12,13 +12,43 @@ namespace AsyncEnumerableExtensions
     public static class AsyncEnumerableFactory
     {
 
+        /// <summary>
+        /// Creates an instance of <see cref="IAsyncEnumerable{T}"/> from an asynchronous generator method.
+        /// </summary>
+        /// <typeparam name="T">Type of the items.</typeparam>
+        /// <param name="generator">Generator method.</param>
+        /// <returns>The encapsulated <see cref="IAsyncEnumerable{T}"/>.</returns>
+        /// <remarks>
+        /// <para>The <paramref name="generator"/> parameter should use <see cref="IAsyncEnumerableSink{T}"/>
+        /// passed in to yield the items.</para>
+        /// <para>In this overload, the asynchronous generator accepts a <see cref="CancellationToken"/>
+        /// which is cancelled when the <see cref="IAsyncEnumerator{T}"/> is disposed.</para>
+        /// </remarks>
+        /// <see cref="IAsyncEnumerableSink{T}.Yield(T)"/>
+        /// <see cref="IAsyncEnumerableSink{T}.Wait"/>
+        /// <see cref="AsyncEnumerableSinkExtensions.YieldAndWait{T}(IAsyncEnumerableSink{T},T)"/>
         public static IAsyncEnumerable<T> FromAsyncGenerator<T>(Func<IAsyncEnumerableSink<T>, CancellationToken, Task> generator)
         {
+            if (generator == null) throw new ArgumentNullException(nameof(generator));
             return new TaskAsyncEnumerable<T>(generator);
         }
 
+        /// <summary>
+        /// Creates an instance of <see cref="IAsyncEnumerable{T}"/> from an asynchronous generator method.
+        /// </summary>
+        /// <typeparam name="T">Type of the items.</typeparam>
+        /// <param name="generator">Generator method.</param>
+        /// <returns>The encapsulated <see cref="IAsyncEnumerable{T}"/>.</returns>
+        /// <remarks>
+        /// <para>The <paramref name="generator"/> parameter should use <see cref="IAsyncEnumerableSink{T}"/>
+        /// passed in to yield the items. </para>
+        /// </remarks>
+        /// <see cref="IAsyncEnumerableSink{T}.Yield(T)"/>
+        /// <see cref="IAsyncEnumerableSink{T}.Wait"/>
+        /// <see cref="AsyncEnumerableSinkExtensions.YieldAndWait{T}(IAsyncEnumerableSink{T},T)"/>
         public static IAsyncEnumerable<T> FromAsyncGenerator<T>(Func<IAsyncEnumerableSink<T>, Task> generator)
         {
+            if (generator == null) throw new ArgumentNullException(nameof(generator));
             return new TaskAsyncEnumerable<T>(generator);
         }
 
diff --git a/AsyncEnumerableExtensions/IAsyncEnumerableSink.cs b/AsyncEnumerableExtensions/IAsyncEnumerableSink.cs
index a8961be..ef7ba87 100644
--- a/AsyncEnumerableExtensions/IAsyncEnumerableSink.cs
+++ b/AsyncEnumerableExtensions/IAsyncEnumerableSink.cs
@@ -32,7 +32,7 @@ public interface IAsyncEnumerableSink<in T>
         /// <param name="cancellationToken">The token used to cancel waiting.</param>
         /// <returns>A task that completes when the yielded item has been consumed.</returns>
         /// <exception cref="OperationCanceledException">The wait operation has been cancelled.</exception>
-        /// <exception cref="ObjectDisposedException">The sink does not accepts items anymore.</exception>
+        /// <exception cref="ObjectDisposedException">The sink does not accept items anymore.</exception>
         Task Wait(CancellationToken cancellationToken);
     }
 
diff --git a/AsyncEnumerableExtensions/TaskAsyncEnumerable.cs b/AsyncEnumerableExtensions/TaskAsyncEnumerable.cs
index 42455d0..7f6ebc3 100644
--- a/AsyncEnumerableExtensions/TaskAsyncEnumerable.cs
+++ b/AsyncEnumerableExtensions/TaskAsyncEnumerable.cs
@@ -8,29 +8,26 @@
 
 namespace AsyncEnumerableExtensions
 {
-    public class TaskAsyncEnumerable<T> : IAsyncEnumerable<T>
+    internal class TaskAsyncEnumerable<T> : IAsyncEnumerable<T>
     {
 
         private readonly Func<IAsyncEnumerableSink<T>, CancellationToken, Task> generator;
-        private readonly bool acceptsCancellationToken;
 
         public TaskAsyncEnumerable(Func<IAsyncEnumerableSink<T>, Task> sourceTask)
         {
             if (sourceTask == null) throw new ArgumentNullException(nameof(sourceTask));
             generator = (sink, ct) => sourceTask(sink);
-            acceptsCancellationToken = false;
         }
 
         public TaskAsyncEnumerable(Func<IAsyncEnumerableSink<T>, CancellationToken, Task> sourceTask)
         {
             this.generator = sourceTask ?? throw new ArgumentNullException(nameof(sourceTask));
-            acceptsCancellationToken = true;
         }
 
         /// <inheritdoc />
         public IAsyncEnumerator<T> GetEnumerator()
         {
-            return new Enumerator(generator, acceptsCancellationToken);
+            return new Enumerator(generator);
         }
 
         private class Enumerator : IAsyncEnumerator<T>
@@ -43,7 +40,7 @@ private class Enumerator : IAsyncEnumerator<T>
             private CancellationToken lastMoveNextCancellationToken = CancellationToken.None;
             private CancellationTokenSource lastCombinedCancellationTokenSource;
 
-            public Enumerator(Func<IAsyncEnumerableSink<T>, CancellationToken, Task> generator, bool acceptsCancellationToken)
+            public Enumerator(Func<IAsyncEnumerableSink<T>, CancellationToken, Task> generator)
             {
                 Debug.Assert(generator != null);
                 this.generator = generator;
@@ -188,10 +185,11 @@ public bool Yield(IEnumerable<T> items)
 
         public Task Wait(CancellationToken cancellationToken)
         {
-            cancellationToken.ThrowIfCancellationRequested();
+            if (cancellationToken.IsCancellationRequested)
+                return Task.Delay(-1, cancellationToken);
             lock (syncLock)
             {
-                if (queue == null) throw new ObjectDisposedException(nameof(AsyncEnumerableBuffer<T>));
+                if (queue == null) return ObjectDisposedTask;
                 if (queue.Count == 0) return CompletedTask;
                 if (onQueueExhaustedTcs == null)
                 {
@@ -249,8 +247,8 @@ internal void Terminate()
         {
             lock (syncLock)
             {
-                onQueueExhaustedTcs?.TrySetCanceled();
-                onYieldTcs?.TrySetCanceled();
+                onQueueExhaustedTcs?.TrySetException(new ObjectDisposedException(nameof(AsyncEnumerableBuffer<T>)));
+                onYieldTcs?.TrySetException(new ObjectDisposedException(nameof(AsyncEnumerableBuffer<T>)));
                 onQueueExhaustedTcs = null;
                 onYieldTcs = null;
                 queue = null;