Akademi C# · Pelajaran

Asas Bekas DI

Fahami pembalikan kawalan, pendaftaran perkhidmatan dan cara bekas DI .NET menyelesaikan kebergantungan.

Pelajaran 1 daripada 413 langkah

Asas Bekas DI ialah pelajaran Akademi C# percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Akademi C#, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Akademi C# merangkumi sejumlah 4 pelajaran.

Apakah Suntikan Kebergantungan?

Suntikan Kebergantungan (DI) ialah corak reka bentuk yang menerima kebergantungannya daripada sumber luaran, bukannya menciptanya sendiri.

Daripada menulis var repo = new UserRepository(); di dalam kelas, kelas tersebut mengisytiharkan perkara yang diperlukan dan bekas DI menyediakannya.

Pembalikan Kawalan

DI ialah pelaksanaan konkrit bagi prinsip Pembalikan Kawalan (IoC): kawalan untuk mencipta kebergantungan dibalikkan daripada kelas bergantung kepada bekas luaran.

Ini menjadikan kelas lebih mudah diuji dan digantikan.

Menyediakan Bekas DI .NET

Dalam app .NET, bekas DI dikonfigurasikan melalui IServiceCollection dalam Program.cs. Perkhidmatan didaftarkan dan kemudiannya diselesaikan oleh masa jalan.

var builder = WebApplication.CreateBuilder(args);

// Register services
builder.Services.AddScoped<IUserRepository, UserRepository>();
builder.Services.AddScoped<UserService>();

var app = builder.Build();
app.Run();

Mendefinisikan Antara Muka & Pelaksanaan

DI berfungsi paling baik apabila anda memprogram berdasarkan antara muka. Takrifkan antara muka untuk kontrak perkhidmatan dan kelas konkrit yang melaksanakannya.

public interface IUserRepository
{
    User? GetById(int id);
}

public class UserRepository : IUserRepository
{
    public User? GetById(int id)
    {
        // fetch from database
        return new User { Id = id, Name = "Alice" };
    }
}

Mendapatkan Perkhidmatan melalui Pembina

Bekas secara automatik menyuntik perkhidmatan yang didaftarkan ke dalam pembina. Kelas hanya perlu mengisytiharkan antara muka yang diperlukan — tiada kata kunci new diperlukan.

public class UserService
{
    private readonly IUserRepository _repo;

    public UserService(IUserRepository repo)
    {
        _repo = repo;
    }

    public User? FindUser(int id) => _repo.GetById(id);
}

Mendaftarkan Berbilang Perkhidmatan

Anda boleh mendaftarkan seberapa banyak perkhidmatan yang diperlukan. Kaedah sambungan yang biasa ialah AddTransient, AddScoped dan AddSingleton — setiap satunya mentakrifkan tempoh hayat yang berbeza.

builder.Services.AddSingleton<IConfig, AppConfig>();
builder.Services.AddScoped<IUserRepository, UserRepository>();
builder.Services.AddTransient<IEmailService, SmtpEmailService>();
builder.Services.AddScoped<UserService>();

Menggunakan IServiceProvider Secara Langsung

Dalam kes yang jarang berlaku, anda perlu mendapatkan perkhidmatan secara imperatif. IServiceProvider membolehkan anda memanggil GetRequiredService<T>() untuk mendapatkan perkhidmatan, tetapi dalam kebanyakan keadaan, utamakan suntikan melalui pembina.

// Anti-pattern (service locator) — use sparingly
public class ManualResolver
{
    private readonly IServiceProvider _sp;

    public ManualResolver(IServiceProvider sp) => _sp = sp;

    public void DoWork()
    {
        var svc = _sp.GetRequiredService<UserService>();
        svc.FindUser(1);
    }
}

Mendaftarkan Generik Terbuka

.NET DI menyokong pendaftaran generik terbuka. Anda boleh mendaftarkan IRepository<> sekali, dan ia akan diselesaikan kepada Repository<T> untuk apa-apa jenis entiti.

builder.Services.AddScoped(typeof(IRepository<>), typeof(Repository<>));

// Resolves as:
// IRepository<User> -> Repository<User>
// IRepository<Order> -> Repository<Order>

Pengesahan pada Permulaan

Dengan ValidateOnStart() atau ValidateScopes = true, bekas boleh mengesan pendaftaran yang salah konfigurasi, seperti menangkap perkhidmatan berskop di dalam perkhidmatan tunggal, ketika aplikasi bermula dan bukannya semasa masa jalan.

builder.Services.AddScoped<IMyService, MyService>();

// Detect scope violations at startup
builder.Host.UseDefaultServiceProvider(options =>
{
    options.ValidateScopes = true;
    options.ValidateOnBuild = true;
});

Menambah Penghias pada Perkhidmatan

Anda boleh membalut perkhidmatan dengan penghias tanpa mengubah suai kelas asal. Daftarkan perkhidmatan dalaman terlebih dahulu, kemudian daftarkan penghias yang membalutnya.

builder.Services.AddScoped<IUserRepository, UserRepository>();

// Decorator pattern
builder.Services.Decorate<IUserRepository, CachedUserRepository>();
// Requires Scrutor NuGet package

Dunia Sebenar: API Minimum dengan DI

Dalam API Minimum, perkhidmatan disuntik terus ke dalam parameter pengendali laluan. Bekas mendapatkannya secara automatik.

app.MapGet("/users/{id}", (int id, UserService svc) =>
{
    var user = svc.FindUser(id);
    return user is null ? Results.NotFound() : Results.Ok(user);
});

Semakan Pantas

Kaedah manakah yang patut anda utamakan untuk mendapatkan kebergantungan dalam kebanyakan kelas?

Jawab dalam pelajaran interaktif

Imbas Kembali: Asas Bekas DI

Perkara penting:

DI menyongsangkan penciptaan kebergantungan: bekas membina objek, bukannya kelas itu sendiri
Daftarkan perkhidmatan dengan AddTransient / AddScoped / AddSingleton
Suntikan melalui pembina ialah pendekatan piawai dan yang diutamakan
Generik terbuka, penghias dan ValidateOnBuild ialah ciri lanjutan yang berkuasa

Percuma untuk bermula

Pelajari C# dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 93
Pelajaran: 346

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Asas Bekas DI” percuma?

Ya — teks penuh “Asas Bekas DI” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Akademi C#, tingkat taraf kepada CoddyKit PRO. Kursus Akademi C# merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Asas Bekas DI”?

Fahami pembalikan kawalan, pendaftaran perkhidmatan dan cara bekas DI .NET menyelesaikan kebergantungan. Anda berlatih Akademi C# menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Akademi C#?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Akademi C# di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Asas Bekas DI” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Akademi C# ini?

Ya. Setiap pelajaran Akademi C# menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Akademi C#