ちょうどVS2012を手に入れ、ハンドルを取得しようとしていますasync。

ブロッキングソースから値をフェッチするメソッドがあるとします。メソッドの呼び出し元をブロックしたくありません。値が到着したときに呼び出されるコールバックを受け取るメソッドを作成することもできますが、C＃5を使用しているため、メソッドを非同期にして、呼び出し側がコールバックを処理する必要がないようにします。

// contrived example (edited in response to Servy's comment)
public static Task<string> PromptForStringAsync(string prompt)
{
    return Task.Factory.StartNew(() => {
        Console.Write(prompt);
        return Console.ReadLine();
    });
}

これを呼び出すメソッドの例を次に示します。PromptForStringAsync非同期でない場合、このメソッドはコールバック内にコールバックをネストする必要があります。asyncを使用すると、非常に自然な方法でメソッドを記述できます。

public static async Task GetNameAsync()
{
    string firstname = await PromptForStringAsync("Enter your first name: ");
    Console.WriteLine("Welcome {0}.", firstname);

    string lastname = await PromptForStringAsync("Enter your last name: ");
    Console.WriteLine("Name saved as '{0} {1}'.", firstname, lastname);
}

ここまでは順調ですね。問題は、GetNameAsync を呼び出すときです。

public static void DoStuff()
{
    GetNameAsync();
    MainWorkOfApplicationIDontWantBlocked();
}

全体のポイントGetNameAsyncは、非同期であることです。欲しくないMainWorkOfApplicationIDontWantBlocked ASAPに戻り、GetNameAsyncにバックグラウンドで処理させので、ブロックし。ただし、この方法で呼び出すと、次のGetNameAsync行にコンパイラの警告が表示されます。

Warning 1   Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the 'await' operator to the result of the call.

「現在のメソッドの実行は、呼び出しが完了する前に続行される」ことを完全に認識しています。それはポイントですが非同期コードですよね？

警告なしでコードをコンパイルすることを好みますが、コードが意図したとおりに動作しているため、ここで「修正」することは何もありません。の戻り値を格納することで警告を取り除くことができますGetNameAsync：

public static void DoStuff()
{
    var result = GetNameAsync(); // supress warning
    MainWorkOfApplicationIDontWantBlocked();
}

しかし、今は余分なコードがあります。Visual Studioは、私がこの不要なコードを書くことを余儀なくされたことを理解しているようです。これは、通常の「値が使用されない」という警告が抑制されるためです。

GetNameAsyncを非同期ではないメソッドでラップすることにより、警告を取り除くこともできます。

    public static Task GetNameWrapper()
    {
        return GetNameAsync();
    }

しかし、それはそれ以上です余分なコードです。そのため、不要な警告を許容しない、または許容しないコードを記述する必要があります。

ここで間違っている非同期の使用について何かありますか？

結果が本当に必要ない場合は、単にGetNameAsyncの署名を変更して返すことができますvoid。

public static async void GetNameAsync()
{
    ...
}

関連する質問への回答を見ることを検討してください： voidを返すこととタスクを返すことの違いは何ですか？

更新

結果が必要な場合は、GetNameAsyncを返すように変更できますTask<string>。

public static async Task<string> GetNameAsync()
{
    string firstname = await PromptForStringAsync("Enter your first name: ");
    string lastname = await PromptForStringAsync("Enter your last name: ");
    return firstname + lastname;
}

次のように使用します。

public static void DoStuff()
{
    Task<string> task = GetNameAsync();

    // Set up a continuation BEFORE MainWorkOfApplicationIDontWantBlocked
    Task anotherTask = task.ContinueWith(r => {
            Console.WriteLine(r.Result);
        });

    MainWorkOfApplicationIDontWantBlocked();

    // OR wait for the result AFTER
    string result = task.Result;
}

私はこの議論にかなり遅れていますが、#pragmaプリプロセッサディレクティブを使用するオプションもあります。私はあちこちに非同期コードがあり、特定の条件で明示的に待機したくないので、他の人と同じように警告と未使用の変数は嫌いです。

#pragma warning disable 4014
SomeMethodAsync();
#pragma warning restore 4014

これ"4014"は、このMSDNページから来ています：コンパイラ警告（レベル1）CS4014。

こちらのhttps://stackoverflow.com/a/12145047/928483の @ ryan-horathによる警告/回答もご覧ください。

待機していない非同期呼び出し中にスローされた例外は失われます。この警告を取り除くには、非同期呼び出しのTask戻り値を変数に割り当てる必要があります。これにより、スローされた例外にアクセスできるようになります。例外は戻り値で示されます。

C＃7.0の更新

C＃7.0では、新しい機能である変数の破棄：破棄-C＃ガイドが追加されました。これもこの点で役立ちます。

_ = SomeMethodAsync();

