C# with Patterns: Domain Core

Há uma série de abordagens e padrões que podemos usar dentro de uma camada de domínio para que as informações sejam recebidas e enviadas para outras camadas de forma correta e eficaz, e para isso usamos padrões como Command, Events, Notification, Specification, etc.

Pensando desta forma, podemos usar uma abordagem que separe as classes e interfaces genéricas do domínio em um projeto central, chamado Domain Core, onde tudo que for genérico ou central deve estar aqui, sobrando para o projeto de domínio apenas as classes, interfaces e responsabilidades específicas das entidades e suas regras de negócio. Outra vantagem, é a reutilização de código, sendo que tudo que for genérico, estará neste projeto.

O exemplo a seguir não tem a intenção de mostrar um aplicativo funcionando com os padrões e abordagens necessárias para um projeto DDD em C#, mas apenas demonstrar com seria uma organização de códigos e suas responsabilidades dentro da proposta, além do mais, também pode ser considerado como uma sugestão e não como um modelo a ser seguido a risca. Portanto, o que tá em discussão não é necessariamente um modelo certo ou errado, mas apenas uma forma de organizar os arquivos do projeto e facilitar a implementação dirigida ao domínio.

Podemos dizer que o core é um núcleo compartilhado do domínio principal e subdomínios e talvez até de domínios genéricos.

Projeto Domain.Core

O projeto Core do domínio deve estar na mesma Solution folder do domínio, e se for um pacote ou DLL deverá ser referenciado pelo domínio. Para começar, siga os passos:

  1. Crie uma solução vazia chamada DomainCore,
  2. Adicione uma Solution folder chamada Domain
  3. Dentro de Domain adicione um projeto do tipo Class Library chamado DomainCore.Domain.Core,
  4. Na raiz do projeto, crie três pastas chamadas Interfaces, Entities e ValueObjects,
  5. Na pasta Interfaces, inclua duas subpastas chamadas Entities e ValueObjects,
  6. Remova todas as referências, para que o projeto esteja o mais limpo possível, e adicione mais tarde conforme for necessário.

Agora temos uma estrutura básica de um projeto base de domínio, ou seja, a aplicação deve parecer como a imagem a seguir:

O objetivo até aqui é manter uma arquitetura funcional e simples, apesar de haver sim alguma complexidade para que tenhamos uma arquitetura decente no início, mas deve facilitar a manutenção no futuro.

Projeto Domain

O projeto que é o domínio de fato deve estar na mesma Solution folder do domínio também, ele pode fazer referência ao core através de uma DLL ou instalação de pacote NuGet. Para montar a camada de domínio siga os passos:

  1. Dentro de Domain adicione um projeto do tipo Class Library chamado DomainCore.Domain,
  2. Na raiz do projeto, crie três pastas chamadas Interfaces, Entities e ValueObjects,
  3. Na pasta Interfaces, inclua duas subpastas chamadas Entities e ValueObjects,
  4. Remova todas as referências, para que o projeto esteja o mais limpo possível, e adicione mais tarde conforme for necessário.
  5. Adicione a referência para o projeto DomainCore.Domain.Core.

Agora temos uma estrutura para as entidades específicas de um projeto de domínio, a aplicação deve parecer como a imagem a seguir:

Interfaces e entidades bases

Vamos incluir os seguintes itens em DomainCore.Domain.Core:

  1. DomainCore.Domain.Core/Interfaces/Entities/IEntity.cs
  2. DomainCore.Domain.Core/Interfaces/ValueObjects/IValueObject.cs
  3. DomainCore.Domain.Core/Entities/Entity.cs
  4. DomainCore.Domain.Core/ValueObjects/ValueObject.cs

Vamos incluir os seguintes itens em DomainCore.Domain:

  • DomainCore.Domain/Interfaces/Entities/IPerson.cs
  • DomainCore.Domain/Interfaces/ValueObjects/IEmail.cs
  • DomainCore.Domain/Entities/Person.cs
  • DomainCore.Domain/ValueObjects/Email.cs

O projeto final deve parecer como este:

Uma organização simples, e que torna a camada de domínio mais limpa e isola os objetos genéricos e padrões para todas as entidades. Facilita também o reuso da arquitetura e correções que afetam muitos objetos.

Serve para abrir também uma discussão acerca da abordagem DDD, pois pode não haver um modelo ideal, mas podemos juntos encontrar caminhos para projetos mais profissionais e mais fáceis de escalar e manter.

O projeto completo pode ser baixado no GitHub em https://github.com/tiagopariz/DomainCore.

4 comentários sobre “C# with Patterns: Domain Core”

  1. Legal. Uma dúvida, você costuma criar mais algum nível de agrupamento, como por exemplo, por agregados e/ou bounded contexts?

    1. Mauro, boa questão!

      Na verdade, criar contextos vai depender do projeto, e se pensar em microservices, o ideal seria não inchar tanto a solução com bounded contexts que poderiam estar em seu próprio projeto e ser consumido como serviço pelo domínio principal. Porém, isso vai depender de uma certa viabilidade de negócio.

      O uso do Core Domain serve também para facilitar esta separação, caso ela necessário, deixando os projetos de domínio somente com a lógica relacionada às entidades, e ainda o Domain.Core pode até ser compilado um pacote NuGet.

    1. Esta estratégia pode ser expandida para as outras camadas, centralizando tudo que é compartilhado e genérico, deixando os projetos apenas com as regras de negócios do domínio.

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *