Как вы создаете асинхронный метод в C #?

Каждый пост в блоге, который я читал, рассказывает вам, как использовать асинхронный метод в C #, но по какой-то странной причине никогда не объясняйте, как создавать свои собственные асинхронные методы для потребления. Итак, у меня есть этот код прямо сейчас, который использует мой метод:

private async void button1_Click(object sender, EventArgs e)
{
    var now = await CountToAsync(1000);
    label1.Text = now.ToString();
}

И я написал этот метод, который CountToAsync:

private Task<DateTime> CountToAsync(int num = 1000)
{
    return Task.Factory.StartNew(() =>
    {
        for (int i = 0; i < num; i++)
        {
            Console.WriteLine("#{0}", i);
        }
    }).ContinueWith(x => DateTime.Now);
}

Является ли это использование Task.Factoryлучшего способа написания асинхронного метода, или я должен написать это по-другому?

Я не рекомендую, StartNewесли вам не нужен этот уровень сложности.

Если ваш асинхронный метод зависит от других асинхронных методов, самый простой подход - использовать asyncключевое слово:

private static async Task<DateTime> CountToAsync(int num = 10)
{
  for (int i = 0; i < num; i++)
  {
    await Task.Delay(TimeSpan.FromSeconds(1));
  }

  return DateTime.Now;
}

Если ваш асинхронный метод выполняет работу с процессором, вы должны использовать Task.Run:

private static async Task<DateTime> CountToAsync(int num = 10)
{
  await Task.Run(() => ...);
  return DateTime.Now;
}

Вы можете найти мое async/ awaitвступление полезным.

Если вы не хотите использовать async / await внутри вашего метода, но по-прежнему «украшаете» его, чтобы иметь возможность использовать ключевое слово await извне, TaskCompletionSource.cs :

public static Task<T> RunAsync<T>(Func<T> function)
{ 
    if (function == null) throw new ArgumentNullException(“function”); 
    var tcs = new TaskCompletionSource<T>(); 
    ThreadPool.QueueUserWorkItem(_ =>          
    { 
        try 
        {  
           T result = function(); 
           tcs.SetResult(result);  
        } 
        catch(Exception exc) { tcs.SetException(exc); } 
   }); 
   return tcs.Task; 
}

Отсюда и здесь

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

Я видел также используется в источнике .NET, например. WebClient.cs :

    [HostProtection(ExternalThreading = true)]
    [ComVisible(false)]
    public Task<string> UploadStringTaskAsync(Uri address, string method, string data)
    {
        // Create the task to be returned
        var tcs = new TaskCompletionSource<string>(address);

        // Setup the callback event handler
        UploadStringCompletedEventHandler handler = null;
        handler = (sender, e) => HandleCompletion(tcs, e, (args) => args.Result, handler, (webClient, completion) => webClient.UploadStringCompleted -= completion);
        this.UploadStringCompleted += handler;

        // Start the async operation.
        try { this.UploadStringAsync(address, method, data, tcs); }
        catch
        {
            this.UploadStringCompleted -= handler;
            throw;
        }

        // Return the task that represents the async operation
        return tcs.Task;
    }

Наконец, я нашел полезным также следующее:

Мне постоянно задают этот вопрос. Подразумевается, что где-то должен быть какой-то поток, который блокирует вызов ввода-вывода для внешнего ресурса. Итак, асинхронный код освобождает поток запросов, но только за счет другого потока в другом месте системы, верно? Нет, совсем нет. Чтобы понять, почему асинхронные запросы масштабируются, я прослежу (упрощенный) пример асинхронного вызова ввода-вывода. Допустим, запрос должен быть записан в файл. Поток запроса вызывает метод асинхронной записи. WriteAsync реализуется библиотекой базовых классов (BCL) и использует порты завершения для своего асинхронного ввода-вывода. Итак, вызов WriteAsync передается в ОС в виде асинхронной записи в файл. Затем ОС связывается со стеком драйверов, передавая данные для записи в пакет запроса ввода-вывода (IRP). Вот где все становится интересным: Если драйвер устройства не может обработать IRP немедленно, он должен обработать его асинхронно. Таким образом, драйвер сообщает диску начать запись и возвращает «ожидающий» ответ ОС. ОС передает этот «ожидающий» ответ в BCL, а BCL возвращает незавершенную задачу в код обработки запросов. Код обработки запросов ожидает задачу, которая возвращает неполную задачу из этого метода и так далее. Наконец, код обработки запроса в итоге возвращает неполную задачу в ASP.NET, и поток запроса освобождается для возврата в пул потоков. Код обработки запросов ожидает задачу, которая возвращает неполную задачу из этого метода и так далее. Наконец, код обработки запроса в итоге возвращает неполную задачу в ASP.NET, и поток запроса освобождается для возврата в пул потоков. Код обработки запросов ожидает задачу, которая возвращает неполную задачу из этого метода и так далее. Наконец, код обработки запроса в итоге возвращает неполную задачу в ASP.NET, и поток запроса освобождается для возврата в пул потоков.

Введение в Async / Await на ASP.NET

Если целью является улучшение масштабируемости (а не отзывчивости), все это зависит от наличия внешнего ввода / вывода, который предоставляет возможность сделать это.

Один очень простой способ сделать метод асинхронным - это использовать метод Task.Yield (). Как говорится в MSDN:

Вы можете использовать await Task.Yield (); в асинхронном методе, чтобы заставить метод завершиться асинхронно.

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

private async Task<DateTime> CountToAsync(int num = 1000)
{
    await Task.Yield();
    for (int i = 0; i < num; i++)
    {
        Console.WriteLine("#{0}", i);
    }
    return DateTime.Now;
}