Pojedyncza lub domyślna lub gdy stan z klauzulą ​​

Question

Mam następujący kod

return 
    this.Storage.Customer.OfType<Preferred>() 
    .Include(b => b.Order) 
    .Where(cust => cust.Id == customerId && cust.CustomerType== (int)cusType) 
    .SingleOrDefault(); 

może być przepisana następująco eliminując gdzie.

return 
    this.Storage.Customer.OfType<Preferred>() 
    .Include(b => b.Order) 
    .SingleOrDefault(cust => cust.Id == customerId && cust.CustomerType == (int)cusType); 

Która z nich jest lepszą praktyką i dlaczego?

Answer 1

Przede wszystkim trzeba zrozumieć różnicę

this.Storage.Customer.OfType<Preferred>() 
.Include(b => b.Order) 
.Where(cust => cust.Id == customerId && cust.CustomerType== (int)cusType) 

spowoduje to utworzenie zapytania, ale nie zostanie wykonane, dopóki nie zostanie wywołana metoda ToList.

Metoda SingleOrDefault faktycznie wykona zapytanie. Więc jeśli chcesz sprawdzić lub zrobić coś z zapytaniem przed jego wykonaniem, powinieneś użyć gdzie, a następnie wywołać SingleOrDefault.

tak ogólnie, używając gdzie jest dobra praktyka, jak na moim osobistym zdaniem

Answer 2

Dzięki złożoności debugowania zwracanej wartości funkcji i niemożności używania wyrażeń lambda w debugger, jest to najlepszy sposób:

var temp = this.Storage.Customer.OfType<Preferred>() 
    .Include(b => b.Order) 
    .Where(cust => cust.Id == customerId && cust.CustomerType == (int)cusType); 

return temp.SingleOrDefault(); 

W ten sposób, jeśli istnieje wyjątek na SingleOrDefault() (coś dość powszechne, jeśli robi złożonych wyrażeń), które można umieścić punkt przerwania na return i zrobić w panelu watch: temp.ToList();

Answer 3

Stary post i to w dużej mierze na podstawie opinii, ale tu jest inny uwagę nie wymienione powyżej:

SingleOrDefault klauzula nie może być a następnie inne warunki, takie jak Select, ponieważ, jak zauważa Patel powyżej, faktycznie wykonuje zapytanie. Na przykład powiedzieć w dół drogi chcesz zmodyfikować kwerendę, aby powrócić tylko nazwisko klienta:

this.Storage.Customer.OfType<Preferred>() 
.Include(b => b.Order) 
.SingleOrDefault(cust => cust.Id == customerId && cust.CustomerType == (int)cusType) 
.Select(cust=>cust.Name); //compile error 

nie będzie działać, a nie można przenieść do klauzuli Select przed SingleOrDefault bo wtedy Id i CustomerType pola nie będą widoczne dla wyrażenia lambda w SingleOrDefault. Zamiast tego trzeba by włożyć z powrotem klauzuli Where pierwszy:

this.Storage.Customer.OfType<Preferred>() 
.Include(b => b.Order) 
.Where(cust => cust.Id == customerId && cust.CustomerType == (int)cusType) 
.Select(cust=>cust.Name) 
.SingleOrDefault(); 

Zatem ponieważ klauzula Where często jest konieczne i zawsze co najmniej tak dobre wyniki, to prawdopodobnie dobra praktyka, aby zawsze używać go do konsystencji, czytelność, i łatwość konserwacji.