Übung: EF Core zu minimaler API hinzufügen

  • 10 Minuten

Sie sind Entwickler für ein Unternehmen, und Sie und Ihr Unternehmen haben über die neue minimale API gehört. Ihr Vorgesetzter hat Sie gebeten, ein Projekt dafür zu erstellen, damit Sie besprechen können, ob sie für Ihr nächstes Projekt verwendet werden soll.

Hinweis

In diesem Modul wird die .NET-CLI (Befehlszeilenschnittstelle) und Visual Studio Code für die lokale Entwicklung verwendet. Nach Abschluss dieses Moduls können Sie die Konzepte mit Visual Studio (Windows), Visual Studio für Mac (macOS) oder bei der Weiterentwicklung mit Visual Studio Code (Windows, Linux und macOS) anwenden.

In diesem Modul wird das .NET 8.0 SDK verwendet. Stellen Sie sicher, dass .NET 8.0 installiert ist, indem Sie in Ihrem bevorzugten Befehlsterminal den folgenden Befehl ausführen:

dotnet --list-sdks

Die daraufhin angezeigte Ausgabe sieht in etwa wie im folgenden Beispiel aus:

6.0.317 [C:\Program Files\dotnet\sdk]
7.0.401 [C:\Program Files\dotnet\sdk]
8.0.100 [C:\Program Files\dotnet\sdk]

Stellen Sie sicher, dass eine Version aufgeführt wird, die mit 8 beginnt. Wenn keine aufgeführt ist oder der Befehl nicht gefunden wird, installieren Sie das neueste .NET 8.0 SDK.

Einrichten des Projekts

Zunächst müssen Sie ein Projekt erstellen. Sie haben .NET 6 installiert, und Sie können losgehen. In dieser Einheit fügen Sie einer Pizzaverwaltungs-API Datenpersistenz hinzu.

  1. Erstellen Sie in einem Terminal eine Web-API, indem Sie Folgendes ausführen dotnet new:

    dotnet new web -o PizzaStore -f net8.0

    Das Verzeichnis "PizzaStore " sollte angezeigt werden.

  2. Wechseln Sie zum PizzaStore-Verzeichnis , indem Sie den folgenden Befehl eingeben:

    cd PizzaStore

  3. Installieren Sie das Swashbuckle-Paket:

    dotnet add package Swashbuckle.AspNetCore --version 6.5.0

  4. Öffnen Sie das Projekt in Visual Studio Code.

  5. Erstellen Sie mithilfe von Visual Studio Code eine Pizza.cs Datei im Projektstamm, und geben Sie ihm den folgenden Inhalt:

    namespace PizzaStore.Models 
{
    public class Pizza
    {
          public int Id { get; set; }
          public string? Name { get; set; }
          public string? Description { get; set; }
    }
}

    Die vorangehende Pizza Klasse ist ein einfaches Objekt, das eine Pizza darstellt. Dieser Code ist Ihr Datenmodell. Später verwenden Sie Entity Framework (EF) Core, um dieses Datenmodell einer Datenbanktabelle zuzuordnen.

  6. Öffnen Sie Program.cs , und fügen Sie den hervorgehobenen Code hinzu:

    using Microsoft.OpenApi.Models;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(c =>
{
     c.SwaggerDoc("v1", new OpenApiInfo {
         Title = "PizzaStore API",
         Description = "Making the Pizzas you love",
         Version = "v1" });
});

var app = builder.Build();
if (app.Environment.IsDevelopment())
{
   app.UseSwagger();
   app.UseSwaggerUI(c =>
   {
      c.SwaggerEndpoint("/swagger/v1/swagger.json", "PizzaStore API V1");
   });
}

app.MapGet("/", () => "Hello World!");

app.Run();

    Möglicherweise erhalten Sie eine Aufforderung von Visual Studio Code, Objekte hinzuzufügen, um das Projekt zu debuggen. Wählen Sie Yes im Dialogfeld aus.

Hinzufügen von EF Core zum Projekt

