У меня есть 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()без ожидания вызывает предупреждение « Поскольку этот вызов не ожидается, текущий метод продолжает выполняться до завершения вызова » в Visual Studio. На странице этого предупреждения говорится:

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

Я уверен, что не хочу ждать завершения звонка; Мне не нужно или у меня нет времени. Но вызов может вызвать исключения.

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

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

Обновить:

Для людей, которые предполагают, что я просто жду результата, это код, который отвечает на веб-запрос в нашем веб-сервисе (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 в другую задачу выполнения без контекста sincronization:

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

Если вы действительно хотите это сделать. Просто для того, чтобы обратиться к «Вызов асинхронного метода в C # без ожидания», вы можете выполнить асинхронный метод внутри a Task.Run. Этот подход будет ждать до MyAsyncMethodконца.

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

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

Обычно асинхронный метод возвращает класс Task. Если вы используете Wait()метод или Resultсвойство и код генерирует исключение - в него включается тип исключения AggregateException- тогда вам нужно выполнить запрос, Exception.InnerExceptionчтобы найти правильное исключение.

Но это также можно использовать .GetAwaiter().GetResult()вместо этого - оно также будет ожидать асинхронную задачу, но не будет переносить исключение.

Итак, вот короткий пример:

public async Task MyMethodAsync()
{
}

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

Возможно, вы захотите также иметь возможность возвращать некоторый параметр из асинхронной функции - это может быть достигнуто путем предоставления дополнительного Action<return type>в асинхронную функцию, например, так:

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

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

Обратите внимание, что асинхронные методы обычно имеют ASyncсуффиксное именование, чтобы избежать коллизий между функциями синхронизации с одинаковыми именами. (Например FileStream.ReadAsync) - я обновил имена функций, чтобы следовать этой рекомендации.