Lernprogramm: Verbinden einer ASP.NET Core-App mit SQL Server mithilfe von .NET Aspire und Entity Framework Core

In diesem Tutorial erstellen Sie eine ASP.NET Core-App, die eine .NET AspireEntity Framework CoreSQL Server-Integration verwendet, um eine Verbindung zu SQL Server herzustellen, um Supportticketdaten zu lesen und zu schreiben. Entity Framework Core ist ein einfacher, erweiterbarer, open source-objektrelationaler Mapper, der es .NET Entwicklern ermöglicht, mit Datenbanken mit .NET Objekten zu arbeiten. Hier erfahren Sie, wie Sie:

• Erstellen Sie eine einfache .NET-App, die für die Verwendung von .NET Aspire-Integrationen eingerichtet ist
• Füge eine .NET Aspire-Integration hinzu, um eine Verbindung mit SQL Server herzustellen.
• Konfigurieren und verwenden Sie .NET.NET Aspire Komponentenfunktionen zum Lesen und Schreiben in der Datenbank

Voraussetzungen

Um mit .NET.NET Aspirezu arbeiten, benötigen Sie folgendes lokal installiert:

• .NET 8.0 oder .NET 9,0
• Eine OCI-kompatible Containerlaufzeit, z. B.:
  • Docker Desktop oder Podman. Weitere Informationen finden Sie im Abschnitt Container Runtime.
• Eine integrierte Entwicklerumgebung (Integrated Developer Environment, IDE) oder ein Code-Editor, z. B.:
  • Visual Studio 2022 Version 17.9 oder höher (optional)
  • Visual Studio Code (optional)
    • C# Dev Kit: Erweiterung (wahlweise)
  • JetBrains Rider mit .NET.NET Aspire Plug-in (Optional)

Weitere Informationen finden Sie unter .NET.NET Aspire Setup und Toolingund .NET.NET Aspire SDK.

Erstellen der Beispiellösung

1. Navigieren Sie oben in Visual Studiozu Datei>Neues>Projekt.
2. Suchen Sie im Dialogfeld nach Blazor und wählen Sie Blazor Web-Appaus. Wählen Sie Weiteraus.
3. Führen Sie auf dem Bildschirm "Konfigurieren des neuen Projekts" Folgendes aus:
   • Geben Sie einen Projektnamen von AspireSQLEFCoreein.
   • Behalten Sie den rest der Werte bei ihren Standardwerten bei, und wählen Sie Weiteraus.
4. Auf dem Bildschirm Zusätzliche Informationen:
   • Stellen Sie sicher, dass .NET 9,0 ausgewählt ist.
   • Stellen Sie sicher, dass der interaktiver Rendermodus auf Nonefestgelegt ist.
   • Aktivieren Sie die Option Enlist in .NET.NET Aspire Orchestrierungsoption, und wählen Sie Erstellenaus.

Visual Studio erstellt eine neue ASP.NET Core-Lösung, die so strukturiert ist, dass sie .NET Aspireverwendet. Die Lösung besteht aus den folgenden Projekten:

• AspireSQLEFCore-: Ein Blazor-Projekt, das von den Standardeinstellungen der Dienste abhängt.
• AspireSQLEFCore.AppHost: Ein Orchestratorprojekt, das für die Verbindung und Konfiguration der verschiedenen Projekte und Dienste Ihrer App entwickelt wurde. Der Orchestrator sollte als Startprojekt festgelegt werden.
• AspireSQLEFCore.ServiceDefaults: Eine freigegebene Klassenbibliothek zum Speichern von Konfigurationen, die in allen Projekten in Ihrer Lösung wiederverwendet werden können.

Erstellen des Datenbankmodells und der Kontextklassen

Um eine vom Benutzer übermittelte Supportanfrage darzustellen, fügen Sie die folgende SupportTicket Modellklasse im Stammverzeichnis des projekts AspireSQLEFCore hinzu.

using System.ComponentModel.DataAnnotations;

namespace AspireSQLEFCore;

public sealed class SupportTicket
{
    public int Id { get; set; }
    [Required]
    public string Title { get; set; } = string.Empty;
    [Required]
    public string Description { get; set; } = string.Empty;
}

Fügen Sie die folgende TicketDbContext Datenkontextklasse im Stammverzeichnis des projekts AspireSQLEFCore hinzu. Die Klasse erbt System.Data.Entity.DbContext, um mit Entity Framework zu arbeiten und Ihre Datenbank darzustellen.

