C# with Patterns: Notification

Segundo Martin Fowler, Notificação é um objeto que coleta dados sobre erros e outras informações na camada de domínio e que comunica com as outras camadas, principalmente com a camada de apresentação.

O padrão Notification, ou notificação, é uma solução elegante para tratar erros de sistema desnecessários, pois exceção, além de causar uma parada abrupta na execução de todo o programa, tem um custo muito alto para o processador. Por isso, usando uma lista de notificações é possível coletar os problemas previsíveis, listar, classificar e informar às outras camadas, ou até mesmo ao usuário, de uma só vez sobre todos os problemas que ele precisa corrigir antes de continuar.

A testabilidade do código também aumenta, pois é possível definir erros, alertas e mensagens padrões para determinadas situações sem lançar exceções, ou seja, agiliza o teste e fica muito mais claro o que o sistema espera de entrada. Ainda é possível combinar esta abordagem com outros padrões, como Specification e Design By Contract e criar um tratamento poderoso e profissional de validações.

O Artigo de Martin Fowler

O artigo original sobre Notification foi escrito em 2004, e faz parte do livro Patterns of Enterprise Application Architecture de 2003, e nele, Fowler até demonstra como usar o padrão usando C# em uma aplicação windows, mas para que fosse mais fácil entender hoje, eu atualizei a sintaxe usando C# 7.0 e desenvolvi alguns métodos que ele não incluiu no artigo, portanto, se você quiser acessar é só entrar no meu repositório Notification by Martin Fowler do GitHub e conferir a abordagem descrita por ele em uma aplicação console.

O Flunt e o Design By Contract de André Baltieri

André Baltieri, MVP da Microsoft, desenvolveu um pacote Nugget, chamado originalmente de Fluent Validator, no qual tive o prazer de contribuir, e que mais tarde foi rebatizado de Flunt. O Flunt é um sistema poderoso e extensível de validação e notificações em domínios, reduzindo “Ifs” e Testes, contribuindo na otimização do tempo,  podendo assim focar na codificação e na regra de negócio do seu domínio do projeto.

Para conhecer os detalhes deste pacote fenomenal e seu código fonte, é só ler o artigo Design By Contracts e também assistir os vídeos do canal dele. Posso garantir que será de grande proveito!

O Meu Projeto de Domain Notification

É possível usar as notificações de um modo simples, apenas para atender um necessidade específica, criando apenas uma lista de mensagens, mas este padrão é poderoso o suficiente para que seja usado em domínios complexos, e combinado com outras abordagens. O projeto que desenvolvi tem um nível de complexidade médio, por este motivo já indiquei o Flunt, pois é uma forma de usar o conceito para validações com o mínimo de esforço e máxima confiabilidade, e assim já terá grandes ganhos, como a redução do uso de exceções e Ifs. Mas se você é como eu, que gostaria de usar ao máximo o padrão e ter controle sobre todo o seu funcionamento, vai ver como desenvolver e usar neste exemplo prático.

Domain Driven Design – DDD

Quase todos os meus projetos são desenvolvidos usando a abordagem de arquitetura DDD, ou seja, quase sempre terá um projeto focado no domínio, assim como o uso de objetos de valor e pelo menos as camadas de domínio, aplicação e apresentação. Se você não faz ideia do que estou falando, não há problemas, é possível entender este artigo mesmo assim, mas se quiser saber mais sobre desenvolvimento dirigido ao domínio, segue a indicação de um excelente vídeo do Eduardo Pires, MVP da Microsoft.

A solução

Abra o Visual Studio, crie uma solução vazia chamada DomainNotification, inclua três Solutions folder chamadas Domain, Application e Presentation.

Na pasta Domain inclua um projeto do tipo Class Library chamado DomainNotification.Domain, na pasta Application inclua um projeto do tipo Class Library chamado DomainNotification.Application e finalmente na pasta Presentation inclua um projeto do tipo Console application chamado DomainNotification.Prompt e defina como Set as StartUp project. A estrutura deve parecer como a imagem a seguir.

Projeto de Domínio

O projeto de domínio será onde residirão as entidades principais, assim como suas classes bases abstratas, também conhecidas como camada de Supertypes. Mas vamos começar criando as estruturas e classes de notificação, que estarão nesta camada.

No projeto de domínio, inclua uma pasta chamada Interfaces, e dentro desta pasta, outra chamada Notifications. Em Notifications, inclua uma interface chamada IDescription e INotification.

A interface INotification tem como objetivo definir um contrato para criação de notificações, definindo o mínimo que um classe precisa ter, ela facilita também o uso de injeção de dependência, podendo ajudar na redução de acoplamento entre projetos.

IDescription define um contrato mínimo para uma descrição de uma notificação lançada, assim como sobrescreve o método ToString() para que possa ser usada como um texto simples.

Ainda no projeto de domínio, inclua uma pasta chamada Notifications, e dentro desta pasta, inclua duas classes abstratas, uma chamada Description e outra chamada Notification.

A classe Description é abstrata, e tem como objetivo ser usada como herança para a classe que será a descrição da notificação em si, assim como a classe Notification que será usada como Supertype para a classe de notificação.

Estas quatro classes sustentam todo o core das notificações, fornecendo o mínimo para ser usado em uma entidade de domínio, por exemplo. mas também permite uma extensão do recurso, podendo adicionar outras peculiaridades necessárias.

Erros como notificações

Um dos principais usos de notificações é para tratamento de erros e validações de dados, e para isso, é economizado então uma parada e o lançamento desnecessário de uma exceção do Framework. A proposta aqui é criar um exemplo que usa uma interface e algumas classes básicas: ILevel, Error, ErrorDescription e classes para a severidade do erro.

