Comment commander un enfant collections d'entités en EF

J'ai la requête suivante:

public IEnumerable<Team> GetAllTeamsWithMembers(int ownerUserId)
        {
            return _ctx.Teams
                 .Include(x => x.TeamMembers)
                 .Where(x => x.UserId == ownerUserId)
                 .OrderBy(x => x.Name).ToList();

        }

Comment puis-je commander les équipes par leur nom, et alors tous les enfants des membres de chaque équipe triés par leur nom?

Il semble que ce faire j'ai besoin de créer un nouveau DTO de la classe et de l'utilisation d'un select. J'aimerais utiliser l'EF entités déjà créé, dans ce cas, l'Équipe a une propriété de navigation pour les Membres. Je retourne IEnumerable<Team> de mon dépôt de la couche.

Il ne semble pas être une belle façon d'ordonner à l'enfant collections dans les EF. Quelqu'un peut-il aider?

InformationsquelleAutor jaffa | 2011-12-09
  1. 24

    Vous pouvez charger les données et de les trier en mémoire après le chargement.

    IEnumerable<Team> teams = _ctx.Teams
            .Include(x => x.TeamMembers)
            .Include(x => x.TeamMembers.Select(u => u.User))
            .Where(x => x.UserId == ownerUserId)
            .OrderBy(x => x.Name).ToList();

foreach (var team in teams)
{
    team.TeamMembers = team.TeamMembers.OrderBy(m => m.Name);
    foreach (var teamMember in team.TeamMembers)
    {
        teamMember.Users = teamMember.Users.OrderBy(u => u.Name);
    }
}

    Ou vous pouvez utiliser les Projections et utiliser le Suivi des modifications de EF pour trier votre collection. Voici un exemple de filtrage Comprennent un mais les mêmes travaux pour la Commande.

    • Merci pour cette, simple et efficace. Je pensais qu'il pouvait être quelque chose d'un peu plus LINQish, ne tient pas sur la boucle, mais il fait le travail!
    InformationsquelleAutor Wouter de Kort
  2. 2

    Vous pourriez faire un dump de votre équipes et de leurs membres de l'équipe dans un type anonyme (probablement pas ce que vous voulez), comme ceci:

    public IEnumerable<Team> GetAllTeamsWithMembers(int ownerUserId)
{
    return (from t in _ctx.Teams
        where t.UserId == ownerUserId
        select new {
            Team = t,
            TeamMembers = t.TeamMembers.OrderBy(m => m.Name)
        }).ToList()
}

    Vous pouvez ensuite parcourir en boucle:

    foreach(Team team in GetAllTeamsWithMembers(1234))
{
    string teamName = team.Team.Name;
    string firstTeamMemberName = team.TeamMembers.First().Name;
}

    Mise à jour: Pour l'enregistrement, mon avis est de ne pas utiliser cette solution, mais pour trier chaque collection dans une boucle ou lors du rendu/de liaison.

    J'ai enlevé la 2ème solution, car il a été souligné que les EF ne peut pas sélectionner dans d'autres entités.

    • La deuxième option ne fonctionne pas, malheureusement, parce que LINQ to entities ne permet pas de se projeter dans une entité.
    • La première option ne fonctionne que si vous ajoutez un .Sélectionnez(a => un.De l'équipe) après votre ToList().
    • Je ne le savais pas.
    • Si vous le faites, alors il n'omettre la liste ordonnée des Membres de l'Équipe, n'est-ce pas? La liste ordonnée de ne pas être stocké dans l'Équipe.TeamMembers propriété, mais comme un frère ou une sœur de l'Équipe dans un nouveau type anonyme.
    • Non, ce n'est pas vrai. Parce que vous avez activé ChangeTracking automatique relation correctif va définir le TeamMembers propriété de l'Équipe, et parce que les entités sont triés lorsqu'ils sont ajoutés à la ChangeTracker cela fonctionne.
    • Je suis en train d'apprendre toutes sortes de choses. Merci. 😀

    InformationsquelleAutor Ricky Smith
  3. 0

    Malheureusement désireux de chargement (Include) ne prend en charge aucun de filtrage ou de tri de l'enfant chargé des collections.

    Mais comme indiqué dans l'acceptation de réponse, vous pouvez trier chaque collection après qu'ils ont été désireux chargé. J'ai écrit une méthode d'extension qui gère le tri d'un ensemble par un enfant de la propriété facilement en place donc il n'est pas nécessaire pour la réaffectation:

    public static class Extensions
{
    public static void SortOn<T>(this List<T> enumerable, Expression<Func<T, object>> expression)
    {
        var type = expression.Parameters[0].Type;
        var memberName = ((MemberExpression)((UnaryExpression)expression.Body).Operand).Member.Name;

        enumerable.Sort((x, y) =>
        {
            var first = (IComparable)type.GetProperty(memberName).GetValue(x);
            var second = (IComparable)type.GetProperty(memberName).GetValue(y);
            return first.CompareTo(second);
        });
    }
}

    Ensuite le tri de l'enfant collections pourrait être succinctement écrit comme:

    foreach (var team in teams)
    team.TeamMembers.SortOn(_ => _.Name);
    InformationsquelleAutor Matthew Steven Monkan