Czy aplikacja ASP.NET MVC powinna bezpośrednio używać Entity Framework jako modelu?

Buduję swoją pierwszą aplikację MVC w Visual Studio 2013 (MVC 5) i jestem trochę niejasny, jak najlepiej skonfigurować mój model.

Wygenerowałem model struktury encji przy użyciu kodu najpierw z istniejącej bazy danych. Moim pierwszym instynktem było stworzenie pewnych klas pośrednich, które byłyby modelem używanym przez widoki i aby te klasy działały z klasami struktury encji.

Kiedy pisałem klasy pośrednie, zdałem sobie sprawę, że w większości po prostu ponownie wdrażam wiele rzeczy, które klasy EF już zrobiły tylko z okazjonalnym prywatnym ustawiaczem lub przesyłałem z jednego typu danych na inny. Więc to wydawało się marnotrawstwem.

Czy ogólną zasadą jest bezpośrednie używanie klas struktury encji jako modelu dla aplikacji MVC? Czy jest jakaś korzyść, której mi brakuje w budowaniu tych klas pośrednich?

W moich aplikacjach zawsze rozdzielałem różne rzeczy dla różnych baz danych (Entity Framework) i MVC. Podzieliłem je również na różne projekty:

• Example.Entities - zawiera moje byty dla EF i kontekst DB dla dostępu do nich.
• Przykład Modele - zawiera modele MVC.
• Example.Web - aplikacja internetowa. Zależy zarówno od Example.Domain, jak i Example.Models.

Zamiast przechowywania odniesień do innych obiektów, takich jak jednostki domeny, modele MVC przechowują identyfikatory jako liczby całkowite.

Kiedy przychodzi żądanie GET dla strony, kontroler MVC wykonuje zapytanie do bazy danych, które zwraca jednostkę. Napisałem metody „konwertera”, które pobierają jednostkę domeny i przekształcają ją w model MVC. Istnieją inne metody, które działają odwrotnie (od modelu MVC do encji domeny). Model zostaje następnie przekazany do widoku, a tym samym do klienta.

Kiedy przychodzi żądanie POST, kontroler MVC otrzymuje model MVC. Metoda konwertera konwertuje to na jednostkę domeny. Ta metoda wykonuje również wszelkie weryfikacje, których nie można wyrazić jako atrybuty, i upewnia się, że jeśli jednostka domeny już istnieje, to ją aktualizujemy, a nie otrzymujemy nową. Metody zwykle wyglądają mniej więcej tak:

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;
    }
}

Korzystając z tych metod, usuwam duplikację, która w innym przypadku wystąpiłaby w każdym kontrolerze. Zastosowanie generycznych może jeszcze bardziej zduplikować rzeczy.

Robienie rzeczy w ten sposób zapewnia wiele korzyści:

• Możesz dostosować model do konkretnego widoku lub akcji. Załóżmy, że masz formularz rejestracyjny dla osoby, która po przesłaniu tworzy wiele różnych podmiotów (osoba, organizacja, adres). Bez osobnych modeli MVC będzie to bardzo trudne.
• Jeśli muszę przekazać do widoku więcej informacji, niż byłoby to dostępne tylko w encji, lub połączyć dwie encje w jeden model, moje cenne modele baz danych nigdy nie zostaną zmienione.
• Jeśli kiedykolwiek serializujesz model MVC jako JSON lub XML, otrzymasz tylko natychmiastowy serializowany model, a nie wszystkie inne podmioty powiązane z tym modelem.

Powiedziałbym, że to naprawdę zależy od twojej aplikacji. Czy robi to po prostu czysty CRUD, bez logiki biznesowej? Następnie użyłbym modeli EF bezpośrednio w moich widokach.

W większości przypadków dotyczy to przynajmniej logiki biznesowej, a następnie dobrym pomysłem może być warstwa między modelami danych / EF a widokiem. W takim przypadku może być właściwe wykonanie „CQRS-lite” (patrz poniżej) i użycie różnych modeli do i z kontrolera. Przez większość czasu czytane modele są o wiele „grubsze” niż modele zapisu…

Jeśli jednak aplikacja zawiera dużo logiki biznesowej i / lub wymaga dużej skali, zaimplementowałbym przynajmniej jej rdzeń za pomocą CQRS (segregacja odpowiedzialności za zapytania), DDD (Domain Driven Design) i ewentualnie Sourcing zdarzeń. Następnie EF może być użyty jako fasada modelu do odczytu.

Pamiętaj również, że nie musisz trzymać się jednej strategii / wzoru dla całej aplikacji, niektóre obszary mogą być czystym CRUD, a inne mogą zawierać dużo logiki biznesowej ...