Wie man Blazor WebAssembly Webkomponenten mit einem Northwind-Datenmodell entwickelt

Die Entwicklung von Webanwendungen unter Verwendung von Blazor WebAssembly erfordert eine sorgfältige Planung sowohl der Client- als auch der Server-Komponenten. Der Fokus dieses Kapitels liegt auf der Entwicklung einer Blazor WebAssembly-Anwendung, die eine Web-API mit dem Northwind-Datenmodell verwendet. In diesem Kontext werden die Schritte zur Erstellung und Konfiguration von Server- und Client-Projekten sowie zur Implementierung von Webdiensten, die auf Entitäten zugreifen, detailliert erläutert.

Im Gegensatz zu früheren Projekten, in denen relative Pfadreferenzen direkt auf die benötigten Ressourcen zugreifen konnten, erfordert dieses Projekt eine höhere Ebene von Ordnern. Die Verzeichnistiefe wird aufgrund der zusätzlichen Server-, Client- und Shared-Ordner auf drei Ebenen erhöht, was zu einem veränderten Umgang mit Dateipfaden führt. Daher müssen relative Pfade bei Referenzen angepasst werden, um die ordnungsgemäße Funktionalität zu gewährleisten.

Projektaufbau und Konfiguration

Der erste Schritt besteht darin, das Serverprojekt (Northwind.BlazorWasm.Server) über die Befehlszeile oder das Terminal zu erstellen. Dies gewährleistet, dass alle notwendigen Abhängigkeiten und Konfigurationen für den Server ordnungsgemäß installiert sind. In der Program.cs-Datei des Serverprojekts sind dann die benötigten Namespaces zu importieren. Diese umfassen unter anderem Namespaces für Minimal-API-Attribute, das Hinzufügen des Northwind-Datenbankkontexts und die Konfiguration der JSON-Serialisierung:

csharp
Copy code
using Microsoft.AspNetCore.Mvc;

using Packt.Shared; 
using System.Text.Json.Serialization;
using HttpJsonOptions = Microsoft.AspNetCore.Http.Json.JsonOptions;

Nach der Erstellung des Builders wird eine Konfiguration für den Dienst zur Behandlung von JSON-Optionen hinzugefügt. Dabei ist besonders darauf zu achten, dass die Referenzbeziehungen (beispielsweise zwischen einem Mitarbeiter und seinem Vorgesetzten) nicht zu einer Laufzeit-Ausnahme führen, wenn zirkuläre Referenzen auftreten:

csharp
Copy code
builder.Services.Configure(options => {

    options.SerializerOptions.ReferenceHandler = ReferenceHandler.Preserve;
});

Es ist wichtig, Microsoft.AspNetCore.Http.Json.JsonOptions und nicht Microsoft.AspNetCore.Mvc.JsonOptions zu konfigurieren, da letzteres für andere Arten erforderlich ist.

Zusätzlich wird der Northwind-Datenbankkontext in den Dependency Injection-Dienst hinzugefügt:

csharp
Copy code
builder.Services.AddNorthwindContext();

Nun können Endpunkte definiert werden, um mit den Mitarbeiterdaten zu arbeiten. Dazu gehören GET- und POST-Methoden, um Mitarbeiter abzurufen oder hinzuzufügen. Beispielhaft sieht der Code wie folgt aus:

csharp
Copy code
app.MapGet("api/employees", ([FromServices] NorthwindContext db) => 

    Results.Json(db.Employees)).WithName("GetEmployees").Produces(StatusCodes.Status200OK);

Ein weiterer Endpunkt ermöglicht das Abrufen eines bestimmten Mitarbeiters basierend auf der ID:

csharp
Copy code
app.MapGet("api/employees/{id:int}", ([FromServices] NorthwindContext db, [FromRoute] int id) => {
    Employee? employee = db.Employees.Find(id);
    if (employee == null) {
        return Results.NotFound();
    } else {
        return Results.Json(employee);
    }
});

Ein POST-Endpunkt ermöglicht es, einen neuen Mitarbeiter zu erstellen und in der Datenbank zu speichern:

csharp
Copy code
app.MapPost("api/employees", async ([FromBody] Employee employee, [FromServices] NorthwindContext db) => {

    db.Employees.Add(employee);
    await db.SaveChangesAsync();
    return Results.Created($"api/employees/{employee.EmployeeId}", employee);
});

