コルーチンの代わりとしての async/await 質問する

Question

更新しました、フォローアップのブログ投稿：C# 8.0 と IAsyncEnumerable を使用した非同期コルーチン。

私はコルーチンの代わりに C# イテレータを使用しており、うまく機能しています。構文がより明確で、型の安全性も得られるため、async/await に切り替えたいと思っています...

私にとって、これは非常に興味深い質問ですが、完全に理解するまでに少し時間がかかりました。おそらく、概念を説明するのに十分なサンプルコードが提供されなかったのでしょう。完全なアプリがあれば役立つので、まずはこのギャップを埋めてみます。次のコードは、私が理解した使用パターンを示しています。間違っていたら訂正してください。

using System;
using System.Collections;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApplication
{
    // https://stackoverflow.com/q/22852251/1768303

    public class Program
    {
        class Resource : IDisposable
        {
            public void Dispose()
            {
                Console.WriteLine("Resource.Dispose");
            }

            ~Resource()
            {
                Console.WriteLine("~Resource");
            }
        }

        private IEnumerator Sleep(int milliseconds)
        {
            using (var resource = new Resource())
            {
                Stopwatch timer = Stopwatch.StartNew();
                do
                {
                    yield return null;
                }
                while (timer.ElapsedMilliseconds < milliseconds);
            }
        }

        void EnumeratorTest()
        {
            var enumerator = Sleep(100);
            enumerator.MoveNext();
            Thread.Sleep(500);
            //while (e.MoveNext());
            ((IDisposable)enumerator).Dispose();
        }

        public static void Main(string[] args)
        {
            new Program().EnumeratorTest();
            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true);
            GC.WaitForPendingFinalizers();
            Console.ReadLine();
        }
    }
}

ここで、Resource.Disposeはのために呼び出されます((IDisposable)enumerator).Dispose()。を呼び出さない場合は、適切なアンワインドのために、コメントを解除してイテレータが正常に終了するようにするenumerator.Dispose()必要があります。//while (e.MoveNext());

さて、これを実装する最良の方法はasync/await、カスタムアウェイター:

using System;
using System.Collections;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApplication
{
    // https://stackoverflow.com/q/22852251/1768303
    public class Program
    {
        class Resource : IDisposable
        {
            public void Dispose()
            {
                Console.WriteLine("Resource.Dispose");
            }

            ~Resource()
            {
                Console.WriteLine("~Resource");
            }
        }

        async Task SleepAsync(int milliseconds, Awaiter awaiter)
        {
            using (var resource = new Resource())
            {
                Stopwatch timer = Stopwatch.StartNew();
                do
                {
                    await awaiter;
                }
                while (timer.ElapsedMilliseconds < milliseconds);
            }
            Console.WriteLine("Exit SleepAsync");
        }

        void AwaiterTest()
        {
            var awaiter = new Awaiter();
            var task = SleepAsync(100, awaiter);
            awaiter.MoveNext();
            Thread.Sleep(500);

            //while (awaiter.MoveNext()) ;
            awaiter.Dispose();
            task.Dispose();
        }

        public static void Main(string[] args)
        {
            new Program().AwaiterTest();
            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true);
            GC.WaitForPendingFinalizers();
            Console.ReadLine();
        }

        // custom awaiter
        public class Awaiter :
            System.Runtime.CompilerServices.INotifyCompletion,
            IDisposable
        {
            Action _continuation;
            readonly CancellationTokenSource _cts = new CancellationTokenSource();

            public Awaiter()
            {
                Console.WriteLine("Awaiter()");
            }

            ~Awaiter()
            {
                Console.WriteLine("~Awaiter()");
            }

            public void Cancel()
            {
                _cts.Cancel();
            }

            // let the client observe cancellation
            public CancellationToken Token { get { return _cts.Token; } }

            // resume after await, called upon external event
            public bool MoveNext()
            {
                if (_continuation == null)
                    return false;

                var continuation = _continuation;
                _continuation = null;
                continuation();
                return _continuation != null;
            }

            // custom Awaiter methods
            public Awaiter GetAwaiter()
            {
                return this;
            }

            public bool IsCompleted
            {
                get { return false; }
            }

            public void GetResult()
            {
                this.Token.ThrowIfCancellationRequested();
            }

            // INotifyCompletion
            public void OnCompleted(Action continuation)
            {
                _continuation = continuation;
            }

            // IDispose
            public void Dispose()
            {
                Console.WriteLine("Awaiter.Dispose()");
                if (_continuation != null)
                {
                    Cancel();
                    MoveNext();
                }
            }
        }
    }
}

アンワインドする時間になったら、内部でキャンセルを要求しAwaiter.Dispose、ステートマシンを次のステップに進めます (保留中の継続がある場合)。これにより、内部でキャンセルが観察されますAwaiter.GetResult(これはコンパイラ生成コードによって呼び出されます)。これにより、ステートメントがスローされTaskCanceledException、さらにアンワインドされますusing。したがって、はResource適切に破棄されます。最後に、タスクはキャンセルされた状態 ( task.IsCancelled == true) に遷移します。

私の意見では、これは現在のスレッドにカスタム同期コンテキストをインストールするよりもシンプルで直接的なアプローチです。マルチスレッドに簡単に適応できます（詳細はここ）。

IEnumeratorこれにより、 / を使用する場合よりも自由度が高くなりますyield。コルーチンロジック内で使用できtry/catch、例外、キャンセル、結果をオブジェクトを介して直接監視できますTask。

更新しましたIDispose、私の知る限り、状態マシンに関しては、イテレータが生成したに類似するものはありませんasync。キャンセル/巻き戻しをしたい場合は、状態マシンを終了させる必要があります。キャンセルを防止するための不注意な使用を考慮したい場合は、の内部( の後)が null でないかどうかを確認し、致命的な例外をスローするのtry/catchが最善だと思います。_continuationAwaiter.CancelMoveNext帯域外(ヘルパーasync voidメソッドを使用)。

Answer 1