# Het 'Entity Framework' toevoegen voor Blog Posts (Pt 6)

<!--category-- ASP.NET, Entity Framework -->
<datetime class="hidden">2024-08-20T05:45</datetime>

# 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.

[TOC]

Zie delen [1](/blog/addingentityframeworkforblogpostspt1), [2](/blog/addingentityframeworkforblogpostspt2), [3](/blog/addingentityframeworkforblogpostspt3) , [4](/blog/addingentityframeworkforblogpostspt4) en [5](/blog/addingentityframeworkforblogpostspt5) 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:

```mermaid
   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 :.

```csharp
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:

```csharp
    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.