Integration von Blazor Client-Seite

Der Client, der auf Blazor WebAssembly basiert, wird mit einer zusätzlichen Abhängigkeit für die QuickGrid-Komponente ausgestattet. QuickGrid ist ein Open-Source-Komponentenpaket, das eine grundlegende Grid-Komponente bietet, die für die Anzeige von Entitäten in einer tabellarischen Form verwendet werden kann.

csharp
Copy code
builder.Services.AddHttpClient("Northwind.BlazorWasm.ServerAPI", client => 
    client.BaseAddress = new Uri(builder.HostEnvironment.BaseAddress));

In der _Imports.razor-Datei werden dann die entsprechenden Namespaces importiert, um die Verwendung von QuickGrid und JSON-Serialisierung zu ermöglichen:

razor
Copy code
@using Microsoft.AspNetCore.Components.QuickGrid

@using System.Text.Json
@using System.Text.Json.Serialization

Die Employees.razor-Seite ist dafür verantwortlich, eine Liste der Mitarbeiter zu laden und anzuzeigen. Dabei wird die Möglichkeit berücksichtigt, die Liste entweder für alle Mitarbeiter oder für Mitarbeiter aus einem bestimmten Land zu filtern. Der HTTP-Client wird verwendet, um die Daten vom Server abzurufen und die Mitarbeiter in einem QuickGrid anzuzeigen:

razor
Copy code
@inject IHttpClientFactory httpClientFactory

@code {
    [Parameter] public string? Country { get; set; }
    private IQueryable? employees;
    protected override async Task OnParametersSetAsync() {
        Employee[]? employeesArray = null;
        JsonSerializerOptions jsonOptions = new() { 
            ReferenceHandler = ReferenceHandler.Preserve, 
            PropertyNameCaseInsensitive = true 
        };
        HttpClient client = httpClientFactory.CreateClient("Northwind.BlazorWasm.ServerAPI");
        string path = "api/employees";
        try {
            employeesArray = (await client.GetFromJsonAsync(path, jsonOptions));
        } catch (Exception ex) {
            Console.WriteLine($"{ex.GetType()}: {ex.Message}");
        }
        if (employeesArray is not null) {
            employees = employeesArray.AsQueryable();
            if (!string.IsNullOrWhiteSpace(Country)) {
                employees = employees.Where(emp => emp.Country == Country);
            }
        }
    }
}

Der HTTP-Client kommuniziert mit der API, um die Mitarbeiterdaten abzurufen. Da zirkuläre Referenzen zwischen den Entitäten auftreten können (z.B. zwischen einem Mitarbeiter und seinem Manager), wird die Serialisierung so konfiguriert, dass Referenzen beibehalten werden, um Laufzeitfehler zu vermeiden. Auch wenn der Webdienst eine Filterung nach Land ermöglicht, wird in diesem Fall der gesamte Mitarbeiterstamm abgerufen und eine clientseitige Filterung angewendet, um die Daten im Grid anzuzeigen.

Weitere Hinweise zur Implementierung

Es ist wichtig zu beachten, dass beim Aufbau von Webanwendungen mit Blazor WebAssembly und minimalen APIs eine präzise Handhabung von Datenstrukturen und deren Serialisierung erforderlich ist. Der Umgang mit zirkulären Referenzen, insbesondere bei komplexen Entitäten wie denen im Northwind-Datenmodell, erfordert sorgfältige Planung, um Laufzeitfehler zu vermeiden.

Welche neuen Funktionen bringt C# 11 und .NET 7 für Entwickler?

In der Entwicklung von Anwendungen und Services mit .NET gibt es ständig neue Funktionen und Verbesserungen, die den Programmieralltag erleichtern und die Entwicklungseffizienz steigern sollen. Mit der Einführung von .NET 7 und C# 11 wurden zahlreiche Neuerungen und Optimierungen eingeführt, die es Entwicklern ermöglichen, leistungsfähigere und wartungsfreundlichere Software zu erstellen. Eine dieser Neuerungen ist die vereinfachte Handhabung von null-Werten in Methodenparametern.

