Query LINQ con una clausola WHERE con condizioni multiple

Question

Uso EntityFramework con POCOs.
Supponiamo che io sono pocos definito come questo (semplificato):

class Class1 
{ 
    public int ID; 
    public int SomeNumber; 
} 

class Class2 
{ 
    public int ID; 
    public int SomeNumber; 
} 

class Class3 
{ 
    public int ID; 
    public int SomeNumber; 
} 

class SomeClass 
{ 
    public int ID; 
    public int? Class1ID; 
    public Class1 Class1; 
    public int? Class2ID; 
    public Class2 Class2; 
    public int? Class3ID; 
    public Class3 Class3; 
} 

Voglio recuperare tutti SomeClass record del database, che appartengono a un uno di Class1, Class2 o Class3 dove ClassX.SomeNumber uguale qualche numero.

ho scritto la query LINQ che assomiglia a questo:

Database DB = new Database(); // object context 
var result = DB.SomeClass.ToList(); 

int SomeNumber = 1; // some number 
List<SomeClass> retValue = result 
    .Where(x => 
     { 
      int Number = 0; 
      if (x.Class1 != null) 
       Number = x.Class1.SomeNumber; 
      else if (x.Class2 != null) 
       Number = x.Class2.SomeNumber; 
      else if (x.Class3 != null) 
       Number = x.Class3.SomeNumber; 
      return Number == SomeNumber; 
     }) 
    .ToList(); 

... però retValue non contiene alcun record.

La soluzione

A quanto pare ho dovuto specificare .Include dichiarazioni perché lazy loading è stato disattivato e x.Class1, x.Class2 e x.Class3 aveva sempre il valore null. Mi vergogno perché non ho dichiarato esplicitamente che il caricamento pigro è stato disabilitato - il problema sarebbe stato ovvio allora.

Tuttavia, grazie al post di Ladislav, ho migliorato il mio codice in questo modo:

Database DB = new Database(); // object context 

int SomeNumber = 1; // some number 
List<SomeClass> retValue = DB.SomeClass 
    .Include("Class1") 
    .Include("Class2") 
    .Include("Class3") 
    .Where(x => 
     SomeNumber == x.Class1.SomeNumber || 
     SomeNumber == x.Class2.SomeNumber || 
     SomeNumber == x.Class3.SomeNumber) 
    .ToList(); 

non sapevo LINQ to Entities dovrebbero eseguire coalescenza automatica nullo.

Answer 1

IMHO si dovrebbe essere OK con solo questo:

Database DB = new Database(); 
var result = DB.SomeClass.Where(x => 
          Number == x.Class1.SomeNumber || 
          Number == x.Class2.SomeNumber || 
          Number == x.Class3.SomeNumber) 
         .ToList(); 

I suoi carichi di query tutti i dati e dopo che è valutare le condizioni in .NET = È necessario testare valore null prima di accedere SomeNumber, ma che non è necessaria se si valuta SomeNumber in SQL tramite le entità Linq. Linq-to-entities dovrebbe eseguire coal coal null automatico.

Answer 2

Secondo la tua logica, se x.Class1 non è nullo, ma x.Class1.SomeNumber è 3, non controllerà tutte le altre clausole.

Se si desidera controllare, se solo alcuni ClassN.SomeNumber == SomeNumber, allora si dovrebbe fare in questo modo:

int SomeNumber = 1; // some number 
List<SomeClass> retValue = result 
    .Where(x => 
     { 
      if (x.Class1 != null && x.Class1.SomeNumber == SomeNumber) 
       return true; 
      else if (x.Class2 != null && x.Class2.SomeNumber == SomeNumber) 
       return true; 
      else if (x.Class3 != null && x.Class3.SomeNumber == SomeNumber) 
       return true; 
      return false; 
     }) 
    .ToList();