Щойно отримав 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не було асинхронізації, для цього методу потрібно буде вкладати зворотний дзвінок у зворотній зв'язок. За допомогою асинхроніки я можу написати свій метод таким природним чином:

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()
{
    ...
}

Розглянемо відповідь на відповідне запитання: Яка різниця між поверненням порожнечі та поверненням завдання?

Оновлення

Якщо вам потрібен результат, ви можете змінити 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 .

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

Винятки, викинуті під час виклику асинхронізації, якого не чекають, будуть втрачені. Щоб позбутися цього попередження, слід призначити змінній значення повернення Завдання виклику асинхронізації. Це гарантує вам доступ до будь-яких викинутих винятків, які будуть вказані у зворотному значенні.

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

C # 7.0 додає нову функцію, відкиньте змінні: Відкидання - Посібник по C # , який також може допомогти у цьому плані.

_ = SomeMethodAsync();

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

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

Спосіб розширення:

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

Використання:

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

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

async void ПОГАНО!

1. Яка різниця між поверненням порожнечі та поверненням завдання?
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)
    {
    }
}

З повагою

Це ваш спрощений приклад, який спричиняє чудовий код. Зазвичай ви хочете використовувати дані, які були отримані з блокуючого джерела в якийсь момент програми, тож ви хочете отримати результат назад, щоб можна було дістатися до даних.

Якщо у вас дійсно є щось, що відбувається повністю ізольовано від решти програми, async не буде правильним підходом. Просто запустіть нову нитку для цього завдання.

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

Якщо ні, то, можливо, ви захочете поглянути на це питання: " Пожежа та забудьте" ,

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

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