No se puede especificar el modificador 'asíncrono' en el método 'Principal' de una aplicación de consola

Soy nuevo en la programación asincrónica con el asyncmodificador. Estoy tratando de descubrir cómo asegurarme de que mi Mainmétodo de una aplicación de consola realmente se ejecute de forma asincrónica.

class Program
{
    static void Main(string[] args)
    {
        Bootstrapper bs = new Bootstrapper();
        var list = bs.GetList();
    }
}

public class Bootstrapper {

    public async Task<List<TvChannel>> GetList()
    {
        GetPrograms pro = new GetPrograms();

        return await pro.DownloadTvChannels();
    }
}

Sé que esto no se ejecuta de forma asincrónica desde "la parte superior". Como no es posible especificar el asyncmodificador en el Mainmétodo, ¿cómo puedo ejecutar el código de mainforma asincrónica?

Como descubrió, en VS11 el compilador no permitirá un async Mainmétodo. Esto fue permitido (pero nunca recomendado) en VS2010 con el Async CTP.

Tengo publicaciones de blog recientes sobre programas de consola asíncronos / en espera y asíncronos en particular. Aquí hay información de fondo de la publicación de introducción:

Si "esperar" ve que lo esperable no se ha completado, entonces actúa de forma asíncrona. Le dice a la persona que espera ejecutar el resto del método cuando se complete, y luego regresa del método asíncrono. Await también capturará el contexto actual cuando pase el resto del método a lo esperado.

Más adelante, cuando se complete lo esperado, ejecutará el resto del método asíncrono (dentro del contexto capturado).

He aquí por qué este es un problema en los programas de consola con un async Main:

Recuerde de nuestra publicación de introducción que un método asincrónico volverá a la persona que llama antes de que se complete. Esto funciona perfectamente en aplicaciones de UI (el método solo regresa al bucle de eventos de UI) y en aplicaciones ASP.NET (el método regresa del hilo pero mantiene viva la solicitud). No funciona tan bien para los programas de consola: Main regresa al sistema operativo, por lo que su programa se cierra.

Una solución es proporcionar su propio contexto: un "bucle principal" para su programa de consola que sea compatible con la sincronización.

