Bagaimana cara kerja dependency injection di .NET?

Question

Accepted Answer

**Dependency Injection (DI)** tersedia di dalam .NET modern — framework menyertakan DI container yang secara otomatis membuat instance kelas dan **menginject dependensinya**. Anda mendaftarkan service (memetakan interface ke implementasi) dan container menyelesaikannya, memungkinkan kode yang loosely-coupled dan dapat diuji. Ini adalah fondasi dari ASP.NET Core. ## Registering services ```csharp // in Program.cs — register services with a LIFETIME builder.Services.AddScoped(); // interface → implementation builder.Services.AddSingleton(); builder.Services.AddTransient(); ``` Anda mendaftarkan setiap service dengan memetakan **interface ke implementasi** dengan lifetime tertentu. Maka apa pun yang bergantung pada interface akan mendapatkan implementasi yang terdaftar. ## Constructor injection (pola standar) ```csharp public class UserService { private readonly IUserRepository _repo; private readonly IEmailSender _email; // dependencies are declared in the constructor — the container INJECTS them automatically public UserService(IUserRepository repo, IEmailSender email) { _repo = repo; _email = email; } } // you never `new UserService(...)` manually — the container builds it, resolving the chain ``` Dependensi dideklarasikan sebagai parameter konstruktor (diketik sebagai interface); container membuat instance kelas dan menginject implementasi yang terdaftar, menyelesaikan seluruh dependency graph secara otomatis. ## Service lifetimes (penting untuk memilih dengan benar) ```text Singleton → ONE instance for the entire app lifetime (shared; must be thread-safe) Scoped → one instance PER request (the common default for web — e.g. DbContext) Transient → a NEW instance every time it's requested (lightweight, stateless services) → Choosing wrong (e.g. a singleton capturing a scoped DbContext) causes subtle bugs. ``` ## Manfaatnya: loose coupling dan testability ```csharp // because UserService depends on INTERFACES, you can inject MOCKS in tests var service = new UserService(mockRepo, mockEmail); // no real DB/email needed ``` ## Mengapa ini penting Dependency injection adalah fondasi dari .NET modern — ini **tersedia di dalam framework** dan merupakan tulang punggung ASP.NET Core, jadi memahaminya sangat penting untuk pengembangan aplikasi C# modern apa pun. DI container bawaan framework secara otomatis membuat instance kelas dan menginject dependensinya (menyelesaikan seluruh dependency graph), jadi Anda mendaftarkan service dan membiarkan container merangkai semuanya bersama-sama daripada secara manual menginstan dependensi. Manfaat inti sangat signifikan dan merupakan pusat dari mengapa DI ditekankan: **loose coupling** (bergantung pada interface daripada kelas konkret, sehingga implementasi dapat ditukar) dan khususnya **testability** (menginject implementasi mock dalam test daripada dependensi nyata seperti database atau service email — membuat unit testing yang menyeluruh menjadi praktis). Memahami cara mendaftarkan service (memetakan interface ke implementasi), constructor injection (pola standar), dan — secara penting — **service lifetimes** (`Singleton`, `Scoped`, `Transient`) sangat penting: memilih lifetime yang salah menyebabkan bug yang halus dan sulit di-debug (misalnya singleton yang menahan `DbContext` scoped, atau masalah thread-safety dengan singleton yang dibagikan), jadi memahami kapan setiap lifetime berlaku (Scoped per-request untuk hal seperti DbContext, Singleton untuk service stateless yang dibagikan, Transient untuk yang ringan) adalah kritis. Karena DI tersedia di dalam .NET, mendasari arsitektur ASP.NET Core, dan merupakan kunci untuk menulis kode yang loosely-coupled dan dapat diuji, menguasainya — container, constructor injection, desain berbasis interface, dan khususnya service lifetimes — adalah pengetahuan senior yang penting dan sering diterapkan untuk membangun aplikasi C# modern yang dapat dirawat dan diuji, serta merupakan topik interview yang umum.