我如何在MAIN中调用异步方法

Question

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;
    }
}

如果我想以main（）方法调用go go go go，我该怎么做？我正在尝试C＃新功能，我知道我可以将异步方法连接到一个事件中，并且可以触发该事件，可以调用异步方法。

但是，如果我想直接用主要方法称呼它怎么办？我该怎么做？

我做了类似

的事情

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

}

，但似乎这是一个死锁，屏幕上什么也没有打印。

Answer 1

您的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关键字（以及相关功能）的美的一部分：回调性质大大减少或消除。

Answer 2

而不是等待，最好使用 new test().Go().GetAwaiter().GetResult()由于这将避免将异常包裹在骨料上，因此您可以像往常一样将GO（）方法包围（）方法（例外）块。

Answer 3

由于C＃v7.1 async main方法的发布已可以使用，可以避免在已经发布的答案中对解决方法的需求。添加了以下签名：

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

Answer 4

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

Answer 5

只要您从返回的任务访问结果对象，就无需使用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");
}

Answer 6

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

Answer 7

使用.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>>();
        }
    } 
}

Answer 8

c＃9顶级语句更简化的事情，现在您甚至不必做任何额外的事情即可从Main调用async方法只是这样做：

using System;
using System.Threading.Tasks;
await Task.Delay(1000);
Console.WriteLine("Hello World!");

有关更多信息，请参阅C＃9.0中的新事物，顶级语句：

顶级语句可能包含异步表达式。在这种情况下，合成的入口点返回Task或Task<int>。

Answer 9

尝试"结果"属性

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