Frühere Versionen von C# erforderten häufig explizite Nullprüfungen, bei denen eine Methode aufgerufen wurde, um zu überprüfen, ob ein Parameter null war, und gegebenenfalls eine Ausnahme zu werfen. In früheren C#-Versionen musste dies mit einem if-Statement und dem Werfen einer ArgumentNullException erfolgen, um sicherzustellen, dass die Parameter korrekt übergeben wurden. Hier ein einfaches Beispiel aus der Praxis:

csharp
Copy code
public void Hire(Person manager, Person employee) {
   if (manager == null) {
       throw new ArgumentNullException(nameof(manager));
   }
   if (employee == null) {
       throw new ArgumentNullException(nameof(employee));
   }
   ...
}

Mit .NET 6 wurde diese Vorgehensweise vereinfacht, indem eine neue Methode eingeführt wurde, die automatisch eine Ausnahme wirft, falls ein Argument null ist. Dies verbessert den Codefluss und macht die Anwendung sicherer und leserlicher:

csharp
Copy code
public void Hire(Person manager, Person employee) {

   ArgumentNullException.ThrowIfNull(manager);
   ArgumentNullException.ThrowIfNull(employee);
   ...
}

Doch C# 11 geht noch einen Schritt weiter. Im Jahr 2022 wurde ein neuer Operator in den Vorabversionen von C# 11 eingeführt: der !!-Operator. Dieser Operator ermöglicht es, Nullprüfungen direkt in der Methodensignatur durchzuführen, was den Code erheblich vereinfacht. Ein Beispiel:

csharp
Copy code
public void Hire(Person manager!!, Person employee!!) {

   ...
}

Obwohl dieser Operator theoretisch eine erhebliche Reduzierung von Boilerplate-Code ermöglichen würde, wurde er aufgrund von gemischten Reaktionen innerhalb der Entwicklergemeinschaft wieder aus den Vorabversionen entfernt. Die Erwartungen, dass dieser Operator in der endgültigen Version zurückkehren würde, haben sich nicht erfüllt. Microsoft entschied sich daher, diese Funktion zu streichen. Daher ist es derzeit eher unwahrscheinlich, dass der !!-Operator in künftigen Versionen von C# wieder eingeführt wird.

Neben den Verbesserungen in der Null-Prüfung brachte C# 11 auch eine Reihe weiterer interessanter Features mit sich. Besonders hervorzuheben sind die sogenannten "Raw String Literals". Diese ermöglichen es Entwicklern, beliebige Textinhalte ohne Escape-Zeichen direkt in den Code einzufügen. Das ist besonders nützlich für die Arbeit mit Formatierungen oder Code, der mehrere Escape-Zeichen benötigt, wie etwa bei der Verarbeitung von JSON, HTML oder XML. Ein Beispiel für die Verwendung eines Raw String Literals:

csharp
Copy code
string xml = """
   <Mark>...</Mark>
   """;

Der Compiler erkennt automatisch die Einrückung und entfernt diese aus dem Inhalt, wodurch der Code übersichtlicher und leichter wartbar wird. Das ist besonders praktisch, wenn der Code in verschiedene Textformate eingebettet wird.

csharp
Copy code
public class Book {

   public required string Isbn { get; set; }

   public string? Title { get; set; }
}

Versucht ein Entwickler, eine Instanz der Book-Klasse zu erstellen, ohne den Isbn-Wert zu setzen, wird ein Compilerfehler erzeugt. Diese Art der statischen Prüfung zur Kompilierzeit trägt dazu bei, Laufzeitfehler zu vermeiden.

C# 11 unterstützt nun auch die Definition von generischen Attributen, eine Funktion, die es Entwicklern ermöglicht, wiederverwendbare und typsichere Attribute zu erstellen. Dies verbessert die Flexibilität und Modularität von .NET-Anwendungen und reduziert die Notwendigkeit für sich wiederholende Codebausteine.

Ein weiteres Highlight von C# 11 und .NET 7 ist die Unterstützung für "Generische Mathematik". Dies bedeutet, dass Entwickler jetzt eigene numerische Typen definieren können, die dann mit den gleichen mathematischen Operatoren arbeiten wie integrierte Datentypen wie int und double. Dies eröffnet Möglichkeiten für die Erstellung von benutzerdefinierten mathematischen Berechnungen und Algorithmen, die über die traditionellen numerischen Datentypen hinausgehen.

