Övning – Lägga till EF Core i minimalt API

10 minuter

Du är utvecklare för ett företag och du och ditt företag har hört talas om det nya minimala API:et. Din chef har bett dig att skapa ett projekt för det så att du kan diskutera om du vill använda det i nästa projekt.

Not

Den här modulen använder .NET CLI (Kommandoradsgränssnitt) och Visual Studio Code för lokal utveckling. När du har slutfört den här modulen kan du använda begreppen genom att använda Visual Studio (Windows), Visual Studio för Mac (macOS) eller fortsätta utvecklingen med hjälp av Visual Studio Code (Windows, Linux och macOS).

Den här modulen använder .NET 8.0 SDK. Kontrollera att du har .NET 8.0 installerat genom att köra följande kommando i önskad kommandoterminal:

dotnet --list-sdks

Utdata som liknar följande exempel visas:

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

Kontrollera att en version som börjar med 8 visas. Om inget visas eller om kommandot inte hittas installerar du den senaste .NET 8.0 SDK:t.

Konfigurera projektet

Först måste du skapa ett projekt. Du har installerat .NET 6 och är redo att gå. I den här lektionen lägger du till datapersistence i ett API för pizzahantering.

I en terminal skapar du ett webb-API genom att köra dotnet new:
```
dotnet new web -o PizzaStore -f net8.0
```
Du bör se katalogen PizzaStore.
Gå till katalogen PizzaStore genom att ange följande kommando:
```
cd PizzaStore
```

Installera Swashbuckle-paketet:

dotnet add package Swashbuckle.AspNetCore --version 6.5.0

Öppna projektet i Visual Studio Code.
Med Visual Studio Code skapar du en Pizza.cs fil i projektroten och ger den följande innehåll:
```
namespace PizzaStore.Models 
{
    public class Pizza
    {
          public int Id { get; set; }
          public string? Name { get; set; }
          public string? Description { get; set; }
    }
}
```
Föregående Pizza klass är ett enkelt objekt som representerar en pizza. Den här koden är din datamodell. Senare använder du Entity Framework (EF) Core för att mappa den här datamodellen till en databastabell.

Öppna Program.cs och lägg till den markerade koden:

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

Du kan uppmanas av Visual Studio Code att lägga till resurser för att felsöka projektet. Välj Yes i dialogrutan.

Lägga till EF Core i projektet

Om du vill lagra objekten i to-do-listan installerar du EntityFrameworkCore.InMemory-paketet.

Tryck på Ctrl+ för att öppna en terminal i Visual Studio Code. I den nya terminalen anger du följande kod för att lägga till EF Core InMemory-paketet:
```
dotnet add package Microsoft.EntityFrameworkCore.InMemory --version 8.0
```
Lägg till using Microsoft.EntityFrameworkCore; längst upp i dina Program.cs - och Pizza.cs-filer .

Nu när du har lagt till EF Core i projektet kan du koppla koden till de data som du vill spara och köra frågor mot den. Om du vill göra det här steget skapar du en PizzaDb-klass. Klassen PizzaDb utför följande uppgifter:
- Exponera egenskapen Pizzas från listan över Pizza i databasen.
- Använd UseInMemoryDatabase för att koppla in minnesintern databaslagring. Dina data lagras här så länge appen körs.
Om du vill konfigurera den minnesinterna databasen lägger du till följande kod längst ned i filen Pizza.cs (ovanför den slutliga }). Du har två klassdefinitioner inom PizzaStore.Models namnrymd.
```
class PizzaDb : DbContext
{
    public PizzaDb(DbContextOptions options) : base(options) { }
    public DbSet<Pizza> Pizzas { get; set; } = null!;
}
```
DbContext representerar en anslutning eller session som används för att fråga efter och spara instanser av entiteter i en databas.
Lägg till using PizzaStore.Models; överst i Program.cs-filen .

Lägg till följande kod innan anropet till AddSwaggerGen:

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

Returnera en lista över objekt

Om du vill läsa från en lista över objekt i pizzalistan lägger du till följande kod ovanför anropet till app.Run(); för att lägga till en "/pizza"-väg:
```
app.MapGet("/pizzas", async (PizzaDb db) => await db.Pizzas.ToListAsync());
```

Kör programmet

Kontrollera att du har sparat alla dina ändringar. Kör appen genom att anropa dotnet run i terminalen. Den här åtgärden skapar appen och är värd för den på en port från 5000–5300. HTTPS har valt en port för den i intervallet 7000-7300.

Not

Om du vill åsidosätta det slumpmässiga portvalsbeteendet kan du ange vilka portar som ska användas i launchSettings.json.

dotnet run

Så här kan utdata se ut i terminalen:

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

Gå till https://localhost:{PORT}/swaggeri webbläsaren. GET /pizzas Välj knappen följt av Prova och Kör. Du ser att listan är tom under Response body.
I terminalen trycker du på Ctrl+C för att sluta köra programmet.

Skapa nya objekt

Nu ska vi lägga till koden till POST nya föremål i pizzalistan. I Program.cs lägger du till följande kod under den app.MapGet som du skapade tidigare.

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

Testa API:et

Kontrollera att du har sparat alla ändringar och kör appen igen. Gå tillbaka till Swagger-användargränssnittet och nu bör du se POST/pizza. Så här lägger du till nya objekt i pizzalistan:

Välj POST /pizza.
Välj Prova.

Ersätt begärandetexten med följande JSON:

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

Välj Kör.

Så här läser du objekten i listan:

Välj GET /pizzas.
Välj Prova.

Välj Kör.

Response body innehåller de objekt som just har lagts till.

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

Tryck på Ctrl+C i terminalen för att sluta köra appen. I resten av den här övningen stoppar och startar du om appen efter behov för att testa ändringarna. Se till att spara alla dina ändringar innan du dotnet run!

Hämta ett enskilt objekt

För att hämta ett objekt med id, lägg till koden under app.MapPost-rutten som du skapade tidigare.

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

Testa GET efter ID

Om du vill testa den här åtgärden kan du antingen gå till https://localhost:{PORT}/pizza/1 eller använda Swagger-användargränssnittet. Eftersom du använder en minnesintern databas visas inte pizzan som du skapade tidigare om du har startat om programmet. Därför måste du använda POST-åtgärden för att lägga till den igen.

Uppdatera ett objekt

Om du vill uppdatera ett befintligt objekt lägger du till koden under den GET /pizza/{id} väg som du skapade:

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

Testa PUT

Välj PUT /pizza/{id} i Swagger-användargränssnittet.
Välj Prova.
I textrutan för id anger du 1.
Uppdatera slutligen Request body. Klistra in följande JSON och ändra name till Pineapple.
```
{
   "id": 1,
   "name": "Pineapple"
}
```
Välj Kör.

Om du vill testa koden rullar du tillbaka till GET /pizza/{id}. Pizzan har nu namnet Pineapple.

Ta bort ett objekt

Om du vill ta bort ett befintligt objekt lägger du till koden under PUT /pizza/{id} som du skapade tidigare:

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

Testa DELETE

Prova nu att ta bort ett objekt med hjälp av Swagger-gränssnittet.

I den här lektionen har du lagt till EF Core i ett befintligt minimalt API-program och använt en minnesintern databas för att lagra data. Därefter får du lära dig hur du använder en riktig databas för att lagra data så att de bevaras mellan programavstängningar.

Feedback

Var den här sidan till hjälp?