LINQ: quando utilizzare SingleOrDefault vs. FirstOrDefault () con criteri di filtro

Considerare i metodi di estensione IEnumerable SingleOrDefault()eFirstOrDefault()

MSDN documenta cheSingleOrDefault :

Restituisce l'unico elemento di una sequenza o un valore predefinito se la sequenza è vuota; questo metodo genera un'eccezione se nella sequenza è presente più di un elemento.

che FirstOrDefaultda MSDN (presumibilmente quando si utilizza un OrderBy()o OrderByDescending()o nessuno),

Restituisce il primo elemento di una sequenza

Considera una manciata di query di esempio, non è sempre chiaro quando utilizzare questi due metodi:

var someCust = db.Customers
.SingleOrDefault(c=>c.ID == 5); //unlikely(?) to be more than one, but technically COULD BE

var bobbyCust = db.Customers
.FirstOrDefault(c=>c.FirstName == "Bobby"); //clearly could be one or many, so use First?

var latestCust = db.Customers
.OrderByDescending(x=> x.CreatedOn)
.FirstOrDefault();//Single or First, or does it matter?

Domanda

Quali convenzioni segui o suggerisci quando decidi di utilizzare SingleOrDefault()e FirstOrDefault()nelle tue domande LINQ?

Ogni volta che lo usi SingleOrDefault, dichiari chiaramente che la query dovrebbe generare al massimo un singolo risultato. D'altra parte, quando FirstOrDefaultviene utilizzata, la query può restituire qualsiasi quantità di risultati ma si afferma che si desidera solo il primo.

Personalmente trovo la semantica molto diversa e l'utilizzo di quella appropriata, a seconda dei risultati attesi, migliora la leggibilità.

Se il set di risultati restituisce 0 record:

• SingleOrDefault restituisce il valore predefinito per il tipo (ad es. il valore predefinito per int è 0)
• FirstOrDefault restituisce il valore predefinito per il tipo

Se il set di risultati restituisce 1 record:

• SingleOrDefault restituisce quel record
• FirstOrDefault restituisce quel record

Se il set di risultati restituisce molti record:

• SingleOrDefault genera un'eccezione
• FirstOrDefault restituisce il primo record

Conclusione:

Se si desidera generare un'eccezione se il set di risultati contiene molti record, utilizzare SingleOrDefault.

Se si desidera sempre 1 record, indipendentemente dal contenuto del set di risultati, utilizzare FirstOrDefault

C'è

• una differenza semantica
• una differenza di prestazioni

tra i due.

Differenza semantica:

• FirstOrDefault restituisce un primo elemento potenzialmente multiplo (o predefinito se non esiste).
• SingleOrDefaultpresuppone che esista un singolo elemento e lo restituisce (o predefinito se non esiste). Più articoli sono una violazione del contratto, viene generata un'eccezione.

Differenza di prestazione

• FirstOrDefaultdi solito è più veloce, scorre fino a quando non trova l'elemento e deve iterare l'intero enumerabile solo quando non lo trova. In molti casi, esiste un'alta probabilità di trovare un oggetto.

• SingleOrDefaultdeve verificare se esiste un solo elemento e quindi itera sempre l'intero enumerabile. Per essere precisi, scorre fino a quando non trova un secondo elemento e genera un'eccezione. Ma nella maggior parte dei casi, non esiste un secondo elemento.

Conclusione

• Utilizzare FirstOrDefault, se non vi interessa quanti articoli ci sono o se non può permettersi l'unicità di controllo (ad esempio, in una collezione molto grande). Quando si verifica l'univocità nell'aggiungere gli articoli alla raccolta, potrebbe essere troppo costoso ricontrollarli durante la ricerca di quegli articoli.

• Utilizzare SingleOrDefaultse non ci si deve preoccupare troppo delle prestazioni e si desidera assicurarsi che l'assunzione di un singolo elemento sia chiara al lettore e verificata in fase di esecuzione.

In pratica, usi First/ FirstOrDefaultspesso anche nei casi in cui assumi un singolo oggetto, per migliorare le prestazioni. Dovresti ancora ricordare che Single/ SingleOrDefaultpuò migliorare la leggibilità (perché afferma l'assunzione di un singolo elemento) e la stabilità (perché lo controlla) e usarlo in modo appropriato.

Nessuno ha menzionato il fatto che FirstOrDefault tradotto in SQL fa il record TOP 1 e SingleOrDefault fa il TOP 2, perché deve sapere che c'è più di 1 record.

Per LINQ -> SQL:

SingleOrDefault

• genererà query come "select * dagli utenti dove userid = 1"
• Seleziona record corrispondente, genera un'eccezione se viene trovato più di un record
• Utilizzare se si stanno recuperando dati in base alla colonna chiave primaria / univoca

FirstOrDefault

• genererà query come "seleziona top 1 * dagli utenti dove userid = 1"
• Seleziona le prime righe corrispondenti
• Utilizzare se si stanno recuperando dati in base alla colonna chiave non primaria / univoca

Uso SingleOrDefaultin situazioni in cui la mia logica impone che il risultato sia zero o uno. Se ce ne sono altri, è una situazione di errore, che è utile.

SingleOrDefault: stai dicendo che "Al massimo" esiste un elemento corrispondente alla query o predefinito FirstOrDefault: Stai dicendo che c'è "Almeno" un elemento corrispondente alla query o predefinita

Dillo ad alta voce la prossima volta che dovrai scegliere e probabilmente dovrai scegliere saggiamente. :)

