Conditionnel Include() dans le Cadre de l'Entité

J'ai vu quelques réponses à des questions similaires, mais je n'arrive pas à travailler sur la façon d'appliquer la réponse à ma question.

var allposts = _context.Posts
            .Include(p => p.Comments)
            .Include(aa => aa.Attachments)
            .Include(a => a.PostAuthor)
            .Where(t => t.PostAuthor.Id == postAuthorId).ToList();

Les pièces jointes peuvent être téléchargées par l'Auteur (type de l'Auteur) ou Contributeur (type de Contributeur). Ce que je veux faire est d'obtenir uniquement les pièces Jointes lorsque le propriétaire de l'attachement est de type de l'Auteur.

Je sais que cela ne fonctionne pas et donne une erreur:

.Include(s=>aa.Attachments.Where(o=>o.Owner is Author))

J'ai lu à propos de Projection Filtrée ici

EDITION - lien vers l'article:
: http://blogs.msdn.com/b/alexj/archive/2009/10/13/tip-37-how-to-do-a-conditional-include.aspx,

mais je ne peux pas obtenir ma tête autour de lui.

Je ne veux pas inclure le filtre dans la clause where finale que je veux TOUS les messages, mais je veux seulement récupérer les pièces jointes pour les messages qui appartiennent à l'Auteur.

EDIT 2: - schéma demandé

public abstract class Post : IPostable
{

    [Key]
    public int Id { get; set; }

    [Required]
    public DateTime PublishDate { get; set; }

    [Required]
    public String Title { get; set; }

    [Required]
    public String Description { get; set; }

    public Person PostAuthor { get; set; }
    public virtual ICollection<Attachment> Attachments { get; set; }
    public List<Comment> Comments { get; set; }
}

Pouvez-vous nous montrer le Posts schéma s'il vous plaît?
voir modifier
Ce que vous demandez n'est pas possible. Linq2Sql va convertir votre code dans les matières premières SQL, et il va retourner à l'enfant les lignes via une jointure. Vous ne pouvez pas faire ce genre de mise en rejoindre en SQL. Votre seule option est de supprimer .Include(aa => aa.Attachments), et ont une deuxième requête qui renvoie les pièces jointes en fonction de si oui ou non le propriétaire est un auteur/contributeur.

OriginalL'auteur grayson | 2015-09-24

c#entity-framework linq linq-to-entities

À partir du lien que vous avez posté, je peux confirmer que l'astuce fonctionne, mais pour un grand nombre (ou plusieurs) relation seulement. Dans ce cas, votre Post-Attachment devrait être une relation, de sorte qu'il est tout à fait applicable. Voici la requête, vous devez avoir:

//this should be disabled temporarily
_context.Configuration.LazyLoadingEnabled = false;
var allposts = _context.Posts.Where(t => t.PostAuthor.Id == postAuthorId)
                       .Select(e => new {
                           e,//for later projection
                           e.Comments,//cache Comments
                           //cache filtered Attachments
                           Attachments = e.Attachments.Where(a => a.Owner is Author),
                           e.PostAuthor//cache PostAuthor
                        })
                       .AsEnumerable()
                       .Select(e => e.e).ToList();

ai-je besoin d'ajouter "_context.La Configuration.LazyLoadingEnabled = true;" renable chargement différé après cet appel?
oui, si vous voulez ré-activer.

OriginalL'auteur Hopeless

Supprimer la virtual mot clé de votre Attachments propriété de navigation pour empêcher le chargement paresseux:

public ICollection<Attachment> Attachments { get; set; }

Première méthode: Problème les deux requêtes distinctes: l'une pour les Messages, l'un pour les pièces Jointes, et de la laisser relation de fix-up faire le reste:

List<Post> postsWithAuthoredAttachments = _context.Posts
    .Include(p => p.Comments) 
    .Include(p => p.PostAuthor)
    .Where(p => p.PostAuthor.Id == postAuthorId)
    .ToList();

List<Attachment> filteredAttachments = _context.Attachments
    .Where(a => a.Post.PostAuthor.Id == postAuthorId)
    .Where(a => a.Owner is Author)
    .ToList()

