Código asincrónico en Startup ASP.NET Core: 4 formas de evitar GetAwaiter (). GetResult ()

Antecedentes sobre la tarea laboral

services
      .AddAuthentication()
      .AddJwtBearer(); 

public static AuthenticationBuilder AddJwtAuthentication(this AuthenticationBuilder builder, AuthJwtOptions options)
{
    var signingKeys = new List<SecurityKey>();

    var jwtBearerOptions = new JwtBearerOptions {Authority = options?.Authority};
    
    new JwtBearerPostConfigureOptions().PostConfigure(string.Empty, jwtBearerOptions);
    try
    {
        var config = jwtBearerOptions.ConfigurationManager
            .GetConfigurationAsync(new CancellationTokenSource(options?.AuthorityTimeoutInMs ?? 5000).Token)
            .GetAwaiter().GetResult();
        var providerSigningKeys = config.SigningKeys;
        signingKeys.AddRange(providerSigningKeys);
    }
    catch (Exception)
    {
        // ignored
    }

    builder
        .AddJwtBearer(options =>
        {
            options.TokenValidationParameters = new TokenValidationParameters
            {
                // ...
                IssuerSigningKeys = signingKeys,
                // ...
            };
        });
    return builder;
}

GetAwaiter (). GetResult () me molesta, pero Microsoft no

public override void Load() => LoadAsync().ConfigureAwait(false).GetAwaiter().GetResult();

El papel de las tareas asincrónicas al iniciar un servicio web

Problema: es necesario iniciar el servicio web para que procese las solicitudes de sus clientes, pero al mismo tiempo hay un conjunto de operaciones (relativamente) largas, sin las cuales el servicio no puede responder al cliente, o sus respuestas serán incorrectas.

• Validación de configuraciones fuertemente tipadas.
• Llenar el caché.
• Conexión preliminar a la base de datos u otros servicios.
• JIT y carga de ensamblaje (servicio de calentamiento).
• Migración de bases de datos. Este es uno de los ejemplos de Andrew Lock, pero él mismo admite que, después de todo, esta operación no es deseable al iniciar el servicio .

Solución n. ° 1: una solución de trabajo que puede confundir a los herederos

public class Program
{
   public static async Task Main(string[] args)
   {
       IWebHost webHost = CreateWebHostBuilder(args).Build();

       using (var scope = webHost.Services.CreateScope())
       {
           //   
           var myService = scope.ServiceProvider.GetRequiredService<MyService>();

           await myService.DoAsyncJob();
       }

       await webHost.RunAsync();
   }

   public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
       WebHost.CreateDefaultBuilder(args)
           .UseStartup<Startup>();
}

Solución # 2: incrustar operaciones asincrónicas en DI

public interface IStartupTask
{
    Task ExecuteAsync(CancellationToken cancellationToken = default);
}

public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddStartupTask<T>(this IServiceCollection services)
        where T : class, IStartupTask
        => services.AddTransient<IStartupTask, T>();
}

public static class StartupTaskWebHostExtensions
{
    public static async Task RunWithTasksAsync(this IWebHost webHost, CancellationToken cancellationToken = default)
    {
        //      DI
        var startupTasks = webHost.Services.GetServices<IStartupTask>();

        //   
        foreach (var startupTask in startupTasks)
        {
            await startupTask.ExecuteAsync(cancellationToken);
        }

        //    
        await webHost.RunAsync(cancellationToken);
    }
}

await CreateWebHostBuilder(args).Build().Run();

await CreateWebHostBuilder(args).Build().RunWithTasksAsync();

Solución # 3: para aquellos que cambiaron a ASP.NET Core 3.x

public class WebHost
{
    public virtual async Task StartAsync(CancellationToken cancellationToken = default)
    {
        // ... initial setup
        await Server.StartAsync(hostingApp, cancellationToken).ConfigureAwait(false);

        // Fire IApplicationLifetime.Started
        _applicationLifetime?.NotifyStarted();

        // Fire IHostedService.Start
        await _hostedServiceExecutor.StartAsync(cancellationToken).ConfigureAwait(false);

        // ...remaining setup
    }
}

public class WebHost
{
    public virtual async Task StartAsync(CancellationToken cancellationToken = default)
    {
        // ... initial setup

        // Fire IHostedService.Start
        await _hostedServiceExecutor.StartAsync(cancellationToken).ConfigureAwait(false);

        // ... more setup
        await Server.StartAsync(hostingApp, cancellationToken).ConfigureAwait(false);

        // Fire IApplicationLifetime.Started
        _applicationLifetime?.NotifyStarted();

        // ...remaining setup
    }
}

Solución # 4: la historia del chequeo de salud y Kubernetes

, , , . Kestrel , , « ».

Siempre determine la sonda de preparación.

Si no tiene una sonda de preparación, sus pods se convierten en puntos finales de los servicios casi al instante. Si su aplicación tarda demasiado tiempo en prepararse para aceptar solicitudes entrantes, las solicitudes de los clientes para el servicio también podrán iniciar pods que aún no están listos para aceptar conexiones entrantes. Como resultado, los clientes recibirán un error de "Conexión rechazada".

public class LongTaskHostedService : IHostedService
{
    public async Task StartAsync(CancellationToken cancellationToken)
    {
            Console.WriteLine("Long task started...");
            await Task.Delay(5000, cancellationToken);
            Console.WriteLine("Long task finished.");
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {...}
}

recomendaciones