Entity Framework Inclure, avec la condition

J'ai besoin de filtrer un courtier basé sur l'id et le incomplète archivages

D'abord, il est retourné au revendeur basé uniquement sur id:

    //TODO: limit checkins to those that are not complete
    return this.ObjectContext.Dealers
        .Include("Groups")
        .Include("Groups.Items")
        .Include("Groups.Items.Observations")
        .Include("Groups.Items.Recommendations")
        .Include("Checkins")
        .Include("Checkins.Inspections")
        .Include("Checkins.Inspections.InspectionItems")
        .Where(d => d.DealerId == id)
        .FirstOrDefault();

Comme vous pouvez le voir, la condition est à la limite de la archivages.
Voici ce que j'ai fait:

var query = from d in this.ObjectContext.Dealers
                            .Include("Groups")
                            .Include("Groups.Items")
                            .Include("Groups.Items.Observations")
                            .Include("Groups.Items.Recommendations")
                            .Include("Checkins.Inspections")
                            .Include("Checkins.Inspections.InspectionItems")
                            .Where(d => d.DealerId == id)
                        select new
                        {
                            Dealer = d,
                            Groups = from g in d.Groups
                                     select new
                                     {
                                         Items = from i in g.Items
                                                 select new
                                                 {
                                                     Group = i.Group,
                                                     Observations = i.Observations,
                                                     Recommendations = i.Recommendations
                                                 }
                                     },
                            Checkins = from c in d.Checkins
                                       where c.Complete == true
                                       select new
                                       {
                                           Inspections = from i in c.Inspections
                                                         select new
                                                         {
                                                             InspectionItems = i.InspectionItems
                                                         }
                                       }

                        };

            var dealer = query.ToArray().Select(o => o.Dealer).First();

            return dealer;

Il fonctionne.
Cependant, je ne suis pas convaincu que je suis en train de faire la bonne chose.

Quelle est la meilleure façon d'accomplir ce que j'ai fait? Une procédure stockée peut-être?

Je ne suis pas sûr, j'ai même l'utilisation Inclure la clause plus

Merci.

OriginalL'auteur Andrei N. | 2011-07-14

2

Peut-être vous pouvez faire usage de la relation mécanisme de correction dans l'EF ObjectContexts. Lorsque vous effectuez plusieurs requêtes dans le même contexte, pour les entités qui sont liées par des associations, ce sont résolus.
En supposant que votre association entre les vendeurs et les Archivages est de 1:n avec les propriétés de navigation sur chaque côté, vous pouvez faire comme:
```
var dealer = yourContext.Dealers
             .Where(p => p.DealerId == id)
             .FirstOrDefault();
if(dealer != null)
{
    yourContext.Checkins
           .Where(c => c.Complete && c.DealerId == dealer.DealerId)
           .ToList();
```
Je n'ai pas testé, mais depuis EF reconnaît que les Archivages, il insère dans le contexte de la deuxième requête appartiennent au concessionnaire de la première requête, les références correspondantes sont créées.

merci de lire ma réponse à vous poster. Je ne comprends pas pourquoi je ne peux pas poster des commentaires de la même manière que je poste les réponses. C'est très limitée dans la mise en forme et la longueur.

OriginalL'auteur Andreas H.
3

Si vous voulez de la charge filtrée de relations avec une seule requête, vous avez en effet l'exécution de tels projection, mais vous n'avez pas besoin de ces appels à l' Include. Une fois que vous êtes à la construction des projections sont pas utilisez - vous avez repris les données sous votre contrôle.

Procédure stockée de vous aider que si vous tomber en arrière à la plaine de ADO.NET parce que les procédures stockées exécutées via Entity framework ne sont pas en mesure de remplir les entités liées (seulement aplatie structures).

Automatique fixupu mentionné par @Andreas exige de multiples requêtes de base de données et que je sais qu'il ne fonctionne que si le chargement paresseux est désactivé car les objets " proxy en quelque sorte n'ont pas d'informations sur la correction et il a encore ses indicateurs internes pour chaque relation comme n'étant pas chargé donc, lorsque vous accédez pour la première fois, ils ont encore exécuter une requête supplémentaire.