using Microsoft.EntityFrameworkCore;
using System.Reflection.Metadata;

namespace AspireSQLEFCore;

public class TicketContext(DbContextOptions options) : DbContext(options)
{
    public DbSet<SupportTicket> Tickets => Set<SupportTicket>();
}

Füge die .NET Aspire-Integration zur Blazor-App hinzu

Fügen Sie das .NET AspireEntity Framework Core SQL-Server-Bibliothekspaket zu Ihrem AspireSQLEFCore--Projekt hinzu.

dotnet add package Aspire.Microsoft.EntityFrameworkCore.SqlServer

Ihr AspireSQLEFCore Projekt ist jetzt für die Verwendung von .NET.NET Aspire Integrationen konfiguriert. Hier ist die aktualisierte Datei AspireSQLEFCore.csproj:

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>net9.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Aspire.Microsoft.EntityFrameworkCore.SqlServer" Version="9.0.0" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\AspireSQLEFCore.ServiceDefaults\AspireSQLEFCore.ServiceDefaults.csproj" />
  </ItemGroup>

</Project>

Konfiguration der .NET.NET Aspire-Integration

Fügen Sie in der Datei Program.cs des Projekts AspireSQLEFCore nach der Erstellung von builder, aber vor dem Aufruf von AddServiceDefaults, einen Aufruf der Erweiterungsmethode AddSqlServerDbContext hinzu. Weitere Informationen finden Sie unter .NET.NET Aspire Dienststandardeinstellungen. Geben Sie den Namen der Verbindungszeichenfolge als Parameter an.

using AspireSQLEFCore;
using AspireSQLEFCore.Components;

var builder = WebApplication.CreateBuilder(args);
builder.AddSqlServerDbContext<TicketContext>("sqldata");

builder.AddServiceDefaults();

// Add services to the container.
builder.Services.AddRazorComponents().AddInteractiveServerComponents();

var app = builder.Build();

app.MapDefaultEndpoints();

Diese Methode führt die folgenden Aufgaben aus:

• Registriert ein TicketContext mit dem DI-Container, um eine Verbindung zur containerisierten Azure SQL-Datenbank herzustellen.
• Automatisch entsprechende Gesundheitsprüfungen, Protokollierung und Telemetrie aktivieren.

Erstellen der Datenbank

Beim lokalen Entwickeln müssen Sie eine Datenbank innerhalb des SQL Server-Containers erstellen. Aktualisieren Sie die Program.cs Datei mit dem folgenden Code:

using AspireSQLEFCore;
using AspireSQLEFCore.Components;

var builder = WebApplication.CreateBuilder(args);
builder.AddSqlServerDbContext<TicketContext>("sqldata");

builder.AddServiceDefaults();

// Add services to the container.
builder.Services.AddRazorComponents().AddInteractiveServerComponents();

var app = builder.Build();

app.MapDefaultEndpoints();

if (app.Environment.IsDevelopment())
{
    using (var scope = app.Services.CreateScope())
    {
        var context = scope.ServiceProvider.GetRequiredService<TicketContext>();
        context.Database.EnsureCreated();
    }
}
else
{
    app.UseExceptionHandler("/Error", createScopeForErrors: true);
    // The default HSTS value is 30 days.
    // You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
    app.UseHsts();
}

Der vorherige Code:

• Überprüft, ob die App in einer Entwicklungsumgebung ausgeführt wird.
• Falls dies der Fall ist, ruft er den TicketContext-Dienst aus dem DI-Container ab und ruft Database.EnsureCreated() auf, um die Datenbank zu erstellen, falls sie noch nicht existiert.

Anmerkung

Beachten Sie, dass EnsureCreated() nicht für Produktionsumgebungen geeignet ist und nur die Im Kontext definierte Datenbank erstellt. Es werden keine Migrationen angewendet. Weitere Informationen zu Entity Framework Core-Migrationen in .NET Aspirefinden Sie in im Abschnitt "Anwenden von Entity Framework Core-Migrationen in .NET Aspire".

Erstellen des Formulars

Für die App ist ein Formular erforderlich, damit der Benutzer die Informationen eines Support-Tickets übermitteln und den Eintrag in die Datenbank speichern kann.

Verwenden Sie das folgende Razor-Markup, um ein einfaches Formular zu erstellen, indem Sie den Inhalt der Datei Home.razor im Verzeichnis AspireSQLEFCore/Components/Pages ersetzen.

@page "/"
@inject TicketContext context

