6. Arquiteturas em camadas
6.1. Introdução
Retomemos a última versão do aplicativo de cálculo de imposto (versão 3, capítulo anterior). Reduzido ao essencial, seu programa de console tinha a seguinte estrutura:
Esse programa combina três processos presentes na maioria dos aplicativos:
- a recuperação de dados armazenados em arquivos, bancos de dados etc.: linhas 1–14;
- a interação com o usuário: linhas 19–20 (entrada) e 23 (saída);
- o uso de um algoritmo de negócio, especificamente o cálculo do imposto: linha 23. Esse cálculo era realizado até então pela classe [AbstractTax], a classe pai de [FileTax] e [JsonTax]: na versão 3, a leitura dos dados e o cálculo ainda estão combinados em um único objeto.
A experiência mostra que isolar essas diferentes etapas de processamento em classes separadas melhora a manutenibilidade do aplicativo. A arquitetura de um aplicativo estruturado dessa forma é a seguinte:

Essa arquitetura é chamada de “arquitetura de três camadas físicas” (three-tier). O termo “tier” designa normalmente uma parte do aplicativo executada em uma máquina diferente. Quando as partes estão na mesma máquina, usa-se antes o termo “arquitetura em camadas”:
- A camada [business] contém as regras de negócio do aplicativo. No nosso caso, são as regras usadas para calcular o imposto de um contribuinte. Essa camada precisa de dados para funcionar:
- as faixas de imposto, que mudam todo ano;
- o número de filhos, o estado civil do contribuinte e a renda anual;
- a camada de acesso a dados, ou [dao] (DAO = Data Access Object), fornece dados já armazenados em arquivos ou bancos de dados. Isso inclui as faixas de imposto, como na versão 3 do aplicativo;
- a camada de interface com o usuário, ou [ui] (UI = User Interface), fornece os dados digitados pelo usuário e exibe os resultados a ele. Aqui, isso se aplica ao número de filhos, ao estado civil e à renda anual do contribuinte.
Em geral:
- a camada [dao] cuida do acesso a dados persistentes (arquivos, bancos de dados) ou não persistentes (rede, sensores etc.);
- a camada [ui] cuida das interações com o usuário, se houver;
- as três camadas são tornadas independentes umas das outras pelo uso de interfaces.
Retomaremos o aplicativo [Tax], que já examinamos várias vezes, para dar a ele uma arquitetura em camadas. Primeiro, precisamos definir as interfaces das diversas camadas do aplicativo.
6.2. As interfaces do aplicativo [Tax]
Lembre-se de que uma interface define um conjunto de assinaturas de métodos e propriedades. As classes que implementam a interface fornecem a implementação real desses métodos e propriedades.
Voltemos à arquitetura em camadas do nosso aplicativo:

Nesse tipo de arquitetura, o usuário costuma tomar a iniciativa. Ele faz uma requisição em [1] e recebe uma resposta em [8]. Isso é chamado de ciclo requisição-resposta. Tomemos como exemplo o cálculo do imposto de um contribuinte. Isso exigirá várias etapas:
- A camada [ui] pergunta ao usuário seu estado civil, número de filhos e salário anual. Essa é a operação [1] descrita acima;
- feito isso, a camada [ui] pede à camada [business] que calcule o imposto. Para isso, envia a ela os dados recebidos do usuário. Essa é a operação [2];
- A camada [business] precisa de certas informações para cumprir sua tarefa: as faixas de imposto. Ela as solicita à camada [dao] pelo caminho [3, 4, 5, 6]: [3] é a requisição inicial e [6] é a resposta a essa requisição;
- Com todos os dados de que precisava, a camada [business] calcula o imposto;
- A camada [business] pode agora responder à requisição feita pela camada [ui] em [2]. Esse é o caminho [7];
- A camada [ui] formata esse resultado e o apresenta ao usuário. Esse é o caminho [8];
- Pode-se imaginar que o usuário faça simulações de imposto e queira salvá-las. Ele usaria o mesmo caminho, [1-8], para isso.
Como se vê nesta descrição, uma camada usa os recursos da camada à sua direita, nunca os da camada à sua esquerda. Considere duas camadas adjacentes:

A camada [A] faz requisições à camada [B]. Nos casos mais simples, uma camada é implementada por uma única classe. Mas um aplicativo evolui com o tempo, e a camada [B] pode ter sucessivamente diferentes classes de implementação: [B1], [B2] e assim por diante. Se a camada [B] for a camada [dao], ela pode ter uma implementação inicial, [B1], que obtém os dados de um arquivo. Alguns anos depois, pode-se querer armazenar esses dados em um banco de dados: criaríamos então uma segunda classe de implementação, [B2]. Se, no aplicativo inicial, a camada [A] trabalhasse diretamente com a classe [B1], seríamos obrigados a reescrever parcialmente o código da camada [A]. Por exemplo, suponha que tivéssemos escrito algo como o seguinte na camada [A]:
- Linha 1: uma instância da classe [B1] é criada;
- linha 3: os dados são solicitados a essa instância.
Se a nova classe de implementação [B2] tiver métodos com a mesma assinatura que a classe [B1], será preciso trocar todas as ocorrências de [B1] por [B2]. Esse é o melhor cenário, e é bastante improvável se você não tiver prestado atenção a essas assinaturas. Na prática, é comum que as classes [B1] e [B2] tenham assinaturas de métodos diferentes, o que significa que uma parte significativa da camada [A] precisa ser reescrita.
Podemos melhorar isso colocando uma interface entre as camadas [A] e [B]. Isso congela, em uma interface, as assinaturas de métodos que a camada [B] expõe à camada [A]. O diagrama anterior passa a ser o seguinte:

A camada [A] não se comunica mais diretamente com a camada [B] , mas com sua interface [IB]. No código da camada [A], a classe de implementação [Bi] da camada [B] agora aparece apenas uma vez, quando o objeto que implementa a interface [IB] é criado. Depois disso, usa-se a interface [IB] — e não sua classe de implementação. O código anterior passa a ser:
- Linha 1: uma instância de
*[ib]que implementa a interface*[IB]é criada pela instanciação da classe*[B1]* ; - Linha 3: os dados são solicitados à instância [ib].
Agora, se substituirmos a implementação [B1] da camada [B] por uma implementação [B2], e ambas as implementações obedecerem à mesma interface [IB], apenas a linha 1 da camada [A] precisará ser modificada. Essa é uma grande vantagem que, por si só, justifica o uso sistemático de interfaces entre duas camadas.
Podemos ir ainda mais longe e tornar a camada [A] completamente independente da camada [B]. No código acima, a linha 1 é um problema porque fixa no código o nome da classe [B1]. O ideal seria que a camada [A] obtivesse uma implementação da interface [IB] sem precisar especificar o nome de uma classe. Isso seria coerente com o diagrama acima: a camada [A] se relaciona com a interface [IB], e não há motivo para que precise conhecer o nome da classe que a implementa.
É isso que a injeção de dependência (DI) possibilita. A arquitetura anterior evolui da seguinte forma:

