LINQ: Kapan harus menggunakan SingleOrDefault vs. FirstOrDefault () dengan kriteria penyaringan

Pertimbangkan metode ekstensi IEnumerable SingleOrDefault()danFirstOrDefault()

Dokumen MSDN itu SingleOrDefault :

Mengembalikan satu-satunya elemen urutan, atau nilai default jika urutannya kosong; Metode ini melempar pengecualian jika ada lebih dari satu elemen dalam urutan.

sedangkan FirstOrDefaultdari MSDN (mungkin saat menggunakan OrderBy()atau OrderByDescending() atau tidak sama sekali),

Mengembalikan elemen pertama dari suatu urutan

Pertimbangkan beberapa contoh kueri, tidak selalu jelas kapan harus menggunakan kedua metode ini:

var someCust = db.Customers
.SingleOrDefault(c=>c.ID == 5); //unlikely(?) to be more than one, but technically COULD BE

var bobbyCust = db.Customers
.FirstOrDefault(c=>c.FirstName == "Bobby"); //clearly could be one or many, so use First?

var latestCust = db.Customers
.OrderByDescending(x=> x.CreatedOn)
.FirstOrDefault();//Single or First, or does it matter?

Pertanyaan

Konvensi apa yang Anda ikuti atau sarankan ketika memutuskan untuk menggunakan SingleOrDefault()dan FirstOrDefault()dalam pertanyaan LINQ Anda?

Setiap kali Anda menggunakan SingleOrDefault, Anda dengan jelas menyatakan bahwa kueri harus menghasilkan paling banyak satu hasil. Di sisi lain, kapanFirstOrDefault digunakan, kueri dapat mengembalikan jumlah hasil berapapun tetapi Anda menyatakan bahwa Anda hanya menginginkan yang pertama.

Saya pribadi menemukan semantik yang sangat berbeda dan menggunakan yang semantik, tergantung pada hasil yang diharapkan, meningkatkan keterbacaan.

Jika set hasil Anda mengembalikan 0 catatan:

• SingleOrDefault mengembalikan nilai default untuk tipe (mis. default untuk int adalah 0)
• FirstOrDefault mengembalikan nilai default untuk tipe tersebut

Jika Anda menghasilkan set, kembalikan 1 catatan:

• SingleOrDefault mengembalikan catatan itu
• FirstOrDefault mengembalikan catatan itu

Jika set hasil Anda mengembalikan banyak catatan:

• SingleOrDefault melempar pengecualian
• FirstOrDefault mengembalikan catatan pertama

Kesimpulan:

Jika Anda ingin pengecualian dilemparkan jika set hasil berisi banyak catatan, gunakan SingleOrDefault.

Jika Anda selalu ingin 1 catatan apa pun yang berisi hasil set, gunakan FirstOrDefault

Ada

• perbedaan semantik
• perbedaan kinerja

antara keduanya.

Perbedaan semantik:

• FirstOrDefault mengembalikan item pertama yang berpotensi banyak (atau default jika tidak ada).
• SingleOrDefaultmengasumsikan bahwa ada satu item dan mengembalikannya (atau default jika tidak ada). Beberapa item merupakan pelanggaran kontrak, pengecualian dilemparkan.

Perbedaan Kinerja

• FirstOrDefaultbiasanya lebih cepat, iterates sampai ia menemukan elemen dan hanya perlu mengulangi seluruh enumerable ketika tidak menemukannya. Dalam banyak kasus, ada kemungkinan besar untuk menemukan item.

• SingleOrDefaultperlu memeriksa apakah hanya ada satu elemen dan karena itu selalu iterates seluruh enumerable. Lebih tepatnya, itu berulang sampai menemukan elemen kedua dan melempar pengecualian. Tetapi dalam kebanyakan kasus, tidak ada elemen kedua.

Kesimpulan

• Gunakan FirstOrDefaultjika Anda tidak peduli berapa banyak item yang ada atau ketika Anda tidak mampu memeriksa keunikan (misalnya dalam koleksi yang sangat besar). Saat Anda memeriksa keunikan dalam menambahkan item ke koleksi, mungkin terlalu mahal untuk memeriksanya lagi saat mencari item tersebut.

