Conditionnel Requêtes Linq

si vous voulez seulement de filtre si certains critères est passé, faire quelque chose comme ceci

var logs = from log in context.Logs
           select log;

if (filterBySeverity)
    logs = logs.Where(p => p.Severity == severity);

if (filterByUser)
    logs = logs.Where(p => p.User == user);

Le faire de cette manière permettra à votre arborescence d'Expression à être exactement ce que vous voulez. De cette façon, le SQL de création sera exactement ce dont vous avez besoin et rien de moins.

J'ai fini à l'aide d'une réponse similaire à Daren, mais avec un IQueryable interface:

IQueryable<Log> matches = m_Locator.Logs;

//Users filter
if (usersFilter)
    matches = matches.Where(l => l.UserName == comboBoxUsers.Text);

 //Severity filter
 if (severityFilter)
     matches = matches.Where(l => l.Severity == comboBoxSeverity.Text);

 Logs = (from log in matches
         orderby log.EventTime descending
         select log).ToList();

Qui fabrique de la requête avant de frapper la base de données. La commande ne fonctionnera pas jusqu'à ce que .ToList() à la fin.

Une autre option serait d'utiliser quelque chose comme le PredicateBuilder discuté ici.
Il vous permet d'écrire du code comme le suivant:

var newKids  = Product.ContainsInDescription ("BlackBerry", "iPhone");

var classics = Product.ContainsInDescription ("Nokia", "Ericsson")
                  .And (Product.IsSelling());

var query = from p in Data.Products.Where (newKids.Or (classics))
            select p;

Noter que je n'ai que cela fonctionne avec Linq 2 SQL. EntityFramework ne pas mettre en œuvre l'Expression.Invoquer, ce qui est nécessaire pour que cette méthode fonctionne. J'ai une question concernant cette question ici.

J'ai résolu ce problème avec une méthode d'extension pour permettre à LINQ to conditionnellement être activé au moyen d'un fluide expression. Cela supprime la nécessité de briser l'expression avec if consolidés.

.If() méthode d'extension:

public static IQueryable<TSource> If<TSource>(
        this IQueryable<TSource> source,
        bool condition,
        Func<IQueryable<TSource>, IQueryable<TSource>> branch)
    {
        return condition ? source : branch(source);
    }

Cela vous permet de le faire:

return context.Logs
     .If(filterBySeverity, q => q.Where(p => p.Severity == severity))
     .If(filterByUser, q => q.Where(p => p.User == user))
     .ToList();

Voici aussi un IEnumerable<T> version qui va gérer la plupart des autres expressions LINQ:

public static IEnumerable<TSource> If<TSource>(
    this IEnumerable<TSource> source,
    bool condition,
    Func<IEnumerable<TSource>, IEnumerable<TSource>> branch)
    {
        return condition ? source : branch(source);
    }

J'ai eu une demande similaire récemment et a finalement trouvé ce dans il MSDN.
CSharp Échantillons pour Visual Studio 2008

Les classes incluses dans le DynamicQuery échantillon de téléchargement vous permettent de créer des requêtes dynamiques à l'exécution dans le format suivant:

var query =
db.Customers.
Where("City = @0 and Orders.Count >= @1", "London", 10).
OrderBy("CompanyName").
Select("new(CompanyName as Name, Phone)");

En utilisant cela, vous pouvez construire une chaîne de requête dynamiquement à l'exécution et la passer dans la méthode where ():

string dynamicQueryString = "City = \"London\" and Order.Count >= 10"; 
var q = from c in db.Customers.Where(queryString, null)
        orderby c.CompanyName
        select c;

Suffit d'utiliser C#'s && opérateur:

var items = dc.Users.Where(l => l.Date == DateTime.Today && l.Severity == "Critical")

Edit: Ah, faut lire plus attentivement. Vous voulais savoir comment conditionnellement ajouter des clauses supplémentaires. Dans ce cas, je n'ai aucune idée. 🙂 Ce que je serais probablement faire est de préparer plusieurs requêtes, et d'exécuter le droit, en fonction de ce que j'ai fini par en avoir besoin.

Bien, ce que je pensais, vous pouvez mettre les conditions de filtre dans une liste générique de Prédicats:

    var list = new List<string> { "me", "you", "meyou", "mow" };

    var predicates = new List<Predicate<string>>();

    predicates.Add(i => i.Contains("me"));
    predicates.Add(i => i.EndsWith("w"));

    var results = new List<string>();

    foreach (var p in predicates)
        results.AddRange(from i in list where p.Invoke(i) select i);               

Que les résultats dans une liste contenant "moi", "meyou", et de "tondre".

Vous pouvez optimiser en faisant le foreach avec les prédicats dans une toute autre fonction que les Rup tous les prédicats.