Melakukan CRUD Lebih Mudah dengan Entity Framework Core

Sekilas tentang ORM

Object-Relational Mapper atau ORM adalah jembatan antara objek di kode kita dan tabel di basis data. Daripada menulis kueri SQL secara manual untuk setiap operasi, kita bekerja lewat model dan biarkan framework menerjemahkannya.

Keuntungan terbesarnya adalah konsistensi. Akses data menjadi lebih mudah dibaca, lebih sedikit boilerplate, dan lebih cepat dikembangkan, terutama untuk operasi CRUD yang berulang.

Komponen inti Entity Framework Core

Di EF Core, hampir semuanya berpusat pada model. Model tersebut tersusun dari dua komponen utama: entity class dan context class. Entity mewakili tabel, sedangkan `DbContext` menjadi pintu masuk untuk query, tracking perubahan, dan penyimpanan data.

Pendekatan ini terasa natural bagi developer .NET karena kita bekerja dengan object C# dan tetap bisa memanfaatkan provider berbeda seperti SQL Server, PostgreSQL, MySQL, atau SQLite.

public class User
{
    public int Id { get; set; }
    public string Name { get; set; } = default!;
    public string? EmailAddress { get; set; }
    public string? PhoneNumber { get; set; }
    public DateTimeOffset Created { get; set; }
}

public class UserApplicationContext : DbContext
{
    public DbSet<User> Users { get; set; } = null!;

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("Data Source=(localdb)\\MSSQLLocalDB;Database=UserApplication;");
    }
}

Kenapa code-first terasa nyaman

Pada pendekatan code-first, kita mendesain domain class lebih dulu lalu membiarkan EF Core menghasilkan skema database melalui migration. Workflow ini cocok saat struktur aplikasi masih berkembang dan kita ingin perubahan skema tetap terlacak.

Setelah entity dan context siap, migration menjadi cara yang aman untuk membawa perubahan model ke database. Bukan cuma bikin tabel, tapi juga menjadi dokumentasi evolusi skema project.

• Buat model dan context.
• Tambahkan migration lewat tools EF Core.
• Update database agar struktur tabel mengikuti model yang baru.

Mencoba CRUD pada entitas User

Setelah fondasinya siap, operasi CRUD terasa sangat lugas. Kita cukup membuat object baru untuk insert, mengakses `context.Users` untuk read, memodifikasi entity yang ditemukan untuk update, lalu menghapus object yang sudah dilacak untuk delete.

Nilai dari EF Core benar-benar terasa di sini: kode bisnis tetap dominan, sementara detail SQL berada di balik layar.

using var context = new UserApplicationContext();

context.Users.Add(new User
{
    Name = "Johnathan",
    EmailAddress = "john@email.com",
    PhoneNumber = "082121212112",
    Created = DateTimeOffset.Now
});

var users = context.Users.ToList();

var user = context.Users.FirstOrDefault(item => item.Name == "Johnathan");
if (user is not null)
{
    user.Name = "Finn";
}

context.SaveChanges();

Berpindah provider tanpa mengubah alur berpikir

Salah satu poin menyenangkan dari EF Core adalah kemudahan saat ingin mencoba layanan basis data lain. Pada artikel aslinya, alur yang sama dipindahkan dari SQL Server ke SQLite hanya dengan mengganti package provider dan menyesuaikan konfigurasi koneksi.

Ini menunjukkan bahwa abstraction yang baik bukan cuma membuat kode lebih singkat, tetapi juga memberi fleksibilitas ketika kebutuhan project berubah.

Simpulan

EF Core membantu developer fokus pada model dan perilaku aplikasi, bukan tenggelam dalam pengulangan SQL. Untuk project .NET yang butuh produktivitas sekaligus struktur yang tetap rapi, ini adalah pondasi yang sangat kuat.

Kalau baru memulai, bangun dulu satu studi kasus kecil seperti entitas User. Dari situ pola EF Core biasanya cepat terasa masuk akal.