
Sebuah halaman senarai dalam aplikasi ASP.NET Core boleh rasa sangat pantas ketika pembangunan dengan sepuluh rekod ujian, tetapi menjadi lembap sebaik sahaja masuk ke produksi dengan dua ribu rekod sebenar. Apabila disemak, selalunya puncanya bukan satu query gergasi yang kompleks—sebaliknya ratusan query kecil yang ditembak satu demi satu ke pangkalan data setiap kali halaman itu dibuka.
Masalah ini dikenali sebagai pola N+1, dan ia sangat mudah terlepas pandang jika kita hanya menguji menggunakan data kosong atau pangkalan data tempatan yang berjalan di mesin yang sama. Di localhost, 150 query kecil mungkin cuma mengambil masa 40 milisaat. Di pelayan produksi yang berasingan dengan sambungan rangkaian antara app server dan database server, 150 perjalanan ulang-alik itu boleh bertukar menjadi dua atau tiga saat sebelum HTML sempat dirender.
Masalah yang nampak sihat dengan sepuluh rekod
Pola ini biasanya berlaku apabila kita mengambil senarai induk dahulu, kemudian dalam gelung (foreach atau ketika memetakan ke ViewModel/DTO), kod mengakses navigation property yang belum dimuatkan, atau memanggil servis lain yang menjalankan query berasingan untuk setiap item.
Sebagai contoh mudah, bayangkan paparan senarai invois pelanggan:
// Contoh bermasalah: setiap invois mencetuskan query tambahan jika Lazy Loading aktif
// atau jika pembangun memanggil query berasingan di dalam gelung.
var invoices = await _db.Invoices
.OrderByDescending(x => x.IssuedAt)
.Take(50)
.ToListAsync();
foreach (var inv in invoices)
{
var customerName = await _db.Customers
.Where(c => c.Id == inv.CustomerId)
.Select(c => c.Name)
.FirstOrDefaultAsync();
}
Jika ada 50 invois di satu halaman, kod di atas menjalankan 1 query untuk senarai invois dan 50 query lagi untuk nama pelanggan. Kalau halaman itu memaparkan 200 rekod tanpa pagination, bilangan query terus melonjak kepada 201 kali untuk satu permintaan HTTP.
Cara kesan query senyap sebelum masuk produksi
Langkah pertama ialah berhenti meneka dan hidupkan log SQL semasa fasa pembangunan. Dalam appsettings.Development.json, anda boleh menetapkan tahap log untuk kategori arahan pangkalan data EF Core:
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.EntityFrameworkCore.Database.Command": "Information"
}
}
}
Atau semasa konfigurasi DbContext, aktifkan LogTo(Console.WriteLine, LogLevel.Information) hanya untuk persekitaran pembangunan supaya anda dapat melihat teks SQL sebenar serta parameter yang dijana. Apabila anda membuka satu halaman dan terminal tiba-tiba memuntahkan puluhan SELECT yang hampir serupa dengan hanya nilai WHERE yang berubah, anda sudah jumpa puncanya.
Untuk ujian yang lebih hampir dengan keadaan sebenar, isi pangkalan data pembangunan dengan sekurang-kurangnya beberapa ribu rekod menggunakan skrip seed. Masalah prestasi jarang muncul pada jadual yang hanya ada lima baris data.
Projection, AsNoTracking dan perangkap Include
Apabila berdepan paparan senarai yang hanya bersifat baca (read-only), cara paling bersih selalunya ialah menggunakan projection terus dengan .Select(...) ke DTO atau ViewModel, digabungkan dengan .AsNoTracking():
var invoices = await _db.Invoices
.AsNoTracking()
.OrderByDescending(x => x.IssuedAt)
.Take(50)
.Select(inv => new InvoiceRowDto
{
Id = inv.Id,
InvoiceNumber = inv.InvoiceNumber,
CustomerName = inv.Customer.Name,
TotalAmount = inv.TotalAmount
})
.ToListAsync();
Dengan cara ini, EF Core menjana satu SELECT dengan JOIN yang hanya mengambil empat kolum yang diperlukan—bukan menarik semua kolum teks panjang atau nota dalam jadual Invoices dan Customers, dan tanpa membebankan Change Tracker untuk menjejak perubahan objek yang tidak akan disunting pun.
Satu lagi kesilapan yang kerap berlaku ialah menyambung terlalu banyak .Include() pada hubungan koleksi satu-ke-banyak secara serentak. Jika satu entiti mempunyai dua atau tiga koleksi anak dan semuanya digabungkan dalam satu JOIN besar, hasilnya boleh mencetuskan Cartesian explosion—baris data berulang berganda-ganda dan penggunaan memori melonjak. Dalam kes sebegitu, .AsSplitQuery() boleh membantu memecahkan query kepada beberapa SELECT yang lebih terkawal, namun tetap perlu diukur kesannya.
Ukur masa sebenar, bukan sekadar kira jumlah query
Mengurangkan jumlah query tidak automatik menjadikan aplikasi lebih laju jika satu query tunggal itu menarik jutaan bait data yang tidak perlu, atau menapis di memori selepas .ToListAsync() dipanggil terlalu awal. Sentiasa pastikan .Where(), .OrderBy(), .Skip() dan .Take() berada sebelum .ToListAsync() supaya penapisan berlaku di pangkalan data, bukan dalam RAM pelayan web.
Rujuk dokumentasi Microsoft tentang prestasi EF Core untuk memahami perbezaan antara eager loading, explicit loading dan projection dengan lebih terperinci. Kemudian, ukur pada aplikasi anda sendiri sebelum dan selepas perubahan: catat masa respons (ms), jumlah query, serta saiz payload yang dikembalikan.
Jangan lupa semak juga reka bentuk halaman itu sendiri. Adakah pengguna benar-benar perlukan semua 500 rekod dimuatkan serentak, atau pagination yang kemas dan penapis carian ringkas sudah memadai? Kadang-kadang pembaikan paling berkesan ialah gabungan query yang bersih dan antaramuka yang tidak tamak memaparkan segala-galanya sekali gus.