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.

Visual Studio: alterar o framework padrão para novos projetos

Introdução

Muitas vezes é preciso que todos os novos projetos já estejam em uma versão do .Net Framework específica, ou simplesmente, que já seja criado com o target na última versão disponível no Visual Studio.

Alterando a versão padrão

Abra o Visual Studio, clique em File, em seguida em New e por último em Project…

Anote a versão do .Net Framework que será a padrão para os novos projetos, como por exemplo “4.6.1”.

Pressione as teclas Win + R, em Abrir digite o comando regedit e clique em Ok.

A janela do Editor do Registro será exibida.

Localize a chave HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\14.0\NewProjectDialog, e edite a chave fxVersion para a versão do .Net Framework desejada.

Observação: onde está escrito 14.0, que equivale a versão do Visual Studio 2015, pode ser alterada para a versão do seu Visual Studio, como por exemplo, 13.0 para o 2013.

O Visual Studio 2017 não precisa desta configuração, pois ele lembra a última versão usada ao criar um projeto.

Pronto, agora todas os novos projetos serão automaticamente definido com a versão configurada por padrão.