Arbeiten mit Daten

Tipp

Diese Inhalte sind ein Auszug aus dem eBook „Blazor for ASP NET Web Forms Developers for Azure“, verfügbar unter .NET Docs oder als kostenlos herunterladbare PDF-Datei, die offline gelesen werden kann.

PDF herunterladen

Der Datenzugriff ist das Rückgrat einer ASP.NET Web Forms-App. Was geschieht mit diesen Daten, wenn Sie Webformulare entwickeln? Für Web Forms gab es mehrere Datenzugriffsmöglichkeiten für die Interaktion mit einer Datenbank:

• Projektmappen-Explorer
• ADO.NET
• Entity Framework

Datenquellen waren Steuerelemente, die Sie auf einer Web Forms-Seite verwenden und wie andere Steuerelemente konfigurieren konnten. In Visual Studio konnten Steuerelemente mithilfe benutzerfreundlicher Dialogfelder konfiguriert und an Web Forms-Seiten gebunden werden. Entwickler, die mit einem Low- oder No-Code-Ansatz arbeiten, bevorzugten diese Methode, als Web Forms veröffentlicht wurde.

ADO.NET ist der Low-Level-Ansatz für die Interaktion mit einer Datenbank. Ihre Apps konnten eine Verbindung mit der Datenbank mit Befehlen, Datentabellen und Datasets für die Interaktion herstellen. Die Ergebnisse konnten dann mit wenig Code an Felder auf dem Bildschirm gebunden werden. Der Nachteil dieses Ansatzes bestand darin, dass die ADO.NET-Objekte (Connection, Command und DataTable) an Bibliotheken gebunden waren, die von einem Datenbankanbieter stammten. Durch die Verwendung dieser Komponenten wurde der Code starr und konnte nur schwer zu einer anderen Datenbank migriert werden.

Entity Framework

Entity Framework (EF) ist das Open-Source-Framework für die objektrelationale Zuordnung, das von der .NET Foundation verwaltet wird. EF wurde mit .NET Framework veröffentlicht und ermöglicht es, Code für Datenbankverbindung, Speicherschemas und Interaktionen zu generieren. Mit dieser Abstraktion können Sie sich auf die Geschäftsregeln Ihrer App konzentrieren und die Datenbankverwaltung durch einen vertrauenswürdigen Datenbankadministrator ermöglichen. In .NET können Sie eine aktualisierte Version von EF verwenden, die als EF Core bezeichnet wird. Mit EF Core können Sie die Interaktionen zwischen Ihrem Code und der Datenbank mithilfe einiger Befehle generieren und verwalten, die über das Befehlszeilentool dotnet ef verfügbar sind. Im Folgenden werden einige Beispiele vorgestellt, um Ihnen den Einstieg in die Arbeit mit Datenbanken zu erleichtern.

Code-First-Ansatz in EF

Sie können schnell mit der Erstellung Ihrer Datenbankinteraktionen beginnen, indem Sie zunächst die Klassenobjekte erstellen, mit denen Sie arbeiten möchten. EF enthält ein Tool, mit dem Sie den geeigneten Datenbankcode für Ihre Klassen generieren können. Dieser Ansatz wird als Code-First-Entwicklung bezeichnet. Nehmen Sie an, dass die folgende Product-Klasse für eine Storefront-Beispiel-App vorliegt, die in einer relationalen Datenbank wie Microsoft SQL Server gespeichert werden soll.

public class Product
{
    public int Id { get; set; }

    [Required]
    public string Name { get; set; }

    [MaxLength(4000)]
    public string Description { get; set; }

    [Range(0, 99999,99)]
    [DataType(DataType.Currency)]
    public decimal Price { get; set; }
}

Das Produkt verfügt über einen Primärschlüssel und drei zusätzliche Felder, die in der Datenbank erstellt werden:

• EF erkennt die Eigenschaft Id per Konvention als Primärschlüssel.
• Name wird in einer Spalte für Textwerte gespeichert. Das Attribut [Required] dieser Eigenschaft fügt die Einschränkung not null hinzu, um das deklarierte Verhalten der Eigenschaft zu erzwingen.
• Description wird in einer Spalte für Textwerte gespeichert. Die maximale Länge wurde im Attribut [MaxLength] auf 4000 Zeichen festgelegt. Das Datenbankschema wird mit einer Spalte namens MaxLength und dem Datentyp varchar(4000) konfiguriert.
• Die Eigenschaft Price wird als Währung gespeichert. Das Attribut [Range] generiert geeignete Einschränkungen, um die Datenspeicherung außerhalb der deklarierten Mindest- und Höchstwerte zu verhindern.

Sie müssen die Klasse Product zu einem Datenbankkontext hinzufügen, der die Verbindungs- und Übersetzungsvorgänge für die Datenbank definiert.

public class MyDbContext : DbContext
{
    public DbSet<Product> Products { get; set; }
}

Die Klasse MyDbContext stellt eine Eigenschaft bereit, die den Zugriff und die Übersetzung für die Klasse Product definiert. Ihre Anwendung konfiguriert diese Klasse für die Interaktion mit der Datenbank mit den folgenden Einträgen in der Startup-Methode der Klasse ConfigureServices (oder an der entsprechenden Position in Program.cs, unter Verwendung der builder.Services-Eigenschaft anstelle von services):

services.AddDbContext<MyDbContext>(options =>
    options.UseSqlServer("MY DATABASE CONNECTION STRING"));