タスクを未使用の変数に割り当てるか、メソッドのシグネチャを変更してvoidを返すソリューションは特に好きではありません。前者は不要で直感的でないコードを作成しますが、インターフェースを実装している場合や、返されたタスクを使用する関数を別の方法で使用している場合、後者は不可能な場合があります。

私の解決策は、何もしないDoNotAwait（）と呼ばれるTaskの拡張メソッドを作成することです。これにより、ReSharperなどのすべての警告が抑制されるだけでなく、コードが理解しやすくなり、呼び出しを待機することを本当に意図していたことをコードの将来のメンテナーに示すことができます。

延長方法：

public static class TaskExtensions
{
    public static void DoNotAwait(this Task task) { }
}

使用法：

public static void DoStuff()
{
    GetNameAsync().DoNotAwait();
    MainWorkOfApplicationIDontWantBlocked();
}

追加用に編集：これは、拡張メソッドがまだ開始されていない場合にタスクを開始するJonathan Allenのソリューションに似ていますが、呼び出し元の意図が完全に明確になるように、私は単一目的の関数を使用することを好みます。

async void 悪い！

1. voidを返すこととタスクを返すことの違いは何ですか？
2. https://jaylee.org/archive/2012/07/08/c-sharp-async-tips-and-tricks-part-2-async-void.html

私が提案しているのはTask、匿名メソッドを介して明示的に実行することです...

例えば

public static void DoStuff()
{
    Task.Run(async () => GetNameAsync());
    MainWorkOfApplicationIDontWantBlocked();
}

または、ブロックしたい場合は、無名メソッドを待つことができます

public static void DoStuff()
{
    Task.Run(async () => await GetNameAsync());
    MainWorkOfApplicationThatWillBeBlocked();
}

ただし、 GetNameAsyncメソッドがUIまたはUIバインドされた何かと対話する必要がある場合（WINRT / MVVM、私はあなたを見ています）、少しファンキーになります=）

このようなUIディスパッチャーへの参照を渡す必要があります...

Task.Run(async () => await GetNameAsync(CoreApplication.MainView.CoreWindow.Dispatcher));

そして、あなたの非同期メソッドで、あなたはあなたのUIまたはUIにバインドされた要素と対話する必要があるでしょう、そのディスパッチャー...

dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => {  this.UserName = userName; });

これは私が現在やっていることです：

SomeAyncFunction().RunConcurrently();

どこRunConcurrentlyとして定義されています...

 /// <summary> 
 /// Runs the Task in a concurrent thread without waiting for it to complete. This will start the task if it is not already running. 
 /// </summary> 
 /// <param name="task">The task to run.</param> 
 /// <remarks>This is usually used to avoid warning messages about not waiting for the task to complete.</remarks> 
 public static void RunConcurrently(this Task task) 
 { 
     if (task == null) 
         throw new ArgumentNullException("task", "task is null."); 

     if (task.Status == TaskStatus.Created) 
         task.Start(); 
 } 

https://github.com/docevaad/Anchor/blob/master/Tortuga.Anchor/Tortuga.Anchor.source/shared/TaskUtilities.cs

https://www.nuget.org/packages/Tortuga.Anchor/

この警告に関するマイクロソフトの記事によると、返されたタスクを変数に割り当てるだけで解決できます。以下は、Microsoftの例で提供されているコードの翻訳です。

    // To suppress the warning without awaiting, you can assign the 
    // returned task to a variable. The assignment doesn't change how
    // the program runs. However, the recommended practice is always to
    // await a call to an async method.
    // Replace Call #1 with the following line.
    Task delayTask = CalledMethodAsync(delay);

これを実行すると、ReSharperで「ローカル変数は使用されません」というメッセージが表示されることに注意してください。

ここでは、簡単なソリューションです。

public static class TasksExtensions
{
    public static void RunAndForget(this Task task)
    {
    }
}

よろしく

不要なコードを作成するのは、あなたの単純化した例です。通常は、プログラムのある時点でブロッキングソースからフェッチされたデータを使用するので、データにアクセスできるように結果を戻す必要があります。

プログラムの残りの部分から完全に切り離されて発生することが本当にある場合、非同期は適切なアプローチではありません。そのタスクの新しいスレッドを開始するだけです。

結果を無視してもよろしいですか？予期しない例外を無視するように？

ない場合は、この質問を見たい場合があります：火をとアプローチを忘れ、

メソッドシグネチャをreturnに変更したくない場合void（return voidは常にvoid edである必要があるため）、このようなC＃7.0+の破棄機能を使用できます。ソース検証ツールの警告）：

public static void DoStuff()
{
    _ = GetNameAsync(); // we don't need the return value (suppresses warning)
    MainWorkOfApplicationIDontWantBlocked();
}