Skip to content

6. Arquitecturas en capas

6.1. Introducción

Retomemos la última versión de la aplicación de cálculo de impuestos (versión 3, capítulo anterior). Reducido a lo esencial, su programa de consola tenía la siguiente estructura:

// creación de un objeto ITax a partir de un archivo de texto o JSON
ITax tax;
try
{
    tax = Path.GetExtension(fileName).ToLower() switch
    {
        ".json" => new JsonTax(path),
        _ => new FileTax(path)
    };
}
catch (TaxException e)
{
    Console.WriteLine($"The following error occurred: [Code={(ErrorCode)e.Code}, Message={e.Message}]");
    return 1;
}
// bucle de entrada
while (true)
{
    Console.Write("Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: ");
    string parameters = (Console.ReadLine() ?? "").Trim();
    ...
    // los parámetros son correctos: calculamos el impuesto
    Console.WriteLine($"Tax={tax.Calculate(married == "y", nbChildren, salary)} euros");
}

Este programa combina tres procesos presentes en la mayoría de las aplicaciones:

  • la obtención de datos almacenados en archivos, bases de datos, etc.: líneas 1–14;
  • la interacción con el usuario: líneas 19–20 (entrada) y 23 (salida);
  • el uso de un algoritmo de negocio, concretamente el cálculo del impuesto: línea 23. Este cálculo lo realizaba hasta ahora la clase [AbstractTax], la clase padre de [FileTax] y [JsonTax]: en la versión 3, la lectura de datos y el cálculo todavía se combinan dentro de un único objeto.

La experiencia ha demostrado que aislar estos distintos procesamientos en clases separadas mejora la mantenibilidad de la aplicación. La arquitectura de una aplicación estructurada de esta manera es la siguiente:

Image

Esta arquitectura se denomina “arquitectura de tres niveles”. Normalmente, el término “nivel” se refiere a una parte de la aplicación que se ejecuta en una máquina distinta. Cuando las partes están en la misma máquina, se utiliza en su lugar el término “arquitectura en capas”:

  • La capa [business] contiene las reglas de negocio de la aplicación. En nuestra aplicación, son las reglas que se usan para calcular el impuesto de un contribuyente. Esta capa necesita datos para funcionar:
    • los tramos impositivos, que cambian cada año;
    • el número de hijos, el estado civil del contribuyente y sus ingresos anuales;
  • la capa de acceso a datos, o [dao] (DAO = Data Access Object), proporciona los datos ya almacenados en archivos o bases de datos. Esto incluye los tramos impositivos, como en la versión 3 de la aplicación;
  • la capa de interfaz de usuario, o [ui] (UI = User Interface), proporciona los datos ingresados por el usuario y le muestra los resultados. Aquí esto se aplica al número de hijos, al estado civil y a los ingresos anuales del contribuyente.

En general:

  • la capa [dao] se encarga del acceso a datos persistentes (archivos, bases de datos) o no persistentes (red, sensores, etc.);
  • la capa [ui] se encarga de las interacciones con el usuario, si lo hay;
  • las tres capas se hacen independientes entre sí mediante el uso de interfaces.

Retomaremos la aplicación [Tax], que ya hemos examinado varias veces, para darle una arquitectura en capas. Primero, debemos definir las interfaces de las distintas capas de la aplicación.

6.2. Las interfaces de la aplicación [Tax]

Recuerde que una interfaz define un conjunto de firmas de métodos y propiedades. Las clases que implementan la interfaz proporcionan la implementación real de esos métodos y propiedades.

Volvamos a la arquitectura en capas de nuestra aplicación:

Image

En este tipo de arquitectura, el usuario suele tomar la iniciativa. El usuario hace una solicitud en [1] y recibe una respuesta en [8]. Esto se denomina ciclo de solicitud-respuesta. Tomemos el ejemplo del cálculo del impuesto de un contribuyente. Esto requerirá varios pasos:

  • La capa [ui] pide al usuario su estado civil, su número de hijos y su salario anual. Esta es la operación [1] descrita anteriormente;
  • una vez hecho esto, la capa [ui] pide a la capa [business] que calcule el impuesto. Para ello, le envía los datos que recibió del usuario. Esta es la operación [2];
  • La capa [business] necesita cierta información para realizar su tarea: los tramos impositivos. Los solicita a la capa [dao] por la ruta [3, 4, 5, 6]: [3] es la solicitud inicial y [6] es la respuesta a esa solicitud;
  • Con todos los datos que necesitaba, la capa [business] calcula el impuesto;
  • La capa [business] ya puede responder a la solicitud que le hizo la capa [ui] en [2]. Esta es la ruta [7];
  • La capa [ui] da formato a este resultado y luego lo presenta al usuario. Esta es la ruta [8];
  • Podría imaginarse que el usuario realice simulaciones de impuestos y quiera guardarlas. Utilizaría la misma ruta, [1-8], para hacerlo.

Como se ve en esta descripción, una capa utiliza los recursos de la capa que está a su derecha, nunca los de la que está a su izquierda. Consideremos dos capas adyacentes:

Image

La capa [A] hace solicitudes a la capa [B]. En los casos más simples, una capa se implementa con una sola clase. Pero una aplicación evoluciona con el tiempo, y la capa [B] puede tener sucesivamente distintas clases de implementación: [B1], [B2], y así sucesivamente. Si la capa [B] es la capa [dao], puede tener una implementación inicial, [B1], que obtiene los datos de un archivo. Unos años después, podría querer almacenar estos datos en una base de datos: entonces crearía una segunda clase de implementación, [B2]. Si, en la aplicación inicial, la capa [A] trabajaba directamente con la clase [B1], nos veríamos obligados a reescribir parcialmente el código de la capa [A]. Por ejemplo, supongamos que escribimos algo como lo siguiente en la capa [A]:

1
2
3
B1 b1 = new B1(...);
...
b1.GetData(...);
  • Línea 1: se crea una instancia de la clase [B1];
  • línea 3: se solicitan datos a esta instancia.

Si la nueva clase de implementación [B2] tiene métodos con la misma firma que la clase [B1], deberá cambiar todas las instancias de [B1] por [B2]. Este es el mejor de los casos, y es bastante improbable si no se ha prestado atención a estas firmas. En la práctica, es común que las clases [B1] y [B2] tengan firmas de métodos distintas, lo que significa que una parte importante de la capa [A] debe reescribirse.

Podemos mejorar esto colocando una interfaz entre las capas [A] y [B]. Esto fija en una interfaz las firmas de los métodos que la capa [B] expone a la capa [A]. El diagrama anterior se convierte en el siguiente:

Image

La capa [A] ya no se comunica directamente con la capa [B] sino con su interfaz [IB]. En el código de la capa [A], la clase de implementación [Bi] de la capa [B] aparece ahora una sola vez, cuando se crea el objeto que implementa la interfaz [IB]. Después de eso, se utiliza la interfaz [IB], y no su clase de implementación. El código anterior queda así:

1
2
3
IB ib = new B1(...);
...
ib.GetData(...);
  • Línea 1: se crea una instancia de *[ib] que implementa la interfaz *[IB] al instanciar la clase *[B1]* ;
  • Línea 3: se solicitan datos a la instancia [ib].

Ahora, si reemplazamos la implementación [B1] de la capa [B] por una implementación [B2], y ambas implementaciones respetan la misma interfaz [IB], solo es necesario modificar la línea 1 de la capa [A]. Esta es una ventaja importante que, por sí sola, justifica el uso sistemático de interfaces entre dos capas.

Podemos ir aún más lejos y hacer que la capa [A] sea completamente independiente de la capa [B]. En el código anterior, la línea 1 plantea un problema porque incluye directamente en el código el nombre de la clase [B1]. Idealmente, la capa [A] debería obtener una implementación de la interfaz [IB] sin tener que especificar un nombre de clase. Esto sería coherente con el diagrama anterior: la capa [A] se relaciona con la interfaz [IB], y no hay razón para que necesite conocer el nombre de la clase que implementa esa interfaz.

Esto es lo que permite la inyección de dependencias (DI). La arquitectura anterior evoluciona de la siguiente manera:

Image

Un componente transversal, el contenedor de inyección de dependencias, crea los objetos que implementan las capas y los conecta entre sí: entrega a la capa [A] una referencia al objeto que implementa la capa [B]. El código de la capa [A] adopta entonces la siguiente forma:

1
2
3
4
5
6
7
8
9
// la capa [A] recibe la capa [B] mediante su constructor
public class A(IB ib)
{
    public void Work()
    {
        ...
        ib.GetData(...);
    }
}
  • Línea 2: la capa [A] recibe, a través de su constructor, una instancia [ib] que implementa la interfaz [IB]. No es la capa [A] la que la crea, sino el contenedor;
  • Línea 7: se solicitan datos a la instancia [ib].

La clase de implementación [B1] ya no aparece en ninguna parte del código de la capa [A]. Cuando la implementación [B1] se reemplaza por una nueva implementación [B2], nada cambiará en el código de la capa [A]: lo único que cambiará es el único lugar de la aplicación donde se le indica al contenedor qué clase implementa [IB]. Este lugar incluso puede leer el nombre de la implementación que se va a usar desde un archivo de configuración.

El curso de 2008 usaba para ello el framework Spring.NET y un archivo de configuración XML llamado [App.config]. Spring.NET ya no recibe mantenimiento; .NET ofrece ahora su propio contenedor, [Microsoft.Extensions.DependencyInjection], que usan todas las aplicaciones ASP.NET Core. Este es el que utilizaremos en la versión 5 de la aplicación. La combinación de “interfaces de C# + inyección de dependencias” aporta una mejora decisiva al mantenimiento de las aplicaciones al hacer que las capas sean independientes entre sí.

Volvamos a la arquitectura en capas de nuestra aplicación. En casos simples, podemos comenzar por la capa [business] para explorar las interfaces de la aplicación. Para funcionar, la aplicación necesita datos:

  • ya disponibles en archivos, bases de datos o a través de la red. Estos datos los proporciona la capa [dao];
  • aún no disponibles. En ese caso, los proporciona la capa [ui], que los obtiene del usuario.

¿Qué interfaz debe ofrecer la capa [dao] a la capa [business]? La capa [dao] debe proporcionar los tramos impositivos a la capa [business]. En nuestra aplicación, la capa [dao] utiliza datos existentes pero no crea datos nuevos. Su interfaz puede ser la siguiente:

using Entities;

namespace Dao;

