async を伴うメソッド定義の記述方法と戻り値について

Question

C#6.0
.NET Framework 4.6 で開発する上で、
非同期処理について調査をしています。

async/await を使った書き方について、
例えば次のような書き方ができると思います。

private Task Hoge()
{
    return Task.Run(() => DoWork());
}

private async Task HogeAsync()
{
    await Task.Run(() => DoWork());
}

private void DoWork()
{
    // 何か処理
}

Hoge() はタスクを明示的に返すだけのものですが、
HogeAsync() は非同期的に処理をおこなおうとしています。

ところで、この HogeAsync() メソッドの定義の記述方法なのですが、
Task クラスを戻り値として指定していますが、
明示的に return していないため、
通常のメソッドとして見ると違和感を覚えます。
これは await キーワードの裏側に return があるのでしょうか？
その場合、

private async Task HogeAsync()
{
    await Task.Run(() => DoWork1());
    await Task.Run(() => DoWork2());
}

このように複数の await を使用するとどうなるのでしょうか。

それとも、async キーワードを伴うメソッドは、
このメソッド全体をタスクとして認識し、
メソッド全体の処理そのものを Task クラスの戻り値とするのでしょうか。

Comments

[退会済みユーザー]

質問者さん、無言ですが、回答がついていますのでそれらに対するフィードバックを書いてください。役に立った/立たなかったぐらいはすぐ回答できるのでは？　役に立たなかったなら何が期待する答えと違うかを書けば、期待する回答が出てくるかも。とにかく無言は NG です。

[twyujiro15]

申し訳ありません。タイミング悪く、質問を投げてからしばらくパソコンの環境から離れてしまっていました。意図的ではなかったとはいえ、しばらく無言になってしまい、ご回答いただいた皆様に不快な思いをさせてしまったことをお詫びします。

[退会済みユーザー]

質問のコメント (Task を return しないのはなぜ？) についてはレスを返しましたので見てください。

それでこのスレッドの疑問は解決したと思いますが、であればこのスレッドはクローズしてください。前のスレッドもクローズ願います。

Answer 1

これは await キーワードの裏側に return があるのでしょうか？

実際にコンパイラは

using System;
using System.Threading.Tasks;


class Test {
        
    public async Task HogeAsync()
    {
        await Task.Run(() => DoWork1());
        await Task.Run(() => DoWork2());
    }
    
    private void DoWork1() {}
    private void DoWork2() {}

}

このコードを

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using System.Threading.Tasks;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
internal class Test
{
    [CompilerGenerated]
    private sealed class <HogeAsync>d__0 : IAsyncStateMachine
    {
        public int <>1__state;

        public AsyncTaskMethodBuilder <>t__builder;

        public Test <>4__this;

        private TaskAwaiter <>u__1;

