Latihan - Menambahkan EF Core ke API minimal

10 menit

Anda adalah pengembang untuk perusahaan, dan Anda dan perusahaan Anda telah mendengar tentang API minimal baru. Manajer Anda telah meminta Anda untuk membuat proyek untuk itu sehingga Anda dapat mendiskusikan apakah akan menggunakannya pada proyek Anda berikutnya.

Nota

Modul ini menggunakan .NET CLI (Antarmuka Baris Perintah) dan Visual Studio Code untuk pengembangan lokal. Setelah menyelesaikan modul ini, Anda dapat menerapkan konsep menggunakan Visual Studio (Windows), Visual Studio untuk Mac (macOS), atau melanjutkan pengembangan menggunakan Visual Studio Code (Windows, Linux, & macOS).

Modul ini menggunakan .NET 8.0 SDK. Pastikan Anda telah menginstal .NET 8.0 dengan menjalankan perintah berikut di terminal perintah pilihan Anda:

dotnet --list-sdks

Output yang mirip dengan contoh berikut muncul:

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

Pastikan bahwa versi yang dimulai dengan 8 tercantum. Jika tidak ada yang tercantum atau perintah tidak ditemukan, menginstal .NET 8.0 SDK terbaru.

Menyiapkan proyek

Pertama, Anda perlu membuat proyek. Anda telah menginstal .NET 6 dan Anda siap untuk pergi. Di unit ini, Anda akan menambahkan persistensi data ke API manajemen pizza.

Di terminal, buat API web dengan menjalankan dotnet new:
```
dotnet new web -o PizzaStore -f net8.0
```
Anda seharusnya melihat direktori PizzaStore.
Buka direktori PizzaStore dengan memasukkan perintah berikut:
```
cd PizzaStore
```

Pasang paket Swashbuckle:

dotnet add package Swashbuckle.AspNetCore --version 6.5.0

Buka proyek di Visual Studio Code.
Menggunakan Visual Studio Code, buat file Pizza.cs di akar proyek dan berikan konten berikut:
```
namespace PizzaStore.Models 
{
    public class Pizza
    {
          public int Id { get; set; }
          public string? Name { get; set; }
          public string? Description { get; set; }
    }
}
```
Kelas Pizza sebelumnya adalah objek sederhana yang mewakili pizza. Kode ini adalah model data Anda. Nantinya, Anda akan menggunakan Entity Framework (EF) Core untuk memetakan model data ini ke tabel database.

Buka Program.cs dan tambahkan kode yang disorot:

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

Anda mungkin menerima permintaan dari Visual Studio Code untuk menambahkan aset untuk men-debug proyek. Pilih Yes dalam dialog.

Menambahkan EF Core ke proyek

Untuk menyimpan item dalam daftar to-do, instal paket EntityFrameworkCore.InMemory.

Tekan Ctrl+' untuk membuka terminal di Visual Studio Code. Di terminal baru, masukkan kode berikut untuk menambahkan paket EF Core InMemory:
```
dotnet add package Microsoft.EntityFrameworkCore.InMemory --version 8.0
```
Tambahkan using Microsoft.EntityFrameworkCore; ke bagian atas file Program.cs dan Pizza.cs Anda.

Sekarang setelah EF Core ditambahkan ke proyek, Anda dapat menghubungkan kode Anda ke data yang ingin Anda simpan dan kueri. Untuk melakukan langkah ini, Anda membuat kelas PizzaDb. Kelas PizzaDb akan melakukan tugas-tugas berikut:
- Ungkapkan properti Pizzas Anda dari daftar Pizza Anda di dalam database.
- Gunakan UseInMemoryDatabase untuk menyambungkan penyimpanan database dalam memori. Data Anda disimpan di sini selama aplikasi berjalan.
Untuk menyiapkan database dalam memori Anda, tambahkan kode berikut ke bagian bawah file Pizza.cs (di atas }akhir ). Anda akan memiliki dua definisi kelas dalam namespace PizzaStore.Models.
```
class PizzaDb : DbContext
{
    public PizzaDb(DbContextOptions options) : base(options) { }
    public DbSet<Pizza> Pizzas { get; set; } = null!;
}
```
DbContext mewakili koneksi atau sesi yang digunakan untuk mengkueri dan menyimpan instans entitas dalam database.
Tambahkan using PizzaStore.Models; ke bagian atas file Program.cs Anda.