Um die Elemente in der liste to-do zu speichern, installieren Sie das EntityFrameworkCore.InMemory Paket.

  1. Drücken Sie STRG+' , um ein Terminal in Visual Studio Code zu öffnen. Geben Sie im neuen Terminal den folgenden Code ein, um das EF Core InMemory-Paket hinzuzufügen:

    dotnet add package Microsoft.EntityFrameworkCore.InMemory --version 8.0

  2. Fügen Sie using Microsoft.EntityFrameworkCore; am Anfang ihrer Program.cs - und Pizza.cs Dateien hinzu.

    Nachdem Sie ef Core dem Projekt hinzugefügt haben, können Sie den Code mit den Daten verknüpfen, die Sie speichern und abfragen möchten. Zu diesem Schritt erstellen Sie eine PizzaDb Klasse. Die PizzaDb Klasse führt die folgenden Aufgaben aus:

    • Verfügbarmachen der Pizzas-Eigenschaft aus der Liste von Pizza in der Datenbank
    • Verknüpfen des In-Memory-Datenbankspeichers mithilfe von UseInMemoryDatabase Ihre Daten werden hier gespeichert, solange die App ausgeführt wird.

  3. Um die In-Memory-Datenbank einzurichten, fügen Sie den folgenden Code am Ende der Pizza.cs Datei (vor dem letzten }) hinzu. Sie verfügen über zwei Klassendefinitionen im PizzaStore.Models Namespace.

    class PizzaDb : DbContext
{
    public PizzaDb(DbContextOptions options) : base(options) { }
    public DbSet<Pizza> Pizzas { get; set; } = null!;
}

    DbContext stellt eine Verbindung oder Sitzung dar, die zum Abfragen und Speichern von Instanzen von Entitäten in einer Datenbank verwendet wird.

  4. Fügen Sie using PizzaStore.Models; am Anfang der Program.cs Datei hinzu.

  5. Fügen Sie in Program.cs vor dem Aufruf AddSwaggerGenden folgenden Code hinzu:

    builder.Services.AddDbContext<PizzaDb>(options => options.UseInMemoryDatabase("items"));

Zurückgeben einer Liste von Elementen

  • Um aus einer Liste von Elementen in der Pizzaliste zu lesen, fügen Sie den folgenden Code oberhalb des Aufrufs von app.Run(); hinzu, um die Route „/pizzas“ hinzuzufügen:

    app.MapGet("/pizzas", async (PizzaDb db) => await db.Pizzas.ToListAsync());

Ausführen der Anwendung

  1. Vergewissern Sie sich, dass Sie alle Änderungen gespeichert haben. Führen Sie die App aus, indem Sie dotnet run im Terminal ausführen. Mit dieser Aktion wird die App erstellt und auf einem Port von 5000-5300 gehostet. HTTPS hat einen Port für ihn im Bereich 7000-7300 ausgewählt.

    Hinweis

    Wenn Sie das Zufällige Portauswahlverhalten außer Kraft setzen möchten, können Sie die Ports festlegen, die in launchSettings.jsonverwendet werden sollen.

    dotnet run

    So kann die Ausgabe im Terminal aussehen:

    Building...
 info: Microsoft.Hosting.Lifetime[14]
       Now listening on: https://localhost:7200
 info: Microsoft.Hosting.Lifetime[14]
       Now listening on: http://localhost:5100
 info: Microsoft.Hosting.Lifetime[0]
       Application started. Press Ctrl+C to shut down.
 info: Microsoft.Hosting.Lifetime[0]
       Hosting environment: Development
 info: Microsoft.Hosting.Lifetime[0]
       Content root path: /<path>/PizzaStore

  2. Wechseln Sie in Ihrem Browser zu https://localhost:{PORT}/swagger. Wählen Sie die GET /pizzas Schaltfläche aus, gefolgt von " Ausprobieren" und "Ausführen". Sie werden sehen, dass die Liste unter Response body leer ist.

  3. Drücken Sie im Terminal STRG+C , um die Ausführung des Programms zu beenden.

Neue Elemente erstellen

Fügen wir den Code zum Einfügen (POST) neuer Elemente zur Pizzaliste hinzu. Fügen Sie in Program.cs den folgenden Code unter dem app.MapGet zuvor erstellten Code hinzu.

app.MapPost("/pizza", async (PizzaDb db, Pizza pizza) =>
{
    await db.Pizzas.AddAsync(pizza);
    await db.SaveChangesAsync();
    return Results.Created($"/pizza/{pizza.Id}", pizza);
});

Testen der API

