【C#】非同期処理とasync/await

// Aが終わったらB、Bが終わったらCというように順番に実行される
// 言い換えると、Aの処理が完了するまでBが実行されることはない
ExecuteA();
ExecuteB();
ExecuteC();

// Task.Runを用いてスレッドプール上で処理を実行する
// 同期処理とは異なり、A、B、Cの完了を待たずに処理を続行する
Task.Run(() => ExecuteA());
Task.Run(() => ExecuteB());
Task.Run(() => ExecuteC());

// いわゆるコールバック地獄
FooAsync(x =>
{
    BarAsync(x, y =>
    {
        BazAsync(y, z =>
        {
            // 内部で例外が発生しても外側には伝搬されない
            throw new Exception("Error!");
        });
    });
});

// asyncキーワードをつけ、戻り値をTask<int>に
// C#において非同期メソッドは**Asyncのような命名が用いられる
async Task<int> FooAsync(int x)
{
    // 非同期メソッドをawaitで待機
    int y = await BarAsync(x);
    int z = await BazAsync(y);

    // 普通にreturnで値を返せる
    return x + y + z;
}

// 戻り値が不要(void)の場合は非ジェネリックなTaskを使用する
async Task QuxAsync()
{
   ...
}

// 同期処理と同じようにtry-catch-finallyが使える
try
{
    return await FooAsync(10);
}
catch (Exception ex)
{
    ...
}
finally
{
    ...
}

var taskA = FooAsync();
var taskB = BarAsync();
var taskC = BazAsync();

// 全てのタスクが完了するまで待機する
await Task.WhenAll(taskA, taskB, taskC);

// いずれかのタスクが完了するまで待機する
await Task.WhenAny(taskA, taskB, taskC);

// IEnumeratorを戻り値に持つ
IEnumerator FooCoroutine()
{
    // 次のフレームまで待機
    yield return null;

    // 1秒間待機
    yield return new WaitForSeconds(1f);
}

// StartCoroutineでコルーチンを起動
StartCoroutine(FooCoroutine());

// 引数の最後でCancellationTokenを渡す
async Task FooAsync(int a, int b, CancellationToken cancellationToken)
{
   ...
}

// CancellationTokenSourceを作成
var cts = new CancellationTokenSource();

// 作成したCancellationTokenSourceからCancelllationTokenを取得して渡す
await FooAsync(1, 2, cts.Token);

// キャンセル時にはCancelを呼ぶ
cts.Cancel();

// CancelAfterで一定時間後にキャンセルすることも可能
// cts.CancelAfter(1000);

// 使用後はDisposeを呼ぶ
cts.Dispose();

var cts1 = new CancellationTokenSource();
var cts2 = new CancellationTokenSource();

// 2つのCancellationTokenを合成したCancellationTokenSourceを作る
var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cts1.Token, cts2.Token);

// 2つのうち1つのTokenをキャンセルする
cts1.Cancel();

// 作成したCancellationTokenSourceもキャンセルされる (trueが表示される)
Console.WriteLine(linkedCts.IsCancellationRequested);

try
{
   // awaitで非同期メソッドを待機
   await FooAsync(cancellationToken);
}
catch (OperationCanceledException ex) // キャンセル時にOperationCanceledExceptionがthrowされる
{
   // ここでキャンセル時の処理を行う
   ...
}

try
{
   await FooAsync(cancellationToken);
}
// OperationCanceledExceptionは既知の例外としてスルー
catch (Exception ex) when (!(ex is OperationCanceledException))
{
    Console.WriteLine(ex);
}

async Task FooAsync(CancellationToken cancellationToken)
{
    await BarAsync();

    // ここでキャンセル状態になっていたらOperationCanceledExceptionをthrow
    cancellationToken.ThrowIfCancellationRequested();
    
    await BazAsync();
}

// SynchronizationContext.Currentがnullの場合、await後のスレッドは同じにはならない

Console.WriteLine(Thread.CurrentThread.ManagedThreadId); // 1
await Task.Run(() => { });
Console.WriteLine(Thread.CurrentThread.ManagedThreadId); // 4

// メインスレッド
Debug.Log(Thread.CurrentThread.ManagedThreadId);
        
await Task.Run(() =>
{
    // ここは別スレッドで実行される
    Debug.Log(Thread.CurrentThread.ManagedThreadId);
});
        
// await後はメインスレッドに戻ってくる
Debug.Log(Thread.CurrentThread.ManagedThreadId);

// SynchronizationContextをキャプチャしない
await Task.Run(() => { ... }).ConfigureAwait(false);
        
