Arquitetura: camadas de serviços em Domain-Driven Design

Quando desenvolvemos usando a abordagem dirigida por modelos, é preciso entender as responsabilidades e local de cada camada, e entre todas as usadas, um tipo é responsável por chamar e expor de forma abstraída e funcional todas as regras de negócio do domínio, elas são chamadas de serviços.

Os serviços podem estar em alguns locais da arquitetura do software, conforme a necessidade e a função exercida para a solução. Segundo Eric Evans, em seu livro Domain-Driven Design, os serviços são divididos ao menos em três camadas:

Aplicativo – Serviço de mais externo

Digere as entradas, tais como requisições em txt, xml e Json,
Envia mensagens para o serviço de domínio para complementação
Espera a confirmação,
Decide enviar uma notificação através de um serviço de infraestrutura

Domínio – Regras de negócios

Interage com objetos necessários e dispara comportamentos
Fornece confirmações do resultado

Infraestrutura – Mensagens e outras comunicações externas

Envia mensagens
Recebe mensagens

Mas, sem mais delongas, montei uma aplicação bem simples para demonstrar a ideia. São três projetos: Domínio, aplicação e Infraestrutura de mensagens.

Primeiro, vamos criar, no projeto de domínio, uma entidade que representa uma pessoa.

using System;

namespace DDDServicesLayers.Domain.Entities
{
    public class Person
    {
        public Person(Guid id,
                      string name)
        {
            Id = id;
            Name = name;
        }

        public Guid Id { get; private set; }
        public string Name { get; private set; }
    }
}

using System;

namespace DDDServicesLayers.Domain.Entities

{

public class Person

{

public Person(Guid id,

string name)

{

Id = id;

Name = name;

}

public Guid Id { get; private set; }

public string Name { get; private set; }

}

Dentro do mesmo projeto de domínio, vamos adicionar o serviço que salva a pessoa.

using System;
using DDDServicesLayers.Domain.Entities;

namespace DDDServicesLayers.Domain.Services
{
    public class PersonService
    {
        public PersonService(Person person)
        {
            Person = person;
        }

        public Person Person { get; private set; }
        public bool Success { get; private set; }

        public void Save()
        {
            // Save person logic
            Success = true;
        }
    }
}

using System;

using DDDServicesLayers.Domain.Entities;

namespace DDDServicesLayers.Domain.Services

{

public class PersonService

{

public PersonService(Person person)

{

Person = person;

}

public Person Person { get; private set; }

public bool Success { get; private set; }

public void Save()

{

// Save person logic

Success = true;

}

No projeto de Infraestrutura, iremos adicionar o serviõ de envio de mensagens.

using System;

namespace DDDServicesLayers.Infra.Messages.MessageServices
{
    public class EmailService
    {
        public EmailService(string to,
                            string subject,
                            string body)
        {
            To = to;
            Subject = subject;
            Body = body;
        }

        public string To { get; private set; }
        public string Subject { get; private set; }
        public string Body { get; private set; }
        public bool Success { get; private set; }

        public void Send()
        {
            // Send e-mail
            Success = true;
        }
    }
}

using System;

namespace DDDServicesLayers.Infra.Messages.MessageServices

{

public class EmailService

{

public EmailService(string to,

string subject,

string body)

{

To = to;

Subject = subject;

Body = body;

}

public string To { get; private set; }

public string Subject { get; private set; }

public string Body { get; private set; }

public bool Success { get; private set; }

public void Send()

{

// Send e-mail

Success = true;

}

E por fim, vamos adicionar o serviço na camada de aplicação.

using System;
using DDDServicesLayers.Domain.Entities;
using DDDServicesLayers.Domain.Services;
using DDDServicesLayers.Infra.Messages.MessageServices;

namespace DDDServicesLayers.Application.AppServices
{
    public class PersonAppService
    {
        private readonly Person _person; 
        public PersonAppService(string name)
        {
            _person = new Person(Guid.NewGuid(), name);
        }

