ASP.NET MVC, EntityFramework, DBContext, Référentiel dans un projet différent

Je suis actuellement en train de travailler sur un ASP.NET MVC 5 projet, et je suis en train de polir l'architecture du projet; le rendre aussi propre et facile pour les gens à travailler sur elle dans l'avenir que possible.

Pour commencer, j'ai porté mon EntityFramework modèles (y compris IdentityUser et AccountViewModel) pour un projet de bibliothèque de classes au sein de la même solution. C'est référencé par les principaux MVC projet pour le moment.

Cependant, je suis maintenant méditer sur la création d'une nouvelle Couche d'Accès aux Données de projet qui sera le DbContext (ou DbContexts, si je décide sur l'utilisation de plusieurs DbContexts) ainsi que la couche d'accès aux données. Quelle est la meilleure méthode à aller à ce sujet?

Ce DAL projet de référence le Modèle de projet, et le principal projet MVC ne référence que le DAL projet.

Après la lecture de cet article! Je me demandais si, en effet, le modèle de référentiel est en effet obsolète lors de l'utilisation de EntityFramework.

Donc mes deux questions principales sont:

1) quel est le meilleur moyen d'extraire DAL dans un projet distinct

2) quel est le meilleur moyen pour accéder à la base de données de contenu à l'aide de EF

source d'informationauteur teh0wner

  1. 7

    Votre question est assez large. Par exemple, qu'entendez-vous par "la meilleure manière d'accéder à la base de données de contenu à l'aide de EF"? La meilleure façon en termes de performance?

    Je vais essayer de répondre en donnant une option que je préfère (dont j'ai surtout utiliser une variante), qui utilise le modèle de référentiel. Si vous souhaitez utiliser votre EF directement comme un dépôt, vous pourriez dire que vous ne devez pas le modèle de référentiel, mais je tiens à envelopper ceux dans un de mes propres.

    Puisque je ne peux pas savoir ce que signifie pour vous le meilleur moyen, je vais vous donner ma préférence personnelle qui permettrait de suite typique d'un projet web.

    Je ne vais pas poster tout le code pour le rendre complètement fonctionnel, mais vous devriez avoir une idée claire de ce qu'il se passe.

    D'installation (4 projets):

    De l'INTERFACE utilisateur ----------> Domaine.La logique (w. Domaine.Modèles) -----------------> les Données (en maintenant le Contexte EF).

    De données:

    public partial class EFContextContainer : DbContext 
enter code here
public EFContextContainer ()
        : base("name=EFContextContainer")
    {
    }

public DbSet<IdentityUser> IdentityUsers { get;set; }

    Avec une enveloppe de retour le contexte:

    public static class Database
{
    public static EFContextContainerGetContext()
    {
        return new EFContextContainer();
    }

}

    Vous pourriez avoir un référentiel de configuration comme ceci:

    Interface:

    public interface IRepository<T> where T : class
{
    IQueryable<T> GetAll();
    T GetById(Guid id);
    void Add(T entity);
    void Update(T entity);
    void Delete(T entity);
    void Delete(Guid id);
}

    De mise en œuvre (uniquement l'Ajouter(T entité) par souci de concision):

    public class EFRepository<T> : IRepository<T>, IDisposable where T : class
{
    public EFRepository(DbContext dbContext)
    {
        if (dbContext == null)
            throw new ArgumentNullException("dbContext");
        DbContext = dbContext;
        DbSet = DbContext.Set<T>();

    }

    protected DbContext DbContext { get; set; }

    protected DbSet<T> DbSet { get; set; }

    public virtual void Add(T entity)
    {
        DbEntityEntry dbEntityEntry = DbContext.Entry(entity);
        if (dbEntityEntry.State != EntityState.Detached)
        {
            dbEntityEntry.State = EntityState.Added;
        }
        else
        {
            DbSet.Add(entity);
        }
    }

public void Dispose()
    {
        DbContext.Dispose();
    }

}

    De domaine:

    Domaine.La logique (IdentityUserManager serait une classe dans le Domaine.Modèles):

    public class IdentityUserManager
{
    public void Add(IdentityUser idUser)
    {
        using(var idUserRepository = new EFRepository<IdentityUser>(Database.GetContext())
        {
            idUserRepository.Add(idUser);
        }
    }
}

    De l'INTERFACE utilisateur:

    [HttpPost]
public ActionResult Post(UserViewModel model)
{
    UserIdentity user = MapUser(model);
    var userManager = new IdentityUserManager();
    userManager.Add(user);

    return View(new UserViewModel());
}

    (Ce n'est pas tout composé dans Visual Studio, donc pardonnez les fautes d'orthographe.)

    Admettre, il peut y avoir beaucoup plus d'abstraction dans ce code, mais il serait ridicule de le stylet vers le bas l'ensemble de la solution ici. Par exemple, vous pouvez utiliser le Unité de Travail modèle, qui fonctionne très bien avec le modèle de référentiel. Lisez donc ceci est un exemple, pas un guide complet sur la façon de mettre en œuvre ce programme d'installation. Les choses pourraient être mis en place beaucoup plus propre que cet exemple.

    Pour une vue en profondeur de la mise en œuvre de certains de ces modèles, je envie vous de prendre un coup d'oeil dans le cours Single Page Apps par Jean-Papa, sur le Pluriel de Vue. Il fait un excellent travail en expliquant les avantages de ces modèles et la façon de les mettre en œuvre.