// await後も元のスレッドには戻ってこない
...

// 同期的に待機
FooAsync().Wait();

// 同期的に待機し結果を取得
var result = BarAsync().Result;

FooAsync().Wait();
BarAsync().Wait();

async Task FooAsync()
{
    await Task.Run(() => { ... });
    // await後に元のスレッドに戻る場合、Waitでブロックされているためデッドロックが発生
}

async Task BarAsync()
{
    await Task.Run(() => { ... }).ConfigureAwait(false);
    // await後に元のスレッドに戻らないため、デッドロックは起こらない
}

// 新たなTaskCompletionSourceを作成
var tcs = new TaskCompletionSource<int>();

// Taskを待機
await tcs.Task;

// 任意のタイミングでSetResultを呼ぶことで、結果を設定しTaskを完了させる
tcs.SetResult(10);

// キャンセルや失敗の場合は以下を呼び出す
tcs.SetCanceled(cancellationToken);
tcs.SetException(ex);

// コールバックで完了を通知するメソッドがあったとする
void Foo(Action<FooResult> callback) { ... } 

// TaskCompletionSourceを作成
var tcs = new TaskCompletionSource<FooResult>();

// コールバック内でSetResultを呼びTaskを完了させる
Foo(result =>
{
   tcs.SetResult(result);
})

// awaitで待機
await tcs.Task;

// 戻り値は必ずTask/Task<T>
async Task<int> FooAsync(CancellationToken cancellationToken = default)
{
   var x = await BarAsync(cancellationToken);
   var y = await BazAsync(cancellationToken);
   return x + y;
}

static async ValueTask<bool> FooAsync(float x)
{
    if (x == 0f)
    {
        // ここは非同期処理であるためTaskが必要
        await Task.Delay(100);
        return true;
    }

    // ここを通過する場合、一度もawaitを行わない(同期処理である)ためTaskは不要
    // そのためTaskのインスタンスは生成されない
    return false;
}

public interface IValueTaskSource
{
    ValueTaskSourceStatus GetStatus(short token);
    void OnCompleted(Action<object?> continuation, object? state, short token, ValueTaskSourceOnCompletedFlags flags);
    void GetResult(short token);
}

public interface IValueTaskSource<out TResult>
{
    ValueTaskSourceStatus GetStatus(short token);
    void OnCompleted(Action<object?> continuation, object? state, short token, ValueTaskSourceOnCompletedFlags flags);
    TResult GetResult(short token);
}

class ExampleValueTaskSource<T> : IValueTaskSource<T>, IValueTaskSource
{
    // プーリングの処理はメインではないため適当、実際は安全性チェックなどを入れたほうが良さげ
    static ObjectPool<ExampleValueTaskSource<T>> pool = new();

    // mutable structであるためreadonlyでマークしてはいけない
    ManualResetValueTaskSourceCore<T> core;

    // あとはManualResetValueTaskSourceCoreに処理を委譲するだけでOK

    public bool RunContinuationsAsynchronously
    {
        get => core.RunContinuationsAsynchronously;
        set => core.RunContinuationsAsynchronously = value;
    }
    public short Version => core.Version;
    public void Reset() => core.Reset();
    public void SetResult(T result) => core.SetResult(result);
    public void SetException(Exception error) => core.SetException(error);

    public T GetResult(short token)
    {
        try
        {
            return core.GetResult(token);
        }
        finally
        {
            // GetResultでプールにインスタンスを返却する
            pool.Return(this);
        }
    }
    
    void IValueTaskSource.GetResult(short token)
    {
        try
        {
            core.GetResult(token);
        }
        finally
        {
            pool.Return(this);
        }
    }

    public ValueTaskSourceStatus GetStatus(short token) => core.GetStatus(token);
    public void OnCompleted(Action<object?> continuation, object? state, short token, ValueTaskSourceOnCompletedFlags flags) => core.OnCompleted(continuation, state, token, flags);
}

public interface IAsyncEnumerable<out T>
{
    IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = default);
}
 
public interface IAsyncEnumerator<out T> : IAsyncDisposable
{
    T Current { get; }
    ValueTask<bool> MoveNextAsync();
}
 
public interface IAsyncDisposable
{
    ValueTask DisposeAsync();
}

async Task AwaitForeach<T>(IAsyncEnumerable<T> items)
{
    await foreach (var item in items)
    {
        Console.WriteLine(item);
    }
}

IAsyncDisposable asyncDisposable;

// usingの非同期版、スコープを抜けた時点でリソースを破棄する
await using (asyncDisposable)
{
    ...
}

// 非同期using変数宣言も利用可能
await using var x = new AsyncDisposable();

