Ho ereditato un'applicazione del sito Web ASP.NET e lo sviluppatore precedente ha usato quelli che credo siano alcuni concetti DDD. Sono nuovo di DDD e devo ammettere che sto lottando con il lato pratico di esso proveniente da uno sfondo di Transaction Script N-Tier.
Uno dei problemi con il sito è che è lento. Non esiste alcuna impaginazione su griglie enormi e anche il livello della logica di business estrae più dati di quanto sia necessario per il 90% delle operazioni il 70% delle quali viene letto per associare i dati alle griglie.
Il progetto generale prevede che il livello della logica aziendale abbia una classe di servizio per radice aggregata, con vari metodi di tipo "GetByX ()", "FindBestMatching ()" e "Update ()". da cui vengono creati alberi di oggetti di dominio come "Organizzazione" e "Utente".
Nei miei giorni di script di transazione, il mio livello di servizio era simile: ci sarebbe stata probabilmente una logica, una chiamata in un repository (o dall'uso diretto di EF 6 di EF come può essere deriso per il test) e poi la chiamata sarebbe tornato Gli oggetti che sono stati restituiti sarebbero oggetti di tipo DTO contenenti dati di ritorno rilevanti, inclusi eventualmente alcuni oggetti entità POCO. Questi DTO viaggiavano verso i clienti tramite i servizi Web, si collegavano alle griglie ASP.NET o Silverlight ... tutto andava bene.
Le mie operazioni sul mio livello di servizio potrebbero essere molto specifiche, consentendo query come:
"GetUsersWithSurnameIncludeChildren(string surname, int skip, int take)"
che consente di eseguire query DB strette e semplici che supportano il caricamento impaginato e ansioso dei dati correlati. È stato veloce e ha caricato solo i dati effettivamente necessari.
Ora con questo sito che ho ereditato esiste un vero modello OO del dominio aziendale. Queste classi sono POCO, non generate da EF, ma EF viene utilizzato prima come repository (esiste molta mappatura tra gli oggetti dominio e gli oggetti EF). Un oggetto dominio di esempio è sotto (senza alcuna logica).
public class Organisation
{
public int OrganisationID { get; set; }
public string Name { get; set; }
public IList<Organisation> AssociatedOrganisations { get; set; }
public IList<User> Staff { get; set; }
public IList<User> Managers { get; set; }
// Business logic method implemented below here
}
Molte delle classi sono essenzialmente copie degli oggetti del framework entità sottostante, altre hanno una quantità significativa di logica incapsulata al loro interno.
Il modo in cui il sito funziona attualmente è che ogni volta che la classe di servizio OrganisationService crea un nuovo oggetto di dominio Organizzazione (e può creare una raccolta in un colpo) popola anche TUTTI i campi e le raccolte in quell'oggetto ... e tutti i campi e le raccolte in quegli oggetti! Un enorme albero profondo viene creato in memoria e una pila di join e unioni (generate da EF) è necessaria per ottenere tutti i dati. Questo è totalmente inappropriato per un sito web che visualizza principalmente un sacco di griglie piatte.
Le mie domande sono:
1) Un'applicazione che esegue il 70% di estrazione dei dati da un DB per la visualizzazione e una logica di business del 30% è in realtà un cattivo candidato per il DDD?
2) Se il DDD è appropriato, come sono generalmente progettati scenari come questo? Dovrei implementare un "servizio di query" separato progettato per estrarre un sacco di dati flat per il binding a pagine e griglie (questi potrebbero essere solo gli EF POCOS) e riservare gli oggetti Dominio solo per parti dell'applicazione in cui la logica deve effettivamente eseguito?
3) Devo caricare solo i dati nei miei tipi di riferimento e insiemi di oggetti di dominio quando è effettivamente accessibile (come EF lazy loading ...)? I post precedenti che ho letto hanno suggerito che il caricamento lazy in un oggetto dominio è un odore di codice: DDD Lazy Loading Code Smell
Sto per comprare un libro DDD stasera:)