Come gestire una relazione molti a molti con un ORM mappato a un modello di dominio quando non ci sono vincoli tecnici?

1

Domain Driven Design afferma che dovresti avere un modello di dominio, che riflette il linguaggio ubiquitario usato dagli esperti del dominio. Quando si utilizzano gli ORM e molte e molte relazioni sono abituato a fare questo:

public class Student
{
    public Student() 
    {
        this.Courses = new HashSet<Course>();
    }

    public int StudentId { get; set; }
    [Required]
    public string StudentName { get; set; }

    public virtual ICollection<Course> Courses { get; set; }
}

public class Course
{
    public Course()
    {
        this.Students = new HashSet<Student>();
    }

    public int CourseId { get; set; }
    public string CourseName { get; set; }

    public virtual ICollection<Student> Students { get; set; }
}

Tuttavia, con EF Core è necessario creare una classe di partecipazione come descritto qui: link . Nel caso di quanto sopra; Dovrei creare una classe chiamata: StudentCourse.

Qual è il modo più appropriato per mappare un ORM a un modello di dominio assumendo che non vi siano vincoli tecnici come con EF Core se al momento si deve avere una classe di join? Il mio pensiero è:

1) Se la tabella di join ha stato e comportamento, utilizzare una classe join.

2) Se la tabella di join ha un nome riconosciuto dagli esperti del dominio, utilizzare una classe join, ad es. Una persona potrebbe avere diritto a prestiti: qui l'idoneità è la classe di partecipazione ed è un termine riconosciuto dal dominio. Nel caso di quanto sopra; StudentCourse non è riconosciuto dal dominio.

3) Altrimenti non utilizzare una classe di join (come nell'esempio sopra).

    
posta w0051977 28.11.2018 - 22:59
fonte

1 risposta

0

Il paradigma generale che DDD cerca di fornire è uno focalizzato sul comportamento del tuo sistema. Tutto il resto è un dettaglio di implementazione. Pertanto, non si modella il dominio in base a un meccanismo di persistenza specifico, piuttosto si modella il meccanismo di persistenza in base al dominio. Includere una sorta di oggetto "join" nel tuo dominio al fine di facilitare la persistenza su un RDBMS crea un accoppiamento non necessario e inquina / offusca il modello con problemi di persistenza.

Il problema specifico è causato dalla combinazione del modello dati richiesto da un ORM con il modello dominio richiesto dall'applicazione. Non esiste una soluzione DDD da impiegare qui oltre a disaccoppiare la prima da quest'ultima.

Gli ORM sono un ottimo strumento (meccanismo coesivo) per generare un modello dati necessariamente anemico (i metodi non possono essere serializzati all'interno della ragione) e mappatura da / a dati necessariamente anemici memorizzare. In altre parole, un ORM fornisce solo una maggiore esperienza OO per gli sviluppatori e offre un'astrazione (che perde) su un archivio dati. È tutto. Questo è l'obiettivo di ogni ORM (cosa significa di nuovo?).

Detto questo, ci sono due tipi di applicazioni:

La stragrande maggioranza dei sistemi è banale. Cioè, raccolgono e conservano semplicemente i dati per poi girarsi e mostrarli all'utente. Le applicazioni banali si riducono a CRUD con poche regole sparse qua e là per quanto riguarda (soprattutto) il formato / l'intervallo di dati inseriti. In tali sistemi di solito non è necessario isolare un modello di dominio (o isolarne solo piccole porzioni) perché ci sono così poche regole.

Il secondo tipo di applicazione è quello che beneficia veramente di un dominio isolato. È un'applicazione con molte regole aziendali. Spesso questo tipo di applicazione definisce molti tipi di oggetti che non sono affatto persistenti o che includono molti Aggregati. Questo rende l'isolamento di un dominio fondamentale. Il modello di dati di un ORM può solo fornire realmente i limiti di consistenza di un Aggregate attraverso la disciplina (non la struttura) perché tutte le Entità sono rese disponibili (e modificabili).

Indipendentemente dal fatto che tu abbia "visto" questo tipo di applicazione è fuori questione, e non invalida i principi fondamentali dell'architettura pulita. Ogni decisione è un compromesso. Un buon architetto di software lo capisce e si muove di conseguenza. Se i costi di creazione di un modello di dominio isolato non valgono i vantaggi, procedere di conseguenza. Ma capisci il trade off. Questo è il design dei sistemi: trovare il perfetto equilibrio tra preoccupazioni di business e preoccupazioni tecniche. Riguarda il pragmatismo. Lascia l'idealismo agli accademici e jr. sviluppatori e utilitarismo per i CEO. Siamo qui per fornire un equilibrio. Questo è il nostro valore.

    
risposta data 30.11.2018 - 17:59
fonte

Leggi altre domande sui tag