conditionnel inclure dans linq to entities?

Je me sentais comme le suivant devrait être possible, je ne suis pas sûr de ce que l'approche à prendre.

Ce que je voudrais faire est d'utiliser la méthode include pour la forme de mes résultats, c'est à dire définir jusqu'à quel point le long de l'objet graphique pour le traverser. mais... j'aimerais que la traversée soit conditionnel.

something like...

dealerships
    .include( d => d.parts.where(p => p.price < 100.00))
    .include( d => d.parts.suppliers.where(s => s.country == "brazil"));

Je comprends que ce n'est pas valable linq, en fait, qu'il est horriblement mal, mais en gros, je suis à la recherche d'une certaine façon de construire une arborescence d'expression qui sera de retour en forme des résultats, soit l'équivalent de...

select *
from dealerships as d
outer join parts as p on d.dealerid = p.dealerid
    and p.price < 100.00
outer join suppliers as s on p.partid = s.partid
    and s.country = 'brazil'

avec un accent sur les conditions de jointure.

~~je sens que ce serait assez simple avec esql mais~~ ma préférence serait de construire des arbres d'expression à la volée.

comme toujours, reconnaissant pour tout conseil ou d'orientation

Avez-vous jamais trouver une solution à cela? Je vais avoir le même problème.
Pas encore, mais je reste intéressé et continuera à poursuivre...
Je cherchais la même chose

InformationsquelleAutor tim | 2009-07-06

15

Cela devrait faire l'affaire:
```
using (TestEntities db = new TestEntities())
{
    var query = from d in db.Dealership
                select new
                {
                    Dealer = d,
                    Parts = d.Part.Where
                    (
                        p => p.Price < 100.0 
                             && p.Supplier.Country == "Brazil"
                    ),
                    Suppliers = d.Part.Select(p => p.Supplier)
                };

    var dealers = query.ToArray().Select(o => o.Dealer);
    foreach (var dealer in dealers)
    {
        Console.WriteLine(dealer.Name);
        foreach (var part in dealer.Part)
        {
            Console.WriteLine("  " + part.PartId + ", " + part.Price);
            Console.WriteLine
                (
                "  " 
                + part.Supplier.Name 
                + ", " 
                + part.Supplier.Country
                );
        }
    }
}
```
Ce code vous donnera une liste de Concessionnaires chacun contenant une liste filtrée des parties. Chaque partie fait référence à un Fournisseur. La partie intéressante est que vous devez créer les types anonymes dans la sélection, de la façon illustrée. Sinon, la Partie de la propriété de la Concession des objets sera vide.

Aussi, vous devez exécuter l'instruction SQL avant de choisir les concessionnaires à partir de la requête. Sinon, la Partie de la propriété des concessionnaires sera de nouveau vide. C'est pourquoi j'ai mis le ToArray() l'appel à la ligne suivante:
```
var dealers = query.ToArray().Select(o => o.Dealer);
```
Mais je suis d'accord avec Darren que cela peut ne pas être ce que les utilisateurs de votre bibliothèque attendent.
- Une remarque sur ce, j'ai essayé et ça n'a pas fonctionné au début. Finalement, j'ai trouvé que j'avais un Chargement différé activé qui a été à l'origine de ce pas au travail. Une fois que j'ai désactivé le chargement paresseux cela a fonctionné comme un charme. Grâce Jakob!
- Cela vous oblige à retourner un type anonyme au lieu de la crue de type avec les références. Cette "fonctionne" mais laisse moi de vouloir une solution pour retourner l'objet brut avec le véritable objet de collection, filtré à ce que je voulais être retourné. L'anonyme de type de retour des œuvres sûr... mais n'est pas vraiment la véritable solution désirée.
- vous pouvez retourner une Liste tapée de cette façon: var dealers = query.ToArray().Select(o => o.Dealer).ToList(); Il fonctionne, tout simplement!
- Je préfère cette façon, donc je n'ai pas de créer et inutile de tableau: query.Load(); var dealers = query.Select(o => o.Dealer).ToList();
InformationsquelleAutor Jakob Christensen
6

Vous assurer que c'est ce que vous voulez? La seule raison pour laquelle je demande, c'est, une fois que vous ajoutez un filtre sur des Pièces de Concessionnaires, vos résultats ne sont plus les Concessionnaires. Vous avez affaire à des objets spéciaux qui sont, pour la plupart, très proche de Concessionnaires (avec les mêmes propriétés), mais le sens de la "Parties" de la propriété est différente. Au lieu d'être une relation entre les Concessionnaires et les Pièces, il est filtré relation.

