Wie kann ich eine asynchrone Methode in Main aufrufen?

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

Wie kann ich das tun, wenn ich Go in der main () -Methode aufrufen möchte? Ich probiere neue Funktionen aus. Ich weiß, dass ich die asynchrone Methode mit einem Ereignis verknüpfen kann. Durch Auslösen dieses Ereignisses kann die asynchrone Methode aufgerufen werden.

Aber was ist, wenn ich es direkt in der Hauptmethode aufrufen möchte? Wie kann ich das machen?

Ich habe so etwas gemacht

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


}

Aber es scheint ein totes Schloss zu sein und nichts wird auf dem Bildschirm gedruckt.

Ihre MainMethode kann vereinfacht werden. Für C # 7.1 und neuer:

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

Für frühere Versionen von C #:

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

Dies ist Teil der Schönheit des asyncSchlüsselworts (und der zugehörigen Funktionalität): Die Verwendung und Verwirrung von Rückrufen wird stark reduziert oder beseitigt.

Anstelle von Warten sollten Sie besser verwenden, new test().Go().GetAwaiter().GetResult() da dadurch vermieden wird, dass Ausnahmen in AggregateExceptions eingeschlossen werden. Sie können Ihre Go () -Methode also wie gewohnt mit einem try catch-Block (Exception ex) umgeben.

Seit der Veröffentlichung von C # v7.1 stehen async mainMethoden zur Verfügung, die die Problemumgehungen in den bereits veröffentlichten Antworten überflüssig machen. Die folgenden Signaturen wurden hinzugefügt:

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

Auf diese Weise können Sie Ihren Code folgendermaßen schreiben:

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

Solange Sie über die zurückgegebene Aufgabe auf das Ergebnisobjekt zugreifen, müssen Sie GetAwaiter überhaupt nicht verwenden (nur für den Fall, dass Sie auf das Ergebnis zugreifen).

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());

}

Wenn Sie warten möchten, bis eine Aufgabe erledigt ist, und eine weitere Verarbeitung durchführen möchten:

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

Wenn Sie daran interessiert sind, die Ergebnisse von sayHelloAsync zu erhalten und weiter zu verarbeiten:

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();

Eine letzte einfache Möglichkeit, auf die Funktion zu warten:

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

Verwenden Sie .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>>();
        }
    } 
}

Versuchen Sie die Eigenschaft "Ergebnis"

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