Es ist wichtig zu betonen, dass die hier beschriebenen neuen Funktionen eine erhebliche Verbesserung der Entwicklungspraktiken bieten. Besonders die Vereinfachung der Nullprüfungen und die Einführung von required-Eigenschaften steigern die Codequalität und reduzieren das Risiko von Fehlern. Darüber hinaus ermöglichen die neuen Features eine größere Flexibilität beim Arbeiten mit verschiedenen Datenformaten und der Definition von benutzerdefinierten Typen.

Die kontinuierliche Entwicklung von C# und .NET wird immer mehr auf die Bedürfnisse von Entwicklern abgestimmt, wobei das Ziel darin besteht, den Entwicklungsprozess effizienter und fehlerfreier zu gestalten. Es bleibt spannend, welche weiteren Verbesserungen zukünftige Versionen bringen werden.

Wie man mit konkurrierendem Zugriff auf geteilte Ressourcen in C# umgeht

In multithreaded Anwendungen, in denen mehrere Threads auf dieselbe Ressource zugreifen, kann es zu Problemen kommen, wenn zwei oder mehr Threads gleichzeitig auf diese Ressource zugreifen und sie ändern. Ein typisches Beispiel hierfür ist die gleichzeitige Änderung einer Nachricht durch mehrere Threads. Solche Szenarien können durch den Einsatz von Synchronisationsmechanismen wie "Locks" verhindert werden. In diesem Abschnitt zeigen wir, wie man mit dem Konzept des "Locks" in C# umgeht und mögliche Probleme wie Deadlocks und Thread-Sicherheit vermeidet.

Zunächst einmal stellt sich die Frage, wie man verhindern kann, dass mehrere Threads gleichzeitig auf eine Ressource zugreifen und diese verändern. Dies lässt sich erreichen, indem man ein so genanntes "Lock" einführt. Ein Lock ist ein Mechanismus, der sicherstellt, dass immer nur ein Thread gleichzeitig auf eine Ressource zugreifen kann. In C# wird dies typischerweise durch das Schlüsselwort lock umgesetzt, das einen so genannten "Conch"-Objekt verwendet. Ein Conch ist ein einfaches Objekt, das als Mutex fungiert und dafür sorgt, dass immer nur ein Thread auf die geschützte Ressource zugreifen kann.

Implementierung eines Locks mit dem Conch-Objekt

csharp
Copy code
public static object Conch = new();

Nun können wir in den Methoden, die auf die gemeinsam genutzte Ressource zugreifen, das Lock anwenden. Dies geschieht durch das Hinzufügen des lock-Schlüsselworts, wie im folgenden Beispiel gezeigt:

csharp
Copy code
lock (SharedObjects.Conch)

{
    for (int i = 0; i < 5; i++)
    {
        Thread.Sleep(Random.Shared.Next(2000));
        SharedObjects.Message += "A";
        Write(".");
    }
}

Es ist wichtig zu beachten, dass das Lock nicht nur in einer Methode angewendet werden sollte. Wenn nur eine der beiden Methoden ein Lock verwendet, bleibt die Ressource weiterhin von mehreren Threads zugänglich, was das Problem des konkurrierenden Zugriffs nicht löst. Alle Methoden, die auf die Ressource zugreifen, sollten das Lock respektieren.

Die Verwendung eines Locks sorgt dafür, dass entweder Methode A oder Methode B zuerst ausgeführt wird. Sobald eine Methode ihre Arbeit an der Ressource abgeschlossen hat, wird das Lock freigegeben, und der andere Thread hat die Möglichkeit, die Ressource zu nutzen.

Funktionsweise des lock-Schlüsselworts

csharp
Copy code
try
{
    Monitor.Enter(SharedObjects.Conch);
    // Arbeit mit der gemeinsam genutzten Ressource
}
finally
{
    Monitor.Exit(SharedObjects.Conch);
}

Vermeidung von Deadlocks

Ein weiterer wichtiger Aspekt der Thread-Synchronisation ist die Vermeidung von Deadlocks. Ein Deadlock tritt auf, wenn zwei oder mehr Threads in einer Weise aufeinander warten, dass keiner von ihnen fortfahren kann. Dies kann passieren, wenn Threads mehrere Ressourcen sperren und auf die Freigabe von Ressourcen warten, die von anderen Threads gesperrt sind.

