OrionInject 2.0.1

OrionInject 🚀

A lightweight, high-performance Dependency Injection (DI) container for .NET, built with lifetime management, constructor injection, thread safety, and explicit constructor selection in mind.

✨ Features

• Multiple Lifetimes: Singleton, Transient, and Scoped (coming soon).
• Thread-Safe Resolution: Safe for multi-threaded environments.
• Constructor Injection: Automatic resolution of dependencies via constructors.
• Explicit Constructor Selection: Use [Inject] attribute to choose which constructor to use.
• Circular Dependency Detection: Prevents infinite loops during resolution.
• Open Generics Support (planned).
• Minimal Overhead: No reflection-heavy magic at runtime.

📦 Installation

dotnet add package OrionInject

Or add the reference manually in your .csproj:

<PackageReference Include="OrionInject" Version="x.y.z" />

🚀 Quick Start

1. Define Your Services

public interface IMessageService
{
    void Send(string message);
}

public class EmailMessageService : IMessageService
{
    public void Send(string message) => Console.WriteLine($"Email sent: {message}");
}

2. Register Services

var container = new OrionContainer();

container.Register<IMessageService, EmailMessageService>(Lifetime.Singleton);

3. Resolve and Use

var service = container.Resolve<IMessageService>();
service.Send("Hello from OrionInject!");

🎯 Advanced Examples

Explicit Constructor Selection

public class ReportGenerator
{
    private readonly IMessageService _messageService;
    private readonly ILogger _logger;

    [Inject] // OrionInject will use this constructor
    public ReportGenerator(IMessageService messageService)
    {
        _messageService = messageService;
        _logger = new ConsoleLogger();
    }

    public ReportGenerator(IMessageService messageService, ILogger logger)
    {
        _messageService = messageService;
        _logger = logger;
    }
}

Circular Dependency Detection

public class ServiceA
{
    public ServiceA(ServiceB b) { }
}

public class ServiceB
{
    public ServiceB(ServiceA a) { }
}

container.Register<ServiceA>(Lifetime.Transient);
container.Register<ServiceB>(Lifetime.Transient);

// Throws: CircularDependencyException
var a = container.Resolve<ServiceA>();

Thread-Safe Singleton

container.Register<HeavyService>(Lifetime.Singleton);

// Safe to resolve from multiple threads
Parallel.For(0, 10, _ =>
{
    var instance = container.Resolve<HeavyService>();
    Console.WriteLine(instance.GetHashCode());
});

🛠 Tips & Best Practices

• Use Singleton for stateless, shared services.
• Use Transient for short-lived, lightweight objects.
• Mark your preferred constructor with [Inject] when multiple exist.
• Avoid service locators — prefer constructor injection for clarity.