Asynchroner Code in Startup ASP.NET Core: 4 Möglichkeiten, um GetAwaiter () zu umgehen. GetResult ()

Hintergrund zur Arbeitsaufgabe

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 () stört mich. GetResult (), Microsoft jedoch nicht

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

Die Rolle asynchroner Aufgaben beim Starten eines Webdienstes

Problem: Es ist erforderlich, den Webdienst so zu starten, dass er die Anforderungen seiner Clients verarbeitet. Gleichzeitig gibt es eine Reihe von (relativ) langwierigen Vorgängen, ohne die der Dienst dem Client nicht antworten kann, oder seine Antworten sind falsch.

• Validierung stark typisierter Konfigurationen.
• Den Cache füllen.
• Vorläufige Verbindung zur Datenbank oder zu anderen Diensten.
• Laden von JIT und Baugruppe (Aufwärmen des Dienstes).
• Datenbankmigration. Dies ist eines der Beispiele für Andrew Lock, aber er selbst gibt zu, dass dieser Vorgang beim Starten des Dienstes schließlich unerwünscht ist .

Lösung 1: Eine funktionierende Lösung, die die Erben verwirren kann

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

Lösung 2: Betten Sie asynchrone Operationen in DI ein

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

Lösung 3: Für diejenigen, die zu ASP.NET Core 3.x gewechselt sind

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

Lösung 4: Die Geschichte von Health Check und Kubernetes

, , , . Kestrel , , « ».

Bestimmungssonde immer bestimmen.

Wenn Sie keine Bereitschaftsprüfung haben, werden Ihre Pods fast sofort zu Endpunkten von Diensten. Wenn Ihre Anwendung zu viel Zeit benötigt, um eingehende Anfragen anzunehmen, können Kundenanfragen für den Service auch Pods starten, die noch nicht bereit sind, eingehende Verbindungen anzunehmen. Infolgedessen erhalten Clients den Fehler "Verbindung abgelehnt".

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

Ergebnisse