У мене є asyncметод, який не повертає даних:

public async Task MyAsyncMethod()
{
    // do some stuff async, don't return any data
}

Я називаю це іншим методом, який повертає деякі дані:

public string GetStringData()
{
    MyAsyncMethod(); // this generates a warning and swallows exceptions
    return "hello world";
}

Виклик, MyAsyncMethod()не чекаючи, викликає попередження " Оскільки цього дзвінка не очікується, поточний метод продовжує працювати до завершення виклику " у візуальній студії. На сторінці цього попередження зазначено:

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

Я впевнений, що не хочу чекати завершення дзвінка; Мені не потрібно і не маю часу на це. Але виклик може спричинити винятки.

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

Як я безпечно викликати метод асинхронізації, не чекаючи результату?

Оновлення:

Для людей, які підказують, що я просто чекаю результату, це код, який відповідає на веб-запит нашої веб-служби (ASP.NET Web API). Очікування в контексті користувальницького інтерфейсу забезпечує потік користувальницького інтерфейсу безкоштовним, але очікування у виклику веб-запиту зачекає завершення завдання перед тим, як відповісти на запит, тим самим збільшуючи час відповіді без причини.

Якщо ви хочете отримати виняток "асинхронно", ви можете зробити:

  MyAsyncMethod().
    ContinueWith(t => Console.WriteLine(t.Exception),
        TaskContinuationOptions.OnlyOnFaulted);

Це дозволить вам опрацьовувати виняток на потоці, відмінній від "головної" теми. Це означає, що вам не доведеться "чекати" дзвінка MyAsyncMethod()з потоку, який дзвонить MyAsyncMethod; але, все ще дозволяє зробити щось із винятком - але лише у випадку, якщо виняток має місце.

Оновлення:

технічно ви можете зробити щось подібне з await:

try
{
    await MyAsyncMethod().ConfigureAwait(false);
}
catch (Exception ex)
{
    Trace.WriteLine(ex);
}

... що було б корисно, якщо вам потрібно спеціально використовувати try/ catch(або using), але я вважаю, що ContinueWithце трохи більш чітко, тому що ви повинні знати, що ConfigureAwait(false)означає.

Ви повинні спочатку розглянути питання про внесення GetStringDataв asyncметод і він awaitзадача повернувся з MyAsyncMethod.

Якщо ви абсолютно впевнені, що вам не потрібно обробляти винятки з MyAsyncMethod або знаєте, коли це завершується, ви можете зробити це:

public string GetStringData()
{
  var _ = MyAsyncMethod();
  return "hello world";
}

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

Оновлення:

Оскільки ви перебуваєте на ASP.NET і хочете повернутися рано, вам може бути корисна моя публікація в блозі . Однак ASP.NET не був розроблений для цього, і немає гарантії, що ваш код запуститься після повернення відповіді. ASP.NET зробить усе можливе, щоб він запустився, але він не може цього гарантувати.

Отже, це прекрасне рішення для чогось такого простого, як закидання події в журнал, де це не має особливого значення, якщо ви втратите кілька тут і там. Це не гарне рішення для будь-яких операцій, що мають важливе значення для бізнесу. У таких ситуаціях ви повинні прийняти більш складну архітектуру, що має стійкий спосіб збереження операцій (наприклад, черги Azure, MSMQ) та окремий фоновий процес (наприклад, роль робочого Azure, служба Win32) для їх обробки.

Відповідь Пітера Річі - те, чого я хотів, і стаття Стівена Клірі про повернення на ASP.NET була дуже корисною.

Однак, як більш загальна проблема (не специфічна для контексту ASP.NET), наступна програма консолі демонструє використання та поведінку відповіді Петра за допомогою Task.ContinueWith(...)

static void Main(string[] args)
{
  try
  {
    // output "hello world" as method returns early
    Console.WriteLine(GetStringData());
  }
  catch
  {
    // Exception is NOT caught here
  }
  Console.ReadLine();
}

public static string GetStringData()
{
  MyAsyncMethod().ContinueWith(OnMyAsyncMethodFailed, TaskContinuationOptions.OnlyOnFaulted);
  return "hello world";
}

public static async Task MyAsyncMethod()
{
  await Task.Run(() => { throw new Exception("thrown on background thread"); });
}

public static void OnMyAsyncMethodFailed(Task task)
{
  Exception ex = task.Exception;
  // Deal with exceptions here however you want
}

