Find() vs. Where(). FirstOrDefault()

Question

Spesso vedo persone che utilizzano Where.FirstOrDefault() effettuare una ricerca e afferrare il primo elemento. Perché non usare solo Find()? C'è un vantaggio per l'altro? Non potrei dire una differenza.

namespace LinqFindVsWhere 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      List<string> list = new List<string>(); 
      list.AddRange(new string[] 
      { 
       "item1", 
       "item2", 
       "item3", 
       "item4" 
      }); 

      string item2 = list.Find(x => x == "item2"); 
      Console.WriteLine(item2 == null ? "not found" : "found"); 
      string item3 = list.Where(x => x == "item3").FirstOrDefault(); 
      Console.WriteLine(item3 == null ? "not found" : "found"); 
      Console.ReadKey(); 
     } 
    } 
} 

Answer 1

Dove è il metodo Find su IEnumerable<T>? (Domanda retorica.)

I Where e FirstOrDefault metodi sono applicabili contro molteplici tipi di sequenze, tra List<T>, T[], Collection<T>, ecc Qualsiasi sequenza che implementa IEnumerable<T> possono utilizzare questi metodi. Find è disponibile solo per List<T>. I metodi generalmente più applicabili sono quindi più riutilizzabili e hanno un impatto maggiore.

Immagino che la mia prossima domanda sia perché hanno aggiunto il risultato. Questo è un buon consiglio. L'unica cosa che posso pensare è che il FirstOrDefault potrebbe restituire un valore predefinito diverso diverso da null. Altrimenti sembra un'aggiunta inutile

Find su List<T> precedente agli altri metodi. List<T> è stato aggiunto con generici in .NET 2.0 e Find faceva parte dell'API per quella classe. Where e FirstOrDefault sono stati aggiunti come metodi di estensione per IEnumerable<T> con Linq, che è una versione .NET successiva. Non posso dire con certezza che se Linq esistesse con la versione 2.0, Find non sarebbe mai stato aggiunto, ma questo è probabilmente il caso di molte altre funzionalità che sono venute in versioni precedenti di .NET rese obsolete o ridondanti dalle versioni successive.

Answer 2

Find è solo implemented in List<T>, mentre Where().FirstOrDefault() funziona con tutti i IEnumerable<T>.

Answer 3

Ho appena scoperto oggi, eseguendo alcuni test su un elenco di oggetti 80K e ho rilevato che Find() può essere fino al 1000% più veloce rispetto all'utilizzo di Where con FirstOrDefault(). Non lo sapevo fino a quando non testavo un timer prima e dopo tutti. A volte era la stessa ora, altrimenti era più veloce.

Answer 4

C'è una differenza molto importante se la fonte dei dati è Entity Framework: Find troverà le entità nello stato "aggiunto" che non sono ancora persistenti, ma non lo sarà Where. Questo è di design.