Ou pour le dire d'une autre façon, si je tire un concessionnaire de vos résultats et passés à une méthode que j'ai écrit, et puis, dans ma méthode, j'appelle:
```
var count = dealership.Parts.Count();
```
Je m'attends à recevoir les pièces, pas le filtre des pièces à partir de Brésil, où le prix est inférieur à 100$.

Si vous n'utilisez pas le concessionnaire de l'objet à transmettre les données filtrées, il devient très facile. Il devient aussi simple que:
```
    var query = from d in dealerships
               select new { DealershipName = d.Name, 
CheapBrazilProducts = dealership.Parts.Where(d => d.parts.Any(p => p.price < 100.00) || d.parts.suppliers.Any(s => s.country == "brazil")) };
```
Si j'avais juste à me le filtrée définit comme vous l'avez demandé, je serais probablement utiliser la technique je l'ai mentionné ci-dessus, et ensuite utiliser un outil comme Automapper pour copier les résultats filtrés de ma classe anonyme de la vraie classe. Ce n'est pas très élégant, mais il devrait fonctionner.

J'espère que ça aide! C'était un problème intéressant.
- Merci Darren je suis d'accord, dans la mesure où l'identité de l'objet! Je suis également préoccupé de constater que c'est exactement pourquoi cela ne peut pas être pris en charge par l'EF. Ce que j'essaye vraiment de faire ici est d'analyser une chaîne de requête tel que carpartsdb.com/dealerships/parts(prix < 100)/fournisseur(s).pays == brésil) dans une expression de requête et vérifier à l'EF, chuck dans une coutume de la sérialisation xml stratégie et hop vous avez un RestQL Moteur (reposant query language). Je ne suis pas trop attaché à EF, mais veulent être en mesure d'avoir le modèle de l'abstraction et de l'expression des arbres et de l'EF est et ne veulent pas trop s'écarter de la MS de la pile!
- désolé darren, voir ce texte dans plus de réponse dans laquelle il sera plus lisible!
InformationsquelleAutor Darren
1

Suis-je raté quelque chose, ou n'êtes-vous pas tout simplement à la recherche pour le Any mot-clé?
```
var query = dealerships.Where(d => d.parts.Any(p => p.price < 100.00) || 
                              d.parts.suppliers.Any(s => s.country == "brazil"));
```
- je ne pense pas, si je comprends bien, ce serait de retour concessionnaires, où il y avait des pièces et des fournisseurs qui répondent aux conditions, plutôt que de retourner tous les concessionnaires, toutes les parties qui sont de moins de 100 et tous les fournisseurs au brésil. Je me rends compte que cela devrait être une jointure externe. je pense que ce que j'essaie de faire est d'élaguer l'arbre de résultats plutôt que de filtrer les nœuds de niveau supérieur basé sur les valeurs en bas de l'arbre.
InformationsquelleAutor lc.
0

Oui c'est ce que je voulais faire, je pense que la prochaine sortie de Données de Services ont la possibilité de faire exactement ce que LINQ to RESTE requêtes qui serait bien dans le temps, j'ai juste passé à la charge de l'inverse et Comprennent l'entité qui sera chargée plusieurs fois, mais en théorie, il suffit de charger une fois la première Inclure comme dans ce code
```
return this.Context.SearchHistories.Include("Handle")
    .Where(sh => sh.SearchTerm.Contains(searchTerm) && sh.Timestamp > minDate && sh.Timestamp < maxDate);
```
avant j'ai essayé de charger pour une Poignée à la searchHistories qui correspondent à la logique, mais ne savent pas comment utiliser la fonction include de la logique que vous avez posté, donc dans le temps, je pense qu'une recherche inversée serait une solution sale

InformationsquelleAutor

Je sais que cela peut fonctionner avec un seul Inclure. Jamais test avec deux comprend, mais vaut le coup d'essayer:

dealerships
    .Include( d => d.parts)
    .Include( d => d.parts.suppliers)
    .Where(d => d.parts.All(p => p.price < 100.00) && d.parts.suppliers.All(s => s.country == "brazil"))

InformationsquelleAutor Dherik

Vous devez vous connecter pour publier un commentaire.