OrionInject 2.0.4

OrionInject 🚀

A lightweight, high-performance Dependency Injection (DI) container for .NET, designed with:

• 🔁 Lifetime management
• 🧩 Constructor injection
• 🧵 Thread safety
• 🎯 Explicit constructor selection

✨ Features

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

📦 Installation

dotnet add package OrionInject

Or manually in .csproj:

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

🚀 Quick Start

1. Define 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.Get<IMessageService>();
service.Send("Hello from OrionInject!");

🎯 Advanced Usage

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.Get<ServiceA>();

Thread-Safe Singleton

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

Parallel.For(0, 10, _ =>
{
    var instance = container.Get<HeavyService>();
    Console.WriteLine(instance.GetHashCode());
});

🛠 Best Practices

• Use Singleton for stateless, shared services
• Use Transient for lightweight, short-lived objects
• Prefer constructor injection over service locators
• Use [Inject] to guide constructor selection when multiple exist