Interceptor.AOP 1.3.11

📦 Interceptor.AOP

Descripción general

Una librería ligera y extensible para aplicar Aspect-Oriented Programming (AOP) en aplicaciones .NET, usando interceptores automáticos basados en DispatchProxy.

Ideal para centralizar lógica transversal como reintentos, validaciones, cacheo, auditoría, y manejo de errores sin contaminar la lógica de negocio.

• Contiene toda la lógica de interceptación (ExceptionInterceptor<T>)
• Define los atributos como [Audit], [Retry], [Fallback], etc.
• Se puede usar en cualquier tipo de aplicación .NET: consola, worker, API, etc.
• Requiere que vos crees el proxy a mano con ProxyFactory.Create<>(). 🔧 Ideal cuando querés máximo control o no estás usando ASP.NET Core con DI tradicional.

🎯 Propósito

Centralizar y estandarizar:

• 🛡️ Manejo de excepciones con contexto
• 🔁 Reintentos y circuit breaker con Polly
• 🧪 Validaciones automáticas con DataAnnotations
• ⏱️ Medición de tiempo de ejecución
• 🔐 Cacheo en memoria por método
• 📝 Auditoría flexible: entrada, salida y errores

🚀 Características

✔️ Soporte para métodos síncronos y asincrónicos (Task, Task<T>)
✔️ Decoración por atributos: fácil de aplicar, simple y expresiva, sin modificar código existente
✔️ Interceptores desacoplados y extensibles ✔️ Soporte para ILogger<T>, IMemoryCache y IOptions<T> ✔️ Ideal para microservicios, APIs, backend robusto ✔️ Integración lista para DI con Interceptor.AOP.AspNetCore

📥 Instalación

Desde NuGet:

  dotnet add package Interceptor.AOP

🧩 Configuración manual (ProxyFactory)

Ejemplo de uconfiguración en Program.cs o Startup.cs

services.AddSingleton(provider =>
{
    var logger = provider.GetRequiredService<ILogger<ProcesarDatosService>>();
    var memoryCache = provider.GetRequiredService<IMemoryCache>();

    // Instancia real del servicio
    var real = new ProcesarDatosService(logger);

    // Proxy con interceptor
    return ProxyFactory.Create<IProcesarDatosService>(
        real,
        logger,
        memoryCache,
        new InterceptorOptions
        {
            EnableRetries = true,
            EnableValidation = true,
            EnableTiming = true
        });
});

Ejemplo de uso de decoradores

public interface IProcesarDatosService
{
    [Audit("ProcesarArchivo", LogInput = true)]
    [Retry(3)]
    [Fallback("FallbackProcesarArchivo")]
    [MeasureTime]
    [Validate]
    [Cache(60)]
    int ProcesarArchivo(int number);

    int FallbackProcesarArchivo(int number);
}

Ejemplo de implementacion

public class ProcesarDatosService : IProcesarDatosService
{
    private readonly ILogger<ProcesarDatosService> _logger;

    public ProcesarDatosService(ILogger<ProcesarDatosService> logger)
    {
        _logger = logger;
    }

    public int ProcesarArchivo(int number)
    {
        _logger.LogInformation("📊 Calculando algo con {number}", number);
        if (number < 0) throw new Exception("Valor negativo no permitido");
        return number * 10;
    }

    public int FallbackProcesarArchivo(int number)
    {
        _logger.LogWarning("⚠️ Fallback ejecutado para {number}", number);
        return -1;
    }
}

📚 Atributos disponibles

📝[Audit] - Auditoría flexible

Auditoría avanzada

El atributo [Audit] permite registrar entrada, salida y errores con granularidad y contexto funcional:

Por defecto

[Audit]
public Task<string> ObtenerClientesAsync() { ... }

➡️ Registra entrada, salida y errores automáticamente.

Con contexto funcional

[Audit("ProcesarArchivo")]
public void ProcesarArchivo(string path) { ... }

➡️ Aparece en logs como: 📥 Entrada en ProcesarArchivo 📤 Salida de ProcesarArchivo ❌ Error en ProcesarArchivo (Auditable)

Auditoría selectiva

[Audit(LogInput = false, LogOutput = false, LogError = true)] // Solo errores

[Audit(Contexto = "Importación", LogOutput = false)] // Entrada + error

[Audit(LogInput = false, LogOutput = true, LogError = false)] // Solo salida

🔁 [Retry(n)] - Reintentos automáticos

Permite reintentar un método si lanza una excepción.

[Retry(3)]
public void ProcesarArchivo() { ... }

➡️ Reintenta hasta 3 veces antes de fallar.

Ideal cuando interactuás con servicios externos, bases de datos o archivos inestables.

🛑 [Fallback("MetodoAlternativo")] - Método alternativo en caso de error

Define un método de respaldo si el original lanza excepción después de los reintentos.

[Fallback("ProcesarArchivoFallback")]
public void ProcesarArchivo() { ... }

public void ProcesarArchivoFallback() { ... }

➡️ Si ProcesarArchivo() falla, se ejecuta ProcesarArchivoFallback() automáticamente.

⏱️ [MeasureTime] - Medición de rendimiento

Registra cuánto tarda en ejecutarse un método.

[MeasureTime]
public void CalcularEstadisticas() { ... }

➡️ Logea automáticamente algo como:

⏱️ CalcularEstadisticas ejecutado en 215ms

🧪 [Validate] - Validación automática

Aplica validaciones usando [Required], [Range], etc. sobre modelos.

[Validate]
public void GuardarCliente(ClienteModel cliente) { ... }

public class ClienteModel
{
    [Required]
    public string Nombre { get; set; }
}

➡️ Si cliente.Nombre es null, lanza ValidationException.

🧠 [Cache(segundos)] - Cache automático en memoria

Guarda el resultado de un método por X segundos.

[Cache(60)]
public async Task<string> ObtenerDatos() => "Desde API";

➡️ Durante 60 segundos, ObtenerDatos() devuelve la misma respuesta (usando IMemoryCache).

⚠️ Solo válido para métodos síncronos o Task<T>. No se aplica a Task (sin retorno).

Author

• @Juliocbm