Inleiding

Nu ik deze blog met Entity Framework laat draaien, kan ik gemakkelijk nieuwe posts en talen toevoegen. Ik voeg gewoon een nieuwe merkdown-file toe aan het project en check hem in. De GitHub-actie activeert en de site is opgedateerdM SK2

In deze post zal ik een paar kleine aanpassingen aan dit proces behandelen en hoe het toekomstige verbeteringen mogelijk maakt.

Zie delen 1, 2, 3 , 4 en 5 voor de vorige stappen.

Agtergrond Opdateer

Een van de problemen die ik tegenkwam toen ik naar EF verhuisde, was het behouden van mijn proces om de site te updaten zonder te vertragen met de siteupdate. Ik wilde het proces van het toevoegen van een nieuwe post zo eenvoudig mogelijk houden.

In de vorige delen toonde ik hoe ik een MarkdownBlogService om de blogposts en talen te krijgen. Deze dienst werd geïnjecteerd in onze controllers en aansigten. Deze service was een eenvoudige dienst die afteken-bestanden van disket las en ze terugvoerde als BlogViewModels.

Het updateproces is als volgt:

   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)

Om de achtergrond te laten opdateren wanneer de site begint in ASP.NET gebruik ik een IHostedService om nieuwe files te controleren en ze in de database toe te voegen.

Het is super simpel en alles wat het doet, is onder :.

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

Let op dat één van de cruciale aspecten hier is dat EF er heel kieskeurig over is. IServiceScopeFactory Dit komt omdat de dienst een enkelton is en EF het niet leuk vindt dat ' in één enkelton wordt gebruikt. Het gebruik van de IServiceScopeFactory is een gemeenschappelijk patroon in ASP.NET Core wanneer je een gespecificeerde dienst in een singleton-dienst moet gebruiken.

Ik moest ook Task.Run om de taak in een nieuw thread te runnen. Dit is omdat het IHostedService Het draait op de hoofdstroom en ik wilde de toepassing niet blokkeren vanaf het starten.

Dit is de BackgroundEFBlogUpdater class. Het' wordt geïnjecteerd met behulp van de SetupBlog Verlengingsmethode die ik eerder liet zien:

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

Vooral deze lijn. services.AddHostedService<BackgroundEFBlogUpdater>(); In ASP.NET Core start dit een nieuw HostedService dat in de achtergrond werkt. Deze dienst wordt gestart als de applicatie begint en loopt tot het stopt.

Dit is een eenvoudige manier om achtergrondverwerking aan je ASP toe te voegen.

In slotting:

In deze post toonde ik hoe ik een achtergronddienst aan mijn ASP toevoegde.NET Core-applicatie om de database met nieuwe blogposts te updaten. Deze dienst werkt wanneer de applicatie begint en alle nieuwe lêers aan de database voegt.