Akademi C# · Pelajaran

Pemuatan Awal, Malas & Eksplisit

Kawal masa data berkaitan dimuatkan menggunakan Include, ThenInclude, proksi pemuatan malas dan panggilan Load eksplisit.

Pelajaran 1 daripada 413 langkah

Pemuatan Awal, Malas & Eksplisit 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.

Tiga Strategi Pemuatan

EF Core menawarkan tiga strategi untuk memuatkan data berkaitan: Pemuatan Awal (muat bersama pertanyaan), Pemuatan Malas (muat apabila diakses) dan Pemuatan Eksplisit (muat apabila diperlukan). Memilih strategi yang sesuai dapat mengelakkan masalah N+1 dan perjalanan pergi balik ke pangkalan data yang tidak diperlukan.

Pemuatan Awal dengan Include

Pemuatan awal menggunakan Include() untuk menyertakan data berkaitan melalui JOIN dalam pertanyaan SQL yang sama. Ini ialah strategi yang paling mudah dijangka dan mengelakkan masalah N+1.

// Single query with JOIN
var blogs = await _db.Blogs
    .Include(b => b.Posts)
    .Where(b => b.IsActive)
    .ToListAsync();

// SQL: SELECT * FROM Blogs LEFT JOIN Posts ON ...

ThenInclude untuk Perhubungan Bersarang

ThenInclude menyusuri graf navigasi dengan lebih mendalam. Anda boleh memuatkan beberapa aras dalam satu pertanyaan.

var orders = await _db.Orders
    .Include(o => o.Customer)
    .Include(o => o.Lines)
        .ThenInclude(l => l.Product)
            .ThenInclude(p => p.Category)
    .Where(o => o.Status == OrderStatus.Pending)
    .ToListAsync();

Include dengan Penapisan

EF Core 5+ menyokong penapisan data berkaitan di dalam Include. Ini membolehkan anda memuatkan sebahagian anak tanpa pertanyaan berasingan.

// Load only published posts for each blog
var blogs = await _db.Blogs
    .Include(b => b.Posts.Where(p => p.IsPublished)
                         .OrderByDescending(p => p.PublishedAt)
                         .Take(5))
    .ToListAsync();

Penyediaan Pemuatan Malas

Pemuatan malas memuatkan sifat navigasi secara automatik pada kali pertama sifat tersebut diakses. Dayakannya dengan memasang pakej Microsoft.EntityFrameworkCore.Proxies dan memanggil UseLazyLoadingProxies().

// 1. Install package: dotnet add package Microsoft.EntityFrameworkCore.Proxies
// 2. Enable in DbContext setup:
builder.Services.AddDbContext<AppDbContext>(opt =>
    opt.UseSqlite(connStr)
       .UseLazyLoadingProxies());

// 3. Mark navigation properties as virtual:
public class Blog
{
    public int Id { get; set; }
    public virtual ICollection<Post> Posts { get; set; } = new List<Post>();
}

Pemuatan Malas dalam Tindakan (dan Perangkap N+1)

Pemuatan malas memang mudah, tetapi berbahaya dalam gelung — setiap akses mencetuskan pertanyaan SQL baharu dan menyebabkan masalah N+1. Sentiasa utamakan pemuatan awal dalam senario senarai.

var blogs = await _db.Blogs.ToListAsync(); // 1 query

foreach (var blog in blogs)
{
    // BAD: each access fires a new query!
    var count = blog.Posts.Count; // N queries
    Console.WriteLine(count);
}

// FIX: Use eager loading
var blogs2 = await _db.Blogs.Include(b => b.Posts).ToListAsync();

Pemuatan Eksplisit

Pemuatan eksplisit membolehkan anda memuatkan sifat navigasi apabila diperlukan menggunakan Entry().Collection().LoadAsync() atau Entry().Reference().LoadAsync(). Ini berguna apabila anda hanya memerlukan data berkaitan dalam keadaan tertentu.

var blog = await _db.Blogs.FindAsync(1); // no posts loaded

// Load posts only when needed
if (needsPosts)
{
    await _db.Entry(blog!)
             .Collection(b => b.Posts)
             .LoadAsync();
}

