Quand utiliser.D'abord et quand les utiliser.FirstOrDefault avec LINQ?

.First lancera une exception quand il n'y a pas de résultats. .FirstOrDefault ne le fera pas, il retournera simplement null (types de référence) ou la valeur par défaut du type de valeur. (par exemple comme 0 pour un int.) La question ici n'est pas quand vous voulez le type par défaut, mais plus: Êtes-vous prêt à gérer une exception ou à gérer une valeur par défaut? Puisque les exceptions devraient être exceptionnelles, FirstOrDefault est préféré lorsque vous n'êtes pas sûr si vous allez obtenir des résultats de votre requête. Quand logiquement les données devraient être là, la gestion des exceptions peut être envisagée.

Skip() et Take() sont normalement utilisés lors de la configuration de la pagination dans les résultats. (Comme Montrer les 10 premiers résultats, et les 10 suivants sur la page suivante, etc.)

J'espère que cela aide.

.First () lancera une exception s'il n'y a pas de ligne à renvoyer, while .FirstOrDefault() retourne la valeur par défaut (NULL pour tous les types de référence) à la place.

Donc, si vous êtes prêt et prêt à gérer une exception possible, .First() est bien. Si vous préférez vérifier la valeur de retour pour != null de toute façon, alors .FirstOrDefault() est votre meilleur choix.

Mais je suppose que c'est un peu une préférence personnelle, aussi. Utilisez celui qui a le plus de sens pour vous et correspond mieux à votre style de codage.

D'abord()

1. renvoie le premier élément d'une séquence.
2. il lance une erreur lorsqu'il N'y a pas d'élément dans le résultat ou que la source est nulle.
3. Vous devriez l'utiliser, si plus d'un élément est attendu et que vous ne voulez que le premier élément.

FirstOrDefault()

1. Retourne le premier élément d'une séquence, ou une valeur par défaut si aucun élément n'est trouvé.
2. Il génère une erreur uniquement si la source est NULL.
3. Vous devriez l'utiliser, si plus d'un élément est attendu et que vous ne voulez que le premier élément. Aussi bon si le résultat est vide.

Nous avons une table UserInfos, qui a quelques enregistrements comme indiqué ci-dessous. Sur la base de ce tableau ci-dessous, j'ai créé un exemple...

Comment utiliser le Premier()

var result = dc.UserInfos.First(x => x.ID == 1);

Il n'y a qu'un seul enregistrement où ID = = 1. Devrait renvoyer cet enregistrement
ID: 1 prénom: Manish nom: Dubey Email: xyz@xyz.com

var result = dc.UserInfos.First(x => x.FName == "Rahul");   

Il y a plusieurs enregistrements où FName = = "Rahul". Le premier enregistrement devrait être le retour.
ID: 7 prénom: Rahul nom: Sharma courriel: xyz1@xyz.com

var result = dc.UserInfos.First(x => x.ID ==13);

Il n'y a pas d'enregistrement avec ID== 13. Une erreur devrait se produire.
InvalidOperationException: la séquence ne contient aucun élément

Comment Utiliser FirstOrDefault()

var result = dc.UserInfos.FirstOrDefault(x => x.ID == 1);

Il n'y a qu'un seul enregistrement où ID = = 1. Devrait renvoyer cet enregistrement
ID: 1 prénom: Manish nom de famille: Dubey courriel: xyz@xyz.com

var result = dc.UserInfos.FirstOrDefault(x => x.FName == "Rahul");

Il y a plusieurs enregistrements où FName = = "Rahul". Le premier enregistrement devrait être le retour.
ID: 7 prénom: Rahul nom: Sharma courriel: xyz1@xyz.com

var result = dc.UserInfos.FirstOrDefault(x => x.ID ==13);

Il n'y a pas d'enregistrement avec ID== 13. La valeur de retour est nulle

Espère que ça vous aidera à comprendre quand utiliser First() ou FirstOrDefault().

Tout d'Abord, Take est une méthode complètement différente. Il renvoie un IEnumerable<T> et pas un seul T, donc c'est sorti.

Entre First et FirstOrDefault, vous devez utiliser First lorsque vous êtes sûr qu'un élément existe et si ce n'est pas le cas, il y a une erreur.

En passant, si votre séquence contient default(T) éléments (par exemple null) et que vous devez faire la distinction entre être vide et le premier élément étant null, vous ne pouvez pas utiliser FirstOrDefault.

Premier:

• Retourne le premier élément d'une séquence
• lance une exception: il N'y a pas d'éléments dans le résultat
• Utilisez when: lorsque plus de 1 élément est attendu et que vous ne voulez que le premier

FirstOrDefault:

• Retourne le premier élément d'une séquence, ou une valeur par défaut si aucun élément n'est trouvé
• lève exception: seulement si la source est null
• Utilisez when: quand plus de 1 élément est attendu et que vous ne voulez que le premier. Également il est correct que le résultat soit vide

À Partir de: http://www.technicaloverload.com/linq-single-vs-singleordefault-vs-first-vs-firstordefault/

Une autre différence à noter est que si vous déboguez une application dans un environnement de Production, vous n'avez peut-être pas accès aux numéros de ligne, donc identifier quelle instruction .First() particulière dans une méthode a jeté l'exception peut être difficile.