// awaitとyield returnを併用可能に
async IAsyncEnumerable<int> AsyncIterator(int count)
{
    for (int i = 0; i < count; i++)
    {
        yield return i;
        await Task.Delay(TimeSpan.FromSeconds(1));
    }
}

// 1秒毎に整数値が流れてくる
await foreach (var i in AsyncIterator(10))
{
    Console.WriteLine(i);
}

using System.Runtime.CompilerServices;

async IAsyncEnumerable<int> AsyncIterator(int count, [EnumeratorCancellation] CancellationToken cancellationToken)
{
    for (int i = 0; i < count; i++)
    {
        yield return i;
        await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken);
    }
}

static class Foo
{
    public static async Task FooAsync()
    {
        await Task.Delay(TimeSpan.FromSeconds(1));
        Console.WriteLine("Hello!");
    }
}

internal static class Foo
{
    [StructLayout(LayoutKind.Auto)]
    [CompilerGenerated]
    private struct <FooAsync>d__0 : IAsyncStateMachine
    {
        public int <>1__state;

        public AsyncTaskMethodBuilder <>t__builder;

        private TaskAwaiter <>u__1;

        private void MoveNext()
        {
            int num = <>1__state;
            try
            {
                TaskAwaiter awaiter;
                if (num != 0)
                {
                    awaiter = Task.Delay(TimeSpan.FromSeconds(1.0)).GetAwaiter();
                    if (!awaiter.IsCompleted)
                    {
                        num = (<>1__state = 0);
                        <>u__1 = awaiter;
                        <>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
                        return;
                    }
                }
                else
                {
                    awaiter = <>u__1;
                    <>u__1 = default(TaskAwaiter);
                    num = (<>1__state = -1);
                }
                awaiter.GetResult();
                Console.WriteLine("Hello!");
            }
            catch (Exception exception)
            {
                <>1__state = -2;
                <>t__builder.SetException(exception);
                return;
            }
            
            <>1__state = -2;
            <>t__builder.SetResult();
        }

        void IAsyncStateMachine.MoveNext()
        {
            //ILSpy generated this explicit interface implementation from .override directive in MoveNext
            this.MoveNext();
        }

        [DebuggerHidden]
        private void SetStateMachine([Nullable(1)] IAsyncStateMachine stateMachine)
        {
            <>t__builder.SetStateMachine(stateMachine);
        }

        void IAsyncStateMachine.SetStateMachine([Nullable(1)] IAsyncStateMachine stateMachine)
        {
            //ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
            this.SetStateMachine(stateMachine);
        }
    }

    [NullableContext(1)]
    [AsyncStateMachine(typeof(<FooAsync>d__0))]
    public static Task FooAsync()
    {
        <FooAsync>d__0 stateMachine = default(<FooAsync>d__0);
        stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
        stateMachine.<>1__state = -1;
        stateMachine.<>t__builder.Start(ref stateMachine);
        return stateMachine.<>t__builder.Task;
    }
}

// コンパイラはasyncメソッドを駆動するためのステートマシンを生成する
// ステートマシンはDebugビルドではclass, Releaseビルドではstructになる
[StructLayout(LayoutKind.Auto)]
[CompilerGenerated]
private struct <FooAsync>d__0 : IAsyncStateMachine
{
    ...
}

private void MoveNext()
{
    int num = <>1__state;
    try
    {
        TaskAwaiter awaiter;
        if (num != 0)
        {
            // await Task.Delay(TimeSpan.FromSeconds(1));
            // GetAwaiterでAwaiterを取得する
            awaiter = Task.Delay(TimeSpan.FromSeconds(1.0)).GetAwaiter();

            // Awaiterが完了していない場合は次のMoveNextをUnsafeOnCompletedにセット
            if (!awaiter.IsCompleted)
            {
                num = (<>1__state = 0);
                <>u__1 = awaiter;
                <>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
                return;
            }
        }
        else
        {
            awaiter = <>u__1;
            <>u__1 = default(TaskAwaiter);
            num = (<>1__state = -1);
        }

        // 既に完了している場合はそのままGetResultを呼ぶ
        awaiter.GetResult();

        Console.WriteLine("Hello!");
    }
    catch (Exception exception)
    {
        // 例外は失敗扱い、SetExceptionを呼ぶ
        <>1__state = -2;
        <>t__builder.SetException(exception);
        return;
    }
    
    // 完了した場合はSetResultを呼ぶ
    <>1__state = -2;
    <>t__builder.SetResult();
}