Angenommen, Thread X sperrt Ressource A und benötigt dann Ressource B, während Thread Y Ressource B sperrt und dann Ressource A benötigt. In einem solchen Fall kommt es zu einem Deadlock, da jeder Thread auf eine Ressource wartet, die der andere gerade hält.

Um Deadlocks zu vermeiden, kann ein Timeout verwendet werden, wenn versucht wird, ein Lock zu erhalten. Anstatt das einfache lock-Schlüsselwort zu verwenden, kann die Monitor.TryEnter-Methode eingesetzt werden, die mit einem Timeout arbeitet:

csharp
Copy code
try

{
    if (Monitor.TryEnter(SharedObjects.Conch, TimeSpan.FromSeconds(15)))
    {
        for (int i = 0; i < 5; i++)
        {
            Thread.Sleep(Random.Shared.Next(2000));
            SharedObjects.Message += "A";
            Write(".");
        }
    }
    else
    {
        WriteLine("Methode A hat beim Sperren des Conch einen Timeout überschritten.");
    }
}
finally
{
    Monitor.Exit(SharedObjects.Conch);
}

Durch den Einsatz von Monitor.TryEnter können wir sicherstellen, dass ein Thread nicht unendlich lange wartet, sondern nach einem festgelegten Timeout aufgibt. Dies verhindert Deadlocks und stellt sicher, dass die Anwendung weiterhin funktioniert, auch wenn ein Thread nicht in der Lage ist, auf die Ressource zuzugreifen.

Thread-Sicherheit bei Ereignissen

.NET-Ereignisse sind von Natur aus nicht thread-sicher, was bedeutet, dass bei der Verwendung von Ereignissen in einer Multithreading-Umgebung Vorsicht geboten ist. Einige Entwickler versuchen, durch den Einsatz von Locks die Thread-Sicherheit von Ereignissen zu gewährleisten. Dies ist jedoch keine ideale Lösung, da Locks nicht immer die beste Möglichkeit sind, mit Ereignissen in Multithreaded-Szenarien umzugehen. Die Verwendung von Locks zum Hinzufügen oder Entfernen von Event-Handlern kann zu Problemen führen, wenn mehrere Threads gleichzeitig auf dasselbe Ereignis zugreifen.

Atomare Operationen in C#

In einem Multithreading-Szenario ist es wichtig, atomare Operationen zu verstehen, da nicht-atomare Operationen von anderen Threads unterbrochen werden könnten. Ein häufiges Beispiel ist der Inkrement-Operator in C#:

csharp
Copy code
int x = 3;
x++;  // Ist diese Operation atomar?

In solchen Fällen kann die Interlocked-Klasse verwendet werden, um atomare Operationen durchzuführen. Mit Methoden wie Interlocked.Add, Interlocked.Increment und Interlocked.Decrement kann eine atomare Veränderung an einer Zahl vorgenommen werden, ohne dass die Gefahr besteht, dass die Operation von einem anderen Thread unterbrochen wird.

Interlocked bietet eine einfache Möglichkeit, sicherzustellen, dass kritische Variablen atomar geändert werden, und vermeidet so viele der Probleme, die in Multithreaded-Anwendungen auftreten können.

Wie funktionieren Source Generatoren in .NET und welche Bedeutung haben sie für die Codeerzeugung?

Source Generatoren sind eine leistungsfähige Funktion im .NET-Ökosystem, die es Entwicklern ermöglicht, Code während der Kompilierzeit automatisch zu erzeugen. Im Kern implementiert ein Source Generator eine Schnittstelle namens ISourceGenerator und wird mit dem Attribut [Generator] markiert, wodurch er vom Compiler als Codeerzeuger erkannt wird. Die zentrale Methode hierbei ist Execute, welche den Kontext der aktuellen Kompilierung erhält und darauf basierend neuen Quellcode generiert und diesem hinzufügt.

Ein einfaches Beispiel ist das automatische Erzeugen einer Methode, die eine Nachricht auf der Konsole ausgibt. Im Code wird hierzu der Einstiegspunkt der Anwendung, etwa die Hauptklasse, ermittelt, und dynamisch eine statische partielle Klasse mit einer Methode namens Message generiert. Diese Methode enthält eine Konsolenausgabe, die eine vom Entwickler definierte Nachricht anzeigt. Die erzeugten Dateien tragen üblicherweise eine Endung wie .g.cs oder .generated.cs, um sie von manuell geschriebenem Code abzugrenzen – ein Best Practice, das Übersichtlichkeit schafft.