Di Program.cs, sebelum panggilan ke AddSwaggerGen, tambahkan kode berikut:

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

Mengembalikan daftar item

Untuk membaca dari daftar item dalam daftar pizza, tambahkan kode berikut di atas pemanggilan ke app.Run(); guna menambahkan rute "/pizzas":
```
app.MapGet("/pizzas", async (PizzaDb db) => await db.Pizzas.ToListAsync());
```

Jalankan aplikasi

Pastikan Anda telah menyimpan semua perubahan Anda. Jalankan aplikasi dengan memanggil dotnet run di terminal. Tindakan ini akan membangun aplikasi dan menghostingnya di port dari 5000-5300. HTTPS akan memiliki port yang dipilih untuknya dalam rentang 7000-7300.

Nota

Jika Anda ingin mengambil alih perilaku pemilihan port acak, Anda dapat mengatur port yang akan digunakan di launchSettings.json.

dotnet run

Berikut adalah tampilan output di terminal:

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

Di browser Anda, buka https://localhost:{PORT}/swagger. Pilih tombol GET /pizzas, diikuti dengan Cobalah dan Jalankan. Anda akan melihat bahwa daftar kosong di bawah Response body.
Di terminal, tekan Ctrl+C untuk berhenti menjalankan program.

Membuat item baru

Mari kita tambahkan kode POST untuk item baru ke dalam daftar pizza. Di Program.cs, tambahkan kode berikut di bawah app.MapGet yang Anda buat sebelumnya.

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

Menguji API

Pastikan Anda telah menyimpan semua perubahan dan menjalankan aplikasi lagi. Kembali ke antarmuka pengguna Swagger dan sekarang Anda akan melihat POST/pizza. Untuk menambahkan item baru ke daftar pizza:

Pilih POST /pizza.
Pilih Cobalah.

Ganti isi permintaan dengan JSON berikut:

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

Pilih Jalankan.

Untuk membaca item dalam daftar:

Pilih GET /pizzas.
Pilih Cobalah.

Pilih Jalankan.

Response body akan menyertakan item yang baru saja ditambahkan.

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

Tekan Ctrl+C di terminal untuk berhenti menjalankan aplikasi. Untuk sisa latihan ini, hentikan dan mulai ulang aplikasi sesuai keinginan untuk menguji perubahan Anda. Pastikan untuk menyimpan semua perubahan Anda sebelum dotnet run!

Dapatkan satu item

Untuk mendapatkan item menggunakan id, tambahkan kode di bawah rute app.MapPost yang telah Anda buat sebelumnya.

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

Uji GET berdasarkan ID

Untuk menguji operasi ini, Anda dapat membuka https://localhost:{PORT}/pizza/1 atau menggunakan UI Swagger. Karena Anda menggunakan database dalam memori, pizza yang sebelumnya Anda buat tidak akan tercantum jika Anda telah memulai ulang aplikasi. Jadi, Anda harus menggunakan operasi POST untuk menambahkannya lagi.

Memperbarui item

Untuk memperbarui item yang sudah ada, tambahkan kode di bawah rute GET /pizza/{id} yang Anda buat:

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

Uji PUT

Pilih PUT /pizza/{id} di antarmuka pengguna Swagger.
Pilih Cobalah.
Dalam kotak teks id, masukkan 1.
Terakhir, perbarui Request body. Tempelkan JSON berikut dan ubah name ke Pineapple.
```
{
   "id": 1,
   "name": "Pineapple"
}
```
Pilih Jalankan.

Untuk menguji kode, gulir kembali ke GET /pizza/{id}. Pizza sekarang memiliki nama Pineapple.

Menghapus item

Untuk menghapus item yang sudah ada, tambahkan kode di bawah PUT /pizza/{id} yang Anda buat sebelumnya:

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

Menguji DELETE

Sekarang coba hapus item dengan menggunakan antarmuka Swagger.

Dalam unit ini, Anda menambahkan EF Core ke aplikasi API minimal yang ada dan menggunakan database dalam memori untuk menyimpan data. Selanjutnya, Anda akan mempelajari cara mempergunakan basis data yang sesungguhnya untuk menyimpan data sehingga dapat bertahan ketika aplikasi ditutup.

Saran dan Komentar

Apakah halaman ini membantu?