Trova () vs. Where (). FirstOrDefault ()

Vedo spesso persone che usano Where.FirstOrDefault()fare una ricerca e afferrare il primo elemento. Perché non usare solo Find()? C'è un vantaggio per l'altro? Non saprei dire la 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();
        }
    }
}

Dov'è il Findmetodo IEnumerable<T>? (Domanda retorica.)

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

Immagino che la mia prossima domanda sia: perché hanno aggiunto la scoperta? Questo è un buon consiglio. L'unica cosa che mi viene in mente è che FirstOrDefault potrebbe restituire un valore predefinito diverso da null. Altrimenti sembra solo un'aggiunta inutile

Findon List<T>precede gli altri metodi. List<T>è stato aggiunto con generici in .NET 2.0 e Findfaceva parte dell'API per quella classe. Wheree FirstOrDefaultsono stati aggiunti come metodi di estensione per IEnumerable<T>con Linq, che è una versione successiva di .NET. Non posso dire con certezza che se Linq esistesse con la versione 2.0 che Findnon sarebbe mai stata aggiunta, ma questo è probabilmente il caso di molte altre funzionalità fornite nelle versioni .NET precedenti che erano state rese obsolete o ridondanti dalle versioni successive.

L'ho scoperto oggi, facendo alcuni test su un elenco di 80.000 oggetti e ho scoperto che Find()può essere fino al 1000% più veloce rispetto all'uso di un Wherecon FirstOrDefault(). Non lo sapevo fino a quando non ho provato un timer prima e dopo tutto. A volte era lo stesso tempo, altrimenti era più veloce.

C'è una differenza molto importante se la fonte dei dati è Entity Framework: Findtroverà entità nello stato 'aggiunto' che non sono ancora persistite, ma Wherenon lo faranno. Questo è di progettazione.

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

oltre a Anthony, rispondi alla Where()visita attraverso tutti i record e poi restituisca i risultati mentre Find()non è necessario attraversare tutti i record se il predicato corrisponde a un determinato predicato.

quindi supponiamo di avere un elenco di classi Test con proprietà ide nameproprietà.

 List<Test> tests = new List<Test>();
 tests.Add(new Test() { Id = 1, Name = "name1" });
 tests.Add(new Test() { Id = 2, Name = "name2" });
 tests.Add(new Test() { Id = 3, Name = "name3" });
 tests.Add(new Test() { Id = 4, Name = "name2" }); 
 var r = tests.Find(p => p.Name == "name2");
 Console.WriteLine(r.Id);

Fornirà l'output di 2, e solo 2 visite Trova necessarie per dare risultato, ma se lo usi visiteremo Where().FirstOrDefault()tutti i record e quindi otterremo risultati.

Quindi, quando sai che vuoi solo il primo risultato dai record nella raccolta Find()sarà più adatto alloraWhere().FirtorDefault();

Wow, guardo il tutorial EF di MicrosofToolbox oggi su Youtube. Ha detto di usare Find () e FirstOrDefault (condizione) nella query e Find () cercherà i dati che hai eseguito su quell'oggetto (aggiungi o modifica o elimina - ma non ancora salvati nel database) nel frattempo FirstOrDefault farà solo cerca ciò che è già stato salvato

Find()è l'equivalente IEnumerable di a FirstOrDefault(). Non dovresti concatenare entrambi. Where () .FirstOrDefault()perché .Where()passa attraverso l'intero array e quindi eseguirà l'iterazione attraverso l'elenco per trovare il primo elemento. Risparmia una quantità incredibile di tempo inserendo il tuo predicato di ricerca nel FirstOrDefault()metodo.

Inoltre, ti incoraggio a leggere la domanda collegata a questo thread per saperne di più sulle migliori prestazioni sull'uso degli .Find()scenari specifici Performance of Find () vs. FirstOrDefault ()