• Gunakan SingleOrDefaultjika Anda tidak perlu terlalu memperhatikan kinerja dan ingin memastikan bahwa asumsi satu item jelas untuk pembaca dan diperiksa saat runtime.

Dalam praktiknya, Anda menggunakan First/ FirstOrDefaultsering bahkan dalam kasus ketika Anda mengasumsikan satu item, untuk meningkatkan kinerja. Anda harus tetap ingat bahwa Single/ saya SingleOrDefaultdapat meningkatkan keterbacaan (karena itu menyatakan asumsi satu item) dan stabilitas (karena memeriksa itu) dan menggunakannya dengan tepat.

Tidak ada yang menyebutkan bahwa FirstOrDefault diterjemahkan dalam SQL tidak merekam TOP 1, dan SingleOrDefault melakukan TOP 2, karena perlu tahu apakah ada lebih dari 1 catatan.

Untuk LINQ -> SQL:

SingleOrDefault

• akan menghasilkan permintaan seperti "pilih * dari pengguna di mana userid = 1"
• Pilih catatan yang cocok, Melempar pengecualian jika lebih dari satu catatan ditemukan
• Gunakan jika Anda mengambil data berdasarkan kolom kunci utama / unik

Masalah Pertama atau Kesalahan

• akan menghasilkan permintaan seperti "pilih top 1 * dari pengguna di mana userid = 1"
• Pilih baris yang cocok pertama
• Gunakan jika Anda mengambil data berdasarkan kolom kunci non primer / unik

Saya menggunakan SingleOrDefaultdalam situasi di mana logika saya menentukan bahwa akan menjadi nol atau satu hasil. Jika ada lebih banyak, ini adalah situasi kesalahan, yang sangat membantu.

SingleOrDefault: Anda mengatakan bahwa "Paling banyak" ada satu item yang cocok dengan kueri atau default FirstOrDefault: Anda mengatakan bahwa ada "Setidaknya" satu item yang cocok dengan kueri atau default

Katakan dengan keras waktu berikutnya Anda harus memilih dan Anda akan memilih dengan bijak. :)

Dalam kasus Anda, saya akan menggunakan yang berikut:

pilih dengan ID == 5: boleh saja menggunakan SingleOrDefault di sini, karena Anda mengharapkan satu entitas [atau tidak sama sekali], jika Anda mendapatkan lebih dari satu entitas dengan ID 5, ada sesuatu yang salah dan tentu saja pengecualian layak.

ketika mencari orang yang nama depannya sama dengan "Bobby", mungkin ada lebih dari satu (sangat mungkin saya akan berpikir), jadi Anda tidak boleh menggunakan Tunggal atau Pertama, cukup pilih dengan Operasi di mana (jika "Bobby" mengembalikan terlalu banyak entitas, pengguna harus mempersempit pencariannya atau memilih salah satu hasil yang dikembalikan)

urutan berdasarkan tanggal pembuatan juga harus dilakukan dengan Operasi di mana (tidak mungkin hanya memiliki satu entitas, pengurutan tidak akan banyak berguna;) namun ini menyiratkan Anda ingin SEMUA entitas diurutkan - jika Anda ingin SATU saja, gunakan FirstOrDefault, Single akan melempar setiap kali jika Anda mendapatkan lebih dari satu entitas.

Keduanya adalah operator elemen dan mereka digunakan untuk memilih elemen tunggal dari suatu urutan. Tetapi ada perbedaan kecil di antara mereka. Operator SingleOrDefault () akan melempar eksepsi jika lebih dari satu elemen puas dengan kondisi di mana FirstOrDefault () tidak akan melempar eksepsi untuk hal yang sama. Inilah contohnya.

List<int> items = new List<int>() {9,10,9};
//Returns the first element of a sequence after satisfied the condition more than one elements
int result1 = items.Where(item => item == 9).FirstOrDefault();
//Throw the exception after satisfied the condition more than one elements
int result3 = items.Where(item => item == 9).SingleOrDefault();

Dalam contoh terakhir Anda:

var latestCust = db.Customers
.OrderByDescending(x=> x.CreatedOn)
.FirstOrDefault();//Single or First, or doesn't matter?

Ya itu. Jika Anda mencoba menggunakan SingleOrDefault()dan hasil kueri lebih dari catatan Anda akan mendapatkan dan pengecualian. Satu-satunya waktu Anda dapat menggunakan dengan aman SingleOrDefault()adalah ketika Anda mengharapkan hanya 1 dan hanya 1 hasil ...

Jadi seperti yang saya mengerti sekarang, SingleOrDefault akan lebih baik jika Anda meminta data yang dijamin unik yaitu ditegakkan oleh batasan DB seperti kunci primer.

Atau ada cara yang lebih baik untuk menanyakan kunci utama.

Dengan asumsi TableAcc saya miliki

AccountNumber - Primary Key, integer
AccountName
AccountOpenedDate
AccountIsActive
etc.

dan saya ingin meminta AccountNumber 987654, saya gunakan

var data = datacontext.TableAcc.FirstOrDefault(obj => obj.AccountNumber == 987654);

Menurut pendapat saya FirstOrDefaultterlalu sering digunakan. Dalam sebagian besar kasus saat Anda memfilter data, Anda akan diharapkan untuk mendapatkan kembali kumpulan elemen yang cocok dengan kondisi logis atau elemen unik tunggal dengan pengidentifikasi unik - seperti pengguna, buku, posting dll ... Itu mengapa kita bahkan bisa mengatakan bahwa itu FirstOrDefault()adalah bau kode bukan karena ada sesuatu yang salah dengan itu tetapi karena terlalu sering digunakan. Posting blog ini mengeksplorasi topik secara rinci. IMO sebagian besar kali SingleOrDefault()adalah alternatif yang jauh lebih baik jadi waspadai kesalahan ini dan pastikan Anda menggunakan metode yang paling tepat yang dengan jelas mewakili kontrak dan harapan Anda.

Satu hal yang terlewatkan dalam tanggapan ....

Jika ada beberapa hasil, FirstOrDefault tanpa perintah oleh dapat membawa kembali hasil yang berbeda berdasarkan strategi indeks yang pernah digunakan oleh server.

Secara pribadi saya tidak tahan melihat FirstOrDefault dalam kode karena bagi saya dikatakan pengembang tidak peduli dengan hasilnya. Dengan pesanan meskipun itu bisa berguna sebagai cara menegakkan yang terbaru / paling awal. Saya harus memperbaiki banyak masalah yang disebabkan oleh pengembang yang ceroboh menggunakan FirstOrDefault.

Saya bertanya kepada Google untuk penggunaan berbagai metode di GitHub. Ini dilakukan dengan menjalankan kueri pencarian Google untuk setiap metode dan membatasi kueri ke domain github.com dan ekstensi file .cs dengan menggunakan kueri "site: file github.com: cs ..."

Tampaknya metode First * lebih umum digunakan daripada metode Single *.

| Method               | Results |
|----------------------|---------|
| FirstAsync           |     315 |
| SingleAsync          |     166 |
| FirstOrDefaultAsync  |     357 |
| SingleOrDefaultAsync |     237 |
| FirstOrDefault       |   17400 |
| SingleOrDefault      |    2950 |

Saya tidak mengerti mengapa Anda menggunakan FirstOrDefault(x=> x.ID == key)saat ini dapat mengambil hasil lebih cepat jika Anda gunakan Find(key). Jika Anda bertanya dengan kunci utama tabel, aturan praktisnya adalah untuk selalu menggunakan Find(key). FirstOrDefaultharus digunakan untuk hal-hal predikat seperti (x=> x.Username == username)dll.

ini tidak layak downvote karena judul pertanyaan tidak spesifik untuk LINQ pada DB atau LINQ untuk daftar / IEnumerable dll