LINQ dynamique Où - Ne pas ajouter la clause

Question

je le code suivant:

public OTestTable GetTestCode(Func<TestTable, bool> whereClause) 
{ 
    return CoreContext.TestTables.Where(whereClause).Select(TestTableMap.DataToObject).FirstOrDefault(); 
} 

CoreContext est mon contexte de données (qui est initialisé dans une classe de base)

Mon TestTableMap se présente comme suit:

public class TestTableMap 
{ 
    public static readonly Func<TestTable, OTestTable> DataToObject = mapper => 
     new OTestTable 
     { 
      Code = mapper.mycode 

     }; 
} 

Ensuite, dans ma méthode d'affaires que je donne les résultats suivants:

public OTestTable GetTestCode(string code) 
{ 
    return QueryEngine.GetTestCode(id => id.mycode == code); 
} 

Depuis mon programme principal, j'appelle GetTestCode avec une valeur de chaîne.

Quand je regarde profileur SQL, je reçois les éléments suivants:

SELECT [t0].[mycode] 
FROM [dbo].[TestTable] AS [t0] 

Il n'a pas la clause where jointe à la requête SQL. Si j'ajoute la clause where au LINQ comme var query = de c dans DataContext.TestTable où c.mycode == '' select c;

Il ajoutera la clause where.

Cependant, quand j'exécute mon code, il va retourner l'enregistrement correct, mais il semble que je retire tous les enregistrements de la base de données et le filtrage dans mon code (ce qui ne devrait pas arriver).

Des pensées avec ce que je fais mal?

Merci

Answer 1

Pour construire des instructions SQL, LINQ to SQL nécessite un arbre d'expression. Func<TestTable, bool> ne représente pas un arbre d'expression, c'est un pointeur de fonction "boîte noire". LINQ ne peut rien faire d'intelligent avec ceci à part de l'exécuter aveuglément sur une collection en mémoire.

Vous devez faire ceci:

public OTestTable GetTestCode(Expression<Func<TestTable, bool>> whereClause) { 
    return CoreContext.TestTables.Where(whereClause).Select(TestTableMap.DataToObject).FirstOrDefault(); 
} 

Ce code compile en utilisant la méthode d'extension Queryable.Where, qui n'accepte un arbre d'expression, plutôt que la méthode d'extension Enumerable.Where, qui accepte un délégué brut.

Answer 2

Essayez de créer votre clause where:

Expression<Func<T, bool>> whereClause 

Lorsque le paramètre T est votre type de source Table<T> source

Answer 3

Voir aussi le PredicateBuilder ici: http://www.albahari.com/nutshell/predicatebuilder.aspx

Il vous propose des méthodes d'extension pratiques pour prédicat IQueryable<T>. comme ceci:

var predicate = PredicateBuilder.True<Family>(); 
predicate = predicate.And(o => o.Birthday < new DateTime(1980, 1, 1)); 
        .Or(o => o.Name.Contains("ke")); 
var result = Source.Where(predicate).ToList();