Только что получил 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 и позволить 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();
    }

Но это еще более лишний код. Поэтому мне приходится писать код, который мне не нужен, или терпеть ненужные предупреждения.

Есть ли что-то неправильное в моем использовании async?

Если вам действительно не нужен результат, вы можете просто изменить GetNameAsyncподпись, чтобы вернуть void:

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

Попробуйте увидеть ответ на связанный вопрос: в чем разница между возвратом void и возвратом задачи?

Обновить

Если вам нужен результат, вы можете изменить его GetNameAsyncна return, например 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 .

См. Также предупреждение / ответ @ ryan-horath здесь https://stackoverflow.com/a/12145047/928483 .

Исключения, возникшие во время ожидаемого асинхронного вызова, будут потеряны. Чтобы избавиться от этого предупреждения, вы должны присвоить переменной, возвращаемое Task, значение асинхронного вызова. Это гарантирует, что у вас будет доступ ко всем созданным исключениям, которые будут указаны в возвращаемом значении.

Обновление для C # 7.0

В C # 7.0 добавлена ​​новая функция сброса переменных: Discards - Руководство по C # , которая также может помочь в этом отношении.

_ = SomeMethodAsync();

Мне не особо нравятся решения, которые либо назначают задачу неиспользуемой переменной, либо меняют сигнатуру метода, чтобы вернуть void. Первый создает излишний, не интуитивно понятный код, а второй может быть невозможен, если вы реализуете интерфейс или используете другую функцию, в которой вы хотите использовать возвращенную задачу.

Мое решение - создать метод расширения Task под названием DoNotAwait (), который ничего не делает. Это не только подавит все предупреждения, ReSharper или другие, но и сделает код более понятным и укажет будущим сопровождающим вашего кода, что вы действительно намеревались сделать так, чтобы вызов не ожидался.

Метод расширения:

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

Использование:

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

Отредактировано для добавления: это похоже на решение Джонатана Аллена, в котором метод расширения запускает задачу, если она еще не запущена, но я предпочитаю иметь одноцелевые функции, чтобы намерение вызывающего абонента было полностью ясным.

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метод должен взаимодействовать с пользовательским интерфейсом или даже с чем-либо связанным с пользовательским интерфейсом (WINRT / MVVM, я смотрю на вас), тогда он становится немного смешнее =)

Вам нужно будет передать ссылку диспетчеру пользовательского интерфейса следующим образом ...

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

И затем в вашем асинхронном методе вам нужно будет взаимодействовать с вашим пользовательским интерфейсом или элементами, связанными с пользовательским интерфейсом, подумал, что диспетчер ...

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 об этом предупреждении, вы можете решить эту проблему, просто назначив возвращенную задачу переменной. Ниже приведен перевод кода, представленного в примере 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)
    {
    }
}

С уважением

Это ваш упрощенный пример, который вызывает избыточный код. Обычно вы хотели бы использовать данные, которые были извлечены из источника блокировки в какой-то момент программы, поэтому вам нужно вернуть результат, чтобы можно было добраться до данных.

Если у вас действительно есть что-то, что происходит полностью изолированно от остальной программы, асинхронный подход не будет правильным. Просто начните новый поток для этой задачи.

Вы действительно хотите проигнорировать результат? как в том числе игнорировать любые неожиданные исключения?

Если нет, вы можете взглянуть на этот вопрос: подход «огонь и забыть» ,

Если вы не хотите изменять сигнатуру метода для возврата void(поскольку возврат voidвсегда должен быть недействительным ), вы можете использовать такую функцию C # 7.0+ Discard , которая немного лучше, чем присвоение переменной (и должна удалить большинство других предупреждения средств проверки источника):

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