Як я можу викликати метод асинхронізації в Main?

public class test
{
    public async Task Go()
    {
        await PrintAnswerToLife();
        Console.WriteLine("done");
    }

    public async Task PrintAnswerToLife()
    {
        int answer = await GetAnswerToLife();
        Console.WriteLine(answer);
    }

    public async Task<int> GetAnswerToLife()
    {
        await Task.Delay(5000);
        int answer = 21 * 2;
        return answer;
    }
}

якщо я хочу викликати метод Go у main (), як я можу це зробити? Я випробовую нові функції c #, я знаю, що можу підключити метод async до події, і, запускаючи цю подію, можна викликати метод async.

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

Я зробив щось подібне

class Program
{
    static void Main(string[] args)
    {
        test t = new test();
        t.Go().GetAwaiter().OnCompleted(() =>
        {
            Console.WriteLine("finished");
        });
        Console.ReadKey();
    }


}

Але, здається, це глухий замок, і на екрані нічого не друкується.

Ваш Mainметод можна спростити. Для C # 7.1 та новіших версій:

static async Task Main(string[] args)
{
    test t = new test();
    await t.Go();
    Console.WriteLine("finished");
    Console.ReadKey();
}

Для попередніх версій C #:

static void Main(string[] args)
{
    test t = new test();
    t.Go().Wait();
    Console.WriteLine("finished");
    Console.ReadKey();
}

Це є частиною краси asyncключового слова (та пов'язаної з ним функціональності): використання та заплутаний характер зворотних викликів значно зменшується або усувається.

Замість Wait, вам краще використовувати, new test().Go().GetAwaiter().GetResult() оскільки це дозволить уникнути винятків, які обертаються в AggregateExceptions, тому ви можете просто оточити свій метод Go () блоком try catch (Exception ex), як зазвичай.

З моменту випуску async mainметодів C # v7.1 стали доступними для використання, що дозволяє уникнути потреби в обхідних шляхах у вже розміщених відповідях. Додано такі підписи:

public static Task Main();
public static Task<int> Main();
public static Task Main(string[] args);
public static Task<int> Main(string[] args);

Це дозволяє писати ваш код так:

static async Task Main(string[] args)
{
    await DoSomethingAsync();
}

static async Task DoSomethingAsync()
{
    //...
}

class Program
{
    static void Main(string[] args)
    {
       test t = new test();
       Task.Run(async () => await t.Go());
    }
}

Поки ви отримуєте доступ до об'єкта результату із поверненого завдання, взагалі немає потреби використовувати GetAwaiter (Тільки у випадку, якщо ви отримуєте доступ до результату).

static async Task<String> sayHelloAsync(){

       await Task.Delay(1000);
       return "hello world";

}

static void main(string[] args){

      var data = sayHelloAsync();
      //implicitly waits for the result and makes synchronous call. 
      //no need for Console.ReadKey()
      Console.Write(data.Result);
      //synchronous call .. same as previous one
      Console.Write(sayHelloAsync().GetAwaiter().GetResult());

}

якщо ви хочете дочекатися завершення завдання та виконати подальшу обробку:

sayHelloAsyn().GetAwaiter().OnCompleted(() => {
   Console.Write("done" );
});
Console.ReadLine();

Якщо ви зацікавлені отримати результати від sayHelloAsync і виконайте подальшу обробку на ньому:

sayHelloAsync().ContinueWith(prev => {
   //prev.Result should have "hello world"
   Console.Write("done do further processing here .. here is the result from sayHelloAsync" + prev.Result);
});
Console.ReadLine();

Останній простий спосіб очікування на функцію:

static void main(string[] args){
  sayHelloAsync().Wait();
  Console.Read();
}

static async Task sayHelloAsync(){          
  await Task.Delay(1000);
  Console.Write( "hello world");

}

public static void Main(string[] args)
{
    var t = new test();
    Task.Run(async () => { await t.Go();}).Wait();
}

Використовуйте .Зачекайте ()

static void Main(string[] args){
   SomeTaskManager someTaskManager  = new SomeTaskManager();
   Task<List<String>> task = Task.Run(() => marginaleNotesGenerationTask.Execute());
   task.Wait();
   List<String> r = task.Result;
} 

public class SomeTaskManager
{
    public async Task<List<String>> Execute() {
        HttpClient client = new HttpClient();
        client.BaseAddress = new Uri("http://localhost:4000/");     
        client.DefaultRequestHeaders.Accept.Clear();           
        HttpContent httpContent = new StringContent(jsonEnvellope, Encoding.UTF8, "application/json");
        client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
        HttpResponseMessage httpResponse = await client.PostAsync("", httpContent);
        if (httpResponse.Content != null)
        {
            string responseContent = await httpResponse.Content.ReadAsStringAsync();
            dynamic answer = JsonConvert.DeserializeObject(responseContent);
            summaries = answer[0].ToObject<List<String>>();
        }
    } 
}

спробуйте властивість "Результат"

class Program
{
    static void Main(string[] args)
    {
        test t = new test();
        t.Go().Result;
        Console.ReadKey();
    }
}

Заяви верхнього рівня C # 9 ще більше спростили речі, тепер вам навіть не потрібно робити нічого зайвого для виклику asyncметодів з вашого Main, ви можете просто зробити це:

using System;
using System.Threading.Tasks;

await Task.Delay(1000);
Console.WriteLine("Hello World!");

Для отримання додаткової інформації дивіться Що нового в C # 9.0, Заяви верхнього рівня :

Оператори верхнього рівня можуть містити асинхронні вирази. У цьому випадку синтезована точка входу повертає a Task, або Task<int>.