Nosabit.Application 1.2.5

Nosabit.Application

Biblioteca de utilidades para la capa de aplicación en arquitecturas limpias o en capas. Proporciona herramientas para el registro automático de servicios mediante análisis de ensamblados, simplificando la configuración de la inyección de dependencias.

Instalación

Package Manager

Install-Package Nosabit.Application

.NET CLI

dotnet add package Nosabit.Application

Características principales

• Registro automático de servicios: Detecta y registra servicios sin necesidad de configuración manual
• Detección basada en convenciones: Identifica servicios por el sufijo "Service" en el nombre de la clase
• Soporte para atributos personalizados: Permite marcar servicios con atributos para control preciso
• Detección automática de interfaces: Vincula automáticamente clases con sus interfaces correspondientes
• Control de ámbito de vida: Configura servicios como Scoped, Singleton o Transient
• Integración con ASP.NET Core: Se integra perfectamente con el contenedor de IoC de ASP.NET Core

Uso básico

1. Definir el atributo de dependencia (opcional)

El paquete incluye un atributo para marcar servicios y especificar su tipo de inyección:

public enum TypeDependecyInjection
{
    Singleton,
    Scoped,
    Transient
}

[AttributeUsage(AttributeTargets.Class, Inherited = false)]
public class UseDependecyAttribute : Attribute
{
    public TypeDependecyInjection ServicesTypeDependecy { get; set; } = TypeDependecyInjection.Scoped;
    
    public UseDependecyAttribute(TypeDependecyInjection type = TypeDependecyInjection.Scoped)
    {
        ServicesTypeDependecy = type;
    }
}

2. Definir servicios en la capa de aplicación

Puedes definir servicios siguiendo la convención de nombres (*Service) o usando el atributo:

// Usando la convención de nombres (se registrará como Scoped por defecto)
public class ProductoService
{
    // Implementación...
}

// Usando el atributo para especificar el tipo de inyección
[UseDependecy(TypeDependecyInjection.Singleton)]
public class ConfiguracionService
{
    // Implementación...
}

// Con interfaz que sigue la convención de nombres (IProductoDescuentoService)
public interface IProductoDescuentoService
{
    // Definición de interfaz...
}

[UseDependecy(TypeDependecyInjection.Transient)]
public class ProductoDescuentoService : IProductoDescuentoService
{
    // Implementación...
}

3. Registrar todos los servicios automáticamente

En el método de configuración de servicios de tu aplicación:

// En Program.cs o Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    // Registrar todos los servicios del ensamblado de Application
    services.AddApplicationServicesFromAssembly(typeof(ProductoService).Assembly);
    
    // Resto de la configuración de servicios...
}

Funcionamiento detallado

El paquete proporciona un método de extensión AddApplicationServicesFromAssembly que:

1. Escanea el ensamblado proporcionado en busca de clases que:

   • Tengan el atributo UseDependecyAttribute, o
   • Sean clases no abstractas con nombres que terminen en "Service"

2. Para cada servicio encontrado:

   • Determina el tipo de dependencia (Scoped, Singleton o Transient)
   • Busca si el servicio tiene una interfaz que sigue la convención de nombres (I + NombreDeServicio)
   • Registra el servicio en el contenedor de IoC con la configuración adecuada

public static IServiceCollection AddApplicationServicesFromAssembly(
    this IServiceCollection Service, 
    Assembly assembly)
{
    var entityTypes = assembly.GetTypes()
        .Where(type => type.GetCustomAttribute<UseDependecyAttribute>() != null || 
                       (type.IsClass && !type.IsAbstract && type.Name.EndsWith("Service")))
        .ToList();
    
    entityTypes.ForEachEnumerable(entityType =>
    {
        var ServicesAttr = entityType.GetCustomAttribute<UseDependecyAttribute>();
        var typeDI = ServicesAttr?.ServicesTypeDependecy ?? TypeDependecyInjection.Scoped;
        
        var interfaceType = entityType.GetInterfaces()
            .FirstOrDefault(i => i.Name == "I" + entityType.Name);
        
        if (interfaceType == null)
        {
            if (typeDI == TypeDependecyInjection.Singleton)
                Service.AddSingleton(entityType);
            else if (typeDI == TypeDependecyInjection.Scoped)
                Service.AddScoped(entityType);
            else
                Service.AddTransient(entityType);
        }
        else
        {
            // Registrar con la interfaz encontrada
            if (typeDI == TypeDependecyInjection.Singleton)
                Service.AddSingleton(interfaceType, entityType);
            else if (typeDI == TypeDependecyInjection.Scoped)
                Service.AddScoped(interfaceType, entityType);
            else
                Service.AddTransient(interfaceType, entityType);
        }
    });
    
    return Service;
}

Casos de uso

Arquitectura limpia (Clean Architecture)

En una arquitectura limpia, puedes organizar tus servicios en la capa de aplicación:

MyApp/
├── MyApp.Domain/
│   └── Entities/
├── MyApp.Application/
│   ├── Services/
│   │   ├── ProductoService.cs
│   │   ├── IUsuarioService.cs
│   │   └── UsuarioService.cs
│   └── // ...
├── MyApp.Infrastructure/
└── MyApp.Api/
    └── Program.cs

Y luego registrarlos en el punto de entrada de la aplicación:

// En Program.cs
var builder = WebApplication.CreateBuilder(args);

// Registrar todos los servicios de aplicación
builder.Services.AddApplicationServicesFromAssembly(typeof(ProductoService).Assembly);

// Resto de la configuración...

Aplicaciones con múltiples módulos

Para aplicaciones más grandes con múltiples módulos, puedes registrar servicios de diferentes ensamblados:

// Registrar servicios del módulo principal
services.AddApplicationServicesFromAssembly(typeof(ProductoService).Assembly);

// Registrar servicios de un módulo adicional
services.AddApplicationServicesFromAssembly(typeof(ReportesService).Assembly);

Beneficios

• Reduce el código repetitivo: Elimina la necesidad de registrar manualmente cada servicio
• Minimiza errores: Evita olvidar registrar servicios o usar el ámbito incorrecto
• Mejora el mantenimiento: Al agregar nuevos servicios, se registran automáticamente
• Sigue principios SOLID: Facilita trabajar con interfaces y abstracciones
• Código más limpio: Elimina largas secciones de registro de servicios

Integración con otros paquetes Nosabit

Este paquete está diseñado para trabajar con otros paquetes de la familia Nosabit:

• Nosabit.Core: Proporciona utilidades y extensiones comunes
• Nosabit.Adapters.Persistence.SqlServer.RepositoryPattern: Para la capa de persistencia

Requisitos

• .NET 6.0 o superior
• Microsoft.AspNetCore.App

Licencia

Este proyecto está licenciado bajo la Licencia MIT.