// la interfaz de la capa [dao]
public interface ITaxDao
{
    // los tramos del impuesto
    TaxBracket[] TaxBrackets { get; }
}
  • Línea 3: la capa [dao] se coloca en el espacio de nombres [Dao]. Usamos espacios de nombres con ámbito de archivo (C# 10): la declaración [namespace Dao;] se aplica a todo el archivo, sin llaves ni sangría adicional;
  • Línea 9: la interfaz [ITaxDao] define la propiedad de solo lectura [TaxBrackets], que proporciona los tramos impositivos a la capa [business];
  • línea 1: importa el espacio de nombres en el que se define el tipo [TaxBracket]:
1
2
3
4
namespace Entities;

// un tramo del impuesto: una estructura inmutable
public readonly record struct TaxBracket(decimal Limit, decimal CoeffR, decimal CoeffN);

Como en las versiones 2 y 3, un tramo impositivo se representa mediante un [readonly record struct] (C# 10): una estructura de solo lectura para la que el compilador genera el constructor (a partir de los parámetros colocados después del nombre del tipo), las propiedades de solo lectura [Limit], [CoeffR] y [CoeffN], la igualdad por valor y el método [ToString]. Escribimos [new TaxBracket(4962M, 0M, 0M)] para crear un tramo. El curso de 2008 usaba una estructura con propiedades modificables; veremos que la imposibilidad de modificar un tramo elimina un efecto secundario de la antigua capa [business].

¿Qué interfaz debe presentar la capa [business] a la capa [ui]? Repasemos las interacciones entre estas dos capas:

  • La capa [ui] pide al usuario su estado civil, su número de hijos y su salario anual. Esta es la operación [1] del esquema;
  • Una vez hecho esto, la capa [ui] pide a la capa [business] que calcule el impuesto. Para ello, envía a la capa [business] los datos que recibió del usuario. Esta es la operación [2].

La interfaz de la capa [business] podría ser como sigue:

1
2
3
4
5
6
7
namespace Business;

// la interfaz de la capa [business]
public interface ITaxBusiness
{
    int CalculateTax(bool married, int nbChildren, int salary);
}
  • Línea 1: todo lo relacionado con la capa [business] se coloca en el espacio de nombres [Business];
  • línea 6: la interfaz [ITaxBusiness] define un solo método, que calcula el impuesto de un contribuyente a partir de su estado civil, su número de hijos y su salario anual.

Examinaremos ahora una primera implementación de esta arquitectura en capas.

6.3. Aplicación de ejemplo - Versión 4

6.3.1. El proyecto

La versión 4 es un único proyecto de consola, creado mediante:

> dotnet new console -n TaxV4 -o TaxV4

Cada capa ocupa una carpeta distinta:

TaxV4/
  TaxV4.csproj
  Program.cs                 integration of the layers
  TaxData.txt                the tax brackets
  TaxDataInvalid.txt         an incorrect brackets file
  Entities/
    TaxBracket.cs
    TaxException.cs
  Dao/
    ITaxDao.cs
    HardwiredTax.cs
    FileTax.cs
  Business/
    ITaxBusiness.cs
    TaxBusiness.cs
  Ui/
    Dialog.cs
  • La carpeta [Entities] contiene los tipos compartidos por las capas [ui], [business] y [dao]: la estructura [TaxBracket] y la excepción [TaxException], heredadas de la versión 3;
  • la carpeta [Dao] contiene la interfaz y las clases de la capa [dao]. Usaremos dos implementaciones de la interfaz [ITaxDao]: la clase [HardwiredTax], cuyos datos están incluidos directamente en el código (versión 2), y la clase [FileTax], que lee los datos de un archivo de texto (versión 3). La lectura de un archivo JSON, la otra opción de la versión 3, se tratará en la versión 5;
  • La carpeta [Business] contiene la interfaz y la clase de la capa [business];
  • la carpeta [Ui] contiene la clase de la capa [ui];
  • el archivo [Program.cs] crea las capas y las vincula entre sí;
  • el archivo [TaxData.txt] contiene los tramos impositivos que lee la implementación [FileTax] de la capa [dao].

Los nombres de las carpetas son irrelevantes para el compilador: se compilan todos los archivos [.cs] de la carpeta del proyecto y de sus subcarpetas. Se trata de una convención que facilita la lectura del proyecto; se complementa nombrando el espacio de nombres igual que la carpeta.

El archivo [TaxV4.csproj] es el generado por [dotnet new], complementado con una instrucción para copiar los archivos de datos:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <!-- los archivos de datos se copian junto al ejecutable -->
    <None Update="TaxData*.txt" CopyToOutputDirectory="PreserveNewest" />
  </ItemGroup>

</Project>
  • Línea 12: los archivos [TaxData*.txt] se copian junto al ejecutable durante la compilación, en la carpeta [bin/Debug/net10.0]. La capa [dao] los busca en esa ubicación, ya sea que el programa se inicie con [dotnet run] desde la carpeta del proyecto o directamente desde otra carpeta.

6.3.2. Las entidades de la aplicación

Image

Llamamos entidades a los tipos que atraviesan varias capas. Suelen ser las clases y estructuras que encapsulan los datos de la capa [dao]. Estas entidades generalmente llegan hasta la capa [ui]. Las entidades de la aplicación son la estructura [TaxBracket], ya presentada, y la excepción [TaxException] de la versión 3, junto con la lista de sus códigos de error:

namespace Entities;

// los códigos de error de la capa [dao]: potencias de 2, que se pueden combinar
[Flags]
public enum ErrorCode { Access = 1, Line = 2, Field1 = 4, Field2 = 8, Field3 = 16 }

// la excepción lanzada por la capa [dao]
public class TaxException : Exception
{
    // código de error (una combinación de valores de ErrorCode)
    public int Code { get; init; }

    // constructores
    public TaxException(string message) : base(message) { }
    public TaxException(string message, Exception inner) : base(message, inner) { }
}
  • líneas 4–5: los códigos de error. El atributo [Flags] indica que los valores de la enumeración son bits que se pueden combinar con el operador [|]: el valor [ErrorCode.Field2 | ErrorCode.Field3] (8 + 16 = 24) significa que los campos 2 y 3 de una línea son incorrectos. El método [ToString] de una enumeración de este tipo muestra entonces “Field2, Field3”. El valor [Json] de la versión 3 se ha eliminado, ya que esta versión no lee el archivo JSON;
  • línea 8: una excepción específica de la aplicación derivada de la clase [Exception];
  • línea 11: el código de error, un entero que combina valores de [ErrorCode], es una propiedad [init] (C# 9): solo se le puede asignar un valor al crear el objeto, por ejemplo con un inicializador [new TaxException(...) { Code = ... }];
  • líneas 14–15: dos constructores, uno con un mensaje y otro con un mensaje y la excepción original, que será accesible mediante la propiedad [InnerException]. Simplemente llaman al constructor correspondiente de la clase padre [Exception] ([: base(...)]).

En esta versión, solo la clase [FileTax] de la capa [dao] instancia [TaxException].

6.3.3. La capa [dao]

Repasemos la interfaz de la capa [dao]:

using Entities;

namespace Dao;

// la interfaz de la capa [dao]
public interface ITaxDao
{
    // los tramos del impuesto
    TaxBracket[] TaxBrackets { get; }
}

Implementamos esta interfaz de dos maneras distintas. Primero, con la clase [HardwiredTax]:

using Entities;

namespace Dao;

// una capa [dao] cuyos datos están escritos directamente en el código
public class HardwiredTax : ITaxDao
{
    // tramos del impuesto (tabla de 2004 sobre ingresos de 2003)
    public TaxBracket[] TaxBrackets { get; } =
    [
        new(4962M, 0M, 0M),
        new(8382M, 0.068M, 291.09M),
        new(14753M, 0.191M, 1322.92M),
        new(23888M, 0.283M, 2668.39M),
        new(38868M, 0.374M, 4846.98M),
        new(47932M, 0.426M, 6883.66M),
        new(0M, 0.481M, 9505.54M),
    ];
}
  • línea 6: la clase [HardwiredTax] implementa la interfaz [ITaxDao];
  • línea 9: implementación de la propiedad [TaxBrackets] de la interfaz. Es una propiedad automática de solo lectura, inicializada mediante un inicializador de propiedad (C# 6);
  • líneas 11–17: el valor inicial es una expresión de colección (C# 12): la lista de elementos entre corchetes crea una matriz llamada [TaxBracket[]]. Cada elemento se crea con ***[new(...)]***: no se repite el tipo del objeto creado; se infiere del tipo esperado, [TaxBracket] (C# 9).

La interfaz [ITaxDao] también la implementa la clase [FileTax], que lee los tramos impositivos de un archivo de texto. El archivo [TaxData.txt] es el siguiente:

1
2
3
4
5
6
7
4962:0:0
8382:0.068:291.09
14753:0.191:1322.92
23888:0.283:2668.39
38868:0.374:4846.98
47932:0.426:6883.66
0:0.481:9505.54

Cada línea describe un tramo impositivo con el formato [limit:coeffR:coeffN]. Los números se escriben con punto decimal, sea cual sea el idioma del sistema; esto garantiza que el archivo sea legible en todas las máquinas. Los valores son los de la escala de impuestos de 2004 para los ingresos de 2003, conservados tal cual: se trata de un ejercicio. La clase [FileTax] es la siguiente:

using System.Globalization;
using Entities;
using static Entities.ErrorCode;

namespace Dao;

// una capa [dao] que lee los tramos del impuesto de un archivo de texto
// una línea por tramo: limit:coeffR:coeffN (punto decimal)
public class FileTax : ITaxDao
{
    // archivo de datos, relativo a la carpeta del ejecutable
    public string FileName { get; }

    // tramos del impuesto
    public TaxBracket[] TaxBrackets { get; }

    // constructor
    public FileTax(string fileName)
    {
        // almacenamos el nombre del archivo
        FileName = fileName;
        // los tramos leídos
        List<TaxBracket> brackets = [];
        // lectura del archivo línea por línea
        string path = Path.Combine(AppContext.BaseDirectory, fileName);
        int lineNumber = 0;
        try
        {
            if (!File.Exists(path))
            {
                throw new FileNotFoundException($"The file [{fileName}] does not exist", fileName);
            }
            foreach (string lineRead in File.ReadLines(path))
            {
                lineNumber++;
                // las líneas vacías se ignoran
                string line = lineRead.Trim();
                if (line == "")
                {
                    continue;
                }
                // línea dividida en tres campos separados por :
                string[] fields = line.Split(':', StringSplitOptions.TrimEntries);
                ErrorCode code = 0;
                decimal limit = 0, coeffR = 0, coeffN = 0;
                if (fields.Length != 3)
                {
                    code = Line;
                }
                else
                {
                    // conversiones de los 3 campos: cada error agrega su código
                    if (!TryParse(fields[0], out limit)) code |= Field1;
                    if (!TryParse(fields[1], out coeffR)) code |= Field2;
                    if (!TryParse(fields[2], out coeffN)) code |= Field3;
                }
                // ¿error?
                if (code != 0)
                {
                    throw new TaxException($"Line no. {lineNumber} is incorrect: [{line}]") { Code = (int)code };
                }
                // almacenamos el nuevo tramo del impuesto
                brackets.Add(new TaxBracket(limit, coeffR, coeffN));
            }
        }
        catch (Exception e) when (e is IOException or UnauthorizedAccessException)
        {
            // error de acceso al archivo: lo envolvemos en una TaxException
            throw new TaxException($"Error while reading the file {fileName}", e)
            {
                Code = (int)Access
            };
        }
        // devolvemos la lista como arreglo
        TaxBrackets = [.. brackets];
    }

    // un número en formato invariante: dígitos y punto decimal
    private static bool TryParse(string field, out decimal result) =>
        decimal.TryParse(field, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out result);
}
  • Línea 3: la directiva [using static] (C# 6) permite usar los miembros estáticos y los tipos anidados de un tipo sin prefijo. Los valores de una enumeración son constantes y, por lo tanto, miembros estáticos: escribimos [Field1] instead of [ErrorCode.Field1];
  • línea 9: la clase [FileTax] implementa la interfaz [ITaxDao];
  • línea 15: la propiedad de la interfaz [ITaxDao]. No tiene [set]: solo se le puede asignar un valor en el constructor (línea 75);
  • línea 18: el constructor recibe el nombre del archivo de tramos impositivos;
  • línea 23: los tramos impositivos leídos se acumulan en una lista, inicializada con una expresión de colección vacía;
  • línea 25: el archivo se busca en la carpeta del ejecutable, [AppContext.BaseDirectory], donde el archivo [.csproj] lo copió. Si [fileName] es una ruta absoluta, [Path.Combine] la deja tal cual;
  • líneas 29–31: si el archivo no existe, se lanza una [FileNotFoundException] con nuestro propio mensaje. El mensaje de excepción que lanzaría .NET de otro modo contiene la ruta completa del archivo;
  • línea 33: [File.ReadLines] lee el archivo línea por línea: las líneas se leen a medida que avanza el bucle [foreach], y el archivo se cierra al final del bucle, incluso si se lanza una excepción;
  • línea 43: la línea se divide en los dos puntos; la opción [StringSplitOptions.TrimEntries] elimina los espacios alrededor de cada campo;
  • líneas 46–48: una línea que no tiene tres campos no es válida;
  • líneas 53–55: conversión de los tres campos. Cada campo incorrecto agrega un bit al código de error mediante el operador [|=];
  • líneas 58–60: una línea incorrecta lanza una [TaxException], cuyo mensaje indica el número y el contenido de la línea. El código, de tipo [ErrorCode], se convierte en entero mediante [(int)code];
  • línea 63: el tramo leído se agrega a la lista;
  • línea 66: el filtro de excepciones [when] (C# 6) intercepta solo los errores de E/S: [IOException], de la que deriva [FileNotFoundException], y [UnauthorizedAccessException] (permisos insuficientes). El patrón [e is IOException or UnauthorizedAccessException] (C# 9) comprueba ambos tipos. La [TaxException] lanzada en la línea 60 no se captura: se propaga tal cual al código que llama;
  • líneas 69–71: el error de E/S se encapsula en una [TaxException] con el código [Access]; la excepción original se conserva en su propiedad [InnerException];
  • línea 75: la lista se copia en una matriz. El operador [..] (“spread”) de una expresión de colección inserta todos los elementos de otra colección;
  • líneas 79–80: conversión de un campo a [decimal]. El estilo [NumberStyles.AllowDecimalPoint] acepta solo dígitos y un punto decimal, y la referencia cultural invariable [CultureInfo.InvariantCulture] exige un punto como separador decimal. Así, “0,191” se rechaza, aunque una referencia cultural fr-FR lo habría aceptado. El método se escribe con un cuerpo de expresión [=>] (C# 6).

6.3.4. La capa [business]

Repasemos la interfaz de esta capa:

1
2
3
4
5
6
7
namespace Business;

// la interfaz de la capa [business]
public interface ITaxBusiness
{
    int CalculateTax(bool married, int nbChildren, int salary);
}

Su implementación, [TaxBusiness], es la siguiente:

using Dao;
using Entities;

namespace Business;

// la capa [business] recibe la capa [dao] mediante su constructor (constructor primario)
public class TaxBusiness(ITaxDao dao) : ITaxBusiness
{
    // los tramos del impuesto, solicitados una sola vez a la capa [dao]
    private readonly TaxBracket[] brackets = dao.TaxBrackets;

    // cálculo del impuesto
    public int CalculateTax(bool married, int nbChildren, int salary)
    {
        // verificación de los parámetros
        ArgumentOutOfRangeException.ThrowIfNegative(nbChildren);
        ArgumentOutOfRangeException.ThrowIfNegative(salary);
        // número de partes
        decimal shares = nbChildren / 2M + (married ? 2 : 1);
        if (nbChildren >= 3)
        {
            shares += 0.5M;
        }
        // ingreso gravable y cociente familiar
        decimal income = 0.72M * salary;
        decimal qf = income / shares;
        // el tramo: el primero cuyo límite es mayor o igual que QF,
        // el último si ninguno se ajusta (su límite no se usa)
        TaxBracket bracket = brackets[^1];
        for (int i = 0; i < brackets.Length - 1; i++)
        {
            if (qf <= brackets[i].Limit)
            {
                bracket = brackets[i];
                break;
            }
        }
        // impuesto (parte entera)
        return (int)(income * bracket.CoeffR - shares * bracket.CoeffN);
    }
}
  • Línea 7: la clase [TaxBusiness] implementa la interfaz [ITaxBusiness]. La capa [business] debe colaborar con la capa [dao]: por lo tanto, recibe una referencia al objeto que implementa la interfaz [ITaxDao]. Esta referencia es el parámetro [dao] del constructor primario de la clase (C# 12): los parámetros enumerados después del nombre de la clase son los de su constructor, y pueden usarse en todo el cuerpo de la clase;
  • Línea 10: al construir el objeto, la capa [business] solicita los tramos impositivos a la capa [dao] una sola vez y los almacena en un campo de solo lectura. Observe que la capa [business] conoce la capa [dao] solo a través de su interfaz [ITaxDao]: no sabe si los tramos impositivos provienen del código, de un archivo o, más adelante, de una base de datos;
  • Líneas 16–17: la capa [business] no confía en quienes la llaman. Los métodos estáticos [ThrowIfNegative] (.NET 8) lanzan una [ArgumentOutOfRangeException] si su parámetro es negativo; el mensaje de la excepción contiene el nombre del parámetro;
  • líneas 19–22: el número de partes. La división [nbChildren / 2M] es una división decimal porque [2M] es un [decimal]: 3 hijos equivalen a 1,5 partes;
  • líneas 25–26: la renta imponible y el cociente familiar;
  • líneas 29–35: buscamos el primer tramo cuyo umbral es mayor o igual que el cociente familiar. El último tramo, [brackets[^1]] (el índice [^1] hace referencia al último elemento, C# 8), se usa si ningún otro tramo corresponde: su umbral (0) no se utiliza;
  • línea 39: el impuesto, truncado a su parte entera.

El código del curso de 2008 escribía [taxBrackets[taxBrackets.Length - 1].Limit = QF + 1] antes de buscar el tramo, de modo que el bucle de búsqueda siempre terminara. Esta instrucción modificaba el arreglo proporcionado por la [dao] capa: un efecto secundario sobre datos compartidos por todas las capas. De hecho, ya no podría escribirse así, puesto que un [TaxBracket] ahora es de solo lectura. El código moderno simplemente toma el último tramo cuando ningún límite es adecuado, sin modificar los datos que recibe.

6.3.5. La capa [ui]

En las versiones 2 y 3, la interfaz de usuario se escribía en el programa principal, después de la creación del objeto de cálculo. La única diferencia estaba en la forma de crear este objeto. Ahora aislamos esta interacción en una clase dentro de la capa [ui], que conoce la capa [business] únicamente a través de su interfaz:

using Business;

namespace Ui;

// el diálogo de consola con el usuario: solo conoce la interfaz de la capa [business]
public static class Dialog
{
    // ayuda que se muestra en caso de ingreso incorrecto
    private const string Syntax = """
        syntax: Married NbChildren Salary
        Married: y for married, n for not married
        NbChildren: number of children
        Salary: annual salary in euros
        """;

    // bucle de diálogo: ingreso de los parámetros, cálculo, visualización
    public static void Run(ITaxBusiness business)
    {
        while (true)
        {
            // se piden los parámetros del cálculo del impuesto
            Console.Write("Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: ");
            string parameters = Console.ReadLine()?.Trim() ?? "";
            // ¿algo que hacer?
            if (parameters == "")
            {
                break;
            }
            // verificación del número de parámetros
            string[] fields = parameters.Split(' ', StringSplitOptions.RemoveEmptyEntries);
            if (fields.Length != 3)
            {
                Console.WriteLine(Syntax);
                continue;
            }
            // married
            string married = fields[0].ToLower();
            if (married != "y" && married != "n")
            {
                Console.WriteLine($"{Syntax}\nIncorrect Married argument: type y or n");
                continue;
            }
            // número de hijos
            if (!int.TryParse(fields[1], out int nbChildren) || nbChildren < 0)
            {
                Console.WriteLine($"{Syntax}\nIncorrect NbChildren argument: type a positive or zero integer");
                continue;
            }
            // salary
            if (!int.TryParse(fields[2], out int salary) || salary < 0)
            {
                Console.WriteLine($"{Syntax}\nIncorrect Salary argument: type a positive or zero integer");
                continue;
            }
            // los parámetros son correctos: pedimos el cálculo a la capa [business]
            Console.WriteLine($"Tax={business.CalculateTax(married == "y", nbChildren, salary)} euros");
        }
    }
}
  • línea 6: la clase [Dialog] es estática: no tiene estado propio y contiene solo miembros estáticos;
  • líneas 9–14: el mensaje de ayuda es un literal de cadena sin formato (C# 11), delimitado por tres comillas. Puede ocupar varias líneas; se elimina la sangría común de las líneas, determinada por la posición de las comillas de cierre;
  • línea 17: el método [Run] recibe la capa [business] en forma de su interfaz [ITaxBusiness]. No sabe nada de la clase que la implementa ni de la capa [dao];
  • Línea 23: [Console.ReadLine] produce [null] al final del flujo de entrada; el operador [?.] produce entonces [null] sin llamar a [Trim], y el operador [??] reemplaza [null] por la cadena vacía: un fin de flujo termina el diálogo igual que una línea vacía;
  • línea 30: la línea ingresada se divide por espacios; la opción [StringSplitOptions.RemoveEmptyEntries] ignora los espacios múltiples;
  • líneas 44–50: [int.TryParse(fields[1], out int nbChildren)] declara la variable de salida en la propia llamada (C# 7);
  • línea 56: los parámetros son correctos: se solicita el cálculo a la capa [business].

6.3.6. Integración de las capas

Solo falta crear las capas y vincularlas entre sí. Este es el papel del programa principal [Program.cs]:

using Dao;
using Entities;
using Business;
using Ui;

// integración de las capas: es el único lugar donde se nombran las clases de implementación
// argumento: "hardwired" para HardwiredTax, de lo contrario el archivo leído por FileTax (TaxData.txt por defecto)
string source = args.Length > 0 ? args[0] : "TaxData.txt";
ITaxBusiness business;
try
{
    // creación de la capa [dao]
    ITaxDao dao = source == "hardwired" ? new HardwiredTax() : new FileTax(source);
    // creación de la capa [business], que recibe la capa [dao]
    business = new TaxBusiness(dao);
}
catch (TaxException e)
{
    // visualización del error y detención del programa
    string origin = e.InnerException is null ? "" : $", original exception: {e.InnerException.Message}";
    Console.WriteLine($"The following error occurred: [Code={(ErrorCode)e.Code}, Message={e.Message}{origin}]");
    return 1;
}

// la capa [ui]: el diálogo con el usuario
Dialog.Run(business);
return 0;
  • línea 8: el argumento del programa selecciona la implementación de la capa [dao]: [hardwired] para la clase [HardwiredTax]; de lo contrario, el nombre del archivo leído por la clase [FileTax], con [TaxData.txt] como valor predeterminado. Observe que, con las instrucciones de nivel superior, los argumentos de la línea de comandos se almacenan en el arreglo [args];
  • línea 13: creación de la capa [dao]. Este es el único lugar del programa donde se nombran las clases [HardwiredTax] y [FileTax] ;
  • línea 15: creación de la capa [business], que recibe la capa [dao];
  • Líneas 17–22: la creación de la capa [dao] puede lanzar una [TaxException]. Entonces se muestra el error, junto con el mensaje de la excepción original (si existe), y el programa termina con el código de salida 1. Como en la versión 3, el código se convierte a [ErrorCode] para mostrarlo en texto legible;
  • Línea 26: las capas están listas: la capa [ui] interactúa con el usuario.

6.3.7. Ejecuciones

Con el archivo [TaxData.txt] (implementación [FileTax]), y probando la validación de las entradas:

> dotnet run
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 3 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: x 2 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect Married argument: type y or n
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y -2 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect NbChildren argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000€
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect Salary argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Con la implementación [HardwiredTax]:

1
2
3
4
5
6
> dotnet run -- hardwired
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Con un archivo que no existe:

> dotnet run -- TaxDataMissing.txt
The following error occurred: [Code=Access, Message=Error while reading the file TaxDataMissing.txt, original exception: The file [TaxDataMissing.txt] does not exist]

El código de error es [Access], y se muestra el mensaje de la excepción original, [FileNotFoundException].

Con el siguiente archivo, [TaxDataInvalid.txt], donde la línea 3 contiene comas decimales:

1
2
3
4
4962:0:0
8382:0.068:291.09
14753:0,191:1322,92
23888:0.283:2668.39

el resultado es:

> dotnet run -- TaxDataInvalid.txt
The following error occurred: [Code=Field2, Field3, Message=Line no. 3 is incorrect: [14753:0,191:1322,92]]

Los campos 2 y 3 de la línea 3 son incorrectos: el código de error combina los bits de [Field2] y [Field3], y el método [ToString] de una enumeración [Flags] lo muestra como “Field2, Field3.”

6.3.8. Conclusión

La arquitectura en capas y el uso de interfaces han dado cierta flexibilidad a nuestra aplicación. Esto es evidente en la forma en que el programa principal crea las capas [dao] y [business]:

ITaxDao dao = source == "hardwired" ? new HardwiredTax() : new FileTax(source);
business = new TaxBusiness(dao);

Cambiar la implementación de la capa [dao] modifica únicamente la línea 1. Una vez creadas las capas, el código de la capa [ui] es el mismo en ambos casos: se accede a la capa [business] a través de su interfaz [ITaxBusiness], y no a través de su clase de implementación.

La misma flexibilidad se observa en la capa [business]: se construye a partir de una referencia a la interfaz de la capa [dao]. Por lo tanto, cambiar la implementación de esta última no tiene ningún impacto en la capa [business]. Por eso nuestra única clase [TaxBusiness] pudo funcionar sin modificaciones con dos implementaciones distintas de la capa [dao].

6.4. Aplicación de ejemplo - Versión 5

Image

Esta nueva versión se basa en la anterior con los siguientes cambios:

  • Las capas [dao] y [business] se colocan cada una en una biblioteca de clases (DLL) y se prueban con el framework de pruebas unitarias MSTest;
  • La capa [dao] recibe una tercera implementación, [JsonTax], que lee los tramos del impuesto desde un archivo JSON;
  • la integración de las capas queda a cargo del contenedor de inyección de dependencias de .NET, y la implementación de la capa [dao] se selecciona desde un archivo de configuración.

En los proyectos grandes, varios desarrolladores trabajan en la misma aplicación. Las arquitecturas en capas facilitan esta forma de trabajo: dado que las capas se comunican entre sí mediante interfaces bien definidas, un desarrollador que trabaja en una capa no tiene que preocuparse por el trabajo de los demás desarrolladores en las otras capas. Basta con que todos respeten las interfaces.

Así, para probar la capa [business], el desarrollador necesita una implementación de la capa [dao]. Mientras esa implementación no esté terminada, el desarrollador puede usar una implementación ficticia de la capa [dao], siempre que respete la interfaz [ITaxDao]. Esta es otra ventaja de la arquitectura en capas: un retraso en la capa [dao] no impide probar la capa [business]. La implementación simulada (mock) tiene además la ventaja de ser mucho más simple de preparar que la capa [dao] real, que puede requerir un DBMS, conexiones de red, etc.

Una vez que la capa [dao] está completa y probada, se entrega a los desarrolladores de la capa [business] en forma de biblioteca (un proyecto o una DLL) en lugar de código fuente que deba copiarse. Finalmente, la aplicación se entrega como un ejecutable (el de la capa [ui]) y bibliotecas de clases (las demás capas).

6.4.1. La solución TaxV5

La versión 5 es una solución compuesta por cuatro proyectos: uno por capa, más un proyecto de pruebas unitarias. Se construye con los siguientes comandos, ingresados en la carpeta [TaxV5]:

1
2
3
4
5
6
7
8
9
> dotnet new classlib -n Tax.Dao -o Tax.Dao
> dotnet new classlib -n Tax.Business -o Tax.Business
> dotnet new console -n Tax.Ui -o Tax.Ui
> dotnet new mstest -n Tax.Tests -o Tax.Tests
> dotnet new sln --format slnx -n TaxV5
> dotnet sln TaxV5.slnx add Tax.Dao Tax.Business Tax.Ui Tax.Tests
> dotnet add Tax.Business reference Tax.Dao
> dotnet add Tax.Ui reference Tax.Business Tax.Dao
> dotnet add Tax.Tests reference Tax.Business Tax.Dao
  • [dotnet new classlib] crea un proyecto de biblioteca de clases: al compilarlo se produce un archivo DLL, no un ejecutable. La plantilla crea un archivo [Class1.cs], que eliminamos;
  • [dotnet new mstest] crea un proyecto de pruebas, MSTest, que se describe más adelante;
  • [dotnet new sln --format slnx] crea el archivo de solución [TaxV5.slnx], en el formato XML introducido por el SDK en .NET 9. Este es el formato predeterminado de [dotnet new sln] desde .NET 10; la opción [--format slnx] solo lo hace explícito; [dotnet sln add] le agrega los proyectos;
  • [dotnet add reference] agrega una referencia de proyecto a proyecto: la capa [business] usa la capa [dao], la capa [ui] usa las otras dos, al igual que las pruebas.

Esto da como resultado la siguiente estructura de árbol:

TaxV5/
  TaxV5.slnx
  Tax.Dao/                       library: entities and [dao] layer
    Tax.Dao.csproj
    TaxData.txt
    TaxData.json
    Entities/
      TaxBracket.cs
      TaxException.cs
    Dao/
      ITaxDao.cs
      HardwiredTax.cs
      FileTax.cs
      JsonTax.cs
  Tax.Business/                  library: [business] layer
    Tax.Business.csproj
    ITaxBusiness.cs
    TaxBusiness.cs
  Tax.Ui/                        executable: [ui] layer and integration of the layers
    Tax.Ui.csproj
    Dialog.cs
    Program.cs
    appsettings.json
    appsettings-json.json
    appsettings-hardwired.json
    appsettings-error.json
  Tax.Tests/                     MSTest unit tests
    Tax.Tests.csproj
    MSTestSettings.cs
    DaoTests.cs
    BusinessTests.cs
    TaxDataInvalid.txt
  Trials/                        two trial programs
    trial-dao.cs
    trial-business.cs

El archivo de solución es el siguiente:

1
2
3
4
5
6
<Solution>
  <Project Path="Tax.Dao/Tax.Dao.csproj" />
  <Project Path="Tax.Business/Tax.Business.csproj" />
  <Project Path="Tax.Tests/Tax.Tests.csproj" />
  <Project Path="Tax.Ui/Tax.Ui.csproj" />
</Solution>

El comando [dotnet build TaxV5.slnx] compila los cuatro proyectos en el orden especificado por sus referencias: primero [Tax.Dao] , luego [Tax.Business], después [Tax.Ui] y, por último, [Tax.Tests].

6.4.2. La capa [dao]

El proyecto [Tax.Dao] contiene la capa [dao] y las entidades de la aplicación. Su archivo de proyecto es el siguiente:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <!-- los archivos de datos se copian junto al ejecutable
         (y junto al de cualquier proyecto que haga referencia a este) -->
    <None Update="TaxData.txt" CopyToOutputDirectory="PreserveNewest" />
    <None Update="TaxData.json" CopyToOutputDirectory="PreserveNewest" />
  </ItemGroup>

</Project>
  • líneas 4–6: las propiedades generadas por [dotnet new classlib]. No hay una etiqueta [OutputType]: el proyecto produce una biblioteca [Tax.Dao.dll];
  • Líneas 12–13: los archivos de datos se copian a la carpeta de compilación. Los archivos marcados de esta manera también se copian a la carpeta de compilación de cualquier proyecto que haga referencia a [Tax.Dao]: los proyectos [Tax.Ui] y [Tax.Tests] tendrán los archivos de datos sin necesidad de declararlos.

Entidades

La estructura [TaxBracket] y la clase [TaxException] son las de la versión 4. Solo se elimina del archivo la enumeración [ErrorCode] : [TaxException] pasa así a ser común a todas las implementaciones de la capa [dao], sin estar atada a los códigos de ninguna de ellas:

namespace Entities;

// la excepción de la aplicación [Tax], sea cual sea la capa que la lance
public class TaxException : Exception
{
    // código de error
    public int Code { get; init; }

    // constructores
    public TaxException(string message) : base(message) { }
    public TaxException(string message, Exception inner) : base(message, inner) { }
}
  • Línea 7: el código de error sigue siendo un simple entero: cada implementación de la capa [dao] define sus propios códigos.

La implementación [FileTax]

La interfaz [ITaxDao] y la clase [HardwiredTax] son las de la versión 4. La clase [FileTax] difiere únicamente en la ubicación de sus códigos de error:

using System.Globalization;
using Entities;

namespace Dao;

// una capa [dao] que lee los tramos del impuesto de un archivo de texto
// una línea por tramo: limit:coeffR:coeffN (punto decimal)
public class FileTax : ITaxDao
{
    // códigos de error específicos de esta implementación: se pueden combinar
    [Flags]
    public enum ErrorCodes { Access = 1, Line = 2, Field1 = 4, Field2 = 8, Field3 = 16 }

    // archivo de datos, relativo a la carpeta del ejecutable
    public string FileName { get; }
  • líneas 11–12: los códigos de error, que antes estaban en la enumeración [ErrorCode] dentro del espacio de nombres [Entities], se han trasladado a la clase [FileTax], en forma de una enumeración anidada [ErrorCodes]: se trata, en efecto, de códigos propios de esta implementación de la interfaz [ITaxDao] ([JsonTax] tiene los suyos). Se escriben [ErrorCodes.Field1] dentro de la clase y [FileTax.ErrorCodes.Field1] fuera de ella. La directiva [using static] de la versión 4 ya no es necesaria.

Más adelante, en el constructor:

                // ¿error?
                if (code != 0)
                {
                    throw new TaxException($"Line no. {lineNumber} is incorrect: [{line}]") { Code = (int)code };
                }
                // almacenamos el nuevo tramo del impuesto
                brackets.Add(new TaxBracket(limit, coeffR, coeffN));
            }
        }
        catch (Exception e) when (e is IOException or UnauthorizedAccessException)
        {
            // error de acceso al archivo: lo envolvemos en una TaxException
            throw new TaxException($"Error while reading the file {fileName}", e)
            {
                Code = (int)ErrorCodes.Access
            };
        }
        // devolvemos la lista como arreglo
        TaxBrackets = [.. brackets];
    }
  • líneas 63, 72: los errores se encapsulan en una [TaxException]. El código de error, de tipo [ErrorCodes], se convierte en entero mediante [(int)code].

La implementación [JsonTax]

El capítulo anterior mostró cómo leer datos en formato JSON con [System.Text.Json]. La tercera implementación de la capa [dao] lee los tramos del impuesto del siguiente archivo [TaxData.json]:

1
2
3
4
5
6
7
8
9
[
  { "limit": 4962, "coeffR": 0, "coeffN": 0 },
  { "limit": 8382, "coeffR": 0.068, "coeffN": 291.09 },
  { "limit": 14753, "coeffR": 0.191, "coeffN": 1322.92 },
  { "limit": 23888, "coeffR": 0.283, "coeffN": 2668.39 },
  { "limit": 38868, "coeffR": 0.374, "coeffN": 4846.98 },
  { "limit": 47932, "coeffR": 0.426, "coeffN": 6883.66 },
  { "limit": 0, "coeffR": 0.481, "coeffN": 9505.54 }
]

La clase [JsonTax] es la siguiente:

using System.Text.Json;
using System.Text.Json.Serialization;
using Entities;

namespace Dao;

// una capa [dao] que lee los tramos del impuesto de un archivo JSON
public class JsonTax : ITaxDao
{
    // códigos de error específicos de esta implementación
    public enum ErrorCodes { Access = 1, Format = 2 }

    // archivo de datos, relativo a la carpeta del ejecutable
    public string FileName { get; }

    // tramos del impuesto
    public TaxBracket[] TaxBrackets { get; }

    // constructor
    public JsonTax(string fileName)
    {
        FileName = fileName;
        string path = Path.Combine(AppContext.BaseDirectory, fileName);
        string json;
        try
        {
            if (!File.Exists(path))
            {
                throw new FileNotFoundException($"The file [{fileName}] does not exist", fileName);
            }
            json = File.ReadAllText(path);
        }
        catch (Exception e) when (e is IOException or UnauthorizedAccessException)
        {
            throw new TaxException($"Error while reading the file {fileName}", e)
            {
                Code = (int)ErrorCodes.Access
            };
        }
        try
        {
            // deserialización con el código generado en tiempo de compilación (ver BracketsJsonContext)
            TaxBrackets = JsonSerializer.Deserialize(json, BracketsJsonContext.Default.TaxBracketArray)
                ?? throw new JsonException("the file does not contain an array");
        }
        catch (JsonException e)
        {
            throw new TaxException($"The file {fileName} is not a valid JSON file of tax brackets", e)
            {
                Code = (int)ErrorCodes.Format
            };
        }
    }
}

// el código de (de)serialización JSON del tipo TaxBracket[] se genera en tiempo de compilación
// opciones "Web": nombres de propiedades en camelCase, sin distinguir mayúsculas y minúsculas al leer
[JsonSourceGenerationOptions(JsonSerializerDefaults.Web)]
[JsonSerializable(typeof(TaxBracket[]))]
internal partial class BracketsJsonContext : JsonSerializerContext;
  • Línea 11: códigos de error de esta implementación: error de acceso al archivo o contenido incorrecto;
  • Líneas 27–31: el archivo se lee por completo en una cadena, con el mismo manejo de errores de E/S que en [FileTax];
  • línea 43: la cadena JSON se convierte en un arreglo [TaxBracket[]]. El segundo parámetro, [BracketsJsonContext.Default.TaxBracketArray], proporciona el código de deserialización para este tipo;
  • Línea 44: [Deserialize] devuelve [null] si el archivo contiene el literal JSON [null]; entonces la expresión [?? throw] (C# 7) lanza una excepción;
  • líneas 46–50: un archivo que no es un arreglo JSON de tramos provoca una [JsonException], encapsulada en una [TaxException] con código [Format];
  • líneas 58–60: sin un parámetro de este tipo, [JsonSerializer] descubre las propiedades de [TaxBracket] en tiempo de ejecución, mediante reflexión. Aquí, el atributo [JsonSerializable] indica al compilador que genere, dentro de la clase parcial [BracketsJsonContext], el código de (de)serialización para el tipo [TaxBracket[]]. Este código es más rápido y también funciona en aplicaciones compiladas a código nativo (AOT), donde la reflexión está deshabilitada, que es el comportamiento predeterminado de las aplicaciones de archivo único de .NET 10 que utilizaremos. La opción [JsonSerializerDefaults.Web] asigna los nombres JSON en camelCase ([limit]) a las propiedades de C# ([Limit]). Observe que [System.Text.Json] puede construir un [record struct] posicional llamando a su constructor.

Un programa de prueba

Antes de escribir pruebas automatizadas, realicemos una primera prueba visual de la capa [dao]. .NET 10 permite que una aplicación de archivo único haga referencia a un proyecto mediante la directiva [#:project]. El programa [Trials/trial-dao.cs] muestra los tramos proporcionados por las tres implementaciones:

#:project ../Tax.Dao/Tax.Dao.csproj
using Dao;
using Entities;

// los tramos del impuesto proporcionados por las tres implementaciones de la capa [dao]
try
{
    ITaxDao[] daos = [new HardwiredTax(), new FileTax("TaxData.txt"), new JsonTax("TaxData.json")];
    foreach (ITaxDao dao in daos)
    {
        Console.WriteLine($"--- {dao.GetType().Name}");
        foreach (TaxBracket t in dao.TaxBrackets)
        {
            Console.WriteLine($"{t.Limit}:{t.CoeffR}:{t.CoeffN}");
        }
    }
}
catch (TaxException e)
{
    // visualización del error
    string origin = e.InnerException is null ? "" : $", original exception: {e.InnerException.Message}";
    Console.WriteLine($"The following error occurred: [Code={e.Code}, Message={e.Message}{origin}]");
}
  • Línea 1: el programa usa el proyecto [Tax.Dao]. Este proyecto se compila junto con el programa, y sus archivos de datos se copian junto al ejecutable del programa de prueba. Nota: si luego modifica el proyecto referenciado sin modificar el programa, [dotnet run trial-dao.cs] puede reutilizar el ejecutable ya construido; la opción [--no-cache] fuerza entonces una nueva compilación;
  • línea 8: un arreglo de las tres implementaciones de la interfaz [ITaxDao];
  • línea 11: [GetType] devuelve el tipo real del objeto, cuyo nombre de clase es [Name];
  • líneas 18–22: manejo de una posible [TaxException].

Resultados:

> dotnet run trial-dao.cs
--- HardwiredTax
4962:0:0
8382:0.068:291.09
14753:0.191:1322.92
23888:0.283:2668.39
38868:0.374:4846.98
47932:0.426:6883.66
0:0.481:9505.54
--- FileTax
4962:0:0
8382:0.068:291.09
14753:0.191:1322.92
23888:0.283:2668.39
38868:0.374:4846.98
47932:0.426:6883.66
0:0.481:9505.54
--- JsonTax
4962:0:0
8382:0.068:291.09
14753:0.191:1322.92
23888:0.283:2668.39
38868:0.374:4846.98
47932:0.426:6883.66
0:0.481:9505.54

Las tres implementaciones devuelven los mismos tramos. La visualización de los números [decimal] sigue la configuración regional en-US del usuario: punto decimal.

6.4.3. La capa [business]

El archivo de proyecto [Tax.Business.csproj] es el siguiente:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <!-- la capa [business] usa la capa [dao] -->
    <ProjectReference Include="../Tax.Dao/Tax.Dao.csproj" />
  </ItemGroup>

</Project>
  • Línea 11: la referencia al proyecto [Tax.Dao] agregada por [dotnet add reference]. En el curso de 2008, la DLL compilada hacía referencia a la capa [dao], que había que recuperar de una carpeta llamada [bin]; una referencia de proyecto a proyecto compila [Tax.Dao] antes que [Tax.Business] y siempre usa su última versión.

La interfaz [ITaxBusiness] y la clase [TaxBusiness] son de la versión 4. El programa de prueba [Trials/trial-business.cs] realiza algunos cálculos de impuestos:

#:project ../Tax.Business/Tax.Business.csproj
using Dao;
using Entities;
using Business;

// algunos cálculos de impuestos con la capa [dao] FileTax
try
{
    ITaxBusiness business = new TaxBusiness(new FileTax("TaxData.txt"));
    Console.WriteLine($"Tax(true,2,60000)={business.CalculateTax(true, 2, 60000)} euros");
    Console.WriteLine($"Tax(false,3,60000)={business.CalculateTax(false, 3, 60000)} euros");
    Console.WriteLine($"Tax(false,3,6000)={business.CalculateTax(false, 3, 6000)} euros");
    Console.WriteLine($"Tax(false,3,600000)={business.CalculateTax(false, 3, 600000)} euros");
}
catch (TaxException e)
{
    // visualización del error
    string origin = e.InnerException is null ? "" : $", original exception: {e.InnerException.Message}";
    Console.WriteLine($"The following error occurred: [Code={e.Code}, Message={e.Message}{origin}]");
}
  • Línea 1: el programa hace referencia al proyecto [Tax.Business]; como este proyecto hace referencia a [Tax.Dao], el programa también tiene acceso a la capa [dao] y sus funcionalidades;
  • Línea 9: creación de las capas [dao] y [business] . La capa [dao] se implementa mediante la clase [FileTax];
  • Líneas 10–13: llamadas repetidas al único método de la interfaz [ITaxBusiness].

Resultados:

1
2
3
4
5
> dotnet run trial-business.cs
Tax(true,2,60000)=4282 euros
Tax(false,3,60000)=4282 euros
Tax(false,3,6000)=0 euros
Tax(false,3,600000)=179275 euros

Una pareja casada con 2 hijos y una persona soltera con 3 hijos tienen el mismo número de partes (3): sus impuestos son iguales.

6.4.4. Pruebas unitarias con MSTest

6.4.4.1. El principio

Las pruebas realizadas hasta ahora se basaban en la verificación visual: comprobábamos que la pantalla mostrara los resultados esperados. Este método es impracticable cuando hay muchas pruebas que ejecutar: los humanos son propensos a la fatiga, y su capacidad para verificar resultados disminuye a medida que avanza el día. Por lo tanto, las pruebas deben automatizarse y no requerir ninguna intervención humana.

Una aplicación evoluciona con el tiempo. En cada actualización, debemos verificar que no “regrese” a un estado anterior, es decir, que siga superando las pruebas de funcionalidad realizadas durante su desarrollo inicial. Estas pruebas se llaman pruebas de no regresión. Una aplicación de tamaño moderado puede requerir cientos de pruebas: de hecho, se prueba cada método de cada clase de la aplicación. Estas se llaman pruebas unitarias.

Se han desarrollado frameworks para automatizar estas pruebas. El curso de 2008 usaba NUnit 2.4 y su interfaz gráfica de usuario. Aquí usamos MSTest, el framework de pruebas de Microsoft, en su versión 4 (NUnit y xUnit son otros dos frameworks muy utilizados que funcionan según el mismo principio). Las pruebas se ejecutan con el comando [dotnet test] desde la línea de comandos: esto permite lanzarlas automáticamente, por ejemplo, cada vez que se despliegan cambios de código en un servidor de integración continua. Los entornos integrados (Visual Studio, VS Code, Rider) también cuentan con un explorador de pruebas que muestra las pruebas en una estructura de árbol.

6.4.4.2. Un primer ejemplo

Examinemos el principio de las pruebas con MSTest mediante un ejemplo. Creamos un proyecto de pruebas con el comando:

> dotnet new mstest -n DemoTests -o DemoTests

La plantilla crea un archivo de proyecto, que modificamos para usar la versión 4.0.2 de MSTest:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <LangVersion>latest</LangVersion>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="MSTest" Version="4.0.2" />
  </ItemGroup>

  <ItemGroup>
    <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
  </ItemGroup>

</Project>
  • Línea 11: el proyecto usa el paquete NuGet [MSTest]. Este paquete incluye el framework (los atributos y la clase [Assert]), el adaptador que permite a [dotnet test] encontrar y ejecutar las pruebas, y analizadores de código que emiten advertencias sobre pruebas mal escritas;
  • Línea 15: un [using] global: el espacio de nombres [Microsoft.VisualStudio.TestTools.UnitTesting] de MSTest se importa en todos los archivos del proyecto.

La plantilla también crea un archivo [MSTestSettings.cs], que especifica que las pruebas deben ejecutarse en paralelo. Lo reemplazamos por el siguiente para que las pruebas se ejecuten una tras otra y sus resultados aparezcan en un orden coherente:

// las pruebas se ejecutan una tras otra (visualización en orden estable)
[assembly: DoNotParallelize]
  • Línea 2: un atributo que se aplica a todo el ensamblado (DLL) y no a una clase específica.

La clase de pruebas [Tests1] es la siguiente:

namespace DemoTests;

// una clase de pruebas
[TestClass]
public class Tests1
{
    // el método probado
    private static int Sum(int a, int b) => a + b;

    // constructor
    public Tests1()
    {
        Console.WriteLine("constructor");
    }

    // se ejecuta antes de cada prueba
    [TestInitialize]
    public void Before()
    {
        Console.WriteLine("before");
    }

    // se ejecuta después de cada prueba
    [TestCleanup]
    public void After()
    {
        Console.WriteLine("after");
    }

    // una prueba que tiene éxito
    [TestMethod]
    public void T1()
    {
        Console.WriteLine("test1");
        Assert.AreEqual(4, Sum(2, 2));
    }

    // una prueba que falla
    [TestMethod]
    public void T2()
    {
        Console.WriteLine("test2");
        Assert.AreEqual(5, Sum(2, 2), "2 + 2 is not equal to 5");
    }
}
  • Línea 4: el atributo [TestClass] indica que la clase contiene pruebas. Debe ser pública;
  • línea 8: el método que se prueba. En un proyecto real, estaría en otro proyecto, referenciado por el proyecto de pruebas;
  • Líneas 11–13: el constructor. Se usa solo para mostrar un mensaje en pantalla: queremos ver cuándo se ejecuta;
  • línea 17: el atributo [TestInitialize] designa un método que se ejecuta antes de cada prueba;
  • línea 24: el atributo [TestCleanup] designa un método que se ejecuta después de cada prueba;
  • línea 31: el atributo [TestMethod] designa un método de prueba. Un método de prueba es público, no devuelve nada (o devuelve una [Task] si es asíncrono) y, con una excepción que veremos, no tiene parámetros;
  • línea 35: el método [Assert.AreEqual(expected, actual)] verifica que el valor obtenido sea igual al valor esperado. Si no es así, lanza una excepción y la prueba falla. Aquí, la aserción debe cumplirse;
  • línea 43: esta aserción debe fallar. El tercer parámetro es el mensaje que se muestra en caso de fallo.

Las pruebas se ejecutan con el comando [dotnet test] en la carpeta del proyecto. La opción [--logger "console;verbosity=detailed"] muestra los detalles de cada prueba, incluida su salida en pantalla:

> dotnet test --logger "console;verbosity=detailed"
Test run for bin/Debug/net10.0/DemoTests.dll (.NETCoreApp,Version=v10.0)
VSTest version 18.0.2 (x64)

Starting test execution, please wait...
A total of 1 test files matched the specified pattern.
bin/Debug/net10.0/DemoTests.dll
  Passed T1 [14 ms]
  Standard Output Messages:
 constructor
 before
 test1
 after


  Failed T2 [13 ms]
  Error Message:
   Assert.AreEqual failed. Expected:<5>. Actual:<4>. 'expected' expression: '5', 'actual' expression: 'Sum(2, 2)'. 2 + 2 is not equal to 5
  Stack Trace:
     (stack trace removed)
  Standard Output Messages:
 constructor
 before
 test2
 after


  Passed T3 [1 ms]
  Passed T4 [1 ms]
  Passed T5 [1 ms]
  Passed T6 [1 ms]
  Passed T7 (1,1,2) [< 1 ms]
  Passed T7 (2,3,5) [< 1 ms]
  Passed T7 (-1,1,0) [< 1 ms]

Test Run Failed.
Total tests: 9
     Passed: 8
     Failed: 1
 Total time: 0.8964 Seconds
  • línea 8: la prueba [T1] pasó;
  • líneas 10–13: sus salidas en pantalla: se ejecutó el constructor, seguido del método [Before], la prueba y, por último, el método [After];
  • línea 16: la prueba [T2] falló;
  • línea 18: el mensaje de error: el valor esperado, el valor real, las expresiones que los produjeron y el mensaje pasado a [Assert.AreEqual];
  • línea 19: MSTest también muestra la pila de llamadas en el momento del fallo, que conduce a la línea defectuosa. La hemos eliminado de la salida;
  • Líneas 22–25: la salida de la prueba [T2]. Observe que el constructor se ejecutó de nuevo: MSTest crea una nueva instancia de la clase de pruebas para cada prueba. Así, las pruebas son independientes entre sí: una prueba no puede verse afectada por el estado que deja otra. NUnit, en cambio, ejecutaba el constructor una sola vez;
  • líneas 28–34: las pruebas de la clase [Tests2], que se muestra a continuación;
  • líneas 36–39: los resultados: 8 pruebas pasaron y 1 falló. El comando [dotnet test] termina entonces con un código de salida distinto de cero, lo que permite a un script detectar el fallo.

Para ejecutar solo un subconjunto de las pruebas, use la opción [--filter]: [dotnet test --filter Name=T1] ejecuta solo la prueba [T1], mientras que [dotnet test --filter ClassName=DemoTests.Tests2] ejecuta las pruebas de la clase [Tests2].

6.4.4.3. Otras aserciones

La clase [Assert] tiene muchos métodos. La clase [Tests2] incluye algunos de ellos:

namespace DemoTests;

// algunas otras aserciones de MSTest
[TestClass]
public class Tests2
{
    // booleanos, null, referencias
    [TestMethod]
    public void T3()
    {
        bool isTrue = 1 < 2, isFalse = 1 > 2;
        Assert.IsTrue(isTrue);
        Assert.IsFalse(isFalse);
        object obj1 = new(), obj3 = obj1;
        object? obj2 = null;
        Assert.IsNotNull(obj1);
        Assert.IsNull(obj2);
        Assert.AreSame(obj1, obj3);
        Assert.AreNotSame(obj1, new object());
    }

    // reales: igualdad dentro de un delta
    [TestMethod]
    public void T4()
    {
        double d1 = 0.1 + 0.2, d2 = 0.3;
        Assert.AreNotEqual(d2, d1);
        Assert.AreEqual(d2, d1, 1e-6);
    }

    // cadenas y colecciones
    [TestMethod]
    public void T5()
    {
        string message = "Line no. 3 is incorrect";
        Assert.StartsWith("Line", message);
        Assert.Contains("incorrect", message);
        int[] numbers = [1, 2, 3];
        Assert.HasCount(3, numbers);
        Assert.Contains(2, numbers);
    }

    // excepciones: la prueba tiene éxito si se lanza la excepción esperada
    [TestMethod]
    public void T6()
    {
        int[] numbers = [1, 2, 3];
        Assert.ThrowsExactly<IndexOutOfRangeException>(() => numbers[3]);
        FormatException e = Assert.ThrowsExactly<FormatException>(() => int.Parse("x"));
        Assert.IsNotNull(e.Message);
    }

    // una prueba parametrizada: una ejecución por cada atributo [DataRow]
    [TestMethod]
    [DataRow(1, 1, 2)]
    [DataRow(2, 3, 5)]
    [DataRow(-1, 1, 0)]
    public void T7(int a, int b, int sum)
    {
        Assert.AreEqual(sum, a + b);
    }
}
  • líneas 12–13: verifican si una expresión booleana es verdadera o falsa;
  • líneas 16–17: verifican si una referencia es no nula o nula;
  • líneas 18–19: verifican si dos referencias apuntan al mismo objeto;
  • líneas 27–28: los cálculos con números reales [double] son aproximados: [0.1 + 0.2] no es exactamente igual a [0.3]. Por eso comparamos dos números reales con cierto margen de error, en este caso una millonésima;
  • líneas 36–40: aserciones sobre cadenas y colecciones, agregadas por versiones recientes de MSTest. Producen mensajes de error más precisos que [Assert.IsTrue(message.StartsWith("Line"))];
  • líneas 48–49: [Assert.ThrowsExactly<T>(action)] ejecuta la acción (una función anónima [() => ...]) y verifica que lance una excepción exactamente del tipo [T]. Devuelve la excepción lanzada, lo que permite verificar luego sus propiedades. La variante [Assert.Throws<T>] también acepta excepciones de tipos derivados de [T];
  • líneas 55–58: una prueba parametrizada. El método de prueba tiene parámetros, y cada atributo [DataRow] proporciona un conjunto de valores para esos parámetros. La prueba se ejecuta una vez por cada atributo [DataRow]: eso es lo que mostraban las líneas [T7 (1,1,2)], [T7 (2,3,5)], y [T7 (-1,1,0)] de los resultados anteriores.

Resumamos los principales métodos de la clase [Assert]:

Método
Verifica que
Assert.AreEqual(expected, actual)
los dos valores son iguales (método Equals)
Assert.AreEqual(actual1, actual2, delta)
los dos valores reales son iguales con una tolerancia de delta
Assert.AreNotEqual(v1, v2)
los dos valores son distintos
Assert.AreSame(o1, o2), Assert.AreNotSame(o1, o2)
las dos referencias apuntan (o no) al mismo objeto
Assert.IsNull(o), Assert.IsNotNull(o)
la referencia es nula (o no)
Assert.IsTrue(b), Assert.IsFalse(b)
la expresión booleana es verdadera (o falsa)
Assert.IsInstanceOfType<T>(o)
el objeto es de tipo T o de un tipo derivado
Assert.HasCount(n, collection)
la colección tiene n elementos
Assert.Contains(element, collection)
la colección (o la cadena) contiene el elemento
Assert.StartsWith(start, string)
la cadena comienza con start
Assert.ThrowsExactly<T>(action)
la acción lanza una excepción exactamente del tipo T
CollectionAssert.AreEqual(c1, c2)
las dos colecciones tienen los mismos elementos, en el mismo orden

Todos estos métodos aceptan un último parámetro opcional: el mensaje que se muestra en caso de fallo.

6.4.4.4. Pruebas de la capa [dao]

Volvamos a la aplicación [Tax]. El proyecto [Tax.Tests] fue creado con [dotnet new mstest]. Su archivo de proyecto es el siguiente:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <LangVersion>latest</LangVersion>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <!-- el framework de pruebas MSTest -->
    <PackageReference Include="MSTest" Version="4.0.2" />
  </ItemGroup>

  <ItemGroup>
    <!-- las capas probadas -->
    <ProjectReference Include="../Tax.Dao/Tax.Dao.csproj" />
    <ProjectReference Include="../Tax.Business/Tax.Business.csproj" />
  </ItemGroup>

  <ItemGroup>
    <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
  </ItemGroup>

  <ItemGroup>
    <!-- un archivo de datos incorrecto, para probar los errores -->
    <None Update="TaxDataInvalid.txt" CopyToOutputDirectory="PreserveNewest" />
  </ItemGroup>

</Project>
  • Líneas 17–18: las capas que se prueban;
  • línea 27: un archivo de datos incorrecto, que se usa para probar los errores. Los archivos [TaxData.txt] y [TaxData.json] se copian mediante la referencia al proyecto [Tax.Dao].

El archivo [MSTestSettings.cs] pertenece al proyecto [DemoTests]. La clase [DaoTests] prueba la capa [dao]:

using Dao;
using Entities;

namespace Tests;

// pruebas de la capa [dao]
[TestClass]
public class DaoTests
{
    // fábrica de una capa [dao] a partir del nombre de su clase
    private static ITaxDao CreateDao(string implementation) => implementation switch
    {
        "HardwiredTax" => new HardwiredTax(),
        "FileTax" => new FileTax("TaxData.txt"),
        "JsonTax" => new JsonTax("TaxData.json"),
        _ => throw new ArgumentException($"unknown implementation: {implementation}")
    };

    // la misma prueba para las tres implementaciones
    [TestMethod]
    [DataRow("HardwiredTax")]
    [DataRow("FileTax")]
    [DataRow("JsonTax")]
    public void TaxBrackets(string implementation)
    {
        TaxBracket[] brackets = CreateDao(implementation).TaxBrackets;
        // algunas verificaciones
        Assert.HasCount(7, brackets);
        Assert.AreEqual(14753M, brackets[2].Limit);
        Assert.AreEqual(0.191M, brackets[2].CoeffR);
        Assert.AreEqual(1322.92M, brackets[2].CoeffN);
    }

    // las tres implementaciones dan los mismos tramos
    [TestMethod]
    public void SameBrackets()
    {
        TaxBracket[] reference = new HardwiredTax().TaxBrackets;
        CollectionAssert.AreEqual(reference, new FileTax("TaxData.txt").TaxBrackets);
        CollectionAssert.AreEqual(reference, new JsonTax("TaxData.json").TaxBrackets);
    }

    // archivo inexistente
    [TestMethod]
    public void MissingFile()
    {
        TaxException e = Assert.ThrowsExactly<TaxException>(() => new FileTax("TaxDataMissing.txt"));
        Assert.AreEqual((int)FileTax.ErrorCodes.Access, e.Code);
        Assert.IsInstanceOfType<FileNotFoundException>(e.InnerException);
    }

    // archivo cuya línea 3 es incorrecta (comas decimales)
    [TestMethod]
    public void IncorrectLine()
    {
        TaxException e = Assert.ThrowsExactly<TaxException>(() => new FileTax("TaxDataInvalid.txt"));
        Assert.AreEqual((int)(FileTax.ErrorCodes.Field2 | FileTax.ErrorCodes.Field3), e.Code);
        Assert.StartsWith("Line no. 3", e.Message);
    }

    // archivo JSON inexistente
    [TestMethod]
    public void MissingJsonFile()
    {
        TaxException e = Assert.ThrowsExactly<TaxException>(() => new JsonTax("TaxDataMissing.json"));
        Assert.AreEqual((int)JsonTax.ErrorCodes.Access, e.Code);
    }
}
  • líneas 11–16: un método que crea una capa [dao] a partir del nombre de su clase, mediante una expresión [switch] (C# 8);
  • líneas 21–24: la misma prueba se ejecuta para las tres implementaciones. Verifica que haya 7 tramos y comprueba el valor del tramo n.º 2 (el tercero). Los valores esperados se escriben con el sufijo [M]: son [decimal], igual que las propiedades que se comparan;
  • líneas 36–40: las tres implementaciones devuelven exactamente los mismos tramos. [CollectionAssert.AreEqual] compara los arreglos elemento por elemento; la comparación de dos valores [TaxBracket] es una comparación por valor, generada por el compilador para un [record struct];
  • líneas 45–49: un archivo inexistente provoca una [TaxException] con código [Access], que encapsula una [FileNotFoundException];
  • líneas 54–58: el archivo [TaxDataInvalid.txt] produce una [TaxException] cuyo código combina los bits de [Field2] y [Field3];
  • líneas 63–66: la misma verificación para la implementación [JsonTax].

6.4.4.5. Pruebas de la capa [business]

La clase [BusinessTests] prueba la capa [business]:

using Dao;
using Entities;
using Business;

namespace Tests;

// pruebas de la capa [business]
[TestClass]
public class BusinessTests
{
    // la capa [dao] y la capa [business] probada: MSTest crea una instancia de la clase por cada prueba
    private readonly HardwiredTax dao = new();
    private readonly ITaxBusiness business;

    public BusinessTests()
    {
        business = new TaxBusiness(dao);
    }

    // cálculos cuyo resultado se conoce
    [TestMethod]
    [DataRow(true, 2, 60000, 4282)]
    [DataRow(false, 3, 60000, 4282)]
    [DataRow(true, 3, 60000, 2959)]
    [DataRow(false, 0, 60000, 11519)]
    [DataRow(false, 3, 6000, 0)]
    [DataRow(false, 3, 600000, 179275)]
    public void CalculateTax(bool married, int nbChildren, int salary, int tax)
    {
        Assert.AreEqual(tax, business.CalculateTax(married, nbChildren, salary));
    }

    // el cálculo no modifica los tramos proporcionados por la capa [dao]
    [TestMethod]
    public void UnchangedBrackets()
    {
        TaxBracket[] before = [.. dao.TaxBrackets];
        business.CalculateTax(true, 2, 600000);
        CollectionAssert.AreEqual(before, dao.TaxBrackets);
    }

    // los parámetros negativos se rechazan
    [TestMethod]
    public void NegativeParameters()
    {
        Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => business.CalculateTax(true, -1, 60000));
        Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => business.CalculateTax(true, 2, -60000));
    }

    // una capa [dao] simulada (fake): un solo tramo, un impuesto del 10 %
    private class FakeDao : ITaxDao
    {
        public TaxBracket[] TaxBrackets { get; } = [new(0M, 0.1M, 0M)];
    }

    // la capa [business] probada con la capa [dao] simulada
    [TestMethod]
    public void WithFakeDao()
    {
        ITaxBusiness fakeBusiness = new TaxBusiness(new FakeDao());
        // ingreso gravable = 0.72 x 100000 = 72000; impuesto = 10 % de 72000
        Assert.AreEqual(7200, fakeBusiness.CalculateTax(false, 0, 100000));
    }
}
  • Líneas 12–17: la capa [business] que se prueba está construida sobre la capa [dao] [HardwiredTax], que no depende de ningún archivo. Dado que MSTest crea una nueva instancia de la clase para cada prueba, cada prueba tiene capas completamente nuevas;
  • líneas 22–28: cálculos cuyos resultados se conocen. Son los valores de control de la aplicación, ya obtenidos por versiones anteriores: deben seguir siendo exactos en todas las versiones futuras;
  • líneas 35–39: el cálculo del impuesto no modifica los tramos proporcionados por la capa [dao]. Se hace una copia ([.. dao.TaxBrackets]) antes de un cálculo que usa el último tramo, y luego se comparan los resultados. La prueba deja constancia del defecto de la versión de 2008: si alguien lo reintrodujera, esta prueba lo señalaría;
  • líneas 44–47: se rechazan los parámetros negativos;
  • líneas 51–53: una capa [dao] ficticia, como la que usaría el desarrollador de la capa [business] antes de que la capa [dao] real esté lista: un único tramo de impuesto, una tasa del 10 % de la renta imponible. Es una clase anidada dentro de la clase de pruebas;
  • líneas 58–62: la capa [business] funciona con la capa [dao] ficticia. Así, la capa [business] se prueba de forma aislada, independientemente de las implementaciones reales de la capa [dao].

6.4.4.6. Ejecución de las pruebas

En la carpeta [Tax.Tests]:

> dotnet test --logger "console;verbosity=normal"
Test run for bin/Debug/net10.0/Tax.Tests.dll (.NETCoreApp,Version=v10.0)
VSTest version 18.0.2 (x64)

Starting test execution, please wait...
A total of 1 test files matched the specified pattern.
  Passed CalculateTax (True,2,60000,4282) [1 ms]
  Passed CalculateTax (False,3,60000,4282) [< 1 ms]
  Passed CalculateTax (True,3,60000,2959) [< 1 ms]
  Passed CalculateTax (False,0,60000,11519) [< 1 ms]
  Passed CalculateTax (False,3,6000,0) [< 1 ms]
  Passed CalculateTax (False,3,600000,179275) [< 1 ms]
  Passed UnchangedBrackets [< 1 ms]
  Passed NegativeParameters [< 1 ms]
  Passed WithFakeDao [< 1 ms]
  Passed TaxBrackets ("HardwiredTax") [9 ms]
  Passed TaxBrackets ("FileTax") [2 ms]
  Passed TaxBrackets ("JsonTax") [36 ms]
  Passed SameBrackets [1 ms]
  Passed MissingFile [2 ms]
  Passed IncorrectLine [< 1 ms]
  Passed MissingJsonFile [< 1 ms]

Test Run Successful.
Total tests: 16
     Passed: 16
 Total time: 0.8513 Seconds

Las 16 pruebas pasaron: cada atributo [DataRow] cuenta como una prueba. Ahora consideramos que las capas [dao] y [business] son operativas. A diferencia de 2008, no es necesario reconstruir las DLL de las capas para excluir las clases de prueba: las pruebas están en un proyecto aparte, y las bibliotecas [Tax.Dao.dll] y [Tax.Business.dll] contienen únicamente el código de las capas. El comando [dotnet test TaxV5.slnx], ejecutado en la carpeta de la solución, ejecuta las pruebas de todos los proyectos de prueba de la solución.

6.4.5. La capa [ui]

El archivo de proyecto [Tax.Ui.csproj] es el siguiente:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <!-- las capas utilizadas -->
    <ProjectReference Include="../Tax.Dao/Tax.Dao.csproj" />
    <ProjectReference Include="../Tax.Business/Tax.Business.csproj" />
  </ItemGroup>

  <ItemGroup>
    <!-- contenedor de inyección de dependencias y lectura de un archivo de configuración JSON -->
    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.12" />
    <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.12" />
  </ItemGroup>

  <ItemGroup>
    <!-- los archivos de configuración se copian junto al ejecutable -->
    <None Update="appsettings*.json" CopyToOutputDirectory="PreserveNewest" />
  </ItemGroup>

</Project>
  • Línea 4: el proyecto genera un ejecutable;
  • Líneas 12–13: la capa [ui] usa las capas [business] y [dao];
  • Líneas 18–19: dos paquetes NuGet: el contenedor de inyección de dependencias y el lector de archivos de configuración JSON. Se agregaron con los comandos [dotnet add package Microsoft.Extensions.DependencyInjection --version 10.0.12] y [dotnet add package Microsoft.Extensions.Configuration.Json --version 10.0.12];
  • Línea 24: los archivos de configuración se copian junto al ejecutable.

La clase [Dialog] es la de la versión 4, complementada con un método que muestra una excepción y todas las excepciones que encapsula:

    // visualización de una excepción y de todas las que envuelve
    public static void DisplayError(Exception exception)
    {
        string separator = new('-', 40);
        Console.WriteLine($"Exception chain:\n{separator}");
        for (Exception? e = exception; e != null; e = e.InnerException)
        {
            Console.WriteLine($"{e.GetType().FullName}: {e.Message}");
            Console.WriteLine(separator);
        }
    }
}
  • línea 63: una cadena de 40 guiones, creada por el constructor [string(char c, int count)];
  • línea 65: el bucle recorre la cadena de excepciones: cada excepción da acceso, mediante su propiedad [InnerException], a la excepción que encapsula, hasta la última, donde [InnerException] es igual a [null]. El tipo [Exception?] indica que la variable [e] puede ser igual a [null];
  • Línea 67: para cada excepción, se muestran el nombre completo de su clase (incluido el espacio de nombres) y su mensaje.

La clase [Dialog] es pública: las versiones posteriores de la aplicación, que cambiarán la capa [dao], reutilizarán la capa [ui] haciendo referencia al proyecto [Tax.Ui] y llamando a [Dialog.Run(business)].

6.4.6. Integración de las capas mediante inyección de dependencias

En la versión 4, el programa principal creaba las capas [dao] y [business] nombrando sus clases de implementación:

ITaxDao dao = source == "hardwired" ? new HardwiredTax() : new FileTax(source);
business = new TaxBusiness(dao);

Aparte de estas líneas, nada en la aplicación cambia cuando cambia la implementación de una capa, ya que cada capa se comunica con la siguiente mediante una interfaz. Podemos llevar la independencia de las capas un paso más allá confiando su creación a un contenedor de inyección de dependencias y colocando la elección de la implementación de la capa [dao] en un archivo de configuración. Cambiar la implementación de esta capa consiste entonces simplemente en modificar ese archivo, sin recompilar la aplicación.

Image

En el ejemplo anterior, la capa [ui] solicita [0] la capa [business] al contenedor de inyección de dependencias. Para crearla, el contenedor crea primero la capa [dao] [1], luego la capa [business] [2], a la que le pasa la capa [dao]. Por último, devuelve una referencia a la capa [business] [3] a la capa [ui].

6.4.6.1. El archivo de configuración

La elección de la implementación de la capa [dao] se especifica en el archivo [appsettings.json]:

1
2
3
4
5
6
{
  "Dao": {
    "Implementation": "FileTax",
    "File": "TaxData.txt"
  }
}
  • Línea 2: una sección [Dao] contiene la configuración de la capa [dao];
  • Línea 3: la clase que implementa la capa [dao]: [HardwiredTax], [FileTax], o [JsonTax];
  • Línea 4: el archivo de datos, para las implementaciones que leen uno.

[appsettings.json] es el nombre estándar del archivo de configuración de las aplicaciones .NET, en particular de las aplicaciones ASP.NET Core. Reemplaza a los archivos XML [App.config] de .NET Framework, que Spring.NET utilizaba durante el curso de 2008. El proyecto contiene otros tres archivos de configuración, que el programa usa si se pasan sus nombres como argumentos:

1
2
3
appsettings-json.json      : "Implementation": "JsonTax", "File": "TaxData.json"
appsettings-hardwired.json : "Implementation": "HardwiredTax"
appsettings-error.json     : "Implementation": "FileTax", "File": "TaxDataMissing.txt"

6.4.6.2. El programa principal

El programa principal [Program.cs] del proyecto [Tax.Ui] es el siguiente:

using Dao;
using Entities;
using Business;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Ui;

// el archivo de configuración: appsettings.json por defecto, o el que se pasa como argumento
string configFile = args.Length > 0 ? args[0] : "appsettings.json";

// integración de las capas
ITaxBusiness business;
try
{
    // lectura de la configuración, junto al ejecutable
    IConfiguration config = new ConfigurationBuilder()
        .SetBasePath(AppContext.BaseDirectory)
        .AddJsonFile(configFile, optional: false)
        .Build();
    string implementation = config["Dao:Implementation"] ?? "HardwiredTax";
    string file = config["Dao:File"] ?? "";

    // registro de las capas en el contenedor
    var services = new ServiceCollection();
    // la capa [dao]: la implementación se elige mediante la configuración
    services.AddSingleton<ITaxDao>(_ => implementation switch
    {
        "HardwiredTax" => new HardwiredTax(),
        "FileTax" => new FileTax(file),
        "JsonTax" => new JsonTax(file),
        _ => throw new TaxException($"Unknown implementation [{implementation}] of the [dao] layer")
    });
    // la capa [business]: el contenedor le pasará la capa [dao]
    services.AddSingleton<ITaxBusiness, TaxBusiness>();

    // creación del contenedor, luego de la capa [business] (y por lo tanto de la capa [dao])
    ServiceProvider provider = services.BuildServiceProvider();
    business = provider.GetRequiredService<ITaxBusiness>();
}
catch (Exception e)
{
    // visualización del error y detención del programa
    Dialog.DisplayError(e);
    return 1;
}

// el diálogo con el usuario
Dialog.Run(business);
return 0;
  • línea 9: el nombre del archivo de configuración: [appsettings.json] de forma predeterminada, o el que se pase como argumento;
  • líneas 16–19: lectura de la configuración. [ConfigurationBuilder] ensambla una configuración a partir de fuentes: en este caso, un único archivo JSON ([AddJsonFile]), ubicado en la carpeta del ejecutable ([SetBasePath]). El parámetro [optional: false] (un parámetro con nombre, C# 4) hace que el archivo sea obligatorio: su ausencia provoca una [FileNotFoundException];
  • líneas 20–21: la configuración se lee como un diccionario. La clave [Dao:Implementation] hace referencia a la propiedad [Implementation] de la sección [Dao]; el separador de niveles es el signo de dos puntos. El indexador devuelve [null] si la clave no existe: el operador [??] proporciona entonces un valor predeterminado;
  • línea 24: la colección de servicios, es decir, la lista de tipos que el contenedor puede crear y cómo crearlos;
  • líneas 26–31: el registro de la capa [dao]. [AddSingleton<ITaxDao>(factory)] indica que cuando se solicite un [ITaxDao], el contenedor llamará a la función [factory] para crearlo. "Singleton" significa que el objeto se creará una sola vez, en la primera solicitud, y que todas las solicitudes posteriores devolverán el mismo objeto: solo hay una capa [dao] en la aplicación. La fábrica selecciona la clase según la configuración, mediante la expresión [switch]; su parámetro, el propio contenedor, no se usa aquí, de ahí el nombre [_] (“descarte”). Una implementación desconocida produce una [TaxException];
  • línea 34: el registro de la capa [business]: cuando se solicite un [ITaxBusiness], el contenedor creará un objeto [TaxBusiness]. Para ello, examina el constructor de la clase [TaxBusiness], ve que espera un [ITaxDao] y le pasa la capa [dao] registrada anteriormente: esto es la inyección de dependencias. La capa [dao] es una dependencia de la capa [business];
  • línea 37: creación del contenedor a partir de la colección de servicios;
  • línea 38: se solicita al contenedor la capa [business]. El contenedor crea la capa [dao] y luego la capa [business]. [GetRequiredService] lanza una excepción si el tipo solicitado no se ha registrado. Observe que la capa [ui] obtiene la capa [business] sin especificar la clase que la implementa;
  • líneas 40–44: cualquier error de configuración o de creación de las capas se muestra junto con el seguimiento de la pila de la excepción, y el programa termina;
  • línea 48: la interfaz de usuario, idéntica a la de la versión 4.

El curso de 2008 incluía en el archivo de configuración los nombres completos de las clases que se debían instanciar ([Dao.FileTax, TaxV5-dao]): Spring.NET las creaba mediante reflexión. Hemos elegido, en cambio, definir las implementaciones posibles en la fábrica: el archivo de configuración simplemente selecciona entre ellas, y el compilador verifica que las clases existan y tengan los constructores requeridos. En ambos casos, el código de las capas [ui] y [business] nunca especifica la clase que implementa la capa [dao].

6.4.6.3. Ejecuciones

Con el archivo [appsettings.json] (implementación [FileTax]):

1
2
3
4
5
6
7
8
> dotnet run
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 0 60000
Tax=11519 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Con la implementación [JsonTax]:

1
2
3
4
> dotnet run -- appsettings-json.json
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Con la implementación [HardwiredTax]:

1
2
3
4
> dotnet run -- appsettings-hardwired.json
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Cambiamos de implementación de la capa [dao] sin cambiar una sola línea de código ni recompilar la aplicación.

Con el archivo [appsettings-error.json], que hace referencia a un archivo de datos inexistente:

1
2
3
4
5
6
7
> dotnet run -- appsettings-error.json
Exception chain:
----------------------------------------
Entities.TaxException: Error while reading the file TaxDataMissing.txt
----------------------------------------
System.IO.FileNotFoundException: The file [TaxDataMissing.txt] does not exist
----------------------------------------
  • línea 6: la excepción original, de tipo [FileNotFoundException], lanzada por la clase [FileTax];
  • línea 4: la capa [dao] la encapsuló en una [TaxException]. Es esta excepción la que se propagó hasta el programa principal mediante la llamada a [GetRequiredService].

El contenedor de .NET deja pasar sin modificarlas las excepciones lanzadas durante la creación de objetos. Con Spring.NET, el mismo error producía una cadena de ocho excepciones, seis de las cuales eran causadas por el framework ([ConfigurationErrorsException], [ObjectCreationException], [TargetInvocationException], etc.), seguidas de las dos excepciones mencionadas anteriormente. La conclusión clave de esta cadena es que, con frecuencia, la excepción más profunda (la última que se muestra) es la más significativa.

La inyección de dependencias merece por sí sola un capítulo aparte. Solo usamos lo esencial: registrar servicios ([AddSingleton]), construir el contenedor ([BuildServiceProvider]) y obtener un servicio ([GetRequiredService]). El contenedor también puede crear un objeto nuevo para cada solicitud ([AddTransient]) o un objeto por “ámbito”, como por solicitud (HTTP) en una aplicación web ([AddScoped]). Volveremos a verlo en las aplicaciones ASP.NET Core, donde es omnipresente. Puede profundizar en este tema en la documentación de Microsoft: Dependency Injection .NET.

6.5. Conclusión

Este capítulo ha dado a la aplicación [Tax] la arquitectura que conservará hasta el final del curso:

  • una capa [dao] que proporciona los tramos del impuesto a través de la interfaz [ITaxDao];
  • una capa [business] que calcula el impuesto e interactúa con la capa [dao] únicamente a través de su interfaz;
  • una capa [ui] que interactúa con el usuario y conoce la capa [business] únicamente a través de su interfaz [ITaxBusiness];
  • un programa principal (el único que conoce las clases de implementación) que crea las capas y las vincula, en este caso mediante un contenedor de inyección de dependencias y un archivo de configuración;
  • pruebas unitarias automatizadas, que verifican cada capa de forma independiente de las demás y garantizan la no regresión de la aplicación.

Los beneficios de esta arquitectura se verán plenamente en los capítulos siguientes, donde las bibliotecas [Tax.Dao], [Tax.Business] y [Tax.Ui] de la versión 5 se reutilizarán tal cual mediante referencias de proyecto:

  • Versión 6 (capítulo ADO.NET): una nueva implementación, [MySqlTax], de la capa [dao] lee los tramos del impuesto desde una base de datos MySQL. Las capas [business] y [ui] permanecen sin cambios;
  • Versión 7 (capítulo Entity Framework Core): una implementación [EfTax] de la capa [dao] usa el ORM Entity Framework Core para acceder a la misma base de datos;
  • Versión 8 (capítulo Internet): la capa [business] se instala en un servidor TCP, que calcula los impuestos para clientes remotos; se trata, por lo tanto, de una arquitectura de “tres niveles” en sentido estricto;
  • Versión 9 (capítulo Servicios web): la capa [business] se expone mediante un servicio web REST/JSON escrito con ASP.NET Core, cuyo cliente de consola usa [HttpClient].

Cada vez, el trabajo se limitará a escribir la nueva capa y modificar el programa que integra las capas: ese es todo el sentido de la arquitectura en capas.