Um Source Generatoren in einem Projekt zu nutzen, muss das Zielprojekt eine Referenz auf das Projekt mit dem Generator enthalten. In Entwicklungsumgebungen wie Visual Studio 2022 zeigt der Solution Explorer die automatisch generierten Dateien unter Abhängigkeiten > Analyzers an. In Visual Studio Code hingegen ist zusätzlich eine Projektdatei-Konfiguration notwendig, damit die automatische Codegenerierung aktiviert wird, da dort die Analyzer nicht automatisch ausgeführt werden.

Die erzeugten Dateien sind nicht nur Hilfsmittel für Entwickler, sondern beeinflussen die Build-Pipeline und erlauben eine Vielzahl von Automatisierungen – von Codeoptimierungen über Validierungen bis hin zur Integration komplexer Framework-Funktionalitäten ohne manuellen Aufwand. Die Fähigkeit, Code dynamisch zur Kompilierzeit zu modifizieren oder zu ergänzen, öffnet Wege für eine bessere Wartbarkeit und Performanz der Anwendungen.

Neben dem grundlegenden Umgang mit Source Generatoren ist es essentiell, die Auswirkungen auf den Entwicklungsprozess zu verstehen. So kann es erforderlich sein, die Entwicklungsumgebung neu zu starten, um Änderungen der Generatoren vollständig sichtbar zu machen. Außerdem muss beachtet werden, dass nicht alle Entwicklungsumgebungen oder Tools Source Generatoren standardmäßig unterstützen und entsprechend konfiguriert werden müssen.

Wichtig ist zudem das Zusammenspiel von Source Generatoren mit anderen Features des .NET-Frameworks, wie etwa Reflection und Expression Trees, welche ebenfalls dynamische Codeausführung und Analyse ermöglichen, jedoch zu unterschiedlichen Zeitpunkten (zur Laufzeit statt zur Kompilierzeit). Ein ganzheitliches Verständnis dieser Mechanismen erweitert das Potenzial zur Erstellung hochflexibler, leistungsfähiger und wartbarer Software.

Die Integration von Source Generatoren bringt auch eine Veränderung im Softwareentwicklungszyklus mit sich: Automatisierte Codeerzeugung reduziert wiederkehrende Aufgaben, doch erfordert eine sorgfältige Planung und Kontrolle, um unvorhergesehene Seiteneffekte zu vermeiden. Daher ist es ratsam, bei der Einführung von Source Generatoren gründlich zu testen und ihre Funktionsweise im Projektteam transparent zu kommunizieren.

Wie man GraphQL-Mutationen verwendet, um Produkte hinzuzufügen und Daten zu integrieren

GraphQL ist eine leistungsstarke Technologie zur Abfrage und Manipulation von Daten, die zunehmend in modernen Webanwendungen eingesetzt wird. Im Kontext der Entwicklung einer Web-API für eine Anwendung wie die Northwind-Datenbank bietet GraphQL eine flexible Möglichkeit, Daten zu integrieren und Operationen wie das Hinzufügen von Produkten zu automatisieren. In diesem Kapitel wird erläutert, wie eine Mutation in GraphQL erstellt wird, um ein Produkt hinzuzufügen und wie diese Operation in einer .NET-Umgebung implementiert wird.

Die Mutation ist eine spezielle Art von Operation in GraphQL, die es ermöglicht, Daten zu ändern. In diesem Fall geht es darum, ein Produkt in die Northwind-Datenbank einzufügen. Zunächst einmal muss ein Input-Typ definiert werden, der die Parameter für das Hinzufügen eines Produkts beschreibt. Dies könnte zum Beispiel die Produktbezeichnung, die ID des Lieferanten, die Kategorie, die Menge pro Einheit und der Preis pro Einheit umfassen. In einer typischen Anwendung könnte dies so aussehen:

csharp
Copy code
public record AddProductInput(
   string ProductName,
   int? SupplierId,
   int? CategoryId,
   string QuantityPerUnit,
   decimal? UnitPrice,
   short? UnitsInStock,
   short? UnitsOnOrder,
   short? ReorderLevel,
   bool Discontinued);

