Find() vs Où().FirstOrDefault()

Je vois souvent des gens en utilisant Where.FirstOrDefault() de faire une recherche et de saisir le premier élément. Pourquoi ne pas simplement utiliser Find()? Est-il un avantage à l'autre? Je ne pouvais pas dire une différence.

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();
        }
    }
}

FWIW, list.FirstOrDefault(x => x == "item3"); est plus concis que l'aide de deux .Where et .FirstOrDefault.
Je suppose que ma prochaine question serait pourquoi ont-ils ajouter le trouver à tous. C'est une bonne astuce. La seule chose que je peux penser, c'est que le FirstOrDefault pourrait retourner une valeur par défaut différente de la valeur autre que null. Sinon, il semble juste comme une inutile de plus.
Find est antérieure à LINQ. (il était disponible .NET 2.0 et vous ne pouvez pas utiliser les lambdas. Vous avez été obligé d'utiliser des méthodes ou des méthodes anonymes)

InformationsquelleAutor KingOfHypocrites | 2012-02-17

c#linq linq-to-objects

179

Où est le Find méthode sur IEnumerable<T>? (Question rhétorique.)

La Where et FirstOrDefault méthodes sont applicables à l'encontre de plusieurs types de séquences, y compris List<T>, T[], Collection<T>, etc. Une séquence qui met en œuvre IEnumerable<T> pouvez utiliser ces méthodes. Find est disponible uniquement pour les List<T>. Les méthodes qui sont généralement plus applicable, sont alors plus réutilisables et avoir un plus grand impact.

Je suppose que ma prochaine question serait pourquoi ont-ils ajouter le trouver à tous. C'est une bonne astuce. La seule chose que je peux penser, c'est que le FirstOrDefault pourrait retourner une valeur par défaut différente de la valeur autre que null. Sinon, il semble juste comme un inutile plus

Find sur List<T> est antérieure à l'autre des méthodes. List<T> a été ajoutée avec les génériques .NET 2.0, et Find a fait partie de l'API pour la classe. Where et FirstOrDefault ont été ajoutés comme des méthodes d'extension pour IEnumerable<T> avec Linq, ce qui est un plus tard .Version NET. Je ne peux pas dire avec certitude que si Linq existé avec la version 2.0 qui Find n'aurait jamais été ajoutées, mais qui est sans doute le cas pour de nombreuses autres fonctionnalités qui est venu plus tôt .NET les versions qui ont été rendues obsolètes ou redondantes par les versions ultérieures.
- Excellente réponse. Je vous remercie.
- Juste pour compléter: Il n'est pas nécessaire d'appel et de Première ou de la FirstOrDefault: la Première ou à la FirstOrDefault vous permet de spécifier une recherche de prédicat, faire la Où les appels inutiles
- Mais Where(condition).FirstOrDefault() optimise au moins aussi bien et parfois mieux que FirstOrDefault(condition) seul. Nous utilisons toujours Where() pour obtenir les meilleures performances lorsqu'ils sont disponibles.
InformationsquelleAutor Anthony Pegram
42

Je viens de découvrir aujourd'hui, de faire quelques tests sur une liste de 80K des objets et a constaté que Find() peut être jusqu'à 1000% plus rapide que d'utiliser un Where avec FirstOrDefault(). Je ne le savais pas jusqu'à ce que le test d'un timer avant et après chaque tous les. Parfois c'est le même temps, sinon, il était plus rapide.
- Avez-vous essayer avec le lieu ET la FirstOrDefault? Si vous ne l'avez peut-être essayer avec seulement FirstOrDefault et voir si Find() est encore mieux.
- pls voir ici. Trouver est vraiment presque deux fois plus vite. Mais je ne peux pas comprendre cela est-il dû à aucun agent Recenseur généraux seulement?
- Cela sonne comme vous n'a pas été le résultat avec un .ToList() ou .ToArray() pour effectuer la requête.
- C'est parce que Find rend l'utilisation de clés primaires (d'où les indices), alors que Where est une simple requête sql
- Si il n'y a pas de clés primaires? J'ai toujours utiliser FindBy dans ces cas-là...
- Comme de EF6, Trouver et FirstOrDefault de générer à la fois exactement les mêmes instructions SQL. Vous pouvez voir le SQL dans une application console en faisant contexte.La base de données.Log = Console.Écrire; L'située exemple est l'utilisation de mémoire "Trouver" à l'encontre d'une liste de chaînes de caractères, ne va pas à l'encontre d'un DB avec des clés primaires. Peut-être la déclaration la traduction de la clause - qui omet le besoin d'expression lambda de l'analyse est la raison pour laquelle l'amélioration de la performance dans ce cas. Sur une base de données, je doute que vous remarquerez une différence dans la RL situations... je me demande aussi si il a été testé à l'aide de la recherche de la première place de la deuxième...
- Eh bien, cette amélioration des performances est parce que find() vérifier dans la mémoire cache pour objet avant d'atteindre DB considérant que, si() d'aller toujours DB pour obtenir l'objet
- Cela se rapporte à LINQ-to-Entités, plutôt que de LINQ-to-objets, comme spécifié par le posteur d'origine.
InformationsquelleAutor digiben
27

Find est seulement mise en œuvre dans List<T>, tandis que Where().FirstOrDefault() fonctionne avec tous les IEnumerable<T>.

InformationsquelleAutor penartur
27

Il y a une différence très importante si la source des données est l'Entity Framework: Find trouverez des entités dans le "ajoutée" de l'état qui ne sont pas encore persisté, mais Where ne sera pas. C'est par la conception.

InformationsquelleAutor Chalky
0

en plus Anthony répondre
Where() visite à travers tous les enregistrements, puis retourner le résultat(s) tout en Find() n'avez pas besoin de parcourir à travers tous les enregistrements si prédicat match avec le prédicat.

donc, disons que vous disposez de la Liste de la classe de Test ayant id et name propriétés.
```
 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);
```
Donnera sortie de 2, et seulement 2 visites Trouver nécessaire de donner suite , mais si vous utilisez Where().FirstOrDefault() nous allons visiter tous les enregistrements, puis nous obtenons des résultats.

Donc , quand vous savez que vous ne voulez premier résultat à partir d'enregistrements dans la collection Find() sera plus adapté puis Where().FirtorDefault();
- mais si vous l'utilisez, Où().FirstOrDefault (), nous allons visiter tous les enregistrements, puis nous obtenons des résultats. Nope. FirstOrDefault sera " bulle de mise en place de la chaîne et arrêter l'énumération de tout. J'utilise le terme de "bubble up" à défaut d'une meilleure expression, parce qu'en fait, chaque sélecteur/prédicat sera transmise à l'autre, de sorte que la dernière méthode de la chaîne est en train de travailler d'abord.
InformationsquelleAutor M Muneeb Ijaz

Vous devez vous connecter pour publier un commentaire.