DomainGuard

La clase DomainGuard ofrece métodos de extensión específicos para implementar cláusulas de guardia en la capa de dominio. Su propósito principal es garantizar que los objetos de dominio se mantengan en un estado consistente al aplicar las reglas invariantes del negocio.

DomainGuard opera bajo los principios del diseño orientado al dominio (DDD), asegurando que las validaciones críticas se ejecuten dentro del contexto del dominio. Esto permite encapsular las reglas de negocio fundamentales y mantener la integridad del modelo de dominio, incluso frente a cambios en otras capas.

namespace CodeDesignPlus.Net.Exceptions.Guards;

/// <summary>
/// Provides guard clauses for domain layer validations.
/// </summary>
public static class DomainGuard
{
    /// <summary>
    /// Throws an exception if the specified value is null.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="error">The error message to include in the exception if the value is null.</param>
    public static void IsNull([NotNull] object value, string error) => Guard.IsNull(value, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified value is not null.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="error">The error message to include in the exception if the value is not null.</param>
    public static void IsNotNull(object value, string error) => Guard.IsNotNull(value, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified string is null or empty.
    /// </summary>
    /// <param name="value">The string to check.</param>
    /// <param name="error">The error message to include in the exception if the string is null or empty.</param>
    public static void IsNullOrEmpty(string value, string error) => Guard.IsNullOrEmpty(value, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified string is not null or empty.
    /// </summary>
    /// <param name="value">The string to check.</param>
    /// <param name="error">The error message to include in the exception if the string is not null or empty.</param>
    public static void IsNotNullOrEmpty(string value, string error) => Guard.IsNotNullOrEmpty(value, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified string is null or whitespace.
    /// </summary>
    /// <param name="value">The string to check.</param>
    /// <param name="error">The error message to include in the exception if the string is null or whitespace.</param>
    public static void IsNullOrWhiteSpace(string value, string error) => Guard.IsNullOrWhiteSpace(value, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified string is not null or whitespace.
    /// </summary>
    /// <param name="value">The string to check.</param>
    /// <param name="error">The error message to include in the exception if the string is not null or whitespace.</param>
    public static void IsNotNullOrWhiteSpace(string value, string error) => Guard.IsNotNullOrWhiteSpace(value, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified value is true.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="error">The error message to include in the exception if the value is true.</param>
    public static void IsTrue(bool value, string error) => Guard.IsTrue(value, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified value is false.
    /// </summary>
    /// <param name="value">The value to check.</param>
    /// <param name="error">The error message to include in the exception if the value is false.</param>
    public static void IsFalse(bool value, string error) => Guard.IsFalse(value, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified value is not greater than the comparison value.
    /// </summary>
    /// <typeparam name="T">The type of the values to compare.</typeparam>
    /// <param name="value">The value to check.</param>
    /// <param name="compare">The comparison value.</param>
    /// <param name="error">The error message to include in the exception if the value is not greater than the comparison value.</param>
    public static void IsGreaterThan<T>(T value, T compare, string error) where T : IComparable<T> => Guard.IsGreaterThan(value, compare, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified value is not greater than or equal to the comparison value.
    /// </summary>
    /// <typeparam name="T">The type of the values to compare.</typeparam>
    /// <param name="value">The value to check.</param>
    /// <param name="compare">The comparison value.</param>
    /// <param name="error">The error message to include in the exception if the value is not greater than or equal to the comparison value.</param>
    public static void IsGreaterThanOrEqual<T>(T value, T compare, string error) where T : IComparable<T> => Guard.IsGreaterThanOrEqual(value, compare, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified value is not less than the comparison value.
    /// </summary>
    /// <typeparam name="T">The type of the values to compare.</typeparam>
    /// <param name="value">The value to check.</param>
    /// <param name="compare">The comparison value.</param>
    /// <param name="error">The error message to include in the exception if the value is not less than the comparison value.</param>
    public static void IsLessThan<T>(T value, T compare, string error) where T : IComparable<T> => Guard.IsLessThan(value, compare, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified value is not less than or equal to the comparison value.
    /// </summary>
    /// <typeparam name="T">The type of the values to compare.</typeparam>
    /// <param name="value">The value to check.</param>
    /// <param name="compare">The comparison value.</param>
    /// <param name="error">The error message to include in the exception if the value is not less than or equal to the comparison value.</param>
    public static void IsLessThanOrEqual<T>(T value, T compare, string error) where T : IComparable<T> => Guard.IsLessThanOrEqual(value, compare, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified values are not equal.
    /// </summary>
    /// <typeparam name="T">The type of the values to compare.</typeparam>
    /// <param name="value">The value to check.</param>
    /// <param name="compare">The comparison value.</param>
    /// <param name="error">The error message to include in the exception if the values are not equal.</param>
    public static void AreEquals<T>(T value, T compare, string error) where T : IComparable<T> => Guard.AreEquals(value, compare, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified values are equal.
    /// </summary>
    /// <typeparam name="T">The type of the values to compare.</typeparam>
    /// <param name="value">The value to check.</param>
    /// <param name="compare">The comparison value.</param>
    /// <param name="error">The error message to include in the exception if the values are equal.</param>
    public static void AreNotEquals<T>(T value, T compare, string error) where T : IComparable<T> => Guard.AreNotEquals(value, compare, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified value is not within the specified range.
    /// </summary>
    /// <typeparam name="T">The type of the values to compare.</typeparam>
    /// <param name="value">The value to check.</param>
    /// <param name="min">The minimum value of the range.</param>
    /// <param name="max">The maximum value of the range.</param>
    /// <param name="error">The error message to include in the exception if the value is not within the range.</param>
    public static void IsInRange<T>(T value, T min, T max, string error) where T : IComparable<T> => Guard.IsInRange(value, min, max, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified value is within the specified range.
    /// </summary>
    /// <typeparam name="T">The type of the values to compare.</typeparam>
    /// <param name="value">The value to check.</param>
    /// <param name="min">The minimum value of the range.</param>
    /// <param name="max">The maximum value of the range.</param>
    /// <param name="error">The error message to include in the exception if the value is within the range.</param>
    public static void IsNotInRange<T>(T value, T min, T max, string error) where T : IComparable<T> => Guard.IsNotInRange(value, min, max, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified collection is empty.
    /// </summary>
    /// <typeparam name="T">The type of the elements in the collection.</typeparam>
    /// <param name="value">The collection to check.</param>
    /// <param name="error">The error message to include in the exception if the collection is empty.</param>
    public static void IsEmpty<T>(IEnumerable<T> value, string error) => Guard.IsEmpty(value, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified collection is not empty.
    /// </summary>
    /// <typeparam name="T">The type of the elements in the collection.</typeparam>
    /// <param name="value">The collection to check.</param>
    /// <param name="error">The error message to include in the exception if the collection is not empty.</param>
    public static void IsNotEmpty<T>(IEnumerable<T> value, string error) => Guard.IsNotEmpty(value, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified GUID is empty.
    /// </summary>
    /// <param name="value">The GUID to check.</param>
    /// <param name="error">The error message to include in the exception if the GUID is empty.</param>
    public static void GuidIsEmpty(Guid value, string error) => Guard.GuidIsEmpty(value, Layer.Domain, error);

    /// <summary>
    /// Throws an exception if the specified GUID is not empty.
    /// </summary>
    /// <param name="value">The GUID to check.</param>
    /// <param name="error">The error message to include in the exception if the GUID is not empty.</param>
    public static void GuidIsNotEmpty(Guid value, string error) => Guard.GuidIsNotEmpty(value, Layer.Domain, error);
}

Métodos de Extensión

La clase DomainGuard proporciona los siguientes métodos de extensión para realizar validaciones en la capa de dominio, utilizando códigos de error estructurados.

IsNull

Type: public static void IsNull(object value, string error)

Lanza una excepción si el valor especificado es nulo.

public class Pedido
{
    public Pedido(Cliente cliente)
    {
        DomainGuard.IsNull(cliente, "101: El cliente no puede ser nulo en un pedido.");
        Cliente = cliente;
    }
    public Cliente Cliente {get;}
}

IsNotNull

Type: public static void IsNotNull(object value, string error)

Lanza una excepción si el valor especificado no es nulo.

public class Producto
{
   public Producto(Guid id)
    {
        DomainGuard.IsNotNull(id, "102: El ID del producto no puede ser nulo.");
        Id = id;
    }
    public Guid Id {get;}
}

IsNullOrEmpty

Type: public static void IsNullOrEmpty(string value, string error)

Lanza una excepción si la cadena especificada es nula o vacía.

public class Categoria
{
  public Categoria(string nombre)
    {
        DomainGuard.IsNullOrEmpty(nombre, "103: El nombre de la categoría no puede estar vacío.");
        Nombre = nombre;
    }
    public string Nombre { get; }
}

IsNotNullOrEmpty

Type: public static void IsNotNullOrEmpty(string value, string error)

Lanza una excepción si la cadena especificada no es nula o vacía.

public class Direccion
{
  public Direccion(string calle)
    {
        DomainGuard.IsNotNullOrEmpty(calle, "104: La calle no puede ser nula o vacía.");
        Calle = calle;
    }
    public string Calle { get; }
}

IsNullOrWhiteSpace

Type: public static void IsNullOrWhiteSpace(string value, string error)

Lanza una excepción si la cadena especificada es nula o contiene solo espacios en blanco.

public class Email
{
   public Email(string value)
    {
        DomainGuard.IsNullOrWhiteSpace(value, "105: El email no puede estar vacío o contener solo espacios en blanco.");
        Value = value;
    }
     public string Value { get; }
}

IsNotNullOrWhiteSpace

Type: public static void IsNotNullOrWhiteSpace(string value, string error)

Lanza una excepción si la cadena especificada no es nula o no contiene solo espacios en blanco.

public class CodigoPostal
{
    public CodigoPostal(string value)
    {
        DomainGuard.IsNotNullOrWhiteSpace(value, "106: El código postal no puede ser nulo o solo espacios en blanco.");
         Value = value;
    }
     public string Value { get; }
}

IsTrue

Type: public static void IsTrue(bool value, string error)

Lanza una excepción si el valor especificado es verdadero.

public class Envio
{
   public Envio(bool isValido)
    {
        DomainGuard.IsTrue(isValido == false , "107: El envio no es valido.");
       IsValido = isValido;
    }
    public bool IsValido { get; }
}

IsFalse

Type: public static void IsFalse(bool value, string error)

Lanza una excepción si el valor especificado es falso.

public class Pago
{
    public Pago(bool pagoRealizado)
    {
       DomainGuard.IsFalse(pagoRealizado == true, "108: El pago no se ha realizado correctamente.");
       PagoRealizado = pagoRealizado;
    }
    public bool PagoRealizado { get; }
}

IsGreaterThan

Type: public static void IsGreaterThan<T>(T value, T compare, string error) where T : IComparable<T>

Lanza una excepción si el valor especificado no es mayor que el valor de comparación.

public class Edad
{
   public Edad(int value)
    {
        DomainGuard.IsGreaterThan(value, 0, "109: La edad debe ser mayor que 0.");
         Value = value;
    }
    public int Value { get; }
}

IsGreaterThanOrEqual

Type: public static void IsGreaterThanOrEqual<T>(T value, T compare, string error) where T : IComparable<T>

Lanza una excepción si el valor especificado no es mayor o igual que el valor de comparación.

public class Descuento
{
    public Descuento(decimal value)
    {
        DomainGuard.IsGreaterThanOrEqual(value, 0, "110: El descuento no puede ser menor a 0.");
        Value = value;
    }
     public decimal Value { get; }
}

IsLessThan

Type: public static void IsLessThan<T>(T value, T compare, string error) where T : IComparable<T>

Lanza una excepción si el valor especificado no es menor que el valor de comparación.

public class Stock
{
  public Stock(int value)
    {
        DomainGuard.IsLessThan(value, 1000, "111: El stock no puede ser mayor a 1000.");
         Value = value;
    }
    public int Value { get; }
}

IsLessThanOrEqual

Type: public static void IsLessThanOrEqual<T>(T value, T compare, string error) where T : IComparable<T>

Lanza una excepción si el valor especificado no es menor o igual que el valor de comparación.

public class Peso
{
   public Peso(decimal value)
    {
        DomainGuard.IsLessThanOrEqual(value, 1000, "112: El peso no puede ser mayor a 1000.");
        Value = value;
    }
     public decimal Value { get; }
}

AreEquals

Type: public static void AreEquals<T>(T value, T compare, string error) where T : IComparable<T>

Lanza una excepción si los valores especificados no son iguales.

public class Clave
{
    public Clave(string value, string confirmValue)
    {
         DomainGuard.AreEquals(value, confirmValue, "113: Las claves no coinciden.");
         Value = value;
    }
     public string Value { get; }
}

AreNotEquals

Type: public static void AreNotEquals<T>(T value, T compare, string error) where T : IComparable<T>

Lanza una excepción si los valores especificados son iguales.

public class Id
{
    public Id(Guid value, Guid newId)
    {
       DomainGuard.AreNotEquals(value, newId, "114: Los ID son iguales");
        Value = value;
    }
     public Guid Value { get; }
}

IsInRange

Type: public static void IsInRange<T>(T value, T min, T max, string error) where T : IComparable<T>

Lanza una excepción si el valor especificado no está dentro del rango especificado.

public class Calificacion
{
    public Calificacion(int value)
    {
       DomainGuard.IsInRange(value, 0, 5, "115: La calificación debe estar entre 0 y 5.");
        Value = value;
    }
     public int Value { get; }
}

IsNotInRange

Type: public static void IsNotInRange<T>(T value, T min, T max, string error) where T : IComparable<T>

Lanza una excepción si el valor especificado está dentro del rango especificado.

public class Temperatura
{
   public Temperatura(int value)
    {
        DomainGuard.IsNotInRange(value, -10, 40, "116: La temperatura no debe estar entre -10 y 40 grados.");
         Value = value;
    }
      public int Value { get; }
}

IsEmpty

Type: public static void IsEmpty<T>(IEnumerable<T> value, string error)

Lanza una excepción si la colección especificada está vacía.

public class Imagenes
{
  public Imagenes(List<string> value)
    {
       DomainGuard.IsEmpty(value, "117: La lista de imágenes no puede estar vacía.");
        Value = value;
    }
     public List<string> Value { get; }
}

IsNotEmpty

Type: public static void IsNotEmpty<T>(IEnumerable<T> value, string error)

Lanza una excepción si la colección especificada no está vacía.

public class Tags
{
    public Tags(List<string> value)
    {
      DomainGuard.IsNotEmpty(value, "118: La lista de tags no puede estar vacía");
        Value = value;
    }
     public List<string> Value { get; }
}

GuidIsEmpty

Type: public static void GuidIsEmpty(Guid value, string error)

Lanza una excepción si el GUID especificado está vacío.

public class Identificador
{
    public Identificador(Guid value)
    {
         DomainGuard.GuidIsEmpty(value, "119: El identificador no puede ser vacío.");
        Value = value;
    }
     public Guid Value { get; }
}

GuidIsNotEmpty

Type: public static void GuidIsNotEmpty(Guid value, string error)

Lanza una excepción si el GUID especificado no está vacío.

public class Transaccion
{
  public Transaccion(Guid value)
    {
        DomainGuard.GuidIsNotEmpty(value, "120: El ID de la transacción no puede ser vacio");
         Value = value;
    }
      public Guid Value { get; }
}