De retour des données à partir de 2 tables avec Entity Framework

Je travaille avec MVC3 et Entity Framework, mais je suis arrivé à un point où j'ai besoin de plus de données provenant de différentes tables. Habituellement, je ferais quelque chose de ce genre pour obtenir les données à partir d'une table:

Table: Users
id
username

Dans le code que je ferais quelque chose comme cela pour obtenir tous les utilisateurs:

public static IEnumerable<Users> GetUsers( int userId )
{
    MyEntities ent = new MyEntities();

    return from g in ent.Users
           where g.OwnerUserId == userId
           select g;
}

Donc, ce serait de me donner tous mes utilisateurs.

Mais un utilisateur peut se joindre à un groupe, et je dois profiter de tous les noms d'utilisateurs à partir d'un groupe spécifique.

Table: userGroups
id
fk_user_id
fk_group_id

Maintenant, si j'utilise ce code:

public static IEnumerable<userGroups> GetUsersFromGroup( int groupId )
{
    MyEntities ent = new MyEntities();

    return from g in ent.userGroups
           where g.OwnerUserId == userId
           select g;
}

Maintenant, évidemment, cela ne me renvoie les données de la "groupes d'utilisateurs" de la table. Mais de toute façon j'ai aussi besoin du nom d'utilisateur à partir de la table des Utilisateurs. Comment puis-je obtenir des données trop et toujours le retour de mon "groupes d'utilisateurs" comme un IEnumerable?

En SQL, je voudrais simplement faire une JOINTURE GAUCHE, mais je ne peux pas vraiment comprendre comment ça fonctionne ici.

PS, cela n'a rien à voir avec votre question, mais en voyant le "statique" modificateur sur quelque chose qui accède à la base de données qui me frappe comme Une Mauvaise Chose(tm). Je ne sais pas ce que votre situation est, mais il peut être utile d'afficher les moqueries et le couplage lâche que possible refactoring objectifs quand vous le pouvez. Comme il est en ce moment votre code n'est pas en mesure d'être l'objet de tests unitaires ou échangé lorsque les besoins inévitablement changer.
Je pense que vous trouverez que vous pouvez obtenir beaucoup mieux kilométrage de votre ORM et le modèle de domaine si vous arrêtez de penser à vos données dans une table SQL ou de la représentation et de commencer à penser à ce sujet que la cohésion d'un domaine. Le plus grand obstacle que beaucoup de devs visage, c'est qu'ils sentent qu'ils ont besoin pour la conception de leur domaine de modèles à imiter la persistance de la structure. Oublier comment les données sont stockées et de se concentrer sur ce que vous voulez faire avec elle. Avec un peu de planification, vous pouvez réduire le domaine des dépendances sur les problèmes d'infrastructure et de se concentrer sur les affaires de l'utilitaire

OriginalL'auteur w00 | 2012-04-02

  1. 5

    Quelque chose comme ceci peut-être:

    var query = from g in ent.userGroups
            join u in ent.Users on g.fk_user_id equals u.userID
            select new { g, u, });

    Ou avec un LEFT JOIN

    var query = (from g in ent.userGroups
             from u in ent.Users.Where(a => a.fk_user_id == u.userID).DefaultIfEmpty()
             select new { g, u, });

    OriginalL'auteur Arion

  2. 3
    var query = from ug in ent.userGroups
            join u in ent.Users on ug.OwnerUserId = ug.userID
            select new
            {
                Name = u.UserName,
                Id = u.userID
                Group = ug.GroupName
            };

    Si vous avez besoin d'une jointure gauche, puis vous aurez besoin d'DefaultIfEmpty.

    Veuillez consulter les articles suivants:

    OriginalL'auteur Habib

  3. 2

    Ci-dessus requêtes vont vous obliger à modifier votre signature de la méthode, qui pourrait être beaucoup de travail douloureux, selon l'endroit où vous avez cette mise en place. Arion est en particulier assez bien totalement imite la gauche rejoindre le comportement dont vous parlez (qui est excellent, car vous savez quelle est l'Entité qui est en train de faire), mais vous aurez besoin de changer votre type de retour pour une Tuple<userGroups, Users> ou quelque chose de cette nature.

    Ce que vous pouvez essayer à la place est de mettre à jour les groupes d'utilisateurs poco inclure une valeur liquidative de la propriété à la Users table. Si je comprends votre question posée correctement, vous avez un un-à-plusieurs relation qui existe ici. Dans ce cas, vous devez modifier le poco comme suit:

    public class userGroups
{
    public int ID { get; set; }
    public string GroupName { get; set; }
    public virtual ICollection<Users> Users { get; set; }
}

public class Users
{   
    public int ID { get; set; }        
    public string Name { get; set; }
    public virtual userGroups UserGroup { get; set; }
}

    Toutefois, les noms que vous avez posté votre question initiale ne sont pas ce que l'Entité considère normalisé de nommage, de sorte que vous devrez peut-être utiliser des annotations de données comme décrit ici. Ctrl-F "ForeignKey" si vous éprouvez de la difficulté à trouver, c'est une sorte de gros infodump sur les annotations de données dans son ensemble.

    L'avantage est, si vous faites un lien de ce genre, vous n'aurez jamais à vous soucier de se joindre de nouveau. Vous pouvez simplement accéder à la collection Users sur les groupes d'utilisateurs et des accès, a rejoint, et a travaillé pour vous.

    OriginalL'auteur tmesser