Si tiene una máquina con el CTP asíncrono, puede usar GeneralThreadAffineContextdesde Mis documentos \ Microsoft Visual Studio CTP asíncrono \ Muestras (Prueba de C #) Prueba de unidad \ AsyncTestUtilities . Alternativamente, puede usar AsyncContextdesde mi paquete Nito.AsyncEx NuGet .

Aquí hay un ejemplo usando AsyncContext; GeneralThreadAffineContexttiene un uso casi idéntico:

using Nito.AsyncEx;
class Program
{
    static void Main(string[] args)
    {
        AsyncContext.Run(() => MainAsync(args));
    }

    static async void MainAsync(string[] args)
    {
        Bootstrapper bs = new Bootstrapper();
        var list = await bs.GetList();
    }
}

Alternativamente, puede bloquear el hilo principal de la consola hasta que su trabajo asincrónico se haya completado:

class Program
{
    static void Main(string[] args)
    {
        MainAsync(args).GetAwaiter().GetResult();
    }

    static async Task MainAsync(string[] args)
    {
        Bootstrapper bs = new Bootstrapper();
        var list = await bs.GetList();
    }
}

Tenga en cuenta el uso de GetAwaiter().GetResult(); esto evita la AggregateExceptionenvoltura que ocurre si usa Wait()o Result.

Actualización, 2017-11-30: a partir de Visual Studio 2017 Actualización 3 (15.3), el idioma ahora admite un async Main- siempre que regrese Tasko Task<T>. Entonces ahora puedes hacer esto:

class Program
{
    static async Task Main(string[] args)
    {
        Bootstrapper bs = new Bootstrapper();
        var list = await bs.GetList();
    }
}

La semántica parece ser la misma que el GetAwaiter().GetResult()estilo de bloquear el hilo principal. Sin embargo, todavía no hay especificaciones de lenguaje para C # 7.1, por lo que esto es solo una suposición.

Puede resolver esto con esta construcción simple:

class Program
{
    static void Main(string[] args)
    {
        Task.Run(async () =>
        {
            // Do any async anything you need here without worry
        }).GetAwaiter().GetResult();
    }
}

Eso colocará todo lo que haga en el ThreadPool donde lo desee (por lo que otras Tareas que inicie / espere no intenten unirse a un Thread que no deberían), y espere hasta que todo esté listo antes de cerrar la aplicación Consola. No necesita bucles especiales ni libs externos.

Editar: incorpore la solución de Andrew para excepciones no detectadas.

Puede hacer esto sin necesidad de bibliotecas externas también haciendo lo siguiente:

class Program
{
    static void Main(string[] args)
    {
        Bootstrapper bs = new Bootstrapper();
        var getListTask = bs.GetList(); // returns the Task<List<TvChannel>>

        Task.WaitAll(getListTask); // block while the task completes

        var list = getListTask.Result;
    }
}

En C # 7.1 podrá hacer una sincronización asíncrona adecuada . Las firmas apropiadas para el Mainmétodo se han extendido a:

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

Por ejemplo, podrías estar haciendo:

static async Task Main(string[] args)
{
    Bootstrapper bs = new Bootstrapper();
    var list = await bs.GetList();
}

En tiempo de compilación, el método del punto de entrada asíncrono se traducirá a la llamada GetAwaitor().GetResult().

Detalles: https://blogs.msdn.microsoft.com/mazhou/2017/05/30/c-7-series-part-2-async-main

EDITAR:

Para habilitar las características del lenguaje C # 7.1, debe hacer clic derecho en el proyecto y hacer clic en "Propiedades" y luego ir a la pestaña "Crear". Allí, haga clic en el botón avanzado en la parte inferior:

En el menú desplegable de la versión de idioma, seleccione "7.1" (o cualquier valor superior):

El valor predeterminado es "última versión principal" que evaluaría (en el momento de escribir este artículo) a C # 7.0, que no es compatible con async main en las aplicaciones de consola.

Agregaré una característica importante que todas las otras respuestas han pasado por alto: la cancelación.

Una de las grandes cosas de TPL es el soporte de cancelación, y las aplicaciones de consola tienen un método de cancelación incorporado (CTRL + C). Es muy simple unirlos. Así es como estructuro todas mis aplicaciones de consola asíncronas:

static void Main(string[] args)
{
    CancellationTokenSource cts = new CancellationTokenSource();

    System.Console.CancelKeyPress += (s, e) =>
    {
        e.Cancel = true;
        cts.Cancel();
    };

    MainAsync(args, cts.Token).Wait();
}

static async Task MainAsync(string[] args, CancellationToken token)
{
    ...
}

C # 7.1 (usando vs 2017 actualización 3) presenta async main

Puedes escribir:

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

Para más detalles C # 7 Series, Part 2: Async Main

Actualizar:

Puede obtener un error de compilación:

El programa no contiene un método estático 'Principal' adecuado para un punto de entrada

Este error se debe a que vs2017.3 está configurado de forma predeterminada como c # 7.0 no c # 7.1.

Debe modificar explícitamente la configuración de su proyecto para configurar las características de c # 7.1.

Puede configurar c # 7.1 por dos métodos:

Método 1: Usando la ventana de configuración del proyecto:

• Abra la configuración de su proyecto
• Seleccione la pestaña Construir
• Haga clic en el botón Avanzado
• Seleccione la versión que desee Como se muestra en la siguiente figura:

Método 2: Modificar manualmente PropertyGroup de .csproj

Añadir esta propiedad:

    <LangVersion>7.1</LangVersion>

ejemplo:

    <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
        <PlatformTarget>AnyCPU</PlatformTarget>
        <DebugSymbols>true</DebugSymbols>
        <DebugType>full</DebugType>
        <Optimize>false</Optimize>
        <OutputPath>bin\Debug\</OutputPath>
        <DefineConstants>DEBUG;TRACE</DefineConstants>
        <ErrorReport>prompt</ErrorReport>
        <WarningLevel>4</WarningLevel>
        <Prefer32Bit>false</Prefer32Bit>
        <LangVersion>7.1</LangVersion>
    </PropertyGroup>    

Si está utilizando C # 7.1 o posterior, vaya con la respuesta de nawfal y simplemente cambie el tipo de retorno de su método Main a Tasko Task<int>. Si no eres:

• Tener async Task MainAsync como dijo Johan .
• Llame a esto .GetAwaiter().GetResult()para atrapar la excepción subyacente como dijo do0g .
• Cancelación de soporte como dijo Cory .
• Un segundo CTRL+Cdebe terminar el proceso de inmediato. (¡Gracias, binki !)
• Handle OperationCancelledException: devuelve un código de error apropiado.

El código final se ve así:

private static int Main(string[] args)
{
    var cts = new CancellationTokenSource();
    Console.CancelKeyPress += (s, e) =>
    {
        e.Cancel = !cts.IsCancellationRequested;
        cts.Cancel();
    };

    try
    {
        return MainAsync(args, cts.Token).GetAwaiter().GetResult();
    }
    catch (OperationCanceledException)
    {
        return 1223; // Cancelled.
    }
}

private static async Task<int> MainAsync(string[] args, CancellationToken cancellationToken)
{
    // Your code...

    return await Task.FromResult(0); // Success.
}

Todavía no he necesitado tanto, pero cuando utilicé la aplicación de consola para las pruebas rápidas y requirí asíncrono, lo resolví así:

class Program
{
    static void Main(string[] args)
    {
        MainAsync(args).Wait();
    }

    static async Task MainAsync(string[] args)
    {
        // Code here
    }
}

Para llamar a la tarea asincrónicamente desde Main, use

1. Task.Run () para .NET 4.5

2. Task.Factory.StartNew () para .NET 4.0 (puede requerir la biblioteca Microsoft.Bcl.Async para async y esperar palabras clave)

Detalles: http://blogs.msdn.com/b/pfxteam/archive/2011/10/24/10229468.aspx

En Principal, intente cambiar la llamada a GetList por:

Task.Run(() => bs.GetList());

Cuando se introdujo el C # 5 CTP, ciertamente podría marcar Main conasync ... aunque generalmente no era una buena idea hacerlo. Creo que esto fue cambiado por el lanzamiento de VS 2013 para convertirse en un error.

A menos que haya iniciado otros hilos de primer plano , su programa se cerrará cuandoMain complete, incluso si ha comenzado un trabajo de fondo.

¿Qué es lo que realmente intentas hacer? Tenga en cuenta que su GetList()método realmente no necesita ser asíncrono en este momento: está agregando una capa adicional sin ninguna razón real. Es lógicamente equivalente a (pero más complicado que):

public Task<List<TvChannel>> GetList()
{
    return new GetPrograms().DownloadTvChannels();
}

La versión más nueva de C # - C # 7.1 permite crear una aplicación de consola asíncrona. Para habilitar C # 7.1 en el proyecto, debe actualizar su VS al menos a 15.3 y cambiar la versión de C # a C# 7.1o C# latest minor version. Para hacer esto, vaya a Propiedades del proyecto -> Compilación -> Avanzado -> Versión del idioma.

Después de esto, el siguiente código funcionará:

internal class Program
{
    public static async Task Main(string[] args)
    {
         (...)
    }

En MSDN, la documentación del Método Task.Run (Acción) proporciona este ejemplo que muestra cómo ejecutar un método de forma asíncrona desde main:

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
    public static void Main()
    {
        ShowThreadInfo("Application");

        var t = Task.Run(() => ShowThreadInfo("Task") );
        t.Wait();
    }

    static void ShowThreadInfo(String s)
    {
        Console.WriteLine("{0} Thread ID: {1}",
                          s, Thread.CurrentThread.ManagedThreadId);
    }
}
// The example displays the following output:
//       Application thread ID: 1
//       Task thread ID: 3

Tenga en cuenta esta declaración que sigue el ejemplo:

Los ejemplos muestran que la tarea asincrónica se ejecuta en un subproceso diferente que el subproceso principal de la aplicación.

Entonces, si en cambio desea que la tarea se ejecute en el hilo principal de la aplicación, vea la respuesta de @StephenCleary .

Y con respecto al hilo en el que se ejecuta la tarea, también tenga en cuenta Stephen's comentario sobre su respuesta:

Usted puede usar un simple Waito Result, y no hay nada de malo en eso. Pero tenga en cuenta que hay dos diferencias importantes: 1) todasasync continuaciones se ejecutan en el grupo de subprocesos en lugar del subproceso principal, y 2) las excepciones se envuelven en un AggregateException.

