web-dev-qa-db-fra.com

Entity Framework inclut une collection enfant de filtre

J'ai de la difficulté à ajouter une condition de filtre pour les éléments inclus dans ma requête LINQ. Ma requête est comme

var item = _Context.Order.Include("Inner")
           .Include("Inner.first")
           .Include("Inner.second")
           .Where(x => ( !(x.IsDeleted) && (x.IsActive) && 
                 (x.itemid == id))).FirstOrDefault();

Dans le code ci-dessus "Inner" est une autre liste d'articles. Maintenant, je dois filtrer les éléments intérieurs. Je n'ai besoin que d'un élément interne avec la condition de filtre inner.isDeleted = true.

La requête doit renvoyer une classe comme,

public class Order
{

    public string Name { get; set; }
    public List<InnerDetails> Inner{ get; set; }
    public bool IsDeleted { get; set; }
}

et classe InnerDetails comme

public class InnerDetails 
{

    public string Sample { get; set; }
    public bool IsDeleted { get; set; }
    public int firstId { get; set; }
    public int secondID { get; set; }
    public First first{ get; set; }
    public Second second{ get; set; }
}

Quelqu'un peut-il me suggérer une meilleure approche pour le faire parce que je suis nouveau dans LINQ et EF

c#asp.net-mvcentity-frameworklinqentity-framework-6
10
Isha John

Avertissement : Je suis le propriétaire du projet Entity Framework Plus

La fonction EF + Query IncludeFilter permet de filtrer les entités liées.

var item = _Context.Order
           .IncludeFilter(x => x.Inner.Where(y => y.IsDeleted))
           .IncludeFilter(x => x.Inner.Where(y => y.IsDeleted).Select(y => y.first))
           .IncludeFilter(x => x.Inner.Where(y => y.IsDeleted).Select(y => y.second))
           .Where(x => ( !(x.IsDeleted) && (x.IsActive) && 
                 (x.itemid == id))).FirstOrDefault();

Remarque: Vous ne pouvez pas mélanger Inclure et Inclure le filtre.

Wiki: EF + Query IncludeFilter

EDIT: Répondre à la sous-question

Mais nous pouvons y arriver en utilisant EF uniquement

Oui, sous le capot, ma bibliothèque utilise une solution similaire à la projection

var item = _Context.Order.Select(x => new {
                Order = x,
                Inner = x.Inner.Where(y => y.IsDeleted),
                first = x.Inner.Where(y => y.IsDeleted).Select(y => y.first)
                second = x.Inner.Where(y => y.IsDeleted).Select(y => y.second)
            })
            .Where(x => ( !(x.IsDeleted) && (x.IsActive) && (x.itemid == id)))
            .FirstOrDefault()
            .Select(x => x.Order)
            .FirstOrDefault();

Remarque: le code n'a pas été testé

EDIT: Répondre au commentaire

J'ai rencontré ce problème dans EF Core. Allez-vous implémenter IncludeFilter également dans la version EF + Core

À partir de la v1.10.0, le IncludeFilter est désormais pris en charge dans EF Core 2.x

Voir: Release Release

8
Jonathan Magnan

J'ai pu y parvenir dans EF Core. Je suis presque sûr que le même concept s'applique à EF6.

Simplifier votre exemple:

var item = ctx.Order.Include("Inner")
              .Where(x => x.Inner.Any(innerItem => innerItem.IsDeleted))
              .FirstOrDefault();
1
JsonStatham

Vous pouvez y parvenir dans EF Core lui-même:

var item = 
ctx.Order.Include("Inner")
         .Select(x => x.Inner
                .Where(innerItem => innerItem.IsDeleted))
         .FirstOrDefault();

Ou,

var item = 
    ctx.Order.Include(o=> o.Inner
                     .Where(x => x.IsDeleted));
0
Amruthann K S