Le message d'exception n'inclura pas non plus les expressions Lambda que vous pourriez avoir utilisées, ce qui rendrait tout problème encore plus difficile à déboguer.

C'est pourquoi j'utilise toujours FirstOrDefault() même si je sais qu'une entrée nulle constituerait un situation exceptionnelle.

var customer = context.Customers.FirstOrDefault(i => i.Id == customerId);
if (customer == null)
{
   throw new Exception(string.Format("Can't find customer {0}.", customerId));
}

J'ai trouvé un site web qui apperars pour expliquer la nécessité de FirstOrDefault
http://thepursuitofalife.com/the-linq-firstordefault-method-and-null-resultsets/
S'il n'y a pas de résultats à une requête, et que vous voulez appeler First() ou Single() pour obtenir une seule ligne... Vous obtiendrez une "Séquence contient pas d'éléments de" l'exception".

Avertissement: je n'ai jamais utilisé LINQ, donc mes excuses si c'est loin de la marque.

D'abord()

Lorsque vous savez que le résultat contient plus de 1 élément attendu et que vous ne devriez que le premier élément de la séquence.

FirstOrDefault()

FirstOrDefault () est juste comme First () sauf que, si aucun élément ne correspond à la condition spécifiée, il renvoie la valeur par défaut du type sous-jacent de la collection générique. Il ne lance pas InvalidOperationException si aucun élément n'est trouvé. Mais la collection d'élément ou d'une séquence est nulle qu'elle ne lance un exception.

someList.First(); // exception if collection is empty.
someList.FirstOrDefault(); // first item or default(Type)

Lequel utiliser? Il devrait être décidé par la logique métier, et non par la peur de l'échec d'exception/programm.

Par exemple, Si la logique métier dit que nous ne pouvons pas avoir zéro transactions sur un jour ouvrable (il suffit de supposer). Ensuite, vous ne devriez pas essayer de gérer ce scénario avec une programmation intelligente. Je vais toujours utiliser First () sur une telle collection, et laisser le programme échouer si quelque chose d'autre a foiré la logique métier.

Code:

var transactionsOnWorkingDay = GetTransactionOnLatestWorkingDay();
var justNeedOneToProcess = transactionsOnWorkingDay.First(): //Not FirstOrDefault()

Je voudrais voir les autres commentaires sur cette.

Ok, laissez-moi donner mes deux cents. First / Firstordefault sont pour lorsque vous utilisez le deuxième constructeur. Je n'expliquerai pas ce que c'est, mais c'est quand vous en utiliseriez potentiellement toujours un parce que vous ne voulez pas provoquer d'exception.

person = tmp.FirstOrDefault(new Func<Person, bool>((p) =>
{
    return string.IsNullOrEmpty(p.Relationship);
}));

Ce type de fonction appartient aux opérateurs d'éléments. Certains opérateurs d'éléments utiles sont définis ci-dessous.

1. Premier/FirstOrDefault
2. , Dernier/LastOrDefault
3. /Unique SingleOrDefault

Nous utilisons des opérateurs d'éléments lorsque nous devons sélectionner un seul élément d'une séquence basée sur une certaine condition. Ici est un exemple.

  List<int> items = new List<int>() { 8, 5, 2, 4, 2, 6, 9, 2, 10 };

L'opérateur First() renvoie le premier élément d'une séquence après avoir satisfait la condition. Si aucun élément n'est trouvé ensuite, il va lancer une exception.

INT result = items.Où(point => item == 2).Premier ();

FirstOrDefault () opérateur retourne le premier élément d'une séquence après avoir satisfait la condition. Si aucun élément n'est trouvé, il retournera la valeur par défaut de ce type.

INT result1 = éléments.Où(point => item == 2).FirstOrDefault ();

Désolé d'avoir posté une réponse à l'ancien message. détail et bonne explication veuillez donc lire les URL ci dessoushttp://www.technicaloverload.com/linq-single-vs-singleordefault-vs-first-vs-firstordefault/

Http://www.dotnet-tricks.com/Tutorial/linq/E23I160714-Understanding-Single,-SingleOrDefault,-First-and-FirstOrDefault.html

Http://www.c-sharpcorner.com/UploadFile/3d39b4/singleordefault-and-firstordefault-methods-in-linq-to-sql/

Linq plusieurs façons d'implémenter une seule requête simple sur les collections, juste nous écrivons des jointures en sql, un filtre peut être appliqué en premier ou en dernier selon le besoin et la nécessité.

Voici un exemple où nous pouvons trouver un élément avec un id dans une collection. Pour ajouter plus à ce sujet, methods First, FirstOrDefault, retournerait idéalement la même chose lorsqu'une collection a au moins un enregistrement. Si, cependant, une collection est acceptable d'être vide. alors First renverra une exception, mais FirstOrDefault sera de retour null ou par défaut. Par exemple, {[4] } renverra 0. Ainsi, l'utilisation de tel est bien que dit être une préférence personnelle, mais il vaut mieux utiliser FirstOrDefault pour éviter la gestion des exceptions.