[AsyncStateMachine(typeof(<FooAsync>d__0))]
public static Task FooAsync()
{
    // ステートマシンを初期化する
    <FooAsync>d__0 stateMachine = default(<FooAsync>d__0);

    // AsyncMethodBuilderを設定 (Task型ではAsyncTaskMethodBuilderが使用される)
    stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();

    // 開始時のstateを-1に設定
    stateMachine.<>1__state = -1;

    // ステートマシンを開始する
    stateMachine.<>t__builder.Start(ref stateMachine);

    // Taskを返す
    return stateMachine.<>t__builder.Task;
}

namespace System.Runtime.CompilerServices;

public struct AsyncTaskMethodBuilder<TResult>
{
    public static AsyncTaskMethodBuilder<TResult> Create() => default;

    public Task<TResult> Task
    {
        get { ... }
    }

    [DebuggerStepThrough]
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
    {
        ...
    }

    public void SetStateMachine(IAsyncStateMachine stateMachine) { ... }

    public void AwaitOnCompleted<TAwaiter, TStateMachine>(
        ref TAwaiter awaiter, ref TStateMachine stateMachine)
        where TAwaiter : INotifyCompletion
        where TStateMachine : IAsyncStateMachine
    {
        ...
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(
        ref TAwaiter awaiter, ref TStateMachine stateMachine)
        where TAwaiter : ICriticalNotifyCompletion
        where TStateMachine : IAsyncStateMachine
    {
        ...
    }

    public void SetResult(TResult result) { ... }

    public void SetException(Exception exception) { ... }
}

// 適当なawaitさせたい型
class FooAwatable
{
    // Awaiterを返すGetAwaiterメソッドを持つ
    public FooAwaiter GetAwaiter() { ... }
}

static class FooExtensions
{
    // インスタンスメソッドではなく拡張メソッドでもOK
    public static FooAwaiter GetAwaiter(this FooAwaitable foo) { ... }
}

public struct FooAwaiter : INotifyCompletion
{
    // タスクが完了したかどうかを返す
    public bool IsCompleted { get { ... } }

    // 完了時の継続処理を登録する
    public void OnCompleted(Action continuation) { ... }

    // 結果を取得して返す
    // 戻り値は任意の型 (voidでも可)
    public Foo GetResult() { ... }
}

// Awaitableパターンを実装したクラス
public class Foo
{
    public Awaiter GetAwaiter()
    {
        return new Awaiter();
    }

    // とりあえず今回はINotifyCompletionの実装で
    public struct Awaiter : INotifyCompletion
    {
        // await時点では完了していないことにするためfalseを返す
        public bool IsCompleted => false;

        // 継続処理をそのまま呼び出すだけ
        public void OnCompleted(Action continuation)
        {
            continuation();
        }

        // awaitの結果として"Foo!"という文字列を返す
        public string GetResult() { return "Foo!"; }
    }
}

// Fooのインスタンスを作成
var foo = new Foo();

// awaitで待機できる
var result = await foo;

// "Foo!"がConsoleに表示される
Console.WriteLine(result);

// asyncの戻り値にしたい型
// AsyncMethodBuilder属性でマークし、定義したBuilderを引数に指定する
[AsyncMethodBuilder(typeof(AsyncMyTaskMethodBuilder))]
public struct MyTask { ... }

// AsyncMethodBuilderを実装する
public struct AsyncMyTaskMethodBuilder
{
    public static AsyncMyTaskMethodBuilder Create() { ... }

    public void Start<TStateMachine>(ref TStateMachine stateMachine)
        where TStateMachine : IAsyncStateMachine
    {
        ...
    }

    public void SetStateMachine(IAsyncStateMachine stateMachine) { ... }
    public void SetResult() { ... }
    public void SetException(Exception exception) { ... }

    public MyTask Task
    {
        get { ... }
    }

    public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
        where TAwaiter : INotifyCompletion
        where TStateMachine : IAsyncStateMachine
    {
        ...
    }

    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
        where TAwaiter : ICriticalNotifyCompletion
        where TStateMachine : IAsyncStateMachine
    {
        ...
    }
}

async MyTask FooAsync()
{
    await Task.Delay(TimeSpan.FromSeconds(1.0));
}

// PoolingAsyncValueTaskMethodBuilderを利用するように変更する
// asyncメソッド呼び出しのアロケーションが問題となる場面での最適化に便利
[AsyncMethodBuilder(typeof(PoolingAsyncValueTaskMethodBuilder))]
async ValueTask<int> FooAsync()
{
    for (int i = 0; i < 100; i++)
    {
        await Task.Delay(TimeSpan.FromSeconds(1));
    }
}