// Load single reference
var post = await _db.Posts.FindAsync(99);
await _db.Entry(post!)
         .Reference(p => p.Blog)
         .LoadAsync();

Pemuatan Eksplisit dengan Penapis Pertanyaan

Anda boleh menapis pemuatan eksplisit menggunakan .Query() sebelum memanggil LoadAsync(), sekali gus mengurangkan jumlah data yang dikembalikan.

var blog = await _db.Blogs.FindAsync(1);

// Only load posts published this year
await _db.Entry(blog!)
         .Collection(b => b.Posts)
         .Query()
         .Where(p => p.PublishedAt.Year == DateTime.UtcNow.Year)
         .LoadAsync();

Console.WriteLine(blog!.Posts.Count);

Pertanyaan Terpisah untuk Include Berskala Besar

Memuatkan berbilang koleksi dalam satu kueri menyebabkan letupan Cartesian (baris berganda). Gunakan AsSplitQuery() untuk mengeluarkan kueri berasingan bagi setiap koleksi, yang digabungkan dalam memori.

var orders = await _db.Orders
    .Include(o => o.Lines)
    .Include(o => o.Shipments)
    .AsSplitQuery()  // 3 separate SELECTs instead of one giant JOIN
    .ToListAsync();

// Or configure globally:
opt.UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery);

Unjuran untuk Mengelakkan Pengambilan Data Berlebihan

Daripada memuatkan entiti lengkap bersama semua hubungannya, unjurkan kepada objek pemindahan data menggunakan Select. Dengan cara ini, anda mendapat tepat data yang diperlukan dalam satu kueri yang dioptimumkan.

var summaries = await _db.Blogs
    .Select(b => new BlogSummaryDto
    {
        Name      = b.Name,
        PostCount = b.Posts.Count(p => p.IsPublished),
        LatestPost = b.Posts
            .Where(p => p.IsPublished)
            .OrderByDescending(p => p.PublishedAt)
            .Select(p => p.Title)
            .FirstOrDefault()
    })
    .ToListAsync();
// No Include needed - translated to subqueries

Dalam Dunia Sebenar: Memilih Strategi yang Tepat

Gunakan panduan membuat keputusan ini dalam amalan:

Pemuatan segera + Include: anda sentiasa memerlukan data berkaitan, seperti pada halaman senarai
Unjuran: paparan baca sahaja dan respons API — paling cekap
Pemuatan eksplisit: pemuatan bersyarat berdasarkan logik aplikasi
Pemuatan malas: elakkan dalam aplikasi web; gunakan hanya untuk desktop atau penskripan dengan set data kecil

Semakan Pantas

Apakah masalah N+1 dalam konteks pemuatan malas?

Jawab dalam pelajaran interaktif

Imbas Kembali: Strategi Pemuatan

Inti pati utama:

Pemuatan segera (Include): memuatkan data dalam satu kueri — terbaik untuk corak capaian yang boleh dijangka
Include ditapis: memuatkan hanya sebahagian anak entiti — EF Core 5+
Pemuatan malas: mudah digunakan tetapi berisiko — elakkan dalam gelung (masalah N+1)
Pemuatan eksplisit: memuatkan apabila diperlukan dengan kawalan terperinci
Unjuran dengan Select: paling cekap untuk senario baca sahaja
Kueri berasingan: elakkan letupan Cartesian dengan berbilang Include koleksi

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 “Pemuatan Awal, Malas & Eksplisit” percuma?

Ya — teks penuh “Pemuatan Awal, Malas & Eksplisit” 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 “Pemuatan Awal, Malas & Eksplisit”?

Kawal masa data berkaitan dimuatkan menggunakan Include, ThenInclude, proksi pemuatan malas dan panggilan Load eksplisit. 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 “Pemuatan Awal, Malas & Eksplisit” 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

Pemuatan Awal, Malas & Eksplisit
SQL Mentah, Prosedur Tersimpan & Interpolasi
Pertanyaan Terkompil & Prestasi
Penapis Pertanyaan Global & Entiti Milikan

← Kembali ke Akademi C#