        public void Save()
        {
            var personServiceSave = new PersonService(_person);
            personServiceSave.Save();

            if (personServiceSave.Success)
            {
                var emailService = new EmailService("test@mail.com", "Confirm", "Register saved.");
                emailService.Send();
            }
        }
    }
}

using System;

using DDDServicesLayers.Domain.Entities;

using DDDServicesLayers.Domain.Services;

using DDDServicesLayers.Infra.Messages.MessageServices;

namespace DDDServicesLayers.Application.AppServices

{

public class PersonAppService

{

private readonly Person _person;

public PersonAppService(string name)

{

_person = new Person(Guid.NewGuid(), name);

}

public void Save()

{

var personServiceSave = new PersonService(_person);

personServiceSave.Save();

if (personServiceSave.Success)

{

var emailService = new EmailService("test@mail.com", "Confirm", "Register saved.");

emailService.Send();

}

Este projeto está disponível no meu GitHub no endereço a seguir:

https://github.com/tiagopariz/DDDServicesLayers

C# with Patterns: Specification

Muitas vezes precisamos abstrair características complexas, tentando simplificar uma consulta Linq para um campo que retorne apenas true ou false, pois isto é muito útil, principalmente quando usamos Entity Framework. O padrão de comportamento especificação busca tornar características, que muitas vezes complexas, em algo mais simples, legível, reusável e de fácil manutenção, com uma abordagem mais elegante.

Além de auxiliar na criação de consulta, Specification pode ser bastante útil em validações, onde uma entidade de domínio precise checar uma série de informações e retornar se ela satisfaz um cenário válido para alguma finalidade específica ou até mesmo persistir os dados no banco. Em resumo, Specification é a união de regras de negócios e expressões boolianas.

Projeto de exemplo

O projeto de exemplo mostra dois usos da abordagem: uma para definir entidades com características específicas e outra para validar entidades, que pode usado juntamente com notificações e eventos. Para isso crie uma solução chamada Specification, e adicione um projeto do tipo Class Library, chamado Specification.Domain.

A interface ISpecification<T> que define o contrato de implementação do método IsSatisfiedBy() e que recebe a especificação baseada em regras de negócio, que são geradas a partir dos métodos And(), AndNot(), Or(), OrNot() e Not() ou uma expresão Linq.

namespace Specification.Domain.Interfaces.Specifications
{
    public interface ISpecification<T>
    {
        bool IsSatisfiedBy(T candidate);
        ISpecification<T> And(ISpecification<T> specification);
        ISpecification<T> AndNot(ISpecification<T> specification);
        ISpecification<T> Or(ISpecification<T> specification);
        ISpecification<T> OrNot(ISpecification<T> specification);
        ISpecification<T> Not(ISpecification<T> specification);
    }
}

namespace Specification.Domain.Interfaces.Specifications

{

public interface ISpecification<T>

{

bool IsSatisfiedBy(T candidate);

ISpecification<T> And(ISpecification<T> specification);

ISpecification<T> AndNot(ISpecification<T> specification);

ISpecification<T> Or(ISpecification<T> specification);

ISpecification<T> OrNot(ISpecification<T> specification);

ISpecification<T> Not(ISpecification<T> specification);

}

Crie uma pasta chamada Specifications no projeto de domínio, e dentro dela inclua a classe CompositeSpecification, que será a base para as especificações, implementando todos os métodos da interface anterior.

using Specification.Domain.Interfaces.Specifications;

namespace Specification.Domain.Specifications
{
    public abstract class CompositeSpecification<T> : ISpecification<T>
    {
        public abstract bool IsSatisfiedBy(T candidate);
        public ISpecification<T> And(ISpecification<T> specification) => 
            new AndSpecification<T>(this, specification);
        public ISpecification<T> AndNot(ISpecification<T> specification) => 
            new AndNotSpecification<T>(this, specification);
        public ISpecification<T> Or(ISpecification<T> specification) =>
            new OrSpecification<T>(this, specification);
        public ISpecification<T> OrNot(ISpecification<T> specification) =>
            new OrNotSpecification<T>(this, specification);
        public ISpecification<T> Not(ISpecification<T> specification) =>
            new NotSpecification<T>(specification);
    }
}

using Specification.Domain.Interfaces.Specifications;

namespace Specification.Domain.Specifications

{

public abstract class CompositeSpecification<T> : ISpecification<T>

{

public abstract bool IsSatisfiedBy(T candidate);

public ISpecification<T> And(ISpecification<T> specification) =>

new AndSpecification<T>(this, specification);

public ISpecification<T> AndNot(ISpecification<T> specification) =>

new AndNotSpecification<T>(this, specification);

public ISpecification<T> Or(ISpecification<T> specification) =>

new OrSpecification<T>(this, specification);

public ISpecification<T> OrNot(ISpecification<T> specification) =>

new OrNotSpecification<T>(this, specification);

public ISpecification<T> Not(ISpecification<T> specification) =>

new NotSpecification<T>(specification);

}

Com a classe base criada, podemos criar as classes de operadores para definir a regra de negócio, que irá retornar uma resposta true ou false. Para isso, adicione as classes a seguir na pasta Specifications:

using Specification.Domain.Interfaces.Specifications;

namespace Specification.Domain.Specifications
{
    public class AndSpecification<T> : CompositeSpecification<T>
    {
        private readonly ISpecification<T> _leftSpecification;
        private readonly ISpecification<T> _rightSpecification;

        public AndSpecification(ISpecification<T> left, ISpecification<T> right)
        {
            _leftSpecification = left;
            _rightSpecification = right;
        }

        public override bool IsSatisfiedBy(T candidate) =>
            _leftSpecification.IsSatisfiedBy(candidate) &&
            _rightSpecification.IsSatisfiedBy(candidate);
    }
}

using Specification.Domain.Interfaces.Specifications;

namespace Specification.Domain.Specifications

{

public class AndSpecification<T> : CompositeSpecification<T>

{

private readonly ISpecification<T> _leftSpecification;

private readonly ISpecification<T> _rightSpecification;

public AndSpecification(ISpecification<T> left, ISpecification<T> right)

{

_leftSpecification = left;

_rightSpecification = right;

}

public override bool IsSatisfiedBy(T candidate) =>

_leftSpecification.IsSatisfiedBy(candidate) &&

_rightSpecification.IsSatisfiedBy(candidate);

}

using Specification.Domain.Interfaces.Specifications;

namespace Specification.Domain.Specifications
{
    public class AndNotSpecification<T> : CompositeSpecification<T>
    {
        private readonly ISpecification<T> _leftSpecification;
        private readonly ISpecification<T> _rightSpecification;

        public AndNotSpecification(ISpecification<T> left, 
            ISpecification<T> right)
        {
            _leftSpecification = left;
            _rightSpecification = right;
        }

        public override bool IsSatisfiedBy(T candidate) => 
            (_leftSpecification.IsSatisfiedBy(candidate) && 
             _rightSpecification.IsSatisfiedBy(candidate)) != true;
    }
}

using Specification.Domain.Interfaces.Specifications;

namespace Specification.Domain.Specifications

{

public class AndNotSpecification<T> : CompositeSpecification<T>

{

private readonly ISpecification<T> _leftSpecification;

private readonly ISpecification<T> _rightSpecification;

public AndNotSpecification(ISpecification<T> left,

ISpecification<T> right)

{

_leftSpecification = left;

_rightSpecification = right;

}

public override bool IsSatisfiedBy(T candidate) =>

(_leftSpecification.IsSatisfiedBy(candidate) &&

_rightSpecification.IsSatisfiedBy(candidate)) != true;

}

using Specification.Domain.Interfaces.Specifications;

namespace Specification.Domain.Specifications
{
    public class OrSpecification<T> : CompositeSpecification<T>
    {
        private readonly ISpecification<T> _leftSpecification;
        private readonly ISpecification<T> _rightSpecification;

        public OrSpecification(ISpecification<T> left, ISpecification<T> right)
        {
            _leftSpecification = left;
            _rightSpecification = right;
        }

        public override bool IsSatisfiedBy(T candidate)
        {
            return _leftSpecification.IsSatisfiedBy(candidate) ||
                   _rightSpecification.IsSatisfiedBy(candidate);
        }
    }
}

using Specification.Domain.Interfaces.Specifications;

namespace Specification.Domain.Specifications

{

public class OrSpecification<T> : CompositeSpecification<T>

{

private readonly ISpecification<T> _leftSpecification;

private readonly ISpecification<T> _rightSpecification;

public OrSpecification(ISpecification<T> left, ISpecification<T> right)

{

_leftSpecification = left;

_rightSpecification = right;

}

public override bool IsSatisfiedBy(T candidate)

{

return _leftSpecification.IsSatisfiedBy(candidate) ||

_rightSpecification.IsSatisfiedBy(candidate);

}

using Specification.Domain.Interfaces.Specifications;

namespace Specification.Domain.Specifications
{
    public class OrNotSpecification<T> : CompositeSpecification<T>
    {
        private readonly ISpecification<T> _leftSpecification;
        private readonly ISpecification<T> _rightSpecification;

        public OrNotSpecification(ISpecification<T> left, ISpecification<T> right)
        {
            _leftSpecification = left;
            _rightSpecification = right;
        }

        public override bool IsSatisfiedBy(T candidate) =>
            (_leftSpecification.IsSatisfiedBy(candidate) ||
             _rightSpecification.IsSatisfiedBy(candidate)) != true;
    }
}

using Specification.Domain.Interfaces.Specifications;

namespace Specification.Domain.Specifications

{

public class OrNotSpecification<T> : CompositeSpecification<T>

{

private readonly ISpecification<T> _leftSpecification;

private readonly ISpecification<T> _rightSpecification;

public OrNotSpecification(ISpecification<T> left, ISpecification<T> right)

{

_leftSpecification = left;

_rightSpecification = right;

}

public override bool IsSatisfiedBy(T candidate) =>

(_leftSpecification.IsSatisfiedBy(candidate) ||

_rightSpecification.IsSatisfiedBy(candidate)) != true;

}

using Specification.Domain.Interfaces.Specifications;

namespace Specification.Domain.Specifications
{
    public class NotSpecification<T> : CompositeSpecification<T>
    {
        private readonly ISpecification<T> _notSpecification;

        public NotSpecification(ISpecification<T> not)
        {
            _notSpecification = not;
        }

        public override bool IsSatisfiedBy(T candidate) =>
            !_notSpecification.IsSatisfiedBy(candidate);
    }
}

using Specification.Domain.Interfaces.Specifications;

namespace Specification.Domain.Specifications

{

public class NotSpecification<T> : CompositeSpecification<T>

{

private readonly ISpecification<T> _notSpecification;

public NotSpecification(ISpecification<T> not)

{

_notSpecification = not;

}

public override bool IsSatisfiedBy(T candidate) =>

!_notSpecification.IsSatisfiedBy(candidate);

}

using System;

namespace Specification.Domain.Specifications
{
    public class ExpressionSpecification<T> : CompositeSpecification<T>
    {
        private readonly Func<T, bool> _expression;

        public ExpressionSpecification(Func<T, bool> expression)
        {
            if (expression == null)
                throw new ArgumentException();

            _expression = expression;
        }

        public override bool IsSatisfiedBy(T candidate) =>
            _expression(candidate);
    }
}

using System;

namespace Specification.Domain.Specifications

{

public class ExpressionSpecification<T> : CompositeSpecification<T>

{

private readonly Func<T, bool> _expression;

public ExpressionSpecification(Func<T, bool> expression)

{

if (expression == null)

throw new ArgumentException();

_expression = expression;

}

public override bool IsSatisfiedBy(T candidate) =>

_expression(candidate);

}

No projeto de domínio, crie duas pastas chamada Entities e ValueObjects. E em ValueObjects inclua uma classe base para os objetos de valor chamada ValueObject e dentro de Entities inclua uma classe base para as entidades chamada Entity. Estas duas classes terão as propriedades e métodos básicos para as especificações de validação e uma função IsValid que retornará true se os dados preenchidos atenderem os requisitos.

using Specification.Domain.Specifications;

namespace Specification.Domain.ValueObjects
{
    public abstract class ValueObject
    {
        protected CompositeSpecification<object> ValidSpecification = null;

        public bool IsValid()
        {
            return ValidSpecification?.IsSatisfiedBy(this) ?? true;
        }
    }
}

using Specification.Domain.Specifications;

namespace Specification.Domain.ValueObjects

{

public abstract class ValueObject

{

protected CompositeSpecification<object> ValidSpecification = null;

public bool IsValid()

{

return ValidSpecification?.IsSatisfiedBy(this) ?? true;

}

using Specification.Domain.Specifications;

namespace Specification.Domain.Entities
{
    public abstract class Entity
    {
        protected CompositeSpecification<object> ValidSpecification = null;

        public bool IsValid()
        {
            return ValidSpecification?.IsSatisfiedBy(this) ?? true;
        }
    }
}

using Specification.Domain.Specifications;

namespace Specification.Domain.Entities

{

public abstract class Entity

{

protected CompositeSpecification<object> ValidSpecification = null;

public bool IsValid()

{

return ValidSpecification?.IsSatisfiedBy(this) ?? true;

}

Na pasta ValueObjects teremos uma classe de Email que herda de ValueObject, e na pasta de Entities as classes Category e Person e ambas herdam de Entity.

using Specification.Domain.Specifications.ValueObjects;

namespace Specification.Domain.ValueObjects
{
    public class Email : ValueObject
    {
        public const int AddressMinLength = 3;
        public const int AddressMaxLength = 255;

        public Email(string address)
        {
            Address = address;
            ValidSpecification = new EmailValidSpecification<object>();
        }

        public string Address { get; }

        public override string ToString() => Address;
    }
}

using Specification.Domain.Specifications.ValueObjects;

namespace Specification.Domain.ValueObjects

{

public class Email : ValueObject

{

public const int AddressMinLength = 3;

public const int AddressMaxLength = 255;

public Email(string address)

{

Address = address;

ValidSpecification = new EmailValidSpecification<object>();

}

public string Address { get; }

public override string ToString() => Address;

}

namespace Specification.Domain.Entities
{
    public class Category : Entity
    {
        public const int DescriptionMinLength = 1;
        public const int DescriptionMaxLength = 20;

        public Category(int categoryId, string description)
        {
            CategoryId = categoryId;
            Description = description;
        }

        public int CategoryId { get; }
        public string Description { get; }
    }
}

namespace Specification.Domain.Entities

{

public class Category : Entity

{

public const int DescriptionMinLength = 1;

public const int DescriptionMaxLength = 20;

public Category(int categoryId, string description)

{

CategoryId = categoryId;

Description = description;

}

public int CategoryId { get; }

public string Description { get; }

}

using System;
using Specification.Domain.Specifications.Entities;
using Specification.Domain.ValueObjects;

namespace Specification.Domain.Entities
{
    public class Person : Entity
    {
        public const int NameMinLength = 2;
        public const int NameMaxLength = 50;

        public Person(Guid personId, string name, Email email, Category category)
        {
            PersonId = personId;
            Name = name;
            Email = email;
            Category = category;
            ValidSpecification = new PersonValidSpecification<object>();
        }

        public Guid PersonId { get;}
        public string Name { get; }
        public Email Email { get; }
        public Category Category { get; }
    }
}

using System;

using Specification.Domain.Specifications.Entities;

using Specification.Domain.ValueObjects;

namespace Specification.Domain.Entities

{

public class Person : Entity

{

public const int NameMinLength = 2;

public const int NameMaxLength = 50;

public Person(Guid personId, string name, Email email, Category category)

{

PersonId = personId;

Name = name;

Email = email;

Category = category;

ValidSpecification = new PersonValidSpecification<object>();

}

public Guid PersonId { get;}

public string Name { get; }

public Email Email { get; }

public Category Category { get; }

}

Neste ponto, a propriedade ValidSpecification ainda não possui suas especificaçãos que validam pessoa e o e-mail, e para isso temos que criar as classes com as regras de negócio.

Entre na pasta Specification, e dentro dela crie uma pasta chamada ValueObjects e neste diretório inclua uma classe chamada EmailValidSpecification que herda de CompositeSpecification.

using System.Text.RegularExpressions;
using Specification.Domain.ValueObjects;

namespace Specification.Domain.Specifications.ValueObjects
{
    public class EmailValidSpecification<T> : CompositeSpecification<T>
    {
        private readonly bool _required;

        public EmailValidSpecification(bool required = false)
        {
            _required = required;
        }

        public override bool IsSatisfiedBy(T candidate)
        {
            var email = candidate as Email;

            if (string.IsNullOrEmpty(email?.Address) && !_required)
                return true;

            if ((email?.Address ?? "").Length < Email.AddressMinLength)
                return false;

            if ((email?.Address ?? "").Length > Email.AddressMaxLength)
                return false;

            const string pattern = @"^\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$";
            return Regex.IsMatch(email?.Address ?? "", pattern);
        }
    }
}

using System.Text.RegularExpressions;

using Specification.Domain.ValueObjects;

namespace Specification.Domain.Specifications.ValueObjects

{

public class EmailValidSpecification<T> : CompositeSpecification<T>

{

private readonly bool _required;

public EmailValidSpecification(bool required = false)

{

_required = required;

}

public override bool IsSatisfiedBy(T candidate)

{

var email = candidate as Email;

if (string.IsNullOrEmpty(email?.Address) && !_required)

return true;

if ((email?.Address ?? "").Length < Email.AddressMinLength)

return false;

if ((email?.Address ?? "").Length > Email.AddressMaxLength)

return false;

const string pattern = @"^\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$";

return Regex.IsMatch(email?.Address ?? "", pattern);

}

Na pasta Entities de Specification, inclua uma classe chamada PersonNameValidSpecification, que irá validar o nome da pessoa.

using Specification.Domain.Entities;

namespace Specification.Domain.Specifications.Entities
{
    public class PersonNameValidSpecification<T> : CompositeSpecification<T>
    {
        private readonly bool _required;

        public PersonNameValidSpecification(bool required = false)
        {
            _required = required;
        }

        public override bool IsSatisfiedBy(T candidate)
        {
            var person = candidate as Person;

            if (string.IsNullOrEmpty(person?.Name) && !_required)
                return true;

            if ((person?.Name ?? "").Length < Person.NameMinLength)
                return false;

            if ((person?.Name ?? "").Length > Person.NameMaxLength)
                return false;

            return true;
        }
    }
}

using Specification.Domain.Entities;

namespace Specification.Domain.Specifications.Entities

{

public class PersonNameValidSpecification<T> : CompositeSpecification<T>

{

private readonly bool _required;

public PersonNameValidSpecification(bool required = false)

{

_required = required;

}

public override bool IsSatisfiedBy(T candidate)

{

var person = candidate as Person;

if (string.IsNullOrEmpty(person?.Name) && !_required)

return true;

if ((person?.Name ?? "").Length < Person.NameMinLength)

return false;

if ((person?.Name ?? "").Length > Person.NameMaxLength)

return false;

return true;

}

Com as especificação de validação de e-mail e de nome prontas, podemos adicionar uma especificação que irá validar a pessoa como um todo, e para isso inclua uma classe chamada PersonValidSpecification na pasta Entities de Specifications.

using Specification.Domain.Entities;
using Specification.Domain.Specifications.ValueObjects;
using Specification.Domain.ValueObjects;

namespace Specification.Domain.Specifications.Entities
{
    public class PersonValidSpecification<T> : CompositeSpecification<T>
    {
        public override bool IsSatisfiedBy(T candidate)
        {
            var person = candidate as Person;

            var personNameSpecification = new PersonNameValidSpecification<Person>(true);
            if (!personNameSpecification.IsSatisfiedBy(person))
                return false;

            var emailSpecification = new EmailValidSpecification<Email>();
            if (!emailSpecification.IsSatisfiedBy(person?.Email))
                return false;

            return true;
        }
    }
}

using Specification.Domain.Entities;

using Specification.Domain.Specifications.ValueObjects;

using Specification.Domain.ValueObjects;

namespace Specification.Domain.Specifications.Entities

{

public class PersonValidSpecification<T> : CompositeSpecification<T>

{

public override bool IsSatisfiedBy(T candidate)

{

var person = candidate as Person;

var personNameSpecification = new PersonNameValidSpecification<Person>(true);

if (!personNameSpecification.IsSatisfiedBy(person))

return false;

var emailSpecification = new EmailValidSpecification<Email>();

if (!emailSpecification.IsSatisfiedBy(person?.Email))

return false;

return true;

}

Ainda temos um especificação para definir se uma pessoa é cliente, que pode ser usada em filtros de listas baseadas em Linq, portanto inclua o objeto PersonCustomerSpecification na pasta Entities de Specifications.

using Specification.Domain.Entities;

namespace Specification.Domain.Specifications.Entities
{
    public class PersonCustomerSpecification<T> : CompositeSpecification<T>
    {
        private readonly int _categoryId;

        public PersonCustomerSpecification()
        {
            _categoryId = 1;
        }

        public override bool IsSatisfiedBy(T candidate)
        {
            var person = candidate as Person;
            return person != null && person.Category?.CategoryId == _categoryId;
        }
    }
}

using Specification.Domain.Entities;

namespace Specification.Domain.Specifications.Entities

{

public class PersonCustomerSpecification<T> : CompositeSpecification<T>

{

private readonly int _categoryId;

public PersonCustomerSpecification()

{

_categoryId = 1;

}

public override bool IsSatisfiedBy(T candidate)

{

var person = candidate as Person;

return person != null && person.Category?.CategoryId == _categoryId;

}

Projeto de Apresentação

Crie um projeto do tipo Class Library, chamado Specification.Domain, para que, via console, testarmos algumas formas de usar as especificações. E então, no método Main da classe Program, crie uma lista de pessoas através de uma variável do tipo List.

(...)

// Person list
var people = new List<Person> {
    new Person(Guid.NewGuid(), "Jacob 1", new Email("jacob1@gmail.com"), new Category(2, "Partner")),
    new Person(Guid.NewGuid(), "Jacob 2", new Email("jacob2@gmail.com"), new Category(1, "Customer")),
    new Person(Guid.NewGuid(), "Jacob 3", new Email("jacob3@gmail.com"), new Category(2, "Partner")),
    new Person(Guid.NewGuid(), "Jacob 4", new Email("jacob4_gmail.com"), new Category(1, "Customer")),
    new Person(Guid.NewGuid(), "Jacob 5", new Email("jacob5@gmail.com"), new Category(1, "Customer")),
    new Person(Guid.NewGuid(), "Jacob 6", new Email("jacob6@gmail.com"), new Category(1, "Customer")),
    new Person(Guid.NewGuid(), "Jacob 7", new Email("jacob7@gmail.com"), null) };

Console.WriteLine(":: ALL PEOPLE ::");

foreach (var item in people)
{
    Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);
}

(...)

(...)

// Person list

var people = new List<Person> {

new Person(Guid.NewGuid(), "Jacob 1", new Email("jacob1@gmail.com"), new Category(2, "Partner")),

new Person(Guid.NewGuid(), "Jacob 2", new Email("jacob2@gmail.com"), new Category(1, "Customer")),

new Person(Guid.NewGuid(), "Jacob 3", new Email("jacob3@gmail.com"), new Category(2, "Partner")),

new Person(Guid.NewGuid(), "Jacob 4", new Email("jacob4_gmail.com"), new Category(1, "Customer")),

new Person(Guid.NewGuid(), "Jacob 5", new Email("jacob5@gmail.com"), new Category(1, "Customer")),

new Person(Guid.NewGuid(), "Jacob 6", new Email("jacob6@gmail.com"), new Category(1, "Customer")),

new Person(Guid.NewGuid(), "Jacob 7", new Email("jacob7@gmail.com"), null) };

Console.WriteLine(":: ALL PEOPLE ::");

foreach (var item in people)

{

Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);

}

(...)

A seguir vamos listar apenas os clientes, usando a especificação PersonCustomerSpecification.

(...)

Console.WriteLine("");
Console.WriteLine(":: CUSTOMER ::");

ISpecification<Person> personCustomersSpecification = new PersonCustomerSpecification<Person>();

var customer = people.FindAll(x => personCustomersSpecification.IsSatisfiedBy(x));

foreach (var item in customer)
{
    Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);
}

(...)

(...)

Console.WriteLine("");

Console.WriteLine(":: CUSTOMER ::");

ISpecification<Person> personCustomersSpecification = new PersonCustomerSpecification<Person>();

var customer = people.FindAll(x => personCustomersSpecification.IsSatisfiedBy(x));

foreach (var item in customer)

{

Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);

}

(...)

Neste outro exemplo, retornarmos todas as pessoas que são parceiras, usando uma expressão Linq:

(...)

Console.WriteLine("");
Console.WriteLine(":: PARTNER ::");

ISpecification<Person> partnerSpecification = new ExpressionSpecification<Person>(x => x.Category?.CategoryId == 2);

var partners = people.FindAll(x => partnerSpecification.IsSatisfiedBy(x));

foreach (var item in partners)
{
    Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);
}

(...)

(...)

Console.WriteLine("");

Console.WriteLine(":: PARTNER ::");

ISpecification<Person> partnerSpecification = new ExpressionSpecification<Person>(x => x.Category?.CategoryId == 2);

var partners = people.FindAll(x => partnerSpecification.IsSatisfiedBy(x));

foreach (var item in partners)

{

Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);

}

(...)

A seguir é usada uma especificação que filtra apenas entidades válidas usando a especificação pronta, mas esta operação pode ser feita também chamando o método IsValid da própria entidade.

(...)

Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("");
Console.WriteLine(":: ALL VALID ::");

ISpecification<Person> validSpecification = new PersonValidSpecification<Person>();

var validPeople = people.Where(x => validSpecification.IsSatisfiedBy(x));

foreach (var item in validPeople)
{
    Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);
}

(...)

(...)

Console.ForegroundColor = ConsoleColor.Green;

Console.WriteLine("");

Console.WriteLine(":: ALL VALID ::");

ISpecification<Person> validSpecification = new PersonValidSpecification<Person>();

var validPeople = people.Where(x => validSpecification.IsSatisfiedBy(x));

foreach (var item in validPeople)

{

Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);

}

(...)

Toda a classe Program pode ser vista a seguir, com outros exemplos:

using System;
using System.Collections.Generic;
using System.Linq;
using Specification.Domain.Entities;
using Specification.Domain.Interfaces.Specifications;
using Specification.Domain.Specifications;
using Specification.Domain.Specifications.Entities;
using Specification.Domain.ValueObjects;

namespace Specification.Prompt
{
    internal class Program
    {
        public static void Main(string[] args)
        {
            // Person list
            var people = new List<Person> {
                new Person(Guid.NewGuid(), "Jacob 1", new Email("jacob1@gmail.com"), new Category(2, "Partner")),
                new Person(Guid.NewGuid(), "Jacob 2", new Email("jacob2@gmail.com"), new Category(1, "Customer")),
                new Person(Guid.NewGuid(), "Jacob 3", new Email("jacob3@gmail.com"), new Category(2, "Partner")),
                new Person(Guid.NewGuid(), "Jacob 4", new Email("jacob4_gmail.com"), new Category(1, "Customer")),
                new Person(Guid.NewGuid(), "Jacob 5", new Email("jacob5@gmail.com"), new Category(1, "Customer")),
                new Person(Guid.NewGuid(), "Jacob 6", new Email("jacob6@gmail.com"), new Category(1, "Customer")),
                new Person(Guid.NewGuid(), "Jacob 7", new Email("jacob7@gmail.com"), null) };

            Console.WriteLine(":: ALL PEOPLE ::");

            foreach (var item in people)
            {
                Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);
            }

            // Specifications usages

            Console.WriteLine("");
            Console.WriteLine(":: CUSTOMER ::");

            ISpecification<Person> personCustomersSpecification = new PersonCustomerSpecification<Person>();

            var customer = people.FindAll(x => personCustomersSpecification.IsSatisfiedBy(x));

            foreach (var item in customer)
            {
                Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);
            }

            Console.WriteLine("");
            Console.WriteLine(":: PARTNER ::");

            ISpecification<Person> partnerSpecification = new ExpressionSpecification<Person>(x => x.Category?.CategoryId == 2);

            var partners = people.FindAll(x => partnerSpecification.IsSatisfiedBy(x));

            foreach (var item in partners)
            {
                Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);
            }

            Console.WriteLine("");
            Console.WriteLine(":: WITHOUT CATEGORY ::");

            ISpecification<Person> nullSpecification = new ExpressionSpecification<Person>(x => x.Category == null);

            var nullCategory = people.FindAll(x => nullSpecification.IsSatisfiedBy(x));

            foreach (var item in nullCategory)
            {
                Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);
            }

            Console.WriteLine("");
            Console.WriteLine(":: WITH AND WITHOUT CATEGORY ::");

            ISpecification<Person> customersSpecification = new ExpressionSpecification<Person>(x => x.Category?.CategoryId == 1);
            var allWithCategorySpecification = customersSpecification.Or(partnerSpecification);
            var includeNull = allWithCategorySpecification.Or(nullSpecification);

            var allAndNullCategory = people.FindAll(x => includeNull.IsSatisfiedBy(x));

            foreach (var item in allAndNullCategory)
            {
                Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);
            }

            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("");
            Console.WriteLine(":: ALL VALID ::");

            ISpecification<Person> validSpecification = new PersonValidSpecification<Person>();

            var validPeople = people.Where(x => validSpecification.IsSatisfiedBy(x));

            foreach (var item in validPeople)
            {
                Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);
            }

            Console.ForegroundColor = ConsoleColor.Magenta;
            Console.WriteLine("");
            Console.WriteLine(":: VALID CUSTOMERS ::");

            var validCustomers = people.Where(x => validSpecification.IsSatisfiedBy(x) && customersSpecification.IsSatisfiedBy(x));

            foreach (var item in validCustomers)
            {
                Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);
            }

            Console.ForegroundColor = ConsoleColor.White;
            Console.WriteLine("");
            Console.WriteLine(":: VALID PARTNERS ::");

            var validPartners = people.Where(x => validSpecification.IsSatisfiedBy(x) && partnerSpecification.IsSatisfiedBy(x));

            foreach (var item in validPartners)
            {
                Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);
            }

            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("");
            Console.WriteLine(":: INVALID ::");

            var invalidPeople = people.Where(x => !validSpecification.IsSatisfiedBy(x));

            foreach (var item in invalidPeople)
            {
                Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);
            }

            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.WriteLine("");
            Console.WriteLine(":: ISVALID ::");

            var isvalidPeople = people.Where(x => x.IsValid());

            foreach (var item in isvalidPeople)
            {
                Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);
            }

            Console.ReadKey();
        }
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

using System;

using System.Collections.Generic;

using System.Linq;

using Specification.Domain.Entities;

using Specification.Domain.Interfaces.Specifications;

using Specification.Domain.Specifications;

using Specification.Domain.Specifications.Entities;

using Specification.Domain.ValueObjects;

namespace Specification.Prompt

{

internal class Program

{

public static void Main(string[] args)

{

// Person list

var people = new List<Person> {

new Person(Guid.NewGuid(), "Jacob 1", new Email("jacob1@gmail.com"), new Category(2, "Partner")),

new Person(Guid.NewGuid(), "Jacob 2", new Email("jacob2@gmail.com"), new Category(1, "Customer")),

new Person(Guid.NewGuid(), "Jacob 3", new Email("jacob3@gmail.com"), new Category(2, "Partner")),

new Person(Guid.NewGuid(), "Jacob 4", new Email("jacob4_gmail.com"), new Category(1, "Customer")),

new Person(Guid.NewGuid(), "Jacob 5", new Email("jacob5@gmail.com"), new Category(1, "Customer")),

new Person(Guid.NewGuid(), "Jacob 6", new Email("jacob6@gmail.com"), new Category(1, "Customer")),

new Person(Guid.NewGuid(), "Jacob 7", new Email("jacob7@gmail.com"), null) };

Console.WriteLine(":: ALL PEOPLE ::");

foreach (var item in people)

{

Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);

}

// Specifications usages

Console.WriteLine("");

Console.WriteLine(":: CUSTOMER ::");

ISpecification<Person> personCustomersSpecification = new PersonCustomerSpecification<Person>();

var customer = people.FindAll(x => personCustomersSpecification.IsSatisfiedBy(x));

foreach (var item in customer)

{

Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);

}

Console.WriteLine("");

Console.WriteLine(":: PARTNER ::");

ISpecification<Person> partnerSpecification = new ExpressionSpecification<Person>(x => x.Category?.CategoryId == 2);

var partners = people.FindAll(x => partnerSpecification.IsSatisfiedBy(x));

foreach (var item in partners)

{

Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);

}

Console.WriteLine("");

Console.WriteLine(":: WITHOUT CATEGORY ::");

ISpecification<Person> nullSpecification = new ExpressionSpecification<Person>(x => x.Category == null);

var nullCategory = people.FindAll(x => nullSpecification.IsSatisfiedBy(x));

foreach (var item in nullCategory)

{

Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);

}

Console.WriteLine("");

Console.WriteLine(":: WITH AND WITHOUT CATEGORY ::");

ISpecification<Person> customersSpecification = new ExpressionSpecification<Person>(x => x.Category?.CategoryId == 1);

var allWithCategorySpecification = customersSpecification.Or(partnerSpecification);

var includeNull = allWithCategorySpecification.Or(nullSpecification);

var allAndNullCategory = people.FindAll(x => includeNull.IsSatisfiedBy(x));

foreach (var item in allAndNullCategory)

{

Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);

}

Console.ForegroundColor = ConsoleColor.Green;

Console.WriteLine("");

Console.WriteLine(":: ALL VALID ::");

ISpecification<Person> validSpecification = new PersonValidSpecification<Person>();

var validPeople = people.Where(x => validSpecification.IsSatisfiedBy(x));

foreach (var item in validPeople)

{

Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);

}

Console.ForegroundColor = ConsoleColor.Magenta;

Console.WriteLine("");

Console.WriteLine(":: VALID CUSTOMERS ::");

var validCustomers = people.Where(x => validSpecification.IsSatisfiedBy(x) && customersSpecification.IsSatisfiedBy(x));

foreach (var item in validCustomers)

{

Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);

}

Console.ForegroundColor = ConsoleColor.White;

Console.WriteLine("");

Console.WriteLine(":: VALID PARTNERS ::");

var validPartners = people.Where(x => validSpecification.IsSatisfiedBy(x) && partnerSpecification.IsSatisfiedBy(x));

foreach (var item in validPartners)

{

Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);

}

Console.ForegroundColor = ConsoleColor.Red;

Console.WriteLine("");

Console.WriteLine(":: INVALID ::");

var invalidPeople = people.Where(x => !validSpecification.IsSatisfiedBy(x));

foreach (var item in invalidPeople)

{

Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);

}

Console.ForegroundColor = ConsoleColor.Cyan;

Console.WriteLine("");

Console.WriteLine(":: ISVALID ::");

var isvalidPeople = people.Where(x => x.IsValid());

foreach (var item in isvalidPeople)

{

Console.WriteLine(item.PersonId + " | " + item.Name + " | " + item.Email.Address + " | " + item.Category?.Description);

}

Console.ReadKey();

}

E aqui temos a saída completa do console.

Conclusão

Specification é um padrão bastante flexível, tornando as regras de negócio do domínio mais claras. Entretanto, as validações podem ser simplificadas, usando pacotes de terceiros, como por exemplo o Flunt, que une esta abordagem com a Domain Notification, e pode residir em uma camada transversal do projeto.

O projeto completo pode ser baixado no GitHub:

https://github.com/tiagopariz/Specification

Referências

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:

Crie uma solução vazia chamada DomainCore,
Adicione uma Solution folder chamada Domain
Dentro de Domain adicione um projeto do tipo Class Library chamado DomainCore.Domain.Core,
Na raiz do projeto, crie três pastas chamadas Interfaces, Entities e ValueObjects,
Na pasta Interfaces, inclua duas subpastas chamadas Entities e ValueObjects,
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:

Dentro de Domain adicione um projeto do tipo Class Library chamado DomainCore.Domain,
Na raiz do projeto, crie três pastas chamadas Interfaces, Entities e ValueObjects,
Na pasta Interfaces, inclua duas subpastas chamadas Entities e ValueObjects,
Remova todas as referências, para que o projeto esteja o mais limpo possível, e adicione mais tarde conforme for necessário.
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:

DomainCore.Domain.Core/Interfaces/Entities/IEntity.cs
DomainCore.Domain.Core/Interfaces/ValueObjects/IValueObject.cs
DomainCore.Domain.Core/Entities/Entity.cs
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.

C# with Patterns: Adapters

Na série C# with Patterns, que mostra como usar padrões de arquitetura em programação com C#, vamos conhecer o padrão de adaptadores, ou Adapters Pattern.

Continue lendo “C# with Patterns: Adapters”