        private void MoveNext()
        {
            int num = <>1__state;
            try
            {
                TaskAwaiter awaiter;
                TaskAwaiter awaiter2;
                if (num != 0)
                {
                    if (num == 1)
                    {
                        awaiter = <>u__1;
                        <>u__1 = default(TaskAwaiter);
                        num = (<>1__state = -1);
                        goto IL_00ef;
                    }
                    awaiter2 = Task.Run(new Action(<>4__this.<HogeAsync>b__0_0)).GetAwaiter();
                    if (!awaiter2.IsCompleted)
                    {
                        num = (<>1__state = 0);
                        <>u__1 = awaiter2;
                        <HogeAsync>d__0 stateMachine = this;
                        <>t__builder.AwaitUnsafeOnCompleted(ref awaiter2, ref stateMachine);
                        return;
                    }
                }
                else
                {
                    awaiter2 = <>u__1;
                    <>u__1 = default(TaskAwaiter);
                    num = (<>1__state = -1);
                }
                awaiter2.GetResult();
                awaiter = Task.Run(new Action(<>4__this.<HogeAsync>b__0_1)).GetAwaiter();
                if (!awaiter.IsCompleted)
                {
                    num = (<>1__state = 1);
                    <>u__1 = awaiter;
                    <HogeAsync>d__0 stateMachine = this;
                    <>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
                    return;
                }
                goto IL_00ef;
                IL_00ef:
                awaiter.GetResult();
            }
            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(IAsyncStateMachine stateMachine)
        {
        }

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

    [AsyncStateMachine(typeof(<HogeAsync>d__0))]
    [DebuggerStepThrough]
    public Task HogeAsync()
    {
        <HogeAsync>d__0 stateMachine = new <HogeAsync>d__0();
        stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
        stateMachine.<>4__this = this;
        stateMachine.<>1__state = -1;
        stateMachine.<>t__builder.Start(ref stateMachine);
        return stateMachine.<>t__builder.Task;
    }

    private void DoWork1()
    {
    }

    private void DoWork2()
    {
    }

    [CompilerGenerated]
    private void <HogeAsync>b__0_0()
    {
        DoWork1();
    }

    [CompilerGenerated]
    private void <HogeAsync>b__0_1()
    {
        DoWork2();
    }
}

こう変換してる。

HogeAsync()を見ての通り、ちゃんとreturnしてます。

Comments

[twyujiro15]

ご回答ありがとうございます。
実際のコードまで掲載いただいたので大変参考になりました。

つまり、await の裏側に return があり、
さらに、メソッド全体をタスクとして認識し、
HogeAsync() メソッドに記述した処理全体を Task クラスとしての戻り値とする、
という理解は概ね間違いではない、ということで良いのでしょうか。

Answer 2

Task クラスを戻り値として指定していますが、

明示的に return していないため、
通常のメソッドとして見ると違和感を覚えます。

戻り値の型が Task の非同期メソッドは呼び出し元に値を返しません。
詳しくは 非同期の戻り値の型 (C#) を参照してください。

これは await キーワードの裏側に return があるのでしょうか？

IL をデコンパイルした C# のコードを確認したら return ステートメントに相応する記述があるかもしれませんが、私には分かりません。
しかし、少なくとも Task の非同期メソッドに return ステートメントを記述する必要はありません。
もちろん、明示的に return ステートメントを記述することはできます。

このように複数の await を使用するとどうなるのでしょうか。

DoWork1 が非同期で呼び出され、DoWork1 が完了するまで HogeAsync は保留となり、DoWork1 が完了すると HogeAsync は再開します。DoWork2 も同様です。

また、どちらのメソッドも値は返されません。

async キーワードを伴うメソッドは、

このメソッド全体をタスクとして認識し、
メソッド全体の処理そのものを Task クラスの戻り値とするのでしょうか。

概ね正しいと思います。
Task クラスに限らず他の型に関しても非同期メソッドの戻り値に指定することが出来ます。

Comments

[BluOxy]

ゆっくり回答を書いていたので、radian さんと内容が被ってしまいました。

[twyujiro15]

ご回答ありがとうございます。
処理の流れ自体は理解していますが、
メソッドの書き方として、
HogeAsync() メソッドは Task クラスのオブジェクトを返しているはずなのに、
何も返していないような記述になることについて疑問を抱いていました。

[BluOxy]

気持ちは分からなくもないです。しかし、言語仕様でそう決められているようです。
https://docs.microsoft.com/ja-jp/dotnet/csharp/language-reference/language-specification/expressions#function-members

> Fが async で、F の本体が Nothing (式の分類) として分類された式であるか、または return ステートメントに式が含まれていないステートメントブロックである場合、推論される戻り値の型は System.Threading.Tasks.Task です。 ※若干ガバ翻訳は直しています

Answer 3

違和感を覚えると言われても、返り値を持たない非同期メソッドの定義がそうだからとしか言いようがないです。
非同期の戻り値の型 (C#)

async, awaitは只の糖衣構文なので、実際に内部でどうコンパイルされ、どういう処理をしているかが気になるのであれば、ILSpy等で逆コンパイルして覗いてみればよいのではないでしょうか。

Comments

[twyujiro15]

ご回答ありがとうございます。
確かに ILSpy などで確認すべきでした。アドバイスありがとうございます。

Answer 4

質問者さんの別のスレッドで紹介した記事の「async void を避ける」というセクションの説明が参考になりませんか？

async void を避ける
https://docs.microsoft.com/ja-jp/archive/msdn-magazine/2013/march/async-await-best-practices-in-asynchronous-programming#async-void-%E3%82%92%E9%81%BF%E3%81%91%E3%82%8B

以下一部抜粋：

"async Task メソッドまたは async Task<T> メソッドから例外がスローされると、その例外は Task オブジェクトでキャプチャされ、そこで処理されます"

Comments

[twyujiro15]

ご回答ありがとうございます。
少しややこしいですが、
私の言うところの「戻り値」というのは、
非同期処理の結果というわけではなく、
HogeAsync() メソッド自身の戻り値のことです。

例えば int Calc() { } と書かれたメソッドが int 型を返すように、
Task Hoge() { } は Task クラスオブジェクトを return で返していますが、
async Task HogeAsync() { } は
Task クラスオブジェクトを return で返していないような記述になっていることに疑問を抱いていました。

[退会済みユーザー]

> async Task HogeAsync() { } は
Task クラスオブジェクトを return で返していないような記述になっていることに疑問を抱いていました。

async キーワードがあるので自動的に Task を返してくれるということのようです。

Task を返すメソッドに async キーワードをつけない場合は return Task.CompletedTask; のようにします。どういうケースがあるかというと、例えば Interface に定義されているメソッドが Task を返すが実際には非同期にする必要はないという場合があります。具体例は以下の記事のコードを見てください。

http://surferonwww.info/BlogEngine/post/2020/09/06/rolestore-custom-storage-providers.aspx