Implémentation des instructions conditionnelles 'if' dans une requête LINK où 'where'

J'essaie de trouver un moyen de l'interrogation d'un objet dans mon modèle de données et d'y inclure uniquement les paramètres qui ne sont pas null. Comme ci-dessous:

public List<Widget> GetWidgets(string cond1, string cond2, string cond3)
{
    MyDataContext db = new MyDataContext();
    List<Widget> widgets = (from w in db.Widgets
                            where 
                                ... if cond1 != null w.condition1 == cond1 ...
                                ... if cond2 != null w.condition2 == cond2 ...
                                ... if cond3 != null w.condition3 == cond3 ...
                            select w).ToList();
    return widgets;
}

Depuis les widgets de tableau peuvent devenir très grandes, j'aimerais éviter de le faire:

public List<Widget> GetWidgets(string cond1, string cond2, string cond3)
{
    MyDataContext db = new MyDataContext();
    List<Widget> widgets = db.Widgets.ToList();

    if(cond1 != null)
        widgets = widgets.Where(w => w.condition1 == cond1).ToList();

    if(cond2 != null)
        widgets = widgets.Where(w => w.condition2 == cond2).ToList();

    if(cond3 != null)
        widgets = widgets.Where(w => w.condition3 == cond3).ToList();

    return widgets;
}

J'ai regardé plusieurs exemple, mais ne pas vraiment voir tout ce qui correspond à ce que je dois faire.

source d'informationauteur Andy Evans

  1. 29

    Ce que vous voulez éviter est en fait de l'exécution de la requête jusqu'à ce que vous êtes prêt:

    public List<Widget> GetWidgets(string cond1, string cond2, string cond3)
{
    MyDataContext db = new MyDataContext();
    var widgets = db.Widgets;

    if(cond1 != null)
        widgets = widgets.Where(w => w.condition1 == cond1);

    if(cond2 != null)
        widgets = widgets.Where(w => w.condition2 == cond2);

    if(cond3 != null)
        widgets = widgets.Where(w => w.condition3 == cond3);

    return widgets.ToList();
}

    Notez comment le ToList appels sont supprimés. La requête n'est pas exécutée jusqu'à ce que vous commencer à parcourir. Invoquant ToList force que cela arrive, afin que le résultat peut être mis dans un List<> et retourné. Je dirais même à modifier la valeur de retour de la méthode à IEnumerable<Widget> et le saut de l' ToList appel à la fin:

    public IEnumerable<Widget> GetWidgets(string cond1, string cond2, string cond3)
{
    MyDataContext db = new MyDataContext();
    var widgets = db.Widgets;

    if(cond1 != null)
        widgets = widgets.Where(w => w.condition1 == cond1);

   //[...]

    return widgets;
}

    De cette façon, le code appelant obtient de décider lors de l'exécution de la requête (il peut même ajouter des conditions supplémentaires avant de le faire).

  2. 22

    Utiliser un "ou" à la porte: préface chaque widget contrôle de l'état avec un "||" et une vérification pour voir si nous sommes à l'aide de cette condition ou non. Si nous ne le sommes pas, la seconde moitié de l' "ou" n'est pas évaluée. C'est pourquoi il est un grille-nous ne pas aller plus loin si la première partie est évaluée à true.

    Si j'avais écrit ça, je ferais comme ci-dessous. J'ai utilisé le var syntatic de sucre pour tenir requête LINQ et déplacé le ToList() à la fin.

    public List<Widget> GetWidgets(string cond1, string cond2, string cond3) 
{ 
    MyDataContext db = new MyDataContext(); 
    var widgets = from w in db.Widgets 
                  where (cond1 == null || w.condition1 == cond1)
                     && (cond2 == null || w.condition2 == cond2)
                     && (cond3 == null || w.condition3 == cond3)
                  select w;
    return widgets.ToList();
}

    edit: grammaire

  3. 2

    Comment quelque chose comme cela?

            IEnumerable<Widget> condQuery = (from w in db.Widgets);
        if(cond1 != null ) condQuery = condQuery.Where(w=> w.condition1 == cond1);
        if(cond2 != null ) condQuery = condQuery.Where(w=> w.condition2 == cond2);

    etc...?

  4. 1

    Vous êtes en train de demander à un répartiteur dans la requête linq. Le Where méthode prend un prédicat, de sorte que vous pouvez construire votre prédicat avant la création de la requête.

    -- EDIT -- au début, je pensais que c'est plus facile, a écrit de pseudo-code qui n'a même pas compiler. Maintenant, howver, je crois que j'ai le point. Ce code fonctionne; il sépare la construction de la clause where de l'appliquer.

        static Predicate<Widget> combine( 
           Predicate<Widget> existing, 
           Predicate<Widget> condition )
    {
        var newpred = new Predicate<Widget>( w=> existing(w) && condition(w) );
        return newpred;

    }

    et de l'utilisation de ce "bâtiment" de la fonctionnalité comme ça:

        static void Main(string[] args)
    {
        string cond1 = "hi";
        string cond2 = "lo";
        string cond3 = null;
        var pr = new Predicate<Widget>( (Widget w ) => true );
        if (cond1 != null) pr = combine( pr, w => w.condition1 == cond1);
        if (cond2 != null) pr = combine( pr, w => w.condition2 == cond2);
        if (cond3 != null) pr = combine( pr, w => w.condition3 == cond3);

    Je l'ai testé avec une petite aide de tableau:

            var widgets = new Widget[]{
            new Widget (){ condition1 = "" },
            new Widget (){ condition1 = "hi", condition2 = "lo" }
        };

        var selected = widgets.Where( (w) => pr(w));

        foreach (var w in selected) {
            Console.WriteLine(w);
        }
  5. 1

    nous pouvons utiliser un moyen très simple comme ci-dessous.

    (from e in employee
join d in departments on e.departmentId equals d.departmentId
Select new {
e.name,
d.name,
getEmployeeContacts(e)
}
//return active contact if not return first . This is same like if else along with null check
private contact getEmployeeContacts(Employee e )
{
 return e.Contacts.FirstOrDefault(x => x.Active == 1) ?? e.Contacts.FirstOrDefault();
}