# Hinzufügen von Entity Framework für Blog-Posts

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

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

[TOC]

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

```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)

```

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.

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

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

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

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.