Dans mes applications, j'ai toujours séparé les choses, avec différents modèles pour la base de données (Entity Framework) et MVC. Je les ai également séparés en différents projets:
- Example.Entities - contient mes entités pour EF et le contexte DB pour y accéder.
- Example.Models - contient des modèles MVC.
- Example.Web - application web. Dépend à la fois de Example.Domain et de Example.Models.
Au lieu de contenir des références à d'autres objets comme le font les entités de domaine, les modèles MVC contiennent des ID sous forme d'entiers.
Lorsqu'une demande GET pour une page arrive, le contrôleur MVC exécute la requête de base de données, qui renvoie une entité. J'ai écrit des méthodes "Convertisseur" qui prennent une entité de domaine et la convertissent en un modèle MVC. Il existe d'autres méthodes qui font le contraire (d'un modèle MVC à une entité de domaine). Le modèle est ensuite transmis à la vue, et donc au client.
Lorsqu'une demande POST arrive, le contrôleur MVC obtient un modèle MVC. Une méthode de conversion le convertit en une entité de domaine. Cette méthode effectue également toutes les validations qui ne peuvent pas être exprimées en tant qu'attributs et s'assure que si l'entité de domaine existe déjà, nous la mettons à jour plutôt que d'en obtenir une nouvelle. Les méthodes ressemblent généralement à ceci:
public class PersonConverter
{
public MyDatabaseContext _db;
public PersonEntity Convert(PersonModel source)
{
PersonEntity destination = _db.People.Find(source.ID);
if(destination == null)
destination = new PersonEntity();
destination.Name = source.Name;
destination.Organisation = _db.Organisations.Find(source.OrganisationID);
//etc
return destination;
}
public PersonModel Convert(PersonEntity source)
{
PersonModel destination = new PersonModel()
{
Name = source.Name,
OrganisationID = source.Organisation.ID,
//etc
};
return destination;
}
}
En utilisant ces méthodes, je supprime la duplication qui se produirait autrement dans chaque contrôleur. L'utilisation de génériques peut dédupliquer encore plus les choses.
Faire les choses de cette façon présente de multiples avantages:
- Vous pouvez personnaliser un modèle pour une vue ou une action spécifique. Supposons que vous ayez un formulaire d'inscription pour une personne qui, une fois soumis, crée de nombreuses entités différentes (personne, organisation, adresse). Sans modèles MVC séparés, ce sera très difficile.
- Si j'ai besoin de transmettre à la vue plus d'informations que celles qui seraient autrement disponibles uniquement dans l'entité, ou de combiner deux entités en un seul modèle, mes précieux modèles de base de données ne sont jamais touchés.
- Si vous sérialisez un modèle MVC en JSON ou XML, vous obtenez uniquement le modèle immédiat en cours de sérialisation, pas toutes les autres entités liées à celui-ci.