¿En el Diseño Dirigido por Dominio cuando una entidad se clona a sí misma y lo agrega a su contenedor?

Question

Por ejemplo, tenemos dos objetos de dominio: Célula y Cuerpo (como en células y cuerpos humanos).

La clase Body es solo una colección de Celdas, p.

class Body 
{ 
    IList<Cell> cells; 
    public void AddCell(Cell c) { ... } 
    public void RemoveCell(Cell c) { ... } 
} 

La celda tiene un método de división, que internamente crea un clon de sí mismo, p.

Class Cell 
{ 
    public Cell Split() 
    { 
     Cell newCell = new Cell(); 
     // Copy this cell's properties into the new cell. 
     return Cell; 
    } 
} 

Ahora, en DDD cuando las divisiones celulares deben:

1. La célula añadir la celda recién creado para el Cuerpo (lo que significaría que cada objeto de la célula mantiene una referencia a su cuerpo que contiene)?
2. ¿O debería la capa de servicio que recibió la solicitud del usuario intitial llamar a Split, recoger la celda devuelta y agregarla al cuerpo? (se siente como un diseño más anémico usando controladores en lugar de objetos de dominio)
3. ¿O debería el cuerpo contener un método SplitCell?

Gracias de antemano.

Answer 1

Después de leer Domain Driven Design (Evans), parecería que este escenario es mejor tratado con el uso de service.

Answer 2

En DDD, a menudo depende de, bueno, el dominio. Aquí, el ejemplo, y por lo tanto el dominio, parece un poco extraño, pero creo que elegiría un método SplitCell en Body.

Aunque no es muy claro para mí qué significa la división de células, y qué debería desencadenar esta acción, supongo que el cuerpo es responsable de dividir sus celdas. Me sentiría más cómodo con un método Regenerate, o algo así, en el Body, que divide las células internas llamando al método Split en cada una de ellas.

Ok, este ejemplo es definitivamente extraño ...

Answer 3

pensaría que el cuerpo simplemente llamar a la splitCell() en la célula. Entonces el Cuerpo puede hacer lo que quiera con la nueva Célula: agregarse a sí misma, consumirla, tirarla, lo que sea. El cuerpo contiene la celda de todos modos.

Answer 4

Ok, otro enfoque sería enviar un evento al Cuerpo diciendo "me estoy separando" o lo que sea. Y el Cuerpo puede recoger la nueva Celda, tal vez como una carga de ese evento.

Si su actor externo no conoce el cuerpo, ¿el método Split debe devolver un nuevo clon de celda? ¿El actor externo va a usar esto de alguna manera? ¿O puede el método Split no devolver nada (Void) y simplemente enviar un mensaje al cuerpo en el que vive?

Answer 5

El uso de eventos en la clase Cell parece una solución natural, pero es más complicado de implementar en C#.

Tendrá que conectar eventos cuando Cells entren en el alcance, y también deberá desengancharlos cuando se salgan de alcance: de lo contrario, tendrá pérdidas de memoria.

También necesita conectar eventos cada vez que se vuelve a asociar una celda con un Body, es decir, cuando las células se recuperan de un almacén de persistencia. Usar un contenedor para administrar las relaciones (posiblemente un interceptor ORM) podría facilitar esto.

La alternativa más sencilla es mantener una referencia a los padres Body (células sólo pertenecen a un solo Body, ¿verdad?), Y dejar que el nuevo Cell sumarse a él es Body.

• Pros: Fácil de codificar, depurar, comprender.
• Contras: Celular y del cuerpo se vuelven fuertemente acoplado, haciéndolos más difíciles de reutilizar en otros contextos (que puede ser irrelevante)