c# - tutorial - linq select




Quando utilizzare. Prima e quando utilizzare.FirstOrDefault con LINQ? (10)

Ho cercato in giro e non ho ancora trovato una risposta chiara su quando avresti voluto utilizzare. .First e quando avresti voluto usare .FirstOrDefault con LINQ.

  • Quando vorresti usare .First ? Solo quando vuoi recuperare l'eccezione se non vengono restituiti risultati?

    var result = List.Where(x => x == "foo").First();
    
  • E quando vorresti usare .FirstOrDefault ? Quando vuoi sempre il tipo predefinito se nessun risultato?

    var result = List.Where(x => x == "foo").FirstOrDefault();
    
  • E del resto, per quanto riguarda Take?

    var result = List.Where(x => x == "foo").Take(1);
    

.First () genererà un'eccezione se non è presente alcuna riga da restituire, mentre .FirstOrDefault () restituirà il valore predefinito ( NULL per tutti i tipi di riferimento).

Quindi, se sei preparato e disposto a gestire una possibile eccezione, .First() va bene. Se si preferisce controllare comunque il valore restituito per! = Null, .FirstOrDefault() è la scelta migliore.

Ma immagino sia anche un po 'una preferenza personale. Usa quello che ha più senso per te e si adatta meglio al tuo stile di codifica.



Ok lasciami dare i miei due centesimi. First / Firstordefault sono per quando si utilizza il secondo costruttore. Non spiegherò di cosa si tratta, ma è quando ne utilizzeresti potenzialmente sempre uno perché non vuoi causare un'eccezione.

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

Prima di tutto, Take è un metodo completamente diverso. Restituisce un IEnumerable<T> e non un singolo T , quindi è fuori.

Tra First e FirstOrDefault , dovresti usare First quando sei sicuro che esista un elemento e, in caso contrario, c'è un errore.

A proposito, se la sequenza contiene elementi default(T) (ad es. null ) e devi distinguere tra essere vuoto e il primo elemento essere null , non puoi utilizzare FirstOrDefault .


Questo tipo di funzione appartiene agli operatori di elementi. Alcuni operatori di elementi utili sono definiti di seguito.

  1. In primo luogo / FirstOrDefault
  2. Ultima / LastOrDefault
  3. Singolo / SingleOrDefault

Utilizziamo gli operatori di elementi quando è necessario selezionare un singolo elemento da una sequenza in base a una determinata condizione. Ecco un esempio.

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

L'operatore first () restituisce il primo elemento di una sequenza dopo aver soddisfatto la condizione. Se non viene trovato alcun elemento, verrà generata un'eccezione.

int result = items.Where (item => item == 2) .First ();

L'operatore FirstOrDefault () restituisce il primo elemento di una sequenza dopo aver soddisfatto la condizione. Se non viene trovato alcun elemento, restituirà il valore predefinito di quel tipo.

int result1 = items.Where (item => item == 2) .FirstOrDefault ();


Un'altra differenza da notare è che se esegui il debug di un'applicazione in un ambiente di produzione potresti non avere accesso ai numeri di riga, quindi identificare quale particolare .First() in un metodo ha .First() l'eccezione potrebbe essere difficile.

Il messaggio di eccezione non includerà anche le espressioni Lambda che potresti aver utilizzato, il che renderebbe qualsiasi problema anche più difficile da eseguire il debug.

Ecco perché utilizzo sempre FirstOrDefault() anche se so che una voce nulla costituirebbe una situazione eccezionale.

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

linq molti modi per implementare una singola query semplice su collezioni, solo scrivendo join in sql, un filtro può essere applicato prima o dopo a seconda delle necessità e delle necessità.

Ecco un esempio in cui possiamo trovare un elemento con un ID in una raccolta. Per aggiungere altro, i metodi First, FirstOrDefault , restituiscono idealmente lo stesso quando una raccolta ha almeno un record. Se, tuttavia, una raccolta è a posto vuota. quindi First restituirà un'eccezione ma FirstOrDefault restituirà null o default. Ad esempio, int restituirà 0. Quindi l'utilizzo di tale è anche se si dice che sia una preferenza personale, ma è meglio usare FirstOrDefault per evitare la gestione delle eccezioni.


.First genererà un'eccezione quando non ci sono risultati. .FirstOrDefault no, restituirà semplicemente null (tipi di riferimento) o il valore predefinito del tipo di valore. (ad esempio, come 0 per un int.) La domanda qui non è quando si desidera il tipo predefinito, ma più: siete disposti a gestire un'eccezione o gestire un valore predefinito? Poiché le eccezioni dovrebbero essere eccezionali, FirstOrDefault è preferito quando non si è sicuri se si otterranno risultati dalla query. Quando logicamente i dati dovrebbero essere lì, può essere presa in considerazione la gestione delle eccezioni.

Skip() e Take() vengono normalmente utilizzati durante l'impostazione del paging nei risultati. (Come mostrare i primi 10 risultati e il 10 successivo nella pagina successiva, ecc.)

Spero che questo ti aiuti.


Primo()

Quando sai che il risultato contiene più di 1 elemento previsto e dovresti solo il primo elemento della sequenza.

FirstOrDefault ()

FirstOrDefault () è come First () tranne che, se nessun elemento corrisponde alla condizione specificata, restituisce il valore predefinito del tipo sottostante della raccolta generica. Non getta InvalidOperationException se non è stato trovato alcun elemento. Ma la raccolta di un elemento o di una sequenza è nullo di quanto non faccia un'eccezione.


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

Quale usare? Dovrebbe essere deciso dalla logica aziendale, e non dalla paura dell'eccezione / fallimento del programma.

Ad esempio, se la logica aziendale dice che non possiamo avere zero transazioni in qualsiasi giorno lavorativo (supponiamo solo). Quindi non dovresti provare a gestire questo scenario con una programmazione intelligente. Userò sempre First () su tale raccolta e il programma fallirà se qualcos'altro ha rovinato la logica aziendale.

Codice:

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

Mi piacerebbe vedere altri commenti su questo.







linq