Um die Mutation zu implementieren, muss eine Klasse erstellt werden, die die tatsächliche Logik der Mutation enthält. Diese Klasse verarbeitet die Anfrage und fügt das neue Produkt in die Datenbank ein:

csharp
Copy code
public class Mutation
{

   public async Task<AddProductPayload> AddProductAsync(

     AddProductInput input, NorthwindContext db)
   {
     Product product = new()
     {
       ProductName = input.ProductName,
       SupplierId = input.SupplierId,
       CategoryId = input.CategoryId,
       QuantityPerUnit = input.QuantityPerUnit,
       UnitPrice = input.UnitPrice,
       UnitsInStock = input.UnitsInStock,
       UnitsOnOrder = input.UnitsOnOrder,
       ReorderLevel = input.ReorderLevel,
       Discontinued = input.Discontinued
     };
     db.Products.Add(product);
     int affectedRows = await db.SaveChangesAsync();
     return new AddProductPayload(product);
   }
}

In dieser Klasse wird das Produkt mit den übergebenen Eingabewerten erstellt und in die Products-Tabelle der Datenbank eingefügt. Nachdem die Änderungen in der Datenbank gespeichert wurden, wird das hinzugefügte Produkt in einer Payload verpackt und zurückgegeben.

Ein weiterer wichtiger Schritt in der Implementierung von GraphQL-Mutationen ist die Registrierung der Mutation im GraphQL-Server. Dies erfolgt in der Program.cs-Datei der Anwendung, wo der GraphQL-Server konfiguriert wird:

csharp
Copy code
builder.Services

   .AddGraphQLServer()
   .RegisterDbContext()
   .AddQueryType()
   .AddMutationType();

Hierbei wird sichergestellt, dass der GraphQL-Server sowohl Abfragen (Queries) als auch Mutationen (Mutations) korrekt verarbeitet.

Ein praktisches Beispiel für eine GraphQL-Mutation, die das Hinzufügen eines Produkts beschreibt, sieht wie folgt aus:

graphql
Copy code
mutation AddProduct {
   addProduct(
     input: {
       productName: "Tasty Burgers"
       supplierId: 1
       categoryId: 2
       quantityPerUnit: "6 per box"
       unitPrice: 40
       unitsInStock: 0
       unitsOnOrder: 0
       reorderLevel: 0
       discontinued: false
     }
   ) {
     product {
       productId
       productName
     }
   }
}

Ein weiterer nützlicher Aspekt von GraphQL ist, dass Entwickler die Abfragen so gestalten können, dass nur die benötigten Daten zurückgegeben werden. Dies verbessert die Effizienz der Anwendung, indem nur die relevanten Informationen übertragen werden.

Wichtig ist auch zu verstehen, dass die Mutation nicht nur das Produkt hinzufügt, sondern auch in einer strukturierteren Antwort verpackt wird, die die hinzugefügten Daten enthält. So könnte eine erfolgreiche Antwort aussehen:

json
Copy code
{
   "data": {
     "addProduct": {
       "product": {
         "productId": 79,
         "productName": "Tasty Burgers"
       }
     }
   }
}

Diese Antwort stellt sicher, dass der Client nicht nur weiß, dass das Produkt erfolgreich hinzugefügt wurde, sondern auch alle relevanten Informationen über das neu hinzugefügte Produkt erhält.

Zusätzlich ist es sinnvoll, sich mit den verschiedenen Möglichkeiten der Parameterisierung von GraphQL-Anfragen vertraut zu machen, um eine flexible und wiederverwendbare API zu gestalten. Beispielsweise können Eingabewerte wie productName oder unitPrice in Mutationen flexibel angepasst werden, ohne dass die API selbst verändert werden muss.

Ein weiterer zu berücksichtigender Punkt ist die Performance. Während GraphQL eine hohe Flexibilität und Kontrolle bei der Abfrage von Daten bietet, kann es in komplexeren Anwendungen zu Performance-Problemen kommen, wenn zu viele Daten gleichzeitig angefordert werden oder die Abfragen schlecht optimiert sind. Daher sollte auch die Effizienz der Anfragen und die Struktur des Schemas sorgfältig geprüft werden, um unnötige Datenabrufe zu vermeiden.