Nei tuoi casi, utilizzerei quanto segue:

seleziona per ID == 5: è OK usare SingleOrDefault qui, perché ti aspetti un'entità [o nessuna], se hai più di un'entità con ID 5, c'è qualcosa di sbagliato e sicuramente un'eccezione degna.

durante la ricerca di persone il cui nome è uguale a "Bobby", possono essercene più di uno (probabilmente penserei), quindi non dovresti usare Single né First, basta selezionare con l'operazione Where (se "Bobby" restituisce troppi entità, l'utente deve perfezionare la sua ricerca o scegliere uno dei risultati restituiti)

l'ordine per data di creazione dovrebbe essere eseguito anche con un'operazione Where (è improbabile che abbia una sola entità, l'ordinamento non sarebbe di grande utilità;) ciò tuttavia implica che desideri TUTTE le entità ordinate - se vuoi solo UNO, usa FirstOrDefault, Single lancerebbe ogni volta se avessi più di un'entità.

Entrambi sono gli operatori di elementi e vengono utilizzati per selezionare un singolo elemento da una sequenza. Ma c'è una piccola differenza tra loro. L'operatore SingleOrDefault () genererebbe un'eccezione se più di un elemento è soddisfatto, a condizione che FirstOrDefault () non genererà alcuna eccezione per lo stesso. Ecco l'esempio.

List<int> items = new List<int>() {9,10,9};
//Returns the first element of a sequence after satisfied the condition more than one elements
int result1 = items.Where(item => item == 9).FirstOrDefault();
//Throw the exception after satisfied the condition more than one elements
int result3 = items.Where(item => item == 9).SingleOrDefault();

Nel tuo ultimo esempio:

var latestCust = db.Customers
.OrderByDescending(x=> x.CreatedOn)
.FirstOrDefault();//Single or First, or doesn't matter?

Sì lo fa. Se si tenta di utilizzare SingleOrDefault()e la query risulta più che record, si otterrebbe un'eccezione. L'unica volta che puoi usare in sicurezza SingleOrDefault()è quando ti aspetti solo 1 e solo 1 risultato ...

Quindi, come ho capito ora, SingleOrDefault andrà bene se si esegue una query per dati che sono garantiti come unici, vale a dire applicati da vincoli DB come la chiave primaria.

Oppure esiste un modo migliore per eseguire query per la chiave primaria.

Supponendo che il mio TableAcc abbia

AccountNumber - Primary Key, integer
AccountName
AccountOpenedDate
AccountIsActive
etc.

e voglio chiedere un AccountNumber 987654, io uso

var data = datacontext.TableAcc.FirstOrDefault(obj => obj.AccountNumber == 987654);

Secondo me FirstOrDefaultviene abusato molto. Nella maggior parte dei casi, quando si filtrano i dati, ci si aspetterebbe di recuperare una raccolta di elementi corrispondenti alla condizione logica o un singolo elemento univoco dal suo identificatore univoco, ad esempio un utente, un libro, un post, ecc. perché possiamo persino arrivare a dire che FirstOrDefault()è un odore di codice non perché c'è qualcosa che non va, ma perché viene usato troppo spesso. Questo post sul blog esplora l'argomento in dettaglio. IMO la maggior parte delle volte SingleOrDefault()è un'alternativa molto migliore, quindi fai attenzione a questo errore e assicurati di utilizzare il metodo più appropriato che rappresenti chiaramente il tuo contratto e le tue aspettative.

Una cosa che manca nelle risposte ....

Se ci sono più risultati, FirstOrDefault senza un ordine può riportare risultati diversi in base alla strategia di indicizzazione mai utilizzata dal server.

Personalmente non sopporto di vedere FirstOrDefault nel codice perché secondo me lo sviluppatore non si preoccupava dei risultati. Con un ordine, sebbene possa essere utile come modo per far rispettare l'ultimo / il più presto. Ho dovuto correggere molti problemi causati da sviluppatori negligenti utilizzando FirstOrDefault.

Ho chiesto a Google di utilizzare i diversi metodi su GitHub. Questo viene fatto eseguendo una query di ricerca di Google per ciascun metodo e limitando la query al dominio github.com e l'estensione del file .cs utilizzando la query "site: file github.com: cs ..."

Sembra che i metodi First * siano più comunemente usati rispetto ai metodi Single *.

| Method               | Results |
|----------------------|---------|
| FirstAsync           |     315 |
| SingleAsync          |     166 |
| FirstOrDefaultAsync  |     357 |
| SingleOrDefaultAsync |     237 |
| FirstOrDefault       |   17400 |
| SingleOrDefault      |    2950 |

Non capisco perché stai usando FirstOrDefault(x=> x.ID == key)quando questo potrebbe recuperare risultati molto più velocemente se lo usi Find(key). Se si esegue una query con la chiave primaria della tabella, la regola empirica è di utilizzare sempre Find(key). FirstOrDefaultdovrebbe essere usato per cose predicate come (x=> x.Username == username)ecc.

questo non meritava un downvote in quanto l'intestazione della domanda non era specifica per linq su DB o Linq to List / IEnumerable ecc.