Stellen Sie sicher, dass Sie alle Ihre Änderungen gespeichert haben, und führen Sie die App erneut aus. Gehen Sie zurück zur Swagger-Oberfläche, und nun sollten Sie POST/pizza sehen. So fügen Sie der Pizzaliste neue Elemente hinzu:

  1. Wählen Sie POST /Pizza aus.

  2. Wählen Sie "Ausprobieren" aus.

  3. Ersetzen Sie den Anforderungstext durch den folgenden JSON-Code:

    {
    "name": "Pepperoni",
    "description": "A classic pepperoni pizza"
}

  4. Wählen Sie "Ausführen" aus.

So lesen Sie die Elemente in der Liste:

  1. Wählen Sie GET /Pizzas aus.

  2. Wählen Sie "Ausprobieren" aus.

  3. Wählen Sie "Ausführen" aus.

    Dies Response body schließt die soeben hinzugefügten Elemente ein.

    [
  {
    "id": 1,
    "name": "Pepperoni",
    "description": "A classic pepperoni pizza"
  }
]

  4. Drücken Sie STRG+C im Terminal, um die Ausführung der App zu beenden. Beenden Sie die App für den Rest dieser Übung, und starten Sie sie neu, um Ihre Änderungen zu testen. Achten Sie jedoch darauf, vor der Ausführung von dotnet run alle Änderungen zu speichern!

Abrufen eines einzelnen Elements

Um ein Element mit GET nach id abzurufen, fügen Sie den Code unterhalb der app.MapPost-Route hinzu, die Sie zuvor erstellt haben.

app.MapGet("/pizza/{id}", async (PizzaDb db, int id) => await db.Pizzas.FindAsync(id));

Testen des GET anhand der ID

Um diesen Vorgang zu testen, können Sie entweder zur https://localhost:{PORT}/pizza/1 gehen oder die Swagger-Benutzeroberfläche verwenden. Da Sie eine In-Memory-Datenbank verwenden, wird die zuvor erstellte Pizza nicht aufgeführt, wenn Sie die Anwendung neu gestartet haben. Daher müssen Sie ihren POST-Vorgang verwenden, um ihn erneut hinzuzufügen.

Aktualisieren eines Elements

Um ein vorhandenes Element zu aktualisieren, fügen Sie den Code unter der GET /pizza/{id} von Ihnen erstellten Route hinzu:

app.MapPut("/pizza/{id}", async (PizzaDb db, Pizza updatepizza, int id) =>
{
      var pizza = await db.Pizzas.FindAsync(id);
      if (pizza is null) return Results.NotFound();
      pizza.Name = updatepizza.Name;
      pizza.Description = updatepizza.Description;
      await db.SaveChangesAsync();
      return Results.NoContent();
});

Testen von PUT

  1. Wählen Sie PUT /pizza/{id} in der Benutzeroberfläche von Swagger aus.

  2. Wählen Sie "Ausprobieren" aus.

  3. Geben Sie im Textfeld id1 ein.

  4. Aktualisieren Sie schließlich Request body. Fügen Sie den folgenden JSON-Code ein, und ändern Sie ihn name in Pineapple.

    {
   "id": 1,
   "name": "Pineapple"
}

  5. Wählen Sie "Ausführen" aus.

Um den Code zu testen, scrollen Sie zurück zu GET /pizza/{id}. Die Pizza hat jetzt den Namen Pineapple.

Löschen eines Elements

Um ein vorhandenes Element zu löschen, fügen Sie den Code hinzu, unter PUT /pizza/{id} dem Sie zuvor erstellt haben:

app.MapDelete("/pizza/{id}", async (PizzaDb db, int id) =>
{
   var pizza = await db.Pizzas.FindAsync(id);
   if (pizza is null)
   {
      return Results.NotFound();
   }
   db.Pizzas.Remove(pizza);
   await db.SaveChangesAsync();
   return Results.Ok();
});

Testen von DELETE

Versuchen Sie nun, ein Element mithilfe der Swagger-Schnittstelle zu löschen.

In dieser Einheit haben Sie EF Core zu einer vorhandenen minimalen API-Anwendung hinzugefügt und eine In-Memory-Datenbank zum Speichern der Daten verwendet. Als Nächstes erfahren Sie, wie Sie eine echte Datenbank verwenden, um die Daten zwischen dem Herunterfahren der Anwendungen zu speichern, damit sie beibehalten werden.