Quelle est la bonne façon de Joindre deux tables dans ASP.NET MVC?

Vous n'êtes pas seul. Données de la modélisation des masques tellement les rumeurs sur qui il peut être difficile de déterminer ce qui est bien et mal.

Il n'y a rien de mal avec l'utilisation de LINQ jointure interne dans le sens où il fonctionne, et il obtient ce dont vous avez besoin.

Cependant, l'ajout d'ICollection pour le modèle de données pour FileTree décrit une relation stable qui peut être observé lors de la lecture du code, et utilisé chaque fois que vous en avez envie (ce qui sera probablement souvent, ils sont si étroitement liés). c'est à dire non seulement Il fournit la même fonctionnalité que la jointure, mais il explique la relation à d'autres programmeurs sans avoir besoin de commentaires ou de la lecture des exemples de code.

À l'utilisation de ces types de relations, la plupart des Mappings Objet Relationnel (Entity Framework et NHibernate deux exemples de l'ORM) exiger que les modèles de spécifier une clé primaire pour le raccordement de la clé étrangère entre la table enfant dans la collecte et la table parent qui a la collection.

Donc, longue histoire courte, l'utilisation ICollection, mais ensuite également spécifier une clé primaire sur votre modèle de Fichier.

OriginalL'auteur Steve Lillis

Pour l'Identité des Choses que vous pouvez faire:

using System;

using Microsoft.AspNet.Identity.EntityFramework;

///<summary>
///The guid role.
///</summary>
public class GuidRole : IdentityRole<Guid, GuidUserRole>
{
    ///<summary>
    ///Initializes a new instance of the <see cref="GuidRole"/> class.
    ///</summary>
    public GuidRole()
    {
        this.Id = Guid.NewGuid();
    }

    ///<summary>
    ///Initializes a new instance of the <see cref="GuidRole"/> class.
    ///</summary>
    ///<param name="name">
    ///The name.
    ///</param>
    public GuidRole(string name)
        : this()
    {
        this.Name = name;
    }
}

public class GuidUserRole : IdentityUserRole<Guid> { }
public class GuidUserClaim : IdentityUserClaim<Guid> { }
public class GuidUserLogin : IdentityUserLogin<Guid> { }

///<summary>
///The user.
///</summary>
public class User : IdentityUser<Guid, GuidUserLogin, GuidUserRole, GuidUserClaim>
{
    public User()
    {
        this.Id = Guid.NewGuid();
    }
    ///<summary>
    ///Gets or sets the first name.
    ///</summary>
    public string FirstName { get; set; }

    ///<summary>
    ///Gets or sets the last name.
    ///</summary>
    public string LastName { get; set; }
}

Donc, ici, vous pouvez voir que j'ai fait tous mes Modèles d'Identité ont Guid comme une clé primaire de type. Vous pouvez facilement changer cela pour int , et je crois que c'est le chemin à parcourir!

Si vous avez à faire compliqué jointures, vous devez laisser EF hors de lui, car il est tout simplement un ORM. Il ne peut pas remplacer SQL. Vous pouvez toutefois créer une belle jointure SQL dans le code et ont EF exécuter cette requête!

using (var context = new ApplicationDbContext())
{
    var result = context.Database.SqlQuery<SomeDtoToHoldTheData>(
                     "SOME LOVELY SQL" + 
                     "SELECT * FROM DATABASE TABLE" +
                     "EVEN PARAMS GO @HERE",
                     new SqlParameter("Here", "My Param"));
}

Je vous suggère de regarder cette première peut-être?

Évidemment de ne pas concaténer des chaînes de caractères avec la +, ils sont immuables.

Donc permet de faire votre requête:

public class FileResultDto
{
    public string FileName {get;set;}
    public decimal FileSize {get;set;}
}

var query = "SELECT f.FileName, f.FileSize" +
            "FROM Files f" +
            "INNER JOIN FileTree ft ON ft.FolderID = f.FolderID" +
            "INNER JOIN AspNetUsers u ON ft.UserID = u.Id" +
            "WHERE u.id = @id AND ft.FolderPath = @path;";

var userIdParam = new SqlParameter("id", userId);
var pathParam = new SqlParameter("path", path);

var result = context.Database.SqlQuery<FileResultDto>(query, userIdParam, pathParam);

Si vous ne voulez pas aller dans cette voie. Le LINQ je suppose pourrait aller quelque chose comme ceci:

var fileTrees = context.FileTrees.Where(f => f.FolderPath == folderPath && f.UserID == userId)
                   .GroupJoin(
                         context.Files
                         ft => ft.FolderID,
                         f => f.FolderID,
                         (fileTree, files) => { fileTree, files });

var users = context.Users.FirstOrDefault(u => u.Id == userId);

Donc dans fileTrees une liste d'objets anonymes tenue d'une FileTree entité et une liste de File entités. Basé sur l'actuel modèle.

OriginalL'auteur Callum Linington