JZen.AutoInject 1.1.0

🚀 AutoInject

Stop writing constructor injection boilerplate! 🛑
AutoInject is a lightweight library that brings attribute-based dependency injection to .NET, eliminating the need for constructor injection hell.

🎯 Why AutoInject?

Tired of this? 😤

public class OrderService
{
    private readonly IRepository _repository;
    private readonly IEmailService _emailService;
    private readonly ILogger<OrderService> _logger;
    private readonly IPaymentService _paymentService;
    private readonly INotificationService _notificationService;

    public OrderService(
        IRepository repository,
        IEmailService emailService,
        ILogger<OrderService> logger,
        IPaymentService paymentService,
        INotificationService notificationService)
    {
        _repository = repository;
        _emailService = emailService;
        _logger = logger;
        _paymentService = paymentService;
        _notificationService = notificationService;
    }
}

With AutoInject, write this instead: ✨

[AutoInject]
public class OrderService
{
    [Injectable] private readonly IRepository _repository;
    [Injectable] private readonly IEmailService _emailService;
    [Injectable] private readonly ILogger<OrderService> _logger;
    [Injectable] private readonly IPaymentService _paymentService;
    [Injectable] private readonly INotificationService _notificationService;

    // Clean constructor - no dependencies!
    public OrderService() { }
}

🌟 Key Features

• ✅ Zero Boilerplate: No more constructor injection bloat
• ✅ Attribute-Based: Simple [AutoInject] and [Injectable] attributes
• ✅ ASP.NET Core Integration: Seamless integration with built-in DI container
• ✅ Automatic Registration: Auto-scan and register your classes
• ✅ Scoped Management: Automatic scope management for web requests
• ✅ Logger Support: Built-in logger injection support
• ✅ Performance Optimized: Type caching for reflection operations
• ✅ Thread-Safe: Safe for concurrent operations

📦 Installation

# Install from NuGet
Install-Package JZen.AutoInject

Or via .NET CLI:

dotnet add package JZen.AutoInject

Or add to your .csproj:

<PackageReference Include="JZen.AutoInject" Version="1.1.0" />

🚀 Quick Start

1. Configure your services in Program.cs

using AutoInject.Extensions;

var builder = WebApplication.CreateBuilder(args);

// Register your services
builder.Services.AddScoped<IRepository, Repository>();
builder.Services.AddScoped<IEmailService, EmailService>();

// 🔥 Auto-register all classes marked with [AutoInject]
builder.Services.AddAutoInjectClasses(Assembly.GetExecutingAssembly());

var app = builder.Build();

// 🔥 Enable AutoInject
app.UseFactoryDependencyInjection();

app.Run();

2. Mark your classes with [AutoInject]

using AutoInject.Attributes;

[AutoInject]
public class OrderService
{
    [Injectable] private readonly IRepository _repository;
    [Injectable] private readonly IEmailService _emailService;
    [Injectable] private readonly ILogger<OrderService> _logger;

    public async Task ProcessOrderAsync(Order order)
    {
        _logger.LogInformation("Processing order {OrderId}", order.Id);
        
        await _repository.SaveAsync(order);
        await _emailService.SendConfirmationAsync(order.CustomerEmail);
        
        _logger.LogInformation("Order {OrderId} processed successfully", order.Id);
    }
}

3. Use your services normally

[ApiController]
[Route("api/[controller]")]
public class OrdersController : ControllerBase
{
    private readonly OrderService _orderService;

    public OrdersController(OrderService orderService)
    {
        _orderService = orderService;
    }

    [HttpPost]
    public async Task<IActionResult> CreateOrder([FromBody] Order order)
    {
        await _orderService.ProcessOrderAsync(order);
        return Ok();
    }
}

🆕 NEW: InjectBase Auto-Registration

Version 1.1.0 introduces AddInjectBaseClasses() - automatic registration for classes that inherit from InjectBase!

🎯 The Problem

You have repository classes that inherit from InjectBase with [Injectable] properties, but you still need to manually register their dependencies:

// Manual registration (tedious!)
services.AddScoped<IUsuarioLogado, UsuarioLogadoService>();
services.AddScoped<IEmailService, EmailService>();
services.AddScoped<UsuarioRepository>();
services.AddScoped<ProdutoRepository>();
// ... and so on for each dependency

✨ The Solution

// One line registers everything automatically!
services.AddInjectBaseClasses();

🚀 How to Use

1. Create your InjectBase classes:

