Einleitung

Jetzt, da ich dieses Blog läuft mit Entity Framework Ich kann neue Beiträge und Sprachen leicht hinzufügen . .. Ich nur eine neue Markdown-Datei zu dem Projekt hinzufügen und überprüfen Sie es in . die GitHub Aktion Trigger und die Website wird aktualisiert .

In diesem Beitrag I'-ll decken ein paar kleine Ergänzungen, die ich zu diesem Prozess gemacht und wie es zukünftige Verbesserungen ermöglicht .

Siehe Teile 1, 2, 3 , 4 und 5 für die vorherigen Schritte

Hintergrundaktualisierung

Eines der Probleme, die ich mit dem Umzug in EF konfrontiert war meinen Prozess für die Aktualisierung der Website zu halten, während nicht verzögern Sie die Website update-.-Ich wollte den Prozess des Hinzufügens eines neuen Pfosten so einfach wie möglich

In den vorherigen Teilen zeigte ich, wie ich eine MarkdownBlogService Dieser Dienst wurde in unsere Controller und Ansichten eingespritzt Dieser Service war ein einfacher Dienst, der Markdown-Dateien von Festplatte lesen und sie als BlogViewModels.

Der Update-Prozess ist wie folgt:

   flowchart LR
    A[Write New Markdown File] -->|Checkin To Github| B(Github Action Triggers)
    B --> C(Builds Docker Image)
    C --> D(Watchtower Pulls new Image)
    D --> E{New Files Added?}
    E -->|Yes| F(Add File to Database)
    E -->|No| G(Skip Database Seeding)
    F --> H(Site Updated)
    G --> H(Site Updated)

Um eine Aktualisierung des Hintergrunds zu ermöglichen, wenn die Seite in ASP-.-NET gestartet wird, verwende ich ein IHostedService um nach neuen Dateien zu suchen und sie der Datenbank hinzuzufügen.

Es ist super einfach und alles, was es tut, ist unten.

public class BackgroundEFBlogUpdater(IServiceScopeFactory scopeFactory, ILogger<BackgroundEFBlogUpdater> logger) : IHostedService
{
    private Task _backgroundTask;
    public async Task StartAsync(CancellationToken cancellationToken)
    {
       
        var scope = scopeFactory.CreateScope();
        var context = scope.ServiceProvider.GetRequiredService<IBlogPopulator>();
        logger.LogInformation("Starting EF Blog Updater");
      
        _backgroundTask = Task.Run(async () =>    await  context.Populate(), cancellationToken);
       logger.LogInformation("EF Blog Updater Finished");
    }

    public async Task StopAsync(CancellationToken cancellationToken)
    {
        
    }
}

Beachten Sie, dass ein kritischer Aspekt hier ist, dass EF sehr wählerisch über es ist. IServiceScopeFactory um einen neuen Bereich für den Dienst zu schaffen.Dies liegt daran, dass der Service ein Singleton ist und EF doesn-'e nicht wie in einem Singleton verwendet wird. Die Verwendung der IServiceScopeFactory ist ein übliches Muster in ASP-. .NET Core, wenn Sie einen Scoped-Dienst in einem Singleton-Service verwenden müssen ?. ?

Ich musste auch benutzen Task.Run um die Aufgabe in einem neuen Thread zu starten IHostedService läuft auf dem Hauptgewinde und ich habe nicht wollen, dass die Anwendung vom Starten blockiert

Das ist die BackgroundEFBlogUpdater injiziert mit der SetupBlog Erweiterungs-Methode I zeigte vor

    public static void SetupBlog(this IServiceCollection services, IConfiguration configuration, IWebHostEnvironment env)
    {
        var config = services.ConfigurePOCO<BlogConfig>(configuration.GetSection(BlogConfig.Section));
       services.ConfigurePOCO<MarkdownConfig>(configuration.GetSection(MarkdownConfig.Section));
       services.AddScoped<CommentService>();
        switch (config.Mode)
        {
            case BlogMode.File:
                Log.Information("Using file based blog");
                services.AddScoped<IBlogService, MarkdownBlogService>();
                services.AddScoped<IBlogPopulator, MarkdownBlogPopulator>();
                break;
            case BlogMode.Database:
                Log.Information("Using Database based blog");
                services.AddDbContext<MostlylucidDbContext>(options =>
                {
                    if (env.IsDevelopment())
                    {
                        options.EnableSensitiveDataLogging(true);
                    }
                    options.UseNpgsql(configuration.GetConnectionString("DefaultConnection"));
                });
                services.AddScoped<IBlogService, EFBlogService>();
            
                services.AddScoped<IBlogPopulator, EFBlogPopulator>();
                services.AddHostedService<BackgroundEFBlogUpdater>();
                break;
        }
        services.AddScoped<IMarkdownBlogService, MarkdownBlogPopulator>();

        services.AddScoped<MarkdownRenderingService>();
    }

Insbesondere diese Linie services.AddHostedService<BackgroundEFBlogUpdater>(); Dieser Dienst wird gestartet, wenn die Anwendung startet und läuft, bis die Anwendung beendet ist.

Dies ist ein einfacher Weg, um die Hintergrundverarbeitung zu Ihrer ASPA.-NET Core-Anwendung hinzuzufügen.

Schlussfolgerung

In diesem Beitrag zeigte ich, wie ich einen Hintergrunddienst zu meiner ASP-.-NET Core Anwendung hinzugefügt, um die Datenbank mit neuen Blogposts zu aktualisieren. Dieser Dienst läuft, wenn die Anwendung startet und fügt neue Dateien in die Datenbank ein.