Code asynchrone dans Startup ASP.NET Core: 4 façons de contourner GetAwaiter (). GetResult ()

Contexte de la tâche de travail

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

Je suis gêné par GetAwaiter (). GetResult (), mais Microsoft n'est pas

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

Le rôle des tâches asynchrones dans le démarrage d'un service Web

Problème: il est nécessaire de démarrer le service web pour qu'il traite les demandes de ses clients, mais en même temps il y a un ensemble de quelques opérations (relativement) longues, sans lesquelles le service ne peut pas répondre au client, ou ses réponses seront incorrectes.

• Validation de configurations fortement typées.
• Remplir le cache.
• Connexion préliminaire à la base de données ou à d'autres services.
• Chargement JIT et Assembly (préchauffage de service).
• Migration de la base de données. C'est l'un des exemples d'Andrew Lock, mais lui-même admet qu'après tout, cette opération n'est pas souhaitable lors du démarrage du service .

Solution # 1: une solution de travail qui peut confondre les héritiers

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

Solution n ° 2: intégrer des opérations asynchrones dans 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();

Solution n ° 3: pour ceux qui sont passés à 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
    }
}

Solution n ° 4: l'histoire du bilan de santé et de Kubernetes

, , , . Kestrel , , « ».

Déterminez toujours la sonde de préparation.

Si vous ne disposez pas d'une sonde de préparation, vos pods deviennent presque instantanément des points d'extrémité de services. Si votre application met trop de temps à se préparer à accepter les demandes entrantes, les demandes des clients pour le service pourront également démarrer des modules qui ne sont pas encore prêts à accepter les connexions entrantes. Par conséquent, les clients recevront une erreur «Connexion refusée».

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

résultats