GetStringData()повертається достроково, не чекаючи, MyAsyncMethod()і винятки, які викидаються MyAsyncMethod(), розглядаються в, OnMyAsyncMethodFailed(Task task)а не в try/ catchнавколоGetStringData()

Я закінчую це рішення:

public async Task MyAsyncMethod()
{
    // do some stuff async, don't return any data
}

public string GetStringData()
{
    // Run async, no warning, exception are catched
    RunAsync(MyAsyncMethod()); 
    return "hello world";
}

private void RunAsync(Task task)
{
    task.ContinueWith(t =>
    {
        ILog log = ServiceLocator.Current.GetInstance<ILog>();
        log.Error("Unexpected Error", t.Exception);

    }, TaskContinuationOptions.OnlyOnFaulted);
}

Це називається вогнем і забудьте, і для цього є розширення .

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

Встановіть nuget пакет .

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

MyAsyncMethod().Forget();

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

Можливо, може бути краще запустити нитку і залишити її закінчувати самостійно.

У технологіях із циклами повідомлень (не впевнений, чи є ASP одним із них), ви можете заблокувати цикл та обробляти повідомлення, поки завдання не закінчиться, і використовувати ContinueWith для розблокування коду:

public void WaitForTask(Task task)
{
    DispatcherFrame frame = new DispatcherFrame();
    task.ContinueWith(t => frame.Continue = false));
    Dispatcher.PushFrame(frame);
}

Цей підхід схожий на блокування ShowDialog і все ще підтримує інтерфейс користувача чутливим.

Я запізнююсь на вечірку тут, але є дивовижна бібліотека, яку я використовую, про яку я не бачив посилання в інших відповідях

https://github.com/brminnick/AsyncAwaitBestPractices

Якщо вам потрібно "Запустити і забути", ви викликаєте метод розширення для завдання.

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

У вашому прикладі ви б використовували його так:

   public string GetStringData()
    {
        MyAsyncMethod().SafeFireAndForget(onException: (exception) =>
                    {
                      //DO STUFF WITH THE EXCEPTION                    
                    }); 
        return "hello world";
    }

Він також дає очікувані AsyncCommands, що реалізують ICommand з коробки, що чудово підходить для мого рішення MVVM Xamarin

Рішення полягає в запуску HttpClient в інше завдання виконання без контексту синхронізації:

var submit = httpClient.PostAsync(uri, new StringContent(body, Encoding.UTF8,"application/json"));
var t = Task.Run(() => submit.ConfigureAwait(false));
await t.ConfigureAwait(false);

Якщо ти справді хочеш це зробити. Просто для адреси "Виклик асинхронного методу в C # без очікування", ви можете виконати метод асинхронізації всередині Task.Run. Такий підхід буде чекати до MyAsyncMethodкінця.

public string GetStringData()
{
    Task.Run(()=> MyAsyncMethod()).Result;
    return "hello world";
}

awaitасинхронно розгортає Resultзавдання, тоді як лише використання результату блокується до завершення завдання.

Зазвичай метод асинхронізації повертає клас Завдання. Якщо ви використовуєте Wait()метод або Resultвластивість та викиди коду, виняток - тип винятку загортається, AggregateException- вам потрібно здійснити запит, Exception.InnerExceptionщоб знайти правильний виняток.

Але це також можна використовувати .GetAwaiter().GetResult()замість цього - він також буде чекати завдання асинхронізації, але не завершує виняток.

Ось короткий приклад:

public async Task MyMethodAsync()
{
}

public string GetStringData()
{
    MyMethodAsync().GetAwaiter().GetResult();
    return "test";
}

Можливо, ви також можете мати можливість повернути деякий параметр з функції асинхронізації - цього можна досягти, надавши додаткову Action<return type>функцію async, наприклад, наприклад:

public string GetStringData()
{
    return MyMethodWithReturnParameterAsync().GetAwaiter().GetResult();
}

public async Task<String> MyMethodWithReturnParameterAsync()
{
    return "test";
}

Зверніть увагу, що в методах асинхронізації зазвичай є ASyncіменні суфікси, щоб уникнути зіткнення між синхронізуючими функціями з тим самим іменем. (Наприклад FileStream.ReadAsync) - я оновив назви функцій, щоб дотримуватися цієї рекомендації.