<div class="row">
    <div class="col-md-6">
        <div>
            <h1 class="display-4">Request Support</h1>
        </div>
        <EditForm Model="@Ticket" FormName="Tickets" method="post"
                  OnValidSubmit="@HandleValidSubmit" class="mb-4">
            <DataAnnotationsValidator />
            <div class="mb-4">
                <label>Issue Title</label>
                <InputText class="form-control" @bind-Value="@Ticket.Title" />
                <ValidationMessage For="() => Ticket.Title" />
            </div>
            <div class="mb-4">
                <label>Issue Description</label>
                <InputText class="form-control" @bind-Value="@Ticket.Description" />
                <ValidationMessage For="() => Ticket.Description" />
            </div>
            <button class="btn btn-primary" type="submit">Submit</button>
            <button class="btn btn-danger mx-2" type="reset" @onclick=@ClearForm>Clear</button>
        </EditForm>

        <table class="table table-striped">
            @foreach (var ticket in Tickets)
            {
                <tr>
                    <td>@ticket.Id</td>
                    <td>@ticket.Title</td>
                    <td>@ticket.Description</td>
                </tr>
            }
        </table>
    </div>
</div>

@code {
    [SupplyParameterFromForm(FormName = "Tickets")]
    private SupportTicket Ticket { get; set; } = new();

    private List<SupportTicket> Tickets = [];

    private void ClearForm() => Ticket = new();

    protected override async Task OnInitializedAsync()
    {
        Tickets = await context.Tickets.ToListAsync();
    }

    private async Task HandleValidSubmit()
    {
        context.Tickets.Add(Ticket);

        await context.SaveChangesAsync();

        Tickets = await context.Tickets.ToListAsync();

        ClearForm();
    }
}

Weitere Informationen zum Erstellen von Formularen in Blazorfinden Sie unter ASP.NET CoreBlazor Formularübersicht.

Konfigurieren des AppHost

Das AspireSQLEFCore.AppHost Projekt ist der Orchestrator für Ihre App. Sie ist für das Verbinden und Konfigurieren der verschiedenen Projekte und Dienste Ihrer App verantwortlich. Der Orchestrator sollte als Startprojekt festgelegt werden.

Fügen Sie das .NET Aspire Hosting Sql Server NuGet-Paket zu Ihrem AspireStorage.AppHost Projekt hinzu.

dotnet add package Aspire.Hosting.SqlServer

Ersetzen Sie den Inhalt der Program.cs Datei im AspireSQLEFCore.AppHost Projekt durch den folgenden Code:

var builder = DistributedApplication.CreateBuilder(args);

var sql = builder.AddSqlServer("sql")
                 .AddDatabase("sqldata");

builder.AddProject<Projects.AspireSQLEFCore>("aspiresql")
       .WithReference(sql)
       .WaitFor(sql);

builder.Build().Run();

Der vorangehende Code fügt Ihrer App eine SQL Server Containerressource hinzu und konfiguriert eine Verbindung mit einer Datenbank namens sqldata. Die zuvor konfigurierten Entity Framework-Klassen verwenden diese Verbindung automatisch beim Migrieren und Herstellen einer Verbindung mit der Datenbank.

Lokales Ausführen und Testen der App

Die Beispiel-App kann jetzt getestet werden. Überprüfen Sie, ob die übermittelten Formulardaten in der Datenbank beibehalten werden, indem Sie die folgenden Schritte ausführen:

1. Wählen Sie oben in Visual Studio (oder F5) die Schaltfläche "Ausführen" aus, um Ihr .NET.NET Aspire Projektdashboard im Browser zu starten.

2. Klicken Sie auf der Projektseite in der Zeile AspireSQLEFCore auf den Link in der Spalte Endpunkte, um die Benutzeroberfläche Ihrer App zu öffnen.

   

3. Geben Sie Beispieldaten in die Title und Description Formularfelder ein.

4. Wählen Sie die Schaltfläche Absenden aus, und das Formular übermittelt das Supportticket zur Verarbeitung – (wählen Sie dann Löschen aus, um das Formular zu löschen).

5. Die übermittelten Daten werden in der Tabelle am unteren Rand der Seite angezeigt, wenn die Seite neu geladen wird.

Siehe auch

• .NET .NET Aspire mit SQL-Datenbank-Implementierung
• .NET Aspire Bereitstellung über Azure Container Apps
• Bereitstellen eines .NET Aspire Projekts mithilfe von GitHub Aktionen