(Consulte Manejo de excepciones (Biblioteca paralela de tareas) para obtener información sobre cómo incorporar el manejo de excepciones para tratar con un AggregateException.)

Finalmente, en MSDN de la documentación para Task.Delay Method (TimeSpan) , este ejemplo muestra cómo ejecutar una tarea asincrónica que devuelve un valor:

using System;
using System.Threading.Tasks;

public class Example
{
    public static void Main()
    {
        var t = Task.Run(async delegate
                {
                    await Task.Delay(TimeSpan.FromSeconds(1.5));
                    return 42;
                });
        t.Wait();
        Console.WriteLine("Task t Status: {0}, Result: {1}",
                          t.Status, t.Result);
    }
}
// The example displays the following output:
//        Task t Status: RanToCompletion, Result: 42

Tenga en cuenta que en lugar de pasar un delegatea Task.Run, puede pasar una función lambda como esta:

var t = Task.Run(async () =>
        {
            await Task.Delay(TimeSpan.FromSeconds(1.5));
            return 42;
        });

Para evitar la congelación cuando llama a una función en algún lugar de la pila de llamadas que intenta volver a unirse al hilo actual (que está atascado en una Espera), debe hacer lo siguiente:

class Program
{
    static void Main(string[] args)
    {
        Bootstrapper bs = new Bootstrapper();
        List<TvChannel> list = Task.Run((Func<Task<List<TvChannel>>>)bs.GetList).Result;
    }
}

(el reparto solo es necesario para resolver la ambigüedad)

En mi caso, tenía una lista de trabajos que quería ejecutar de forma asíncrona desde mi método principal, he estado usando esto en producción durante bastante tiempo y funciona bien.

static void Main(string[] args)
{
    Task.Run(async () => { await Task.WhenAll(jobslist.Select(nl => RunMulti(nl))); }).GetAwaiter().GetResult();
}
private static async Task RunMulti(List<string> joblist)
{
    await ...
}