Um componente transversal — o contêiner de injeção de dependência — cria os objetos que implementam as camadas e os conecta uns aos outros: ele passa à camada [A] uma referência ao objeto que implementa a camada [B]. O código da camada [A] passa então a ter a seguinte forma:
- Linha 2: a camada [A] recebe, por meio de seu construtor, uma instância [ib] que implementa a interface [IB]. Não é a camada [A] que a cria, mas o contêiner;
- Linha 7: os dados são solicitados à instância [ib].
A classe de implementação [B1] não aparece mais em nenhum lugar do código da camada [A]. Quando a implementação [B1] for substituída por uma nova implementação [B2], nada mudará no código da camada [A]: a única coisa que mudará é o ponto único do aplicativo em que se informa ao contêiner qual classe implementa [IB]. Esse ponto pode até ler o nome da implementação a usar a partir de um arquivo de configuração.
O curso de 2008 usava o framework Spring.NET e um arquivo de configuração XML chamado [App.config] para essa finalidade. O Spring.NET não é mais mantido; o .NET agora oferece seu próprio contêiner, [Microsoft.Extensions.DependencyInjection], usado por todos os aplicativos ASP.NET Core. É esse que usaremos na versão 5 do aplicativo. A combinação de “interfaces C# + injeção de dependência” traz uma melhoria decisiva para a manutenção do aplicativo, tornando as camadas independentes umas das outras.
Voltemos à arquitetura em camadas do nosso aplicativo. Em casos simples, podemos começar pela camada [business] para explorar as interfaces do aplicativo. Para funcionar, o aplicativo precisa de dados:
- já disponíveis em arquivos, bancos de dados ou pela rede. Esses dados são fornecidos pela camada [dao];
- ainda não disponíveis. Nesse caso, eles são fornecidos pela camada [ui], que os obtém do usuário.
Que interface a camada [dao] deve oferecer à camada [business]? A camada [dao] deve fornecer as faixas de imposto à camada [business]. No nosso aplicativo, a camada [dao] usa dados existentes, mas não cria dados novos. Sua interface pode ser a seguinte:
- Linha 3: a camada [dao] é colocada no namespace [Dao]. Usamos namespaces com escopo de arquivo (C# 10): a declaração [namespace Dao;] vale para o arquivo inteiro, sem chaves nem indentação adicional;
- Linha 9: a interface [ITaxDao] define a propriedade somente leitura [TaxBrackets], que fornece as faixas de imposto à camada [business];
- linha 1: importa o namespace em que o tipo [TaxBracket] é definido:
Como nas versões 2 e 3, uma faixa de imposto é representada por um [readonly record struct] (C# 10): uma estrutura somente leitura para a qual o compilador gera o construtor (a partir dos parâmetros colocados após o nome do tipo), as propriedades somente leitura [Limit], [CoeffR] e [CoeffN], a igualdade por valor e o método [ToString]. Escrevemos [new TaxBracket(4962M, 0M, 0M)] para criar uma faixa. O curso de 2008 usava uma estrutura com propriedades modificáveis; veremos que a impossibilidade de modificar uma faixa elimina um efeito colateral da antiga camada [business].
Que interface a camada [business] deve apresentar à camada [ui]? Vamos rever as interações entre essas duas camadas:
- A camada [ui] pergunta ao usuário seu estado civil, número de filhos e salário anual. Essa é a operação [1] do esquema;
- Feito isso, a camada [ui] pede à camada [business] que calcule o imposto. Para isso, envia à camada [business] os dados recebidos do usuário. Essa é a operação [2].
A interface da camada [business] poderia ser assim:
- Linha 1: tudo o que se refere à camada [business] é colocado no namespace [Business];
- linha 6: a interface [ITaxBusiness] define apenas um método, que calcula o imposto de um contribuinte com base em seu estado civil, número de filhos e salário anual.
Examinaremos agora uma primeira implementação dessa arquitetura em camadas.
6.3. Aplicativo de exemplo — Versão 4
6.3.1. O projeto
A versão 4 é um único projeto de console, criado por:
Cada camada ocupa uma pasta separada:
- A pasta [Entities] contém os tipos compartilhados pelas camadas [ui], [business] e [dao]: a estrutura [TaxBracket] e a exceção [TaxException], trazidas da versão 3;
- a pasta [Dao] contém a interface e as classes da camada [dao]. Usaremos duas implementações da interface [ITaxDao]: a classe [HardwiredTax], cujos dados são fixos no código (versão 2), e a classe [FileTax], que lê os dados de um arquivo de texto (versão 3). A leitura de um arquivo JSON — a outra opção da versão 3 — será abordada na versão 5;
- A pasta [Business] contém a interface e a classe da camada [business];
- A pasta [Ui] contém a classe da camada [ui];
- o arquivo [Program.cs] cria as camadas e as liga entre si;
- o arquivo [TaxData.txt] contém as faixas de imposto lidas pela implementação [FileTax] da camada [dao].
Os nomes das pastas são irrelevantes para o compilador: todos os arquivos [.cs] da pasta do projeto e de suas subpastas são compilados. Trata-se de uma convenção que facilita a leitura do projeto; ela é complementada por nomear o namespace de acordo com a pasta.
O arquivo [TaxV4.csproj] é o gerado por [dotnet new], acrescido de uma instrução para copiar os arquivos de dados:
- Linha 12: os arquivos [TaxData*.txt] são copiados para junto do executável durante a compilação, na pasta [bin/Debug/net10.0]. A camada [dao] os procura nesse local, quer o programa seja iniciado por [dotnet run] a partir da pasta do projeto, quer diretamente a partir de outra pasta.
6.3.2. As entidades do aplicativo

Chamamos de entidades os tipos que atravessam várias camadas. Em geral, são as classes e estruturas que encapsulam os dados da camada [dao]. Essas entidades geralmente chegam até a camada [ui]. As entidades do aplicativo são a estrutura [TaxBracket], já apresentada, e a exceção [TaxException] da versão 3, junto com a lista de seus códigos de erro:
- linhas 4–5: os códigos de erro. O atributo [Flags] indica que os valores da enumeração são bits que podem ser combinados com o operador [|]: o valor [ErrorCode.Field2 | ErrorCode.Field3] (8 + 16 = 24) significa que os campos 2 e 3 de uma linha estão incorretos. O método [ToString] de uma enumeração assim exibe então “Field2, Field3”. O valor [Json] da versão 3 foi removido, já que esta versão não lê o arquivo JSON;
- linha 8: uma exceção específica do aplicativo, derivada da classe [Exception];
- linha 11: o código de erro, um inteiro que combina valores de [ErrorCode], é uma propriedade [init] (C# 9): só pode receber um valor na criação do objeto, por exemplo com um inicializador [new TaxException(...) { Code = ... }];
- Linhas 14–15: dois construtores, um com uma mensagem, outro com uma mensagem e a exceção original, que ficará acessível pela propriedade [InnerException]. Eles simplesmente chamam o construtor correspondente da classe pai [Exception] ([: base(...)]).
Nesta versão, apenas a classe [FileTax] da camada [dao] instancia [TaxException].
6.3.3. A camada [dao]
Vamos rever a interface da camada [dao]:
Implementamos essa interface de duas maneiras diferentes. Primeiro, com a classe [HardwiredTax]:
- linha 6: a classe [HardwiredTax] implementa a interface [ITaxDao];
- linha 9: implementação da propriedade [TaxBrackets] da interface. É uma propriedade automática somente leitura, inicializada por um inicializador de propriedade (C# 6);
- Linhas 11–17: o valor inicial é uma expressão de coleção (C# 12): a lista de elementos entre colchetes cria um array chamado [TaxBracket[]]. Cada elemento é criado por
***[new(...)]***: o tipo do objeto criado não é repetido; ele é inferido a partir do tipo esperado,[TaxBracket](C# 9).
A interface [ITaxDao] também é implementada pela classe [FileTax], que lê as faixas de imposto de um arquivo de texto. O arquivo [TaxData.txt] é o seguinte:
Cada linha descreve uma faixa de imposto no formato [limit:coeffR:coeffN]. Os números são escritos com ponto decimal, independentemente do idioma do sistema; isso garante que o arquivo seja legível em todas as máquinas. Os valores são os da tabela de imposto de 2004 para a renda de 2003, mantidos como estão: trata-se de um exercício. A classe [FileTax] é a seguinte:
- Linha 3: a diretiva [using static] (C# 6) permite usar membros estáticos e tipos aninhados de um tipo sem prefixo. Os valores de uma enumeração são constantes e, portanto, membros estáticos: escrevemos [Field1] em vez de [ErrorCode.Field1];
- linha 9: a classe [FileTax] implementa a interface [ITaxDao];
- linha 15: a propriedade da interface [ITaxDao]. Ela não tem [set]: só pode receber um valor no construtor (linha 75);
- linha 18: o construtor recebe o nome do arquivo de faixas de imposto;
- linha 23: as faixas de imposto lidas são acumuladas em uma lista, inicializada por uma expressão de coleção vazia;
- linha 25: o arquivo é procurado na pasta do executável, [AppContext.BaseDirectory], para onde o arquivo [.csproj] o copiou. Se [fileName] for um caminho absoluto, [Path.Combine] o deixa como está;
- linhas 29–31: se o arquivo não existir, uma [FileNotFoundException] é lançada com nossa própria mensagem. A mensagem de exceção que o .NET lançaria por conta própria contém o caminho completo do arquivo;
- Linha 33: [File.ReadLines] lê o arquivo linha a linha: as linhas são lidas à medida que o laço [foreach] avança, e o arquivo é fechado ao fim do laço, mesmo que uma exceção seja lançada;
- linha 43: a linha é dividida nos dois-pontos; a opção [StringSplitOptions.TrimEntries] remove os espaços ao redor de cada campo;
- Linhas 46–48: uma linha que não tem três campos é inválida;
- linhas 53–55: conversão dos três campos. Cada campo incorreto adiciona um bit ao código de erro por meio do operador [|=];
- linhas 58–60: uma linha incorreta dispara uma [TaxException], cuja mensagem informa o número e o conteúdo da linha. O código, do tipo [ErrorCode], é convertido em inteiro por [(int)code];
- linha 63: a faixa lida é adicionada à lista;
- linha 66: o filtro de exceção [when] (C# 6) intercepta apenas erros de E/S: [IOException], da qual [FileNotFoundException] deriva, e [UnauthorizedAccessException] (permissões insuficientes). O padrão [e is IOException or UnauthorizedAccessException] (C# 9) verifica os dois tipos. A [TaxException] lançada na linha 60 não é capturada: ela se propaga como está até o chamador;
- linhas 69–71: o erro de E/S é encapsulado em uma [TaxException] com o código [Access]; a exceção original é mantida em sua propriedade [InnerException];
- linha 75: a lista é copiada para um array. O operador [..] (“spread”) de uma expressão de coleção insere todos os elementos de outra coleção;
- Linhas 79–80: conversão de um campo em [decimal]. O estilo [NumberStyles.AllowDecimalPoint] aceita apenas dígitos e um ponto decimal, e a cultura invariável [CultureInfo.InvariantCulture] exige o ponto como separador decimal. Assim, “0,191” é rejeitado, ainda que uma cultura fr-FR o tivesse aceitado. O método é escrito com um corpo de expressão [=>] (C# 6).
6.3.4. A camada [business]
Vamos rever a interface dessa camada:
Sua implementação, [TaxBusiness], é a seguinte:
- Linha 7: a classe [TaxBusiness] implementa a interface [ITaxBusiness]. A camada [business] deve colaborar com a camada [dao]: por isso, recebe uma referência ao objeto que implementa a interface [ITaxDao]. Essa referência é o parâmetro [dao] do construtor primário da classe (C# 12): os parâmetros listados após o nome da classe são os de seu construtor e podem ser usados em todo o corpo da classe;
- Linha 10: quando o objeto é construído, a camada [business] solicita as faixas de imposto à camada [dao] uma única vez e as armazena em um campo somente leitura. Observe que a camada [business] conhece a camada [dao] apenas por sua interface [ITaxDao]: ela não sabe se as faixas de imposto vêm do código, de um arquivo ou, mais adiante, de um banco de dados;
- Linhas 16–17: a camada [business] não confia em seus chamadores. Os métodos estáticos [ThrowIfNegative] (.NET 8) lançam uma [ArgumentOutOfRangeException] se o parâmetro for negativo; a mensagem da exceção contém o nome do parâmetro;
- linhas 19–22: o número de partes. A divisão [nbChildren / 2M] é uma divisão decimal porque [2M] é um [decimal]: 3 filhos equivalem a 1,5 parte;
- linhas 25–26: a renda tributável e o quociente familiar;
- linhas 29–35: procuramos a primeira faixa cujo limite seja maior ou igual ao quociente familiar. A última faixa, [brackets[^1]] (o índice [^1] refere-se ao último elemento, C# 8), é usada se nenhuma outra faixa servir: seu limite (0) não é usado;
- linha 39: o imposto, truncado em sua parte inteira.
O código do curso de 2008 escrevia [taxBrackets[taxBrackets.Length - 1].Limit = QF + 1] antes de procurar a faixa, para que o laço de busca sempre terminasse. Essa instrução modificava o array fornecido pela camada [dao]: um efeito colateral sobre dados compartilhados por todas as camadas. Na verdade, ela não poderia mais ser escrita assim, pois um [TaxBracket] agora é somente leitura. O código moderno simplesmente usa a última faixa quando nenhum limite é adequado, sem modificar os dados que recebe.
6.3.5. A camada [ui]
Nas versões 2 e 3, a interface com o usuário era escrita no programa principal, após a criação do objeto de cálculo. A única diferença estava na forma como esse objeto era criado. Agora isolamos essa interação em uma classe da camada [ui], que conhece a camada [business] apenas por meio de sua interface:
- linha 6: a classe [Dialog] é estática: não tem estado próprio e contém apenas membros estáticos;
- linhas 9–14: a mensagem de ajuda é um literal de string bruta (C# 11), delimitado por três aspas. Ele pode ocupar várias linhas; a indentação comum das linhas, determinada pela posição das aspas de fechamento, é removida;
- linha 17: o método [Run] recebe a camada [business] na forma de sua interface [ITaxBusiness]. Ele não sabe nada sobre a classe que a implementa nem sobre a camada [dao];
- linha 23: [Console.ReadLine] produz [null] no fim do fluxo de entrada; o operador [?.] então produz [null] sem chamar [Trim], e o operador [??] substitui [null] pela string vazia: um fim de fluxo encerra o diálogo exatamente como uma linha vazia;
- linha 30: a linha digitada é dividida pelos espaços; a opção [StringSplitOptions.RemoveEmptyEntries] ignora espaços múltiplos;
- linhas 44–50: [int.TryParse(fields[1], out int nbChildren)] declara a variável de saída na própria chamada (C# 7);
- linha 56: os parâmetros estão corretos: o cálculo é solicitado à camada [business].
6.3.6. Integração das camadas
Resta criar as camadas e ligá-las entre si. Esse é o papel do programa principal [Program.cs]:
- linha 8: o argumento do programa seleciona a implementação da camada [dao]: [hardwired] para a classe [HardwiredTax]; caso contrário, o nome do arquivo lido pela classe [FileTax], com [TaxData.txt] como padrão. Observe que, com instruções de nível superior, os argumentos da linha de comando ficam armazenados no array [args];
- linha 13: criação da camada [dao]. Este é o único lugar do programa em que as classes [HardwiredTax] e [FileTax] são nomeadas;
- linha 15: criação da camada [business], que recebe a camada [dao];
- linhas 17–22: a criação da camada [dao] pode lançar uma [TaxException]. O erro é então exibido, junto com a mensagem da exceção original (se houver), e o programa termina com código de saída 1. Como na versão 3, o código é convertido em [ErrorCode] para ser exibido em texto legível;
- linha 26: as camadas estão prontas: a camada [ui] interage com o usuário.
6.3.7. Execuções
Usando o arquivo [TaxData.txt] (implementação [FileTax]) e testando a validação das entradas:
Com a implementação [HardwiredTax]:
Com um arquivo que não existe:
O código de erro é [Access], e a mensagem da exceção original, [FileNotFoundException], é exibida.
Com o seguinte arquivo, [TaxDataInvalid.txt], em que a linha 3 contém vírgulas decimais:
o resultado é:
Os campos 2 e 3 da linha 3 estão incorretos: o código de erro combina os bits de [Field2] e [Field3], e o método [ToString] de uma enumeração [Flags] o exibe como “Field2, Field3.”
6.3.8. Conclusão
A arquitetura em camadas e o uso de interfaces trouxeram certa flexibilidade à nossa aplicação. Isso fica evidente na forma como o programa principal cria as camadas [dao] e [business]:
Mudar a implementação da camada [dao] altera apenas a linha 1. Depois que as camadas são criadas, o código da camada [ui] é o mesmo nos dois casos: a camada [business] é acessada por meio de sua interface [ITaxBusiness], e não de sua classe de implementação.
A mesma flexibilidade aparece na camada [business]: ela é construída a partir de uma referência à interface da camada [dao]. Mudar a implementação desta última, portanto, não tem impacto sobre a camada [business]. É por isso que nossa única classe [TaxBusiness] pôde funcionar sem modificação com duas implementações diferentes da camada [dao].
6.4. Aplicação de exemplo - Versão 5

Esta nova versão se baseia na anterior, com as seguintes mudanças:
- As camadas [dao] e [business] são colocadas, cada uma, em uma biblioteca de classes (DLL) e testadas com o framework de testes de unidade MSTest;
- A camada [dao] recebe uma terceira implementação, [JsonTax], que lê as faixas de imposto de um arquivo JSON;
- a integração das camadas é feita pelo contêiner de injeção de dependência do .NET, e a implementação da camada [dao] é selecionada a partir de um arquivo de configuração.
Em grandes projetos, vários desenvolvedores trabalham na mesma aplicação. As arquiteturas em camadas facilitam essa forma de trabalho: como as camadas se comunicam por meio de interfaces bem definidas, um desenvolvedor que trabalha em uma camada não precisa se preocupar com o trabalho dos demais desenvolvedores nas outras camadas. Basta que todos respeitem as interfaces.
Assim, para testar a camada [business], o desenvolvedor precisa de uma implementação da camada [dao]. Enquanto essa implementação não estiver concluída, ele pode usar uma implementação fictícia da camada [dao], desde que ela respeite a interface [ITaxDao]. Esta é mais uma vantagem da arquitetura em camadas: um atraso na camada [dao] não impede que a camada [business] seja testada. A implementação simulada (mock) também tem a vantagem de ser muito mais simples de montar do que a camada [dao] real, que pode exigir um SGBD, conexões de rede etc.
Quando a camada [dao] está concluída e testada, ela é entregue aos desenvolvedores da camada [business] na forma de uma biblioteca (um projeto ou uma DLL), e não de código-fonte a ser copiado. No final, a aplicação é entregue como um executável (o da camada [ui]) e bibliotecas de classes (as demais camadas).
6.4.1. A solução TaxV5
A versão 5 é uma solução composta de quatro projetos: um por camada, mais um projeto de testes de unidade. Ela é construída com os seguintes comandos, digitados na pasta [TaxV5]:
- [dotnet new classlib] cria um projeto de biblioteca de classes: sua compilação produz um arquivo DLL, e não um executável. O template cria um arquivo [Class1.cs], que excluímos;
- [dotnet new mstest] cria um projeto de testes MSTest, descrito mais adiante;
- [dotnet new sln --format slnx] cria o arquivo de solução [TaxV5.slnx], no formato XML introduzido pelo SDK no .NET 9. Esse é o formato padrão de [dotnet new sln] desde o .NET 10; a opção [--format slnx] apenas o torna explícito; [dotnet sln add] adiciona os projetos a ela;
- [dotnet add reference] adiciona uma referência de projeto a projeto: a camada [business] usa a camada [dao], a camada [ui] usa as outras duas, assim como os testes.
Isso resulta na seguinte estrutura em árvore:
O arquivo de solução é o seguinte:
O comando [dotnet build TaxV5.slnx] compila os quatro projetos na ordem determinada por suas referências: primeiro [Tax.Dao] , depois [Tax.Business], em seguida [Tax.Ui] e, por fim, [Tax.Tests].
6.4.2. A camada [dao]
O projeto [Tax.Dao] contém a camada [dao] e as entidades da aplicação. Seu arquivo de projeto é o seguinte:
- linhas 4–6: as propriedades geradas por [dotnet new classlib]. Não há a tag [OutputType]: o projeto produz uma biblioteca [Tax.Dao.dll];
- linhas 12–13: os arquivos de dados são copiados para a pasta de build. Os arquivos marcados dessa forma também são copiados para a pasta de build de qualquer projeto que referencie [Tax.Dao]: os projetos [Tax.Ui] e [Tax.Tests] terão os arquivos de dados sem precisar declará-los.
Entidades
A struct [TaxBracket] e a classe [TaxException] são as da versão 4. Apenas a enumeração [ErrorCode] é removida do arquivo: [TaxException] passa assim a ser comum a todas as implementações da camada [dao], sem estar atrelada aos códigos de nenhuma delas:
- linha 7: o código de erro continua sendo um simples inteiro: cada implementação da camada [dao] define seus próprios códigos.
A implementação [FileTax]
A interface [ITaxDao] e a classe [HardwiredTax] são as da versão 4. A classe [FileTax] difere apenas na localização de seus códigos de erro:
- linhas 11–12: os códigos de erro, antes na enumeração [ErrorCode] dentro do namespace [Entities], foram movidos para a classe [FileTax], na forma de uma enumeração aninhada [ErrorCodes]: são, na verdade, códigos específicos desta implementação da interface [ITaxDao] ([JsonTax] tem os seus). Eles são escritos como [ErrorCodes.Field1] dentro da classe e [FileTax.ErrorCodes.Field1] fora dela. A diretiva [using static] da versão 4 não é mais necessária.
Mais adiante, no construtor:
- linhas 63, 72: os erros são encapsulados em uma [TaxException]. O código de erro, do tipo [ErrorCodes], é convertido em inteiro por [(int)code].
A implementação [JsonTax]
O capítulo anterior mostrou como ler dados no formato JSON com [System.Text.Json]. A terceira implementação da camada [dao] lê as faixas de imposto do seguinte arquivo [TaxData.json]:
A classe [JsonTax] é a seguinte:
- linha 11: códigos de erro desta implementação: erro de acesso ao arquivo ou conteúdo incorreto;
- linhas 27–31: o arquivo é lido por inteiro em uma string, com o mesmo tratamento de erros de E/S que em [FileTax];
- linha 43: a string JSON é convertida em um array [TaxBracket[]]. O segundo parâmetro, [BracketsJsonContext.Default.TaxBracketArray], fornece o código de desserialização para esse tipo;
- linha 44: [Deserialize] retorna [null] se o arquivo contiver o literal JSON [null]; a expressão [?? throw] (C# 7) então lança uma exceção;
- linhas 46–50: um arquivo que não seja um array JSON de faixas provoca uma [JsonException], encapsulada em uma [TaxException] de código [Format];
- linhas 58–60: sem um parâmetro desse tipo, [JsonSerializer] descobre as propriedades de [TaxBracket] em tempo de execução, por meio de reflexão. Aqui, o atributo [JsonSerializable] instrui o compilador a gerar, dentro da classe parcial [BracketsJsonContext], o código de (des)serialização para o tipo [TaxBracket[]]. Esse código é mais rápido e também funciona em aplicações compiladas para código nativo (AOT), nas quais a reflexão é desativada, que é o comportamento padrão das aplicações de arquivo único do .NET 10 que usaremos. A opção [JsonSerializerDefaults.Web] associa os nomes JSON em camelCase ([limit]) às propriedades C# ([Limit]). Observe que [System.Text.Json] consegue construir um [record struct] posicional chamando seu construtor.
Um programa de teste
Antes de escrever testes automatizados, vamos fazer um primeiro teste visual da camada [dao]. O .NET 10 permite que uma aplicação de arquivo único referencie um projeto por meio da diretiva [#:project]. O programa [Trials/trial-dao.cs]exibe as faixas fornecidas pelas três implementações:
- linha 1: o programa usa o projeto [Tax.Dao]. Esse projeto é compilado junto com o programa, e seus arquivos de dados são copiados ao lado do executável do programa de teste. Atenção: se você modificar depois o projeto referenciado sem modificar o programa, [dotnet run trial-dao.cs] pode reutilizar o executável já compilado; a opção [--no-cache] força então uma nova compilação;
- linha 8: um array com as três implementações da interface [ITaxDao];
- linha 11: [GetType] retorna o tipo real do objeto, cujo nome de classe é [Name];
- linhas 18–22: tratamento de uma eventual [TaxException].
Resultados:
As três implementações retornam as mesmas faixas. A exibição dos números [decimal] segue a localidade en-US do usuário: ponto decimal.
6.4.3. A camada [business]
O arquivo de projeto [Tax.Business.csproj] é o seguinte:
- linha 11: a referência ao projeto [Tax.Dao] adicionada por [dotnet add reference]. No curso de 2008, a DLL compilada da camada [dao] precisava ser referenciada, e ela tinha de ser buscada em uma pasta chamada [bin]; uma referência de projeto a projeto compila [Tax.Dao] antes de [Tax.Business] e sempre usa sua versão mais recente.
A interface [ITaxBusiness] e a classe [TaxBusiness] são as da versão 4. O programa de teste [Trials/trial-business.cs] faz alguns cálculos de imposto:
- linha 1: o programa referencia o projeto [Tax.Business]; como esse projeto referencia [Tax.Dao], o programa também tem acesso à camada [dao] e a seus recursos;
- linha 9: criação das camadas [dao] e [business] . A camada [dao] é implementada pela classe [FileTax];
- linhas 10–13: chamadas repetidas ao único método da interface [ITaxBusiness].
Resultados:
Um casal com 2 filhos e uma pessoa solteira com 3 filhos têm o mesmo número de partes (3): seus impostos são iguais.
6.4.4. Testes de unidade com MSTest
6.4.4.1. O princípio
Os testes feitos até aqui se baseavam em verificação visual: conferíamos se a tela exibia os resultados esperados. Esse método é inviável quando há muitos testes a executar: o ser humano é sujeito ao cansaço, e sua capacidade de verificar resultados diminui ao longo do dia. Os testes devem, portanto, ser automatizados e dispensar qualquer intervenção humana.
Uma aplicação evolui com o tempo. A cada atualização, é preciso verificar se ela não “regrediu”, isto é, se continua passando nos testes de funcionalidade realizados durante seu desenvolvimento inicial. Esses testes são chamados de testes de não regressão. Uma aplicação de porte médio pode exigir centenas de testes: na verdade, cada método de cada classe da aplicação é testado. São os chamados testes de unidade.
Foram desenvolvidos frameworks para automatizar esses testes. O curso de 2008 usava o NUnit 2.4 e sua interface gráfica. Aqui usamos o MSTest, o framework de testes da Microsoft, na versão 4 (NUnit e xUnit são dois outros frameworks muito usados que funcionam segundo o mesmo princípio). Os testes são executados com o comando [dotnet test] na linha de comando: isso permite iniciá-los automaticamente, por exemplo, sempre que o código é implantado em um servidor de integração contínua. As IDEs (Visual Studio, VS Code, Rider) também oferecem um gerenciador de testes que exibe os testes em estrutura de árvore.
6.4.4.2. Um primeiro exemplo
Vamos examinar o princípio dos testes MSTest por meio de um exemplo. Criamos um projeto de testes com o comando:
O template cria um arquivo de projeto, que modificamos para usar a versão 4.0.2 do MSTest:
- linha 11: o projeto usa o pacote NuGet [MSTest]. Esse pacote inclui o framework (os atributos e a classe [Assert]), o adaptador que permite a [dotnet test] encontrar e executar os testes, e analisadores de código que emitem avisos para testes mal escritos;
- linha 15: um [using] global: o namespace [Microsoft.VisualStudio.TestTools.UnitTesting] do MSTest é importado em todos os arquivos do projeto.
O template também cria um arquivo [MSTestSettings.cs], que especifica que os testes devem ser executados em paralelo. Nós o substituímos pelo seguinte, para que os testes sejam executados um após o outro e seus resultados apareçam em uma ordem consistente:
- linha 2: um atributo que se aplica ao assembly inteiro (DLL), e não a uma classe específica.
A classe de teste [Tests1] é a seguinte:
- linha 4: o atributo [TestClass] indica que a classe contém testes. Ela deve ser pública;
- linha 8: o método a ser testado. Em um projeto real, ele estaria em outro projeto, referenciado pelo projeto de testes;
- linhas 11–13: o construtor. Ele serve apenas para exibir uma mensagem na tela: queremos ver quando ele é executado;
- linha 17: o atributo [TestInitialize] designa um método executado antes de cada teste;
- linha 24: o atributo [TestCleanup] designa um método executado após cada teste;
- linha 31: o atributo [TestMethod] designa um método de teste. Um método de teste é público, não retorna nada (ou retorna uma [Task] se for assíncrono) e, com uma exceção que veremos adiante, não tem parâmetros;
- linha 35: o método [Assert.AreEqual(expected, actual)] verifica se o valor obtido é igual ao valor esperado. Se não for, ele lança uma exceção e o teste falha. Aqui, a asserção deve passar;
- linha 43: esta asserção deve falhar. O terceiro parâmetro é a mensagem exibida em caso de falha.
Os testes são executados com o comando [dotnet test] na pasta do projeto. A opção [--logger "console;verbosity=detailed"] exibe os detalhes de cada teste, incluindo sua saída na tela:
- linha 8: o teste [T1] passou;
- linhas 10–13: suas saídas na tela: o construtor foi executado, seguido do método [Before], do teste e, por fim, do método [After];
- linha 16: o teste [T2] falhou;
- linha 18: a mensagem de erro: o valor esperado, o valor obtido, as expressões que os produziram e a mensagem passada a [Assert.AreEqual];
- linha 19: o MSTest também exibe a pilha de chamadas no momento da falha, que leva à linha defeituosa. Nós a removemos da saída;
- linhas 22–25: a saída do teste [T2]. Observe que o construtor foi executado novamente: o MSTest cria uma nova instância da classe de teste para cada teste. Os testes são, assim, independentes uns dos outros: um teste não pode ser afetado pelo estado deixado por outro. O NUnit, por outro lado, executava o construtor apenas uma vez;
- linhas 28–34: os testes da classe [Tests2], mostrada a seguir;
- linhas 36–39: os resultados: 8 testes passaram e 1 falhou. O comando [dotnet test] termina então com um código de saída diferente de zero, o que permite a um script detectar a falha.
Para executar apenas um subconjunto dos testes, use a opção [--filter]: [dotnet test --filter Name=T1] executa apenas o teste [T1], enquanto [dotnet test --filter ClassName=DemoTests.Tests2] executa os testes da classe [Tests2].
6.4.4.3. Outras asserções
A classe [Assert] tem muitos métodos. A classe [Tests2] inclui alguns deles:
- linhas 12–13: verificam se uma expressão booleana é verdadeira ou falsa;
- linhas 16–17: verificam se uma referência é não nula ou nula;
- linhas 18–19: verificam se duas referências apontam para o mesmo objeto;
- linhas 27–28: os cálculos com números reais [double] são aproximados: [0.1 + 0.2] não é exatamente igual a [0.3]. Por isso comparamos dois números reais com certa margem de erro, neste caso um milionésimo;
- linhas 36–40: asserções sobre strings e coleções, adicionadas por versões recentes do MSTest. Elas produzem mensagens de erro mais precisas que [Assert.IsTrue(message.StartsWith("Line"))];
- linhas 48–49: [Assert.ThrowsExactly<T>(action)] executa a ação — uma função anônima [() => ...] — e verifica se ela lança uma exceção exatamente do tipo [T]. Ele retorna a exceção lançada, o que permite verificar suas propriedades depois. A variante [Assert.Throws<T>] também aceita exceções de tipos derivados de [T];
- linhas 55–58: um teste parametrizado. O método de teste tem parâmetros, e cada atributo [DataRow] fornece um conjunto de valores para esses parâmetros. O teste é executado uma vez por atributo [DataRow]: é isso que as linhas [T7 (1,1,2)], [T7 (2,3,5)], e [T7 (-1,1,0)] dos resultados anteriores mostraram.
Vamos resumir os principais métodos da classe [Assert]:
Método | Verifica que |
Assert.AreEqual(expected, actual) | os dois valores são iguais (método Equals) |
Assert.AreEqual(actual1, actual2, delta) | os dois valores reais são iguais com tolerância de delta |
Assert.AreNotEqual(v1, v2) | os dois valores são diferentes |
Assert.AreSame(o1, o2), Assert.AreNotSame(o1, o2) | as duas referências apontam (ou não) para o mesmo objeto |
Assert.IsNull(o), Assert.IsNotNull(o) | a referência é nula (ou não) |
Assert.IsTrue(b), Assert.IsFalse(b) | a expressão booleana é verdadeira (ou falsa) |
Assert.IsInstanceOfType<T>(o) | o objeto é do tipo T ou de um tipo derivado |
Assert.HasCount(n, collection) | a coleção tem n elementos |
Assert.Contains(element, collection) | a coleção (ou string) contém o elemento |
Assert.StartsWith(start, string) | a string começa com start |
Assert.ThrowsExactly<T>(action) | a ação lança exatamente uma exceção do tipo T |
CollectionAssert.AreEqual(c1, c2) | as duas coleções têm os mesmos elementos, na mesma ordem |
Todos esses métodos aceitam um último parâmetro opcional: a mensagem exibida em caso de falha.
6.4.4.4. Testes da camada [dao]
Voltemos à aplicação [Tax]. O projeto [Tax.Tests] foi criado por [dotnet new mstest]. Seu arquivo de projeto é o seguinte:
- linhas 17–18: as camadas testadas;
- linha 27: um arquivo de dados incorreto, usado para testar erros. Os arquivos [TaxData.txt] e [TaxData.json] são copiados por meio da referência ao projeto [Tax.Dao].
O arquivo [MSTestSettings.cs] pertence ao projeto [DemoTests]. A classe [DaoTests] testa a camada [dao]:
- linhas 11–16: um método que cria uma camada [dao] a partir do nome de sua classe, usando uma expressão [switch] (C# 8);
- linhas 21–24: o mesmo teste é executado para as três implementações. Ele verifica se há 7 faixas e confere o valor da faixa nº 2 (a terceira). Os valores esperados são escritos com o sufixo [M]: são [decimal], assim como as propriedades comparadas;
- linhas 36–40: as três implementações retornam exatamente as mesmas faixas. [CollectionAssert.AreEqual] compara os arrays elemento a elemento; a comparação de dois valores [TaxBracket] é uma comparação por valor, gerada pelo compilador para um [record struct];
- linhas 45–49: um arquivo ausente provoca uma [TaxException] com código [Access], que encapsula uma [FileNotFoundException];
- linhas 54–58: o arquivo [TaxDataInvalid.txt] resulta em uma [TaxException] cujo código combina os bits de [Field2] e [Field3];
- linhas 63–66: a mesma verificação para a implementação [JsonTax].
6.4.4.5. Testes da camada [business]
A classe [BusinessTests] testa a camada [business]:
- linhas 12–17: a camada [business] testada é construída sobre a camada [dao] [HardwiredTax], que não depende de nenhum arquivo. Como o MSTest cria uma nova instância da classe para cada teste, cada teste tem camadas novas em folha;
- linhas 22–28: cálculos cujos resultados são conhecidos. São os valores de controle da aplicação, já obtidos pelas versões anteriores: eles devem permanecer corretos em todas as versões futuras;
- linhas 35–39: o cálculo do imposto não modifica as faixas de imposto fornecidas pela camada [dao]. Uma cópia ([.. dao.TaxBrackets]) é feita antes de um cálculo que usa a última faixa, e depois os resultados são comparados. O teste preserva a lembrança do defeito da versão de 2008: se alguém o reintroduzisse, este teste o sinalizaria;
- linhas 44–47: parâmetros negativos são rejeitados;
- linhas 51–53: uma camada [dao] fictícia, como a que o desenvolvedor da camada [business] usaria antes de a camada [dao] real estar pronta: uma única faixa de imposto, com alíquota de 10% da renda tributável. É uma classe aninhada na classe de teste;
- linhas 58–62: a camada [business] funciona com a camada [dao] fictícia. A camada [business] é assim testada isoladamente, independentemente das implementações reais da camada [dao].
6.4.4.6. Execução dos testes
Na pasta [Tax.Tests]:
Todos os 16 testes passaram: cada atributo [DataRow] conta como um teste. Consideramos agora as camadas [dao] e [business] operacionais. Ao contrário de 2008, não é necessário recompilar as DLLs das camadas para excluir as classes de teste: os testes estão em um projeto separado, e as bibliotecas [Tax.Dao.dll] e [Tax.Business.dll] contêm apenas o código das camadas. O comando [dotnet test TaxV5.slnx], executado na pasta da solução, roda os testes de todos os projetos de teste da solução.
6.4.5. A camada [ui]
O arquivo de projeto [Tax.Ui.csproj] é o seguinte:
- linha 4: o projeto gera um executável;
- linhas 12–13: a camada [ui] usa as camadas [business] e [dao] ;
- linhas 18–19: dois pacotes NuGet — o contêiner de injeção de dependência e o leitor de arquivos de configuração JSON. Eles foram adicionados pelos comandos [dotnet add package Microsoft.Extensions.DependencyInjection --version 10.0.12] e [dotnet add package Microsoft.Extensions.Configuration.Json --version 10.0.12];
- linha 24: os arquivos de configuração são copiados para junto do executável.
A classe [Dialog] é a da versão 4, acrescida de um método que exibe uma exceção e todas as exceções que ela encapsula:
- linha 63: uma string de 40 hifens, criada pelo construtor [string(char c, int count)];
- linha 65: o laço percorre a cadeia de exceções: cada exceção dá acesso, por meio de sua propriedade [InnerException], à exceção que ela encapsula, até a última, em que [InnerException] é igual a [null]. O tipo [Exception?] indica que a variável [e] pode ser igual a [null];
- linha 67: para cada exceção, são exibidos o nome completo de sua classe (incluindo o namespace) e sua mensagem.
A classe [Dialog] é pública: as versões seguintes da aplicação, que mudarão a camada [dao], reutilizarão a camada [ui] referenciando o projeto [Tax.Ui] e chamando [Dialog.Run(business)].
6.4.6. Integração das camadas por injeção de dependência
Na versão 4, o programa principal criava as camadas [dao] e [business] nomeando suas classes de implementação:
Fora dessas linhas, nada na aplicação muda quando a implementação de uma camada muda, já que cada camada se comunica com a seguinte por meio de uma interface. Podemos levar a independência das camadas um passo além, confiando sua criação a um contêiner de injeção de dependência e colocando a escolha da implementação da camada [dao] em um arquivo de configuração. Mudar a implementação dessa camada passa então a consistir apenas em modificar esse arquivo, sem recompilar a aplicação.

No exemplo acima, a camada [ui] solicita [0] a camada [business] ao contêiner de injeção de dependência. Para criá-la, o contêiner primeiro cria a camada [dao] [1], depois a camada [business] [2], à qual passa a camada [dao]. Por fim, ele retorna uma referência à camada [business] [3] para a camada [ui].
6.4.6.1. O arquivo de configuração
A escolha da implementação da camada [dao] é especificada no arquivo [appsettings.json]:
- linha 2: uma seção [Dao] contém a configuração da camada [dao];
- linha 3: a classe que implementa a camada [dao]: [HardwiredTax], [FileTax], ou [JsonTax];
- linha 4: o arquivo de dados, para as implementações que leem um.
[appsettings.json] é o nome padrão do arquivo de configuração das aplicações .NET, em particular das aplicações ASP.NET Core. Ele substitui os arquivos XML [App.config] do .NET Framework, que eram usados pelo Spring.NET no ano letivo de 2008. O projeto contém outros três arquivos de configuração, que o programa usa se seus nomes forem passados como argumentos:
6.4.6.2. O programa principal
O programa principal [Program.cs] do projeto [Tax.Ui] é o seguinte:
- linha 9: o nome do arquivo de configuração: [appsettings.json] por padrão, ou o passado como argumento;
- linhas 16–19: leitura da configuração. [ConfigurationBuilder] monta uma configuração a partir de fontes: neste caso, um único arquivo JSON ([AddJsonFile]), localizado na pasta do executável ([SetBasePath]). O parâmetro [optional: false] (um parâmetro nomeado, C# 4) torna o arquivo obrigatório: sua ausência provoca uma [FileNotFoundException];
- linhas 20–21: a configuração é lida como um dicionário. A chave [Dao:Implementation] refere-se à propriedade [Implementation] da seção [Dao]; o separador de níveis é o dois-pontos. O indexador retorna [null] se a chave não existir: o operador [??] fornece então um valor padrão;
- linha 24: a coleção de serviços, isto é, a lista de tipos que o contêiner pode criar e a forma de criá-los;
- linhas 26–31: o registro da camada [dao]. [AddSingleton<ITaxDao>(factory)] indica que, quando um [ITaxDao] for solicitado, o contêiner chamará a função [factory] para criá-lo. “Singleton” significa que o objeto será criado apenas uma vez, na primeira solicitação, e que todas as solicitações seguintes retornarão o mesmo objeto: há uma única camada [dao] na aplicação. A factory seleciona a classe com base na configuração, usando a expressão [switch]; seu parâmetro, o próprio contêiner, não é usado aqui, daí o nome [_] (“discard”). Uma implementação desconhecida resulta em uma [TaxException];
- linha 34: o registro da camada [business]: quando um [ITaxBusiness] for solicitado, o contêiner criará um objeto [TaxBusiness]. Para isso, ele examina o construtor da classe [TaxBusiness], vê que ela espera um [ITaxDao] e passa a ela a camada [dao] registrada acima: isso é a injeção de dependência. A camada [dao] é uma dependência da camada [business];
- linha 37: criação do contêiner a partir da coleção de serviços;
- linha 38: pede-se ao contêiner a camada [business]. O contêiner cria a camada [dao] e depois a camada [business]. [GetRequiredService] lança uma exceção se o tipo solicitado não tiver sido registrado. Observe que a camada [ui] obtém a camada [business] sem especificar a classe que a implementa;
- linhas 40–44: quaisquer erros de configuração ou de criação das camadas são exibidos junto com a pilha de chamadas da exceção, e o programa termina;
- linha 48: a interface com o usuário, idêntica à da versão 4.
O curso de 2008 incluía no arquivo de configuração os nomes completos das classes a instanciar ([Dao.FileTax, TaxV5-dao]): o Spring.NET as criava por reflexão. Optamos por definir as implementações possíveis na factory: o arquivo de configuração apenas seleciona uma delas, e o compilador verifica se as classes existem e têm os construtores exigidos. Nos dois casos, o código das camadas [ui] e [business] nunca especifica a classe que implementa a camada [dao].
6.4.6.3. Execuções
Com o arquivo [appsettings.json] (implementação [FileTax]):
Com a implementação [JsonTax]:
Com a implementação [HardwiredTax]:
Mudamos a implementação da camada [dao] sem alterar uma única linha de código nem recompilar a aplicação.
Com o arquivo [appsettings-error.json], que se refere a um arquivo de dados inexistente:
- linha 6: a exceção original, do tipo [FileNotFoundException], lançada pela classe [FileTax];
- linha 4: a camada [dao] a encapsulou em uma [TaxException]. É essa exceção que foi propagada até o programa principal por meio da chamada a [GetRequiredService].
O contêiner do .NET repassa sem modificação as exceções lançadas durante a criação de objetos. Com o Spring.NET, o mesmo erro produzia uma cadeia de oito exceções, seis delas causadas pelo framework ([ConfigurationErrorsException], [ObjectCreationException], [TargetInvocationException] etc.), seguidas das duas exceções mencionadas acima. O principal ensinamento dessa cadeia é que, muitas vezes, a exceção mais profunda — a última exibida — é a mais significativa.
A injeção de dependência merece, por si só, um capítulo à parte. Usamos apenas o essencial: registrar serviços ([AddSingleton]), construir o contêiner ([BuildServiceProvider]) e obter um serviço ([GetRequiredService]). O contêiner também pode criar um novo objeto a cada solicitação ([AddTransient]) ou um objeto por “escopo”, como por requisição (HTTP) em uma aplicação web ([AddScoped]). Voltaremos a isso nas aplicações ASP.NET Core, onde ela é onipresente. Você pode aprofundar o assunto na documentação da Microsoft: Dependency Injection .NET.
6.5. Conclusão
Este capítulo deu à aplicação [Tax] a arquitetura que ela manterá até o final do curso:
- uma camada [dao] que fornece as faixas de imposto por meio da interface [ITaxDao];
- uma camada [business] que calcula o imposto e interage com a camada [dao] apenas por meio de sua interface;
- uma camada [ui] que interage com o usuário e conhece a camada [business] apenas por meio de sua interface [ITaxBusiness];
- um programa principal — o único que conhece as classes de implementação — que cria as camadas e as liga, neste caso por meio de um contêiner de injeção de dependência e de um arquivo de configuração;
- testes de unidade automatizados, que verificam cada camada independentemente das demais e garantem a não regressão da aplicação.
As vantagens dessa arquitetura ficarão plenamente evidentes nos próximos capítulos, em que as bibliotecas [Tax.Dao], [Tax.Business] e [Tax.Ui] da versão 5 serão reutilizadas tal como estão, por meio de referências de projeto:
- Versão 6 (capítulo ADO.NET): uma nova implementação, [MySqlTax], da camada [dao] lê as faixas de imposto de um banco de dados MySQL. As camadas [business] e [ui] permanecem inalteradas;
- Versão 7 (capítulo Entity Framework Core): uma implementação [EfTax] da camada [dao] usa o ORM Entity Framework Core para acessar o mesmo banco de dados;
- Versão 8 (capítulo Internet): a camada [business] é instalada em um servidor TCP, que calcula impostos para clientes remotos; temos, portanto, uma arquitetura “de três camadas” no sentido estrito;
- Versão 9 (capítulo Web Services): a camada [business] é exposta por um web service REST/JSON escrito com ASP.NET Core, cujo cliente de console usa [HttpClient].
Em cada caso, o trabalho se limitará a escrever a nova camada e a modificar o programa que integra as camadas: é esse todo o sentido da arquitetura em camadas.