Relation de correction signifie que vous pouvez accéder à ces filtré les pièces Jointes par l'intermédiaire d'un Poste de navigation de la propriété

Deuxième méthode: une requête à la base de données de suivi d'un mémoire de recherche:

var query = _context.Posts
    .Include(p => p.Comments) 
    .Include(p => p.PostAuthor)
    .Where(p => p.PostAuthor.Id == postAuthorId)
    .Select(p => new 
        {
            Post = p,
            AuthoredAttachments = p.Attachments
                Where(a => a.Owner is Author)
        }
    );

Je voudrais juste utiliser le type anonyme ici

var postsWithAuthoredAttachments = query.ToList()

ou je voudrais créer une classe ViewModel pour éviter l'anonyme de type:

List<MyDisplayTemplate> postsWithAuthoredAttachments = 
     //query as above but use new PostWithAuthoredAttachments in the Select

Ou, si vous voulez vraiment déballer les Postes:

List<Post> postsWithAuthoredAttachments = query.//you could "inline" this variable
    .AsEnumerable() //force the database query to run as is - pulling data into memory
    .Select(p => p) //unwrap the Posts from the in-memory results
    .ToList()

OriginalL'auteur Colin

3

Vous pouvez utiliser cette mise en œuvre d'une méthode d'extension (par exemple.) Include2(). Après cela, vous pouvez appeler le:
```
_context.Posts.Include2(post => post.Attachments.Where(a => a.OwnerId == 1))
```
Le code ci-dessus ne comprend que des pièces jointes où Attachment.OwnerId == 1.

Salut, ce qui ne fonctionne pas quand il n'y a pas de pièces Jointes à un poste. Un, je manque quelque chose

OriginalL'auteur Jan Palas
-3

Lambda dans Include() ne peut point à une propriété:
```
.Include(a => a.Attachments)
.Include(a => a.Attachments.Owner);
```
Votre état n'a pas de sens pour moi parce que Include() signifie join et vous pouvez soit le faire ou pas. Et non conditionnelle.

Comment voulez-vous écrire cela en SQL brut?

Pourquoi ne pas simplement ceci:
```
context.Attachments
       .Where(a => a.Owner.Id == postAuthorId &&
                   a.Owner.Type == authorType);
```
?

Merci. Je suis assez nouveau dans tout cela. Je peux le faire pour obtenir les pièces jointes du type désiré, mais je ne sais pas comment faire pour fusionner de nouveau dans le Post. Mon DisplayTemplate dérive de la Poste et des affichages de Poste.Les pièces jointes
comment vous l'écrire en raw SQL: select * from table1 x join table2 y sur x.fkey=y.fkey et (condition avec y)
ce n'est pas conditionnelle à la rejoindre, est-il?
Une jointure est toujours conditionnel. C'est juste généralement conditionnés sur pkeys. Cependant, vous pouvez total rejoindre sur pkey ET d'autres conditions. De fait, depuis les JOINTURES sont généralement préférés dans de grands ensembles de données.
Une jointure n'est jamais conditionnelle, qu'elle soit présente ou non. Et en effectuant l'une peut être coûteux. Et un bon réglage de la performance est d'éliminer les jointures vous le savez, rien de rendement. Dans U-SQL c'est fait à l'aide de SQL Dynamique d'habitude. Mais voici la question sur EF.

OriginalL'auteur abatishchev

-3

En supposant que "un" être de type "YourType", un conditionnels inclure pourrait être résolu en utilisant une méthode d'extension, par exemple

public static class QueryableExtensions
{
    public static IQueryable<T> ConditionalInclude<T>(this IQueryable<T> source, bool include) where T : YourType
    {
        if (include)
        {
            return source
                .Include(a => a.Attachments)
                .Include(a => a.Attachments.Owner));
        }

        return source;
    }
}

... puis il suffit de l'utiliser comme vous êtes en utilisant .Inclure, par exemple,

bool yourCondition;

.ConditionalInclude(yourCondition)

est-ce une blague ou quelque chose?

OriginalL'auteur CHS

Vous devez vous connecter pour publier un commentaire.