A classe Error herda da classe abstrata Notification, mas estende a possibilidade de listar erros com descrição e nível, assim como verificar erros somente de um nível de severidade ou simplesmente checar se há erros de um tipo específico ou de modo geral.

No projeto de domínio, na pasta de Interfaces crie uma pasta chamada Errors e dentro dela inclua a interface a seguir:

No projeto de domínio, crie uma pasta chamada Errors e dentro dela inclua as três classes a seguir de nível de severidade:

A classe ErrorDescription recebe as informações básicas de uma notificação e ainda um objeto do tipo ILevel com a severidade do erro para incluir na classe Error.

Com estas classes, personalizamos a notificação para uso com exceções, no qual agora poderá ser usada por outra classe que queira listar e comunicar entre camadas este tipo de informação.

Validando uma entidade

Já temos a estrutura básica para que uma entidade de domínio possa usar este recurso, e ainda ter a possibilidade de verificar se ela é válida ou não para ser usada em outra lógica e/ou salvar no banco de dados. Conseguimos implementar adicionando uma propriedade e dois métodos.

A propriedade Errors é do tipo Error, que é uma instância de notificação, será aqui que as validações serão armazenadas e consultas.

Para permitir que as validações possam ser globais, específicas ou opcionais, criamos um método chamado Validate, que só pode ser disparado na entidade, ou seja, se alguma validação que a maioria está usando não fizer sentido para o objeto pode ser ignorada ou se houver outras validações que são tão específicas para aquela entidade, ela pode ser criada e chamada na entidade.

E para fechar as características mínimas para uma classe poder usar as notificações de erros, temos uma função chamada IsValid, que apenas verifica se há ao menos um erro de nível Critical. Erros dos níveis Warning e Information não tornam a classe inválida neste exemplo.

Porém, para não ficar validando coisas que são comuns ou que a maioria das entidades precisam validar, é possível armazenar estas verificações direto na classe base abstrata do domínio, e para isso criei uma região na classe chamada Validations, onde foi colocada todas as funções que são globais ou bastante usadas. Mesmo assim é preciso chamar na classe principal, pois elas são opcionais, mas estão prontas para usar. Para exemplificar o cenário, escrevi uma função para validar Guid e outra para Nomes, assim como duas descrições de erros, em uma região chamada Errors, com suas devida mensagens e níveis de severidade.

No projeto de domínio, crie uma pasta chamada ValueObjects, e dentro dela inclua as classes a seguir:

Crie outra pasta na raiz do projeto chamada Entities, e dentro dela inclua as classes a seguir:

Comandos, Aplicação e Console

Para testar as notificações, vamos criar os comandos, uma camada de serviço de aplicação e um aplicativo console para simular uma entrada de dados e visualizar os retornos. A montagem desta parte do exemplo não é foco do artigo, se quiser saber os detalhes destes padrões, sugiro que busque informações sobre Commands, Application Layer e Presentation Layer.

Comandos

Na raiz do projeto de domínio, crie uma pasta chamada Commands, e nela inclua uma classe abstrata chamada Command e outra concreta chamada SavePerson, como a seguir:

Com os comandos, a camada de domínio está concluída, agora precisamos criar uma camada de aplicação, que será consumida pela camada de apresentação.

Aplicação

A camada aplicação, conhecida como Service Aplication ou Application Layer, coordena a chamada das camadas de apresentação com o domínio e repositórios. Para criar esta camada, no projeto DomainNotification.Application crie uma pasta chamadas Services, e dentro dela inclua uma classe abstrata chamada Service e outra concreta chamada PersonService, como seguem:

Apresentação

A camada de apresentação poderia ser uma página Web, um App Mobile, um Windows Forms, mas para simplificar o nosso exemplo, vamos usar uma Aplicação Console. Esta aplicação vai receber dois campos que será o Nome e o E-Mail, no qual esperamos que o domínio valide e retorne as notificações. As informações serão transportadas através de DTOs (Data Transfer Objects), que podem o não representar uma entidade de domínio. No nosso caso será a representação da classe Person.

No projeto DomainNotification.Prompt crie uma pasta chamada Dto, e dentro dela inclua uma classe chamada PersonDto, como segue:

E por fim, altere a classe Program para que consuma a camada de aplicação:

A aplicação está concluída, agora podemos testar, como por exemplo, não preencher nenhum campo.

Se preencher o nome corretamente, mas preencher o e-mail de forma incorreta, uma notificação será exibida, sem lançar exceção, informando o problema.

Assim como um notificação de sucesso quando os dados são inseridos corretamente.

Conclusão

Domain Notification ou simplesmente Notification é uma padrão de arquitetura que economiza processamento e torna a aplicação mais clara e versátil, podendo trabalhar com outros padrões e tipos de validação.

Acesse o projeto completo no GitHub:

https://github.com/tiagopariz/DomainNotification

3 comentários sobre “C# with Patterns: Notification”

  1. Show de bola Tiago! Eu estou reciclando meus conhecimentos e baseado na serie de back-end robustos do Baltieri, percebi que poderia ser bem custoso fazer as validações do domínio por exception (Confesso que eu não sei o quanto é custo, mas parece ser um consenso geral) e comecei a pesquisar sobre outras formas de validação do domínio e encontrei o seu artigo.
    Gostei muito do jeito que vc destrincha o assunto e como expõe de forma simples e leve. Eu até tenho um conhecimento intermediário em C#, mas não nesse tipo de padrão, então foi de muita valia esse seu artigo!
    Muito obrigado!

Deixe uma resposta

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