public class UsuarioRepository : InjectBase
{
    [Injectable]
    protected readonly IUsuarioLogado _usuarioLogado;

    [Injectable]
    protected readonly IEmailService _emailService;

    public string GetCurrentUserData()
    {
        return $"User: {_usuarioLogado.GetUsuarioNome()}";
    }
}

// Implementations
public class UsuarioLogadoService : IUsuarioLogado
{
    public string GetUsuarioNome() => "João Silva";
}

public class EmailService : IEmailService
{
    public Task SendEmailAsync(string email) => Task.CompletedTask;
}

2. Register everything automatically:

var builder = WebApplication.CreateBuilder(args);

// 🔥 This single line:
// ✅ Finds all classes that inherit from InjectBase
// ✅ Discovers their [Injectable] properties  
// ✅ Finds implementations for each interface
// ✅ Registers everything in DI container
builder.Services.AddInjectBaseClasses();

var app = builder.Build();

3. Use your repositories normally:

[ApiController]
public class UsuarioController : ControllerBase
{
    private readonly UsuarioRepository _repository;

    public UsuarioController(UsuarioRepository repository)
    {
        _repository = repository; // Fully injected and ready!
    }
}

🎛️ Advanced Options

// Specific assembly
services.AddInjectBaseClasses(typeof(MyRepository).Assembly);

// Multiple assemblies
services.AddInjectBaseClasses(new[] { assembly1, assembly2 });

// Different lifetime
services.AddInjectBaseClasses(ServiceLifetime.Singleton);

🤝 Combine Both Approaches

services.AddAutoInjectClasses();    // For [AutoInject] classes
services.AddInjectBaseClasses();    // For InjectBase classes

📚 Advanced Usage

Inherit from InjectBase (Alternative Approach)

using AutoInject;

public class OrderService : InjectBase
{
    [Injectable] private readonly IRepository _repository;
    [Injectable] private readonly IEmailService _emailService;
    
    // Logger is automatically available as _logger
    public void ProcessOrder()
    {
        _logger.LogInformation("Processing order...");
        // Your logic here
    }
}

Automatic Interface Registration

// Register all interfaces from a specific namespace
builder.Services.AddScopedInjection("MyApp.Application.UseCases");

Multiple Assembly Registration

var assemblies = new[] 
{ 
    Assembly.GetExecutingAssembly(),
    typeof(SomeOtherClass).Assembly 
};

builder.Services.AddAutoInjectClasses(assemblies);

Custom Service Lifetimes

// Register as Singleton
builder.Services.AddAutoInjectClasses(
    Assembly.GetExecutingAssembly(), 
    ServiceLifetime.Singleton
);

🔧 How It Works

AutoInject uses a combination of:

1. Reflection: To discover types and properties marked with attributes
2. Custom Factory: Creates instances and injects dependencies
3. Interceptors: Automatically process classes during instantiation
4. Middleware: Manages scoped services lifecycle in web applications
5. Caching: Optimizes reflection operations for better performance

Architecture Overview

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   [AutoInject]  │───▶│     Factory     │───▶│  DI Container   │
│     Classes     │    │   + Interceptor │    │   (ASP.NET)     │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                        │                        │
         ▼                        ▼                        ▼
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   [Injectable]  │    │   Auto-Factory  │    │   Scope Mgmt    │
│   Properties    │    │   Registration  │    │   Middleware    │
└─────────────────┘    └─────────────────┘    └─────────────────┘

🎯 Best Practices

✅ DO

[AutoInject]
public class UserService
{
    [Injectable] private readonly IUserRepository _userRepository;
    [Injectable] private readonly ILogger<UserService> _logger;
    
    // Use private readonly fields
    // Mark with [Injectable]
    // Keep constructors clean
}

❌ DON'T

[AutoInject]
public class UserService
{
    [Injectable] public IUserRepository UserRepository; // Don't use public fields
    [Injectable] private ILogger<UserService> _logger;  // Don't use mutable fields
    
    // Don't mix constructor injection with AutoInject
    public UserService(ISomeService service) { }
}

🔍 Comparison

🤝 Contributing

We welcome contributions! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'Add some AmazingFeature')
4. Push to the branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙋‍♂️ Support

• 📧 Email: [jaelsonrc@hotmail.com]
• 🐛 Issues: GitHub Issues
• 💬 Discussions: GitHub Discussions

Made with ❤️ by developers who hate constructor injection boilerplate!

"Life's too short for constructor injection hell" - Anonymous Developer