Der vorangehende Code stellt eine Verbindung mit einer SQL Server-Datenbank mit der angegebenen Verbindungszeichenfolge her. Sie können die Verbindungszeichenfolge in die Datei appsettings.json, Umgebungsvariablen oder andere Speicherorte für Konfigurationen einfügen und die eingebettete Zeichenfolge entsprechend ersetzen.

Anschließend können Sie die für diese Klasse geeignete Datenbanktabelle mithilfe der folgenden Befehle generieren:

dotnet ef migrations add 'Create Product table'
dotnet ef database update

Mit dem ersten Befehl werden die Änderungen, die Sie am Datenbankschema vornehmen, als neue EF-Migration namens Create Product table definiert. Eine Migration definiert, wie neue Datenbankänderungen angewendet und entfernt werden.

Nach der Anwendung verfügen Sie über eine einfache Product-Tabelle in der Datenbank und über einige neue Klassen, die dem Projekt hinzugefügt wurden und die Verwaltung des Datenbankschemas erleichtern. Diese generierten Klassen werden standardmäßig in einem neuen Ordner namens Migrations abgelegt. Wenn Sie Änderungen an der Klasse Product vornehmen oder weitere ähnliche Klassen hinzufügen möchten, die mit der Datenbank interagieren sollen, müssen Sie die Befehlszeilenbefehle mit einem neuen Namen für die Migration noch mal ausführen. Mit diesem Befehl werden weitere Migrationsklassen generiert, um das Datenbankschema zu aktualisieren.

Database-First-Ansatz in EF

Für vorhandene Datenbanken können Sie die Klassen für EF Core mithilfe der .NET-Befehlszeilentools generieren. Das Gerüst für diese Klassen können Sie mit einer Variation des folgenden Befehls erstellen:

dotnet ef dbcontext scaffold "CONNECTION STRING" Microsoft.EntityFrameworkCore.SqlServer -c MyDbContext -t Product -t Customer

Der vorherige Befehl stellt mithilfe der angegebenen Verbindungszeichenfolge und des Anbieters Microsoft.EntityFrameworkCore.SqlServer eine Verbindung mit der Datenbank her. Nachdem die Verbindung hergestellt wurde, wird eine Datenbankkontext-Klasse namens MyDbContext erstellt. Außerdem werden Unterstützungsklassen für die Tabellen Product und Customer erstellt, die mit den -t-Optionen angegeben wurden. Es gibt viele Konfigurationsoptionen für diesen Befehl, um die für Ihre Datenbank geeignete Klassenhierarchie zu generieren. Eine vollständige Referenz finden Sie in der Dokumentation zu diesem Befehl.

Weitere Informationen zu EF Core finden Sie in der Microsoft-Dokumentation.

Interagieren mit Webdiensten

Bei der Veröffentlichung von ASP.NET wurden für Webserver und -clients bevorzugt SOAP-Dienste eingesetzt, um Daten auszutauschen. Seitdem hat sich viel verändert, und mittlerweile werden für Dienste bevorzugt direkte HTTP-Clientinteraktionen verwendet. Mit ASP.NET Core und Blazor können Sie die Konfiguration für HttpClient in Program.cs oder in der ConfigureServices-Methode der Klasse Startup registrieren. Verwenden Sie diese Konfiguration, wenn Sie mit dem HTTP-Endpunkt interagieren müssen. Sehen Sie sich den folgenden Konfigurationscode an:

// in Program.cs
builder.Services.AddHttpClient("github", client =>
{
    client.BaseAddress = new Uri("http://api.github.com/");
    // Github API versioning
    client.DefaultRequestHeaders.Add("Accept", "application/vnd.github.v3+json");
    // Github requires a user-agent
    client.DefaultRequestHeaders.Add("User-Agent", "BlazorWebForms-Sample");
});

Wenn Sie auf GitHub-Daten zugreifen müssen, erstellen Sie einen Client namens github. Der Client wird mit der Basisadresse konfiguriert, und die Anforderungsheader werden entsprechend festgelegt. Fügen Sie IHttpClientFactory mithilfe der Anweisung @inject oder dem Attribut [Inject] in einer Eigenschaft zu Ihren Blazor-Komponenten hinzu. Mithilfe der folgenden Syntax können Sie Ihren benannten Client erstellen und mit Diensten interagieren:

@inject IHttpClientFactory factory

...

@code {
    protected override async Task OnInitializedAsync()
    {
        var client = factory.CreateClient("github");
        var response = await client.GetAsync("repos/dotnet/docs/issues");
        response.EnsureStatusCode();
        var content = await response.Content.ReadAsStringAsync();
    }
}

Diese Methode gibt die Zeichenfolge zurück, die die Issues im GitHub-Repository dotnet/docs beschreibt. Der Inhalt wird im JSON-Format zurückgegeben und in entsprechende Objekte für GitHub-Issues deserialisiert. Es gibt verschiedene Möglichkeiten, HttpClientFactory so zu konfigurieren, dass vorkonfigurierte HttpClient-Objekte bereitgestellt werden. Konfigurieren Sie mehrere Instanzen von HttpClient mit unterschiedlichen Namen und Endpunkten für die verschiedenen Webdienste, mit denen Sie arbeiten. Durch diesen Ansatz wird die Interaktion mit diesen Diensten insgesamt vereinfacht. Weitere Informationen erhalten Sie unter Stellen von HTTP-Anforderungen mithilfe von IHttpClientFactory in ASP.NET Core.

ZurückWeiter