OK, merci beaucoup pour la réponse. Merci de remarquer que comprend ne sont pas nécessaires et en tenant compte de Andreas réponse. Qu'entendez-vous par "exige de multiples requêtes de base de données"? Êtes-vous ce qui suggère qu'il pourrait ne pas être efficace? Ayant de ce fait par la création d'une projection dans la façon dont je le faisais ne me semble plus être une bonne idée, il semble donc difficile de maintenir et de le modifier. Il doit y avoir un modèle de la façon de le faire de la meilleure façon, alors je me demande, c'est quoi?
La Projection est le seul moyen si vous voulez charger donc beaucoup de relations au sein d'une même requête et de la base de données de l'aller-retour. Si vous écrivez plusieurs requêtes, vous aurez de base de données multiples allers-retours.
Vous avez toujours de trouver un équilibre entre la hâte (include) et le chargement explicite (plusieurs allers-retours). Dans la pratique, sont souvent néfaste en termes de performances. Thatswhy j'ai suggéré l'utilisation Inclure uniquement pour que les propriétés dont vous avez besoin à la requête, un charge d'autres Propriétés liées explicitement. Désireux de chargement produit des requêtes complexes qui peuvent prendre beaucoup de temps à construire, mais comme l'a dit, le chargement explicite besoins de plusieurs requêtes de sql server, il y a toujours l'ajustement nécessaire.
Je suppose que je comprends implication de nombreux inclut.

OriginalL'auteur Ladislav Mrnka

@Andreas H:

Génial, merci beaucoup.

J'ai eu à régler votre suggestion de ce genre et il a travaillé:

var dealer = this.ObjectContext.Dealers
                    .Include("Groups")
                    .Include("Groups.Items")
                    .Include("Groups.Items.Observations")
                    .Include("Groups.Items.Recommendations")
                    .Where(p => p.DealerId == id).
                    FirstOrDefault();
        if (dealer != null)
        {
            this.ObjectContext.Checkins
                    .Include("Inspections")
                    .Include("Inspections.InspectionItems")
                   .Where(c => !c.Complete && c.Dealer.DealerId == dealer.DealerId)
                   .ToList();
        }
        return dealer;

J'utilise encore l'Inclure sinon il ne reviendra pas les entités référencées.

Note également que le Courtier.Les groupes sont sans rapport avec le Concessionnaire.Archivages.

Donc si il n'y a pas archivages satisfait à la condition, les Groupes doivent encore être retourné.

Il est intéressant de noter qu'au début, j'ai mis les deux comprennent pour archivages pour le marchand

var dealer = this.ObjectContext.Dealers
                        .Include("Groups")
                        .Include("Groups.Items")
                        .Include("Groups.Items.Observations")
                        .Include("Groups.Items.Recommendations")
                        .Include("Checkins.Inspections")
                        .Include("Checkins.Inspections.InspectionItems")
                        .Where(p => p.DealerId == id).
                        FirstOrDefault();
            if (dealer != null)
            {
                this.ObjectContext.Checkins
                        .Where(c => c.Complete && c.DealerId == id)
                       .ToList();
            }
            return dealer;

mais il est retourné tous les Archivages, y compris ceux qui ne sont pas complets.

Je ne comprends pas exactement pourquoi ce dernier ne fonctionne pas, mais l'ancien, comment sont les entités sont résolus. J'ai en quelque sorte peut pressentir que le premier renvoie toutes les données.

OriginalL'auteur Andrei N.

Votre solution retenue permettra de générer de multiples requêtes de base de données. Comme Ladislav Mrnka dit une projection est le seul moyen de tirer votre résultat avec une seule requête. La maintenance de votre code bien dur. Peut-être que vous pourriez utiliser un IQueryable-Extension qui crée la projection de manière dynamique et de garder votre code propre:

var query = this.ObjectContext.Dealers.SelectIncluding( new List<Expression<Func<T,object>>>>(){

    x => x.Groups,
    x => x.Groups.Select(y => y.Items),
    x => x.Groups.Select(y => y.Items.Select(z => z.Observations)),
    x => x.Groups.Select(y => y.Items.Select(z => z.Recommendations)),
    x => x.Checkins.Where(y => y.Complete==true),
    x => x.Checkins.Select(y => y.Inspections),
    x => x.Checkins.Select(y => y.Inspections.Select(z => z.InspectionItems))

});
var dealer = query.First();
return dealer;

Vous pouvez trouver l'extension à thiscode/DynamicSelectExtensions sur github

OriginalL'auteur thiscode

Vous devez vous connecter pour publier un commentaire.