Stashbox

https://z4kn4fein.github.io/stashbox
Admin
Stashbox is a lightweight, fast, and portable .NET DI framework, known for its thread-safe,...
Tokens:38,390
Snippets:502
Trust Score:9.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Property/Field Injection Example

Source: https://z4kn4fein.github.io/stashbox/docs/guides/service-resolution

Shows how to register a service for auto property/field injection. This is useful when constructor injection is not feasible, but should be used cautiously.

```csharp
class DbBackup : IJob  
{
    public ILogger Logger { get; set; }
    public IEventBroadcaster EventBroadcaster { get; set; }

    public DbBackup()   
    { }
}

container.Register<ILogger, ConsoleLogger>();
container.Register<IEventBroadcaster, MessageBus>();

// registration of service with auto member injection.  
container.Register<IJob, DbBackup>(options =>   
    options.WithAutoMemberInjection());  

// resolution will inject the properties.  
IJob job = container.Resolve<IJob>();

```

--------------------------------

### Resolution Tree Example Classes

Source: https://z4kn4fein.github.io/stashbox/docs/getting-started/glossary

Defines classes with constructor dependencies to illustrate the concept of a resolution tree.

```csharp
class A  
{  
    public A(B b, C c) { }  
}  
  
class B  
{  
    public B(C c, D d) { }  
}  
  
class C { }  
class D { }
```

--------------------------------

### Install Stashbox via dotnet CLI

Source: https://z4kn4fein.github.io/stashbox/docs/getting-started/introduction

Use this command in the dotnet CLI to add the Stashbox NuGet package to your project.

```bash
dotnet add package Stashbox --version 5.20.0  

```

--------------------------------

### Registering a Decorator as a Wrapper

Source: https://z4kn4fein.github.io/stashbox/docs/advanced/decorators

This example shows how to register a decorator that acts as a wrapper, allowing resolution of a Func that creates the decorated service.

```csharp
container.Register<IEventProcessor, GeneralEventProcessor>();  
container.RegisterDecorator<IEventProcessor, ValidatorProcessor>();  
// () => new ValidatorProcessor(new GeneralEventProcessor())  
var processor = container.Resolve<Func<IEventProcessor>>();  

```

--------------------------------

### Constructor Injection Example

Source: https://z4kn4fein.github.io/stashbox/docs/guides/service-resolution

Demonstrates resolving a service using constructor injection. The container automatically selects the constructor with the most resolvable parameters.

```csharp
class DbBackup : IJob  
{
    private readonly ILogger logger;
    private readonly IEventBroadcaster eventBroadcaster;

    public DbBackup(ILogger logger, IEventBroadcaster eventBroadcaster)
    {
        this.logger = logger;
        this.eventBroadcaster = eventBroadcaster;
    }
}

container.Register<ILogger, ConsoleLogger>();
container.Register<IEventBroadcaster, MessageBus>();

container.Register<IJob, DbBackup>();

// resolution using the available constructor.  
IJob job = container.Resolve<IJob>();

```

--------------------------------

### Install Stashbox via Package Manager Console

Source: https://z4kn4fein.github.io/stashbox/docs/getting-started/introduction

Use this command in the Package Manager Console to install the Stashbox NuGet package.

```powershell
Install-Package Stashbox -Version 5.20.0  

```

--------------------------------

### Decorating Multiple Services with a Single Decorator Class

Source: https://z4kn4fein.github.io/stashbox/docs/advanced/decorators

Illustrates how to organize decorating functionalities for different interfaces within a single decorator class. This example validates an event before publishing and processing.

```csharp
public class EventValidator<TEvent> : IEventProcessor<T>, IEventPublisher<TEvent>
{
    private readonly IEventProcessor<TEvent> processor;
    private readonly IEventPublisher<TEvent> publisher;
    private readonly IEventValidator<TEvent> validator;

    public CompositeValidator(IEventProcessor<TEvent> processor,
        IEventPublisher<TEvent> publisher,
        IEventValidator<TEvent> validator)
    {
        this.processor = processor;
        this.publisher = publisher;
        this.validator = validator;
    }

    public void ProcessEvent(TEvent @event)
    {
        // validate the event first.
        if (!this.validator.IsValid(@event))
            throw new InvalidEventException();

        // if everything is ok, call the processor.
        this.processor.ProcessEvent(@event);
    }

    public void PublishEvent(TEvent @event)
    {
        // validate the event first.
        if (!this.validator.IsValid(@event))
            throw new InvalidEventException();

        // if everything is ok, call the publisher.
        this.publisher.PublishEvent(@event);
    }
}

container.Register(typeof(IEventProcessor<>), typeof(EventProcessor<>));
container.Register(typeof(IEventPublisher<>), typeof(EventPublisher<>));
container.Register(typeof(IEventValidator<>), typeof(EventValidator<>));

// without specifying the interface type, the container binds this registration to all of its implemented types
container.RegisterDecorator(typeof(EventValidator<>));

```

--------------------------------

### Resolve Unknown Types With Registration Configuration

Source: https://z4kn4fein.github.io/stashbox/docs/advanced/special-resolution-cases

Configure how unknown types are resolved by mapping them to specific implementations and lifetimes. This example maps 'IDependency' to 'Dependency' with a singleton lifetime.

```csharp
interface IDependency { }

class Dependency : IDependency { }

class Service   
{
    public Service(IDependency dependency)
    { }
}

var container = new StashboxContainer(config => config
    .WithUnknownTypeResolution(options =>
    {
        if(options.ServiceType == typeof(IDependency))
        {
            options.SetImplementationType(typeof(Dependency))
                .WithLifetime(Lifetimes.Singleton);
        }
    }));

container.Register<Service>();

var service = container.Resolve<Service>();

```

--------------------------------

### Chaining registration options

Source: https://z4kn4fein.github.io/stashbox/docs/configuration/registration-configuration

The registration configuration API is fluent, allowing multiple options to be chained together for complex registrations. This example chains name, lifetime, and disposal tracking options.

```csharp
container.Register<IJob, DbBackup>(options => options  
    .WithName("DbBackup")  
    .WithLifetime(Lifetimes.Singleton)  
    .WithoutDisposalTracking());  

```

--------------------------------

### Setting a custom initializer delegate

Source: https://z4kn4fein.github.io/stashbox/docs/configuration/registration-configuration

The `WithInitializer` option allows you to define a delegate that will be invoked when a service instance is created. This is useful for performing setup tasks on the instance.

```csharp
container.Register<ILogger, FileLogger>(options => options  
    .WithInitializer((logger, resolver) => logger  
        .OpenFile()));  

```

--------------------------------

### Get Registration Diagnostics

Source: https://z4kn4fein.github.io/stashbox/docs/diagnostics/utilities

Obtain a human-readable diagnostic report of all container registrations by calling `GetRegistrationDiagnostics()`. The output is formatted for easy understanding of each mapping.

```csharp
container.Register<IJob, DbBackup>("DbBackupJob");  
container.Register(typeof(IEventHandler<>), typeof(EventHandler<>));  
  
IEnumerable<RegistrationDiagnosticsInfo> diagnostics =   
    container.GetRegistrationDiagnostics();  
  
diagnostics.ForEach(Console.WriteLine);  
// output:  
// IJob => DbBackup, name: DbBackupJob  
// IEventHandler<> => EventHandler<>, name: null  
```

--------------------------------

### Get All Registration Mappings

Source: https://z4kn4fein.github.io/stashbox/docs/diagnostics/utilities

Retrieve all service registration mappings from the container using `GetRegistrationMappings()`. This returns a collection where keys are service types and values are their corresponding registrations.

```csharp
IEnumerable<KeyValuePair<Type, ServiceRegistration>> mappings =   
    container.GetRegistrationMappings();  
```

--------------------------------

### Build Up Existing Instance for Post-Processing

Source: https://z4kn4fein.github.io/stashbox/docs/guides/service-resolution

Demonstrates using the `BuildUp` method to perform post-processing (like property injection) on an already constructed `DbBackup` instance.

```csharp
class DbBackup : IJob  
{
    public ILogger Logger { get; set; }
}
  
DbBackup backup = new DbBackup();
// the container fills the Logger property.
container.BuildUp(backup);
```

--------------------------------

### Create and Use a Basic Scope

Source: https://z4kn4fein.github.io/stashbox/docs/guides/scopes

Demonstrates creating a scope using a 'using' statement for automatic disposal and resolving scoped services within that scope. Instances resolved within the same scope are the same.

```csharp
container.RegisterScoped<IJob, DbBackup>();  
  
// create the scope with using so it'll be auto disposed.  
using (var scope = container.BeginScope())  
{  
    IJob job = scope.Resolve<IJob>();  
    IJob jobAgain = scope.Resolve<IJob>();  
    // job and jobAgain are created in the   
    // same scope, so they are the same instance.  
}  
```

--------------------------------

### Initialize Container with Options

Source: https://z4kn4fein.github.io/stashbox/docs/configuration/container-configuration

Initialize a new Stashbox container with custom configuration options, chaining multiple settings.

```csharp
var container = new StashboxContainer(options => options  
    .WithDisposableTransientTracking()  
    .WithConstructorSelectionRule(Rules.ConstructorSelection.PreferLeastParameters)  
    .WithRegistrationBehavior(Rules.RegistrationBehavior.ThrowException));  
```

--------------------------------

### Instance Registration (Runtime Type API)

Source: https://z4kn4fein.github.io/stashbox/docs/guides/basics

Demonstrates registering a pre-created instance using the runtime type API. The provided instance will be resolved for the specified service type.

```csharp
var job = new DbBackup();  
container.RegisterInstance(job, typeof(IJob));  
  
// resolvedJob and job are the same.  
object resolvedJob = container.Resolve(typeof(IJob));  
```

--------------------------------

### Resolving Services with Metadata using Metadata, ValueTuple, and Tuple

Source: https://z4kn4fein.github.io/stashbox/docs/advanced/wrappers-resolvers

Demonstrates how to register a service with metadata and then resolve it using Metadata<,>, ValueTuple<,>, or Tuple<,>. Useful for attaching arbitrary data to a service registration.

```csharp
container.Register<IJob, DbBackup>(options => options  
    .WithMetadata("connection-string-to-db"));  
  
var jobWithConnectionString = container.Resolve<Metadata<IJob, string>>();  
// prints: "connection-string-to-db"  
Console.WriteLine(jobWithConnectionString.Data);  
  
var alsoJobWithConnectionString = container.Resolve<ValueTuple<IJob, string>>();  
// prints: "connection-string-to-db"  
Console.WriteLine(alsoJobWithConnectionString.Item2);  
  
var stillJobWithConnectionString = container.Resolve<Tuple<IJob, string>>();  
// prints: "connection-string-to-db"  
Console.WriteLine(stillJobWithConnectionString.Item2);
```

--------------------------------

### Instance Registration (Generic API)

Source: https://z4kn4fein.github.io/stashbox/docs/guides/basics

Shows how to register an existing instance of a service, which will be returned whenever the service type is requested. Disposal tracking is enabled by default.

```csharp
var job = new DbBackup();  
container.RegisterInstance<IJob>(job);  
  
// resolvedJob and job are the same.  
IJob resolvedJob = container.Resolve<IJob>();  
```

--------------------------------

### Register and Resolve Services (Generic API)

Source: https://z4kn4fein.github.io/stashbox/docs/guides/basics

Demonstrates registering a service implementation for an interface using the generic API and resolving it. Shows error cases for invalid registrations.

```csharp
container.Register<IJob, DbBackup>();  
IJob job = container.Resolve<IJob>();  
// throws an exception because ConsoleLogger doesn't implement IJob.  
container.Register<IJob, ConsoleLogger>();  
// throws an exception because IJob is not a valid implementation.  
container.Register<IJob, IJob>();  
```

--------------------------------

### Register and Resolve Services (Runtime Type API)

Source: https://z4kn4fein.github.io/stashbox/docs/guides/basics

Demonstrates registering a service implementation for an interface using the runtime type API and resolving it. Shows error cases for invalid registrations.

```csharp
container.Register(typeof(IJob), typeof(DbBackup));  
object job = container.Resolve(typeof(IJob));  
// throws an exception because ConsoleLogger doesn't implement IJob.  
container.Register(typeof(IJob), typeof(ConsoleLogger));  
// throws an exception because IJob is not a valid implementation.  
container.Register(typeof(IJob), typeof(IJob));  
```

--------------------------------

### Async Dispose Service within Using Block

Source: https://z4kn4fein.github.io/stashbox/docs/guides/scopes

Services implementing IAsyncDisposable are automatically disposed asynchronously when the scope is disposed. This example uses 'await using'.

```csharp
await using (var scope = container.BeginScope())  
{  
    var disposable = scope.Resolve<DisposableService>();  
} // 'disposable' will be disposed asynchronously   
  // when the using statement ends.  
```

--------------------------------

### Dispose Service within Using Block

Source: https://z4kn4fein.github.io/stashbox/docs/guides/scopes

Services implementing IDisposable are automatically disposed when the scope is disposed. This example shows disposal within a 'using' statement.

```csharp
using (var scope = container.BeginScope())  
{  
    var disposable = scope.Resolve<DisposableService>();  
} // 'disposable' will be disposed when   
  // the using statement ends.  
```

--------------------------------

### Registering and Resolving Dependencies with Child Containers

Source: https://z4kn4fein.github.io/stashbox/docs/advanced/child-containers

Demonstrates how to register dependencies in parent and child containers and resolve them. When resolving from a child, its registrations take precedence, and if a dependency is missing, the parent is consulted. Resolving from the parent uses its own registrations.

```csharp
interface IDependency {}  
  
class B : IDependency {}  
class C : IDependency {}  
  
class A   
{  
    public A(IDependency dependency)  
    { }  
}  
  
using (var container = new StashboxContainer())  
{  
    // register 'A' into the parent container.  
    container.Register<A>();  
  
    // register 'B' as a dependency into the parent container.  
    container.Register<IDependency, B>();  
  
    var child = container.CreateChildContainer()  
      
    // register 'C' as a dependency into the child container.  
    child.Register<IDependency, C>();  
      
    // 'A' is resolved from the parent and gets  
    // 'C' as IDependency because the resolution  
    // request was initiated on the child.  
    A fromChild = child.Resolve<A>();  
  
    // 'A' gets 'B' as IDependency because the   
    // resolution request was initiated on the parent.  
    A fromParent = container.Resolve<A>();  
} // using will dispose the parent along with the child.  

```

--------------------------------

### Register Factory with Configuration and Dependency

Source: https://z4kn4fein.github.io/stashbox/docs/guides/advanced-registration

Register a DbBackup service using a factory delegate that takes a connection string from configuration and an ILogger dependency.

```csharp
container.Register<IJob, DbBackup>(options => options  
    .WithFactory<ILogger>(logger =>   
        new DbBackup(Configuration["DbConnectionString"], logger)));  

```

--------------------------------

### Respect Optional Constructor Arguments

Source: https://z4kn4fein.github.io/stashbox/docs/advanced/special-resolution-cases

Stashbox respects optional values for constructor and method arguments. In this example, 'name' defaults to null, 'age' to 54, and 'contact' to null.

```csharp
class Person   
{
    public Person(string name = null, int age = 54, IContact contact = null) { }
}

// the name will be null   
// the age will be 54.  
// the contact will be null.  
var person = container.Resolve<Person>();

```

--------------------------------

### Registering Open-Generic Decorators

Source: https://z4kn4fein.github.io/stashbox/docs/advanced/decorators

Demonstrates how to register and use open-generic decorators to extend open-generic services. This allows for inspection of generic parameter constraints and variance handling.

```csharp
interface IEventProcessor<TEvent>  
{
    void ProcessEvent(TEvent @event);
}

class GeneralEventProcessor<TEvent> : IEventProcessor<TEvent>
{
    public void ProcessEvent(TEvent @event) { /* suppose this method is processing the given event.*/ }
}

class ValidatorProcessor<TEvent> : IEventProcessor<TEvent>
{
    private readonly IEventProcessor<TEvent> nextProcessor;

    public ValidatorProcessor(IEventProcessor<TEvent> eventProcessor)
    {
        this.nextProcessor = eventProcessor;
    }

    public void ProcessEvent(TEvent @event)
    {
        // validate the event first.
        if (!this.IsValid(@event))
            throw new InvalidEventException();

        // if everything is ok, call the next processor.
        this.nextProcessor.ProcessEvent(@event);
    }
}

using var container = new StashboxContainer();
container.Register(typeof(IEventProcessor<>), typeof(GeneralEventProcessor<>));
container.RegisterDecorator(typeof(IEventProcessor<>), typeof(ValidatorProcessor<>));

// new ValidatorProcessor<UpdateEvent>(new GeneralEventProcessor<UpdateEvent>())
var eventProcessor = container.Resolve<IEventProcessor<UpdateEvent>>();

// process the event.
eventProcessor.ProcessEvent(new UpdateEvent());

```

--------------------------------

### Registering an instance with options

Source: https://z4kn4fein.github.io/stashbox/docs/configuration/registration-configuration

Use `WithInstance` to register an existing object. You can optionally enable member and method injection on the registered instance by setting `wireUp` to true.

```csharp
container.Register<IJob, DbBackup>(options => options  
    .WithInstance(new DbBackup()));  

```

```csharp
container.Register<ILogger>(options => options  
    .WithInstance(new ConsoleLogger()));  

```

```csharp
container.Register<ILogger>(options => options  
    .WithInstance(new ConsoleLogger(), wireUp: true));  

```

--------------------------------

### Custom Dependency Attribute for Property Injection

Source: https://z4kn4fein.github.io/stashbox/docs/guides/service-resolution

Extend Stashbox to recognize custom attributes for dependency injection by configuring the container with .WithAdditionalDependencyAttribute(). This example uses a CustomDependency attribute for property injection.

```csharp
class DbBackup : IJob  
{
    [CustomDependency("Console")]  
    public ILogger Logger { get; set; }  

    public DbBackup()   
    { }
}

var container = new StashboxContainer(options => options  
    .WithAdditionalDependencyAttribute<CustomDependencyAttribute>());  

container.Register<ILogger, ConsoleLogger>("Console");
container.Register<ILogger, FileLogger>("File");

container.Register<IJob, DbBackup>();  

// the container will resolve DbBackup with ConsoleLogger.
IJob job = container.Resolve<IJob>();  

```

--------------------------------

### Register with Constructor by Arguments

Source: https://z4kn4fein.github.io/stashbox/docs/configuration/registration-configuration

Selects a constructor and provides specific arguments to use during its invocation.

```csharp
container.Register<IUserRepository, UserRepository>(options => options
    .WithConstructorByArguments(new ConsoleLogger()));


```

--------------------------------

### Activate Service with Injected Dependency (Generic API)

Source: https://z4kn4fein.github.io/stashbox/docs/guides/service-resolution

Activates a `DbBackup` instance using the generic `Activate` method, allowing the container to inject its dependencies.

```csharp
// use dependency injected by container.  
DbBackup backup = container.Activate<DbBackup>();
```

--------------------------------

### Named Service Registration and Resolution

Source: https://z4kn4fein.github.io/stashbox/docs/getting-started/glossary

Shows how to register a service with a name and then resolve it using that specific name.

```csharp
container.Register<IService, Implementation>("Example");  
// the named request.  
var service = container.Resolve<IService>("Example");
```

--------------------------------

### Conditional registration based on service type

Source: https://z4kn4fein.github.io/stashbox/docs/configuration/registration-configuration

The `HasServiceType` option is used in batch registrations to apply conditions based on the service type. This example registers a service with a scoped lifetime only if it implements `IService2`.

```csharp
container.RegisterAssemblyContaining<IService1>(configurator: options =>  
    {  
        if (options.HasServiceType<IService2>())  
            options.WithScopedLifetime();  
    });  
  

```

--------------------------------

### Registering Services with Parameter-less Factory

Source: https://z4kn4fein.github.io/stashbox/docs/configuration/registration-configuration

Use WithFactory with an empty parameter list to register services using a delegate that does not require any pre-resolved dependencies.

```csharp
container.Register<IUserRepository, UserRepository>(options => options  
    .WithFactory(()) => new UserRepository(new ConsoleLogger()));  
```

--------------------------------

### Custom DependencyName Attribute for Constructor Injection

Source: https://z4kn4fein.github.io/stashbox/docs/guides/service-resolution

Configure Stashbox to use custom attributes for injecting dependency names by using .WithAdditionalDependencyNameAttribute(). This example uses a CustomName attribute to inject the service's registered name.

```csharp
class DbBackup : IJob  
{
    public string Name { get; set; }  

    public DbBackup([CustomName] string name)   
    { }
}

var container = new StashboxContainer(options => options  
    .WithAdditionalDependencyNameAttribute<CustomNameAttribute>());  

container.Register<IJob, DbBackup>("Backup");  

IJob job = container.Resolve<IJob>();  
// name is "Backup".
var name = job.Name;  

```

--------------------------------

### Resolve Unknown Types Without Registration Configuration

Source: https://z4kn4fein.github.io/stashbox/docs/advanced/special-resolution-cases

When unknown type resolution is enabled without specific configuration, the container can resolve non-interface and non-abstract unknown types. This example shows implicit registration for 'Dependency' and injection into 'Service'.

```csharp
class Dependency { }
  
class Service   
{
    public Service(Dependency dependency)
    { }
}

var container = new StashboxContainer(config => config
    .WithUnknownTypeResolution());

container.Register<Service>();

var service = container.Resolve<Service>();

```

--------------------------------

### Activate Service with Overridden Dependency (Generic API)

Source: https://z4kn4fein.github.io/stashbox/docs/guides/service-resolution

Activates a `DbBackup` instance using the generic `Activate` method, overriding its `ILogger` dependency with a `ConsoleLogger`.

```csharp
// override the injected dependency.  
DbBackup backup = container.Activate<DbBackup>(new ConsoleLogger());
```

--------------------------------

### Simple Decorator Use Case

Source: https://z4kn4fein.github.io/stashbox/docs/advanced/decorators

Demonstrates registering a service and then decorating it with additional validation capabilities. This sets up an event processing pipeline where validation occurs before actual processing.

```csharp
class Event { }
class UpdateEvent : Event { }

interface IEventProcessor
{
    void ProcessEvent(Event @event);
}

interface IEventValidator
{
    bool IsValid(Event @event);
}

class EventValidator : IEventValidator
{
    public bool IsValid(Event @event) { /* do the actual validation. */ }
}

class GeneralEventProcessor : IEventProcessor
{
    public void ProcessEvent(Event @event)
    {
        // suppose this method is processing the given event.
        this.DoTheActualProcessing(@event);
    }
}

class ValidatorProcessor : IEventProcessor
{
    private readonly IEventProcessor nextProcessor;
    private readonly IEventValidator eventValidator;
    public ValidatorProcessor(IEventProcessor eventProcessor, IEventValidator eventValidator)
    {
        this.nextProcessor = eventProcessor;
        this.eventValidator = eventValidator;
    }

    public void ProcessEvent(Event @event)
    {
        // validate the event first.
        if (!this.eventValidator.IsValid(@event))
            throw new InvalidEventException();

        // if everything is ok, call the next processor.
        this.nextProcessor.ProcessEvent(@event);
    }
}

using var container = new StashboxContainer();

container.Register<IEventValidator, EventValidator>();
container.Register<IEventProcessor, GeneralEventProcessor>();
container.RegisterDecorator<IEventProcessor, ValidatorProcessor>();

// new ValidatorProcessor(new GeneralEventProcessor(), new EventValidator())
var eventProcessor = container.Resolve<IEventProcessor>();

// process the event.
eventProcessor.ProcessEvent(new UpdateEvent());

```

--------------------------------

### Named Instance Registration (Generic API)

Source: https://z4kn4fein.github.io/stashbox/docs/guides/basics

Shows how to register a specific instance for a named service. The instance is resolved using both the service type and the name.

```csharp
var job = new DbBackup();  
container.RegisterInstance<IJob>(job, "DbBackup");  
  
// resolvedJob and job are the same.  
IJob resolvedJob = container.Resolve<IJob>("DbBackup");  
```

--------------------------------

### Register Service with Initializer and Finalizer

Source: https://z4kn4fein.github.io/stashbox/docs/guides/advanced-registration

Registers a service and defines delegates for initialization upon construction and finalization upon disposal. The initializer runs after instantiation, and the finalizer runs before disposal.

```csharp
container.Register<ILogger, FileLogger>(options => options  
    // delegate that called right after instantiation.  
    .WithInitializer((logger, resolver) => logger.OpenFile())  
    // delegate that called right before the instance's disposal.  
    .WithFinalizer(logger => logger.CloseFile()));  

```

--------------------------------

### Named Registration (Generic API)

Source: https://z4kn4fein.github.io/stashbox/docs/guides/basics

Shows how to register multiple implementations for the same service type using unique names and how to resolve a specific named service.

```csharp
container.Register<IJob, DbBackup>("DbBackup");  
container.Register<IJob, StorageCleanup>("StorageCleanup");  
IJob cleanup = container.Resolve<IJob>("StorageCleanup");  
```

--------------------------------

### Batch Instance Registration

Source: https://z4kn4fein.github.io/stashbox/docs/guides/basics

Illustrates registering multiple instances for the same service type in a single call, allowing them to be resolved as a collection.

```csharp
container.RegisterInstances<IJob>(new DbBackup(), new StorageCleanup());  
IEnumerable<IJob> jobs = container.ResolveAll<IJob>();  
```

--------------------------------

### Activate Service with Injected Dependency (Runtime Type API)

Source: https://z4kn4fein.github.io/stashbox/docs/guides/service-resolution

Activates a `DbBackup` instance by its type using the runtime `Activate` method, allowing the container to inject its dependencies.

```csharp
// use dependency injected by container.  
object backup = container.Activate(typeof(DbBackup));
```

--------------------------------

### Register Service with Constructor by Argument Types

Source: https://z4kn4fein.github.io/stashbox/docs/diagnostics/validation

Register a service using specific constructor argument types. Throws ConstructorNotFoundException if the constructor does not exist.

```csharp
class Service {
    public Service(Dependency dep) { }
}

container.Register<Service>(options => options.WithConstructorByArgumentTypes(typeof(string), typeof(int)));
```

--------------------------------

### Activate Service with Overridden Dependency (Runtime Type API)

Source: https://z4kn4fein.github.io/stashbox/docs/guides/service-resolution

Activates a `DbBackup` instance by its type using the runtime `Activate` method, overriding its `ILogger` dependency with a `ConsoleLogger`.

```csharp
// override the injected dependency.  
object backup = container.Activate(typeof(DbBackup), new ConsoleLogger());
```

--------------------------------

### Wire Up Generic Instance Registration

Source: https://z4kn4fein.github.io/stashbox/docs/guides/basics

Registers an existing instance with the container, performing property and field injection if configured. Use this when you have a pre-created instance.

```csharp
container.WireUp<IJob>(new DbBackup());  
IJob job = container.Resolve<IJob>();  
```

--------------------------------

### Registering a Service with a Parameterized Factory Delegate

Source: https://z4kn4fein.github.io/stashbox/docs/guides/advanced-registration?id=factory-registration

Bind a parameterized factory delegate that accepts dependencies. The container resolves and passes the specified dependencies to the delegate for service instantiation. This allows the factory to utilize other services managed by the container.

```csharp
container.Register<IJob, DbBackup>(options => options  
    .WithFactory<ILogger>(logger => new DbBackup(logger)));  
  
// the container uses the factory for instantiation.  
IJob job = container.Resolve<IJob>();  

```

--------------------------------

### Configure and Use Stashbox Container

Source: https://z4kn4fein.github.io/stashbox/docs/getting-started/introduction

Configures the Stashbox container by registering services and then resolves and uses an IJob. Ensure Stashbox is added as a NuGet package.

```csharp
using Stashbox;
using System;

namespace Example
{
    public class Program
    {
        private static readonly IStashboxContainer container;

        static Program()
        {
            // 1. Create container
            container = new StashboxContainer();

            // 2. Register your services
            container.RegisterSingleton<ILogger, ConsoleLogger>();
            container.Register<IEventBroadcaster, MessageBus>();
            container.Register<IJob, DbBackup>();

            // 3. Validate the configuration.
            container.Validate();
        }

        static void Main(string[] args)
        {
            // 4. Resolve and use your service
            var job = container.Resolve<IJob>();
            job.DoTheJob();
        }
    }
}

```

--------------------------------

### Register with Constructor by Argument Types

Source: https://z4kn4fein.github.io/stashbox/docs/configuration/registration-configuration

Selects a specific constructor for registration based on the types of its arguments.

```csharp
container.Register<IUserRepository, UserRepository>(options => options
    .WithConstructorByArgumentTypes(typeof(ILogger)));


```

--------------------------------

### Define and Compose a Single Composition Root

Source: https://z4kn4fein.github.io/stashbox/docs/guides/advanced-registration

Defines a composition root implementation for wiring up services and then composes it using the container. The composition root can have its own dependencies.

```csharp
class ExampleRoot : ICompositionRoot  
{
    public ExampleRoot(IDependency rootDependency)  
    { }  

    public void Compose(IStashboxContainer container)  
    {
       container.Register<IServiceA, ServiceA>();  
       container.Register<IServiceB, ServiceB>();  
    }
}

// compose a single root.
container.ComposeBy<ExampleRoot>();  

```

--------------------------------

### Prefer Constructor with Fewest Parameters

Source: https://z4kn4fein.github.io/stashbox/docs/configuration/registration-configuration

Use this rule to select the constructor with the shortest parameter list during dependency resolution.

```csharp
options.WithConstructorSelectionRule(
    Rules.ConstructorSelection.PreferLeastParameters)


```

--------------------------------

### Registering Services for Named Scopes

Source: https://z4kn4fein.github.io/stashbox/docs/guides/scopes

Demonstrates how to register services with named scope lifetimes using 'InNamedScope'. This allows services to be shared only within specific named scope groups.

```csharp
container.Register<IJob, DbBackup>(options =>   
    options.InNamedScope("DbScope"));  
  
container.Register<IJob, DbCleanup>(options =>   
    options.InNamedScope("DbScope"));  
  
container.Register<IJob, DbIndexRebuild>(options =>   
    options.InNamedScope("DbSubScope"));  
  
container.Register<IJob, StorageCleanup>(options =>   
    options.InNamedScope("StorageScope"));  
```

--------------------------------

### Add Stashbox to Project File

Source: https://z4kn4fein.github.io/stashbox/docs/getting-started/introduction

Include this XML snippet in your .csproj file to add Stashbox as a package reference.

```xml
<PackageReference Include="Stashbox" Version="5.20.0" />  

```

--------------------------------

### Compose Assembly with ICompositionRoot

Source: https://z4kn4fein.github.io/stashbox/docs/diagnostics/validation

Use this to compose an assembly. Throws CompositionRootNotFoundException if no ICompositionRoot is found.

```csharp
container.ComposeAssembly(typeof(Service).Assembly);
```

--------------------------------

### Creating and Retrieving Child Containers by Identifier

Source: https://z4kn4fein.github.io/stashbox/docs/advanced/child-containers

Shows how to create a child container with a specific identifier and later retrieve it using the parent container's GetChildContainer method.

```csharp
using var container = new StashboxContainer();  
container.CreateChildContainer("child");  
// ...  
  
var child = container.GetChildContainer("child");  

```

--------------------------------

### Registering a Service with a Parameter-less Factory Delegate

Source: https://z4kn4fein.github.io/stashbox/docs/guides/advanced-registration?id=factory-registration

Bind a parameter-less factory delegate to a registration. The container invokes this delegate to instantiate the service. This is useful when the service's instantiation logic is simple and does not require external dependencies resolved by the container.

```csharp
container.Register<ILogger, ConsoleLogger>(options => options  
    .WithFactory(() => new ConsoleLogger()));  
  
// the container uses the factory for instantiation.  
IJob job = container.Resolve<ILogger>();  

```

--------------------------------

### Define Service with Named Dependency

Source: https://z4kn4fein.github.io/stashbox/docs/guides/service-resolution

Defines a `DbBackup` class with a named dependency for `ILogger` (named "console"), enabling specific overrides.

```csharp
class DbBackup : IJob  
{
    public DbBackup([Dependency("console")]ILogger logger)
    {
    }

}
```

--------------------------------

### Resolving Services with Identifiers using KeyValuePair and ReadOnlyKeyValue

Source: https://z4kn4fein.github.io/stashbox/docs/advanced/wrappers-resolvers

Demonstrates how to register services with unique identifiers (names) and resolve them using KeyValuePair<object, TService> or ReadOnlyKeyValue<object, TService>. Useful for distinguishing between multiple registrations of the same service type.

```csharp
container.Register<IService, Service1>("FirstServiceId");  
container.Register<IService, Service2>("SecondServiceId");  
container.Register<IService, Service3>();  
  
var serviceKeyValue1 = container  
    .Resolve<KeyValuePair<object, IService>>("FirstServiceId");  
// prints: "FirstServiceId"  
Console.WriteLine(serviceKeyValue1.Key);  
  
var serviceKeyValue2 = container  
    .Resolve<ReadOnlyKeyValue<object, IService>>("SecondServiceId");  
// prints: "SecondServiceId"  
Console.WriteLine(serviceKeyValue2.Key);
```

--------------------------------

### Register Service with Injection Parameters

Source: https://z4kn4fein.github.io/stashbox/docs/guides/advanced-registration

Registers a service and specifies injection parameters for its constructor. These parameters are resolved and passed during the service's instantiation.

```csharp
container.Register<IJob, DbBackup>(options => options  
    .WithInjectionParameter("logger", new ConsoleLogger())  
    .WithInjectionParameter("eventBroadcaster", new MessageBus()));  

// the injection parameters will be passed to DbBackup's constructor.  
IJob backup = container.Resolve<IJob>();  

```

--------------------------------

### Registering Services with Parameterized Factories

Source: https://z4kn4fein.github.io/stashbox/docs/configuration/registration-configuration

Use WithFactory to register services with delegates that accept pre-resolved dependencies as parameters. The number of parameters can vary.

```csharp
container.Register<IUserRepository, UserRepository>(options => options  
    .WithFactory<ILogger>(logger => new UserRepository(logger)));  

container.Register<IUserRepository, UserRepository>(options => options  
    .WithFactory<ILogger, IDbContext>((logger, context) => new UserRepository(logger, context)));  

container.Register<IUserRepository, UserRepository>(options => options  
    .WithFactory<ILogger, IDbContext, IOptions>((logger, context, options) =>   
        new UserRepository(logger, context, options)));  

container.Register<IUserRepository, UserRepository>(options => options  
    .WithFactory<ILogger, IDbConnection, IOptions, IUserValidator>((logger, connection, options, validator) =>   
        new UserRepository(logger, connection, options, validator)));  

container.Register<IUserRepository, UserRepository>(options => options  
    .WithFactory<ILogger, IDbConnection, IOptions, IUserValidator, IPermissionManage>(  
        (logger, connection, options, validator, permissionManager) =>   
            new UserRepository(logger, connection, options, validator, permissionManager)));  
```

--------------------------------

### Set Constructor Selection Rule: PreferLeastParameters

Source: https://z4kn4fein.github.io/stashbox/docs/configuration/container-configuration

Configure the container to prefer the constructor with the fewest parameters during instantiation.

```csharp
new StashboxContainer(options => options  
    .WithConstructorSelectionRule(  
        Rules.ConstructorSelection.PreferLeastParameters));  
```

--------------------------------

### Registering Services with Factory Using Dependency Resolver

Source: https://z4kn4fein.github.io/stashbox/docs/configuration/registration-configuration

Register services using a factory delegate that accepts an IDependencyResolver, allowing resolution of other dependencies within the delegate.

```csharp
container.Register<IUserRepository, UserRepository>(options => options  
    .WithFactory<ILogger, IDependencyResolver>((logger, resolver) =>   
        new UserRepository(logger, resolver.Resolve<IDbConnection>())));  
```

--------------------------------

### Self Registration (Generic API)

Source: https://z4kn4fein.github.io/stashbox/docs/guides/basics

Shows how to register a service to itself using the generic API, where the implementation type is also the service type.

```csharp
container.Register<DbBackup>();  
DbBackup backup = container.Resolve<DbBackup>();  
```

--------------------------------

### Implementing the Composite Pattern with Decorators

Source: https://z4kn4fein.github.io/stashbox/docs/advanced/decorators

Shows how to use the Composite pattern by registering a decorator that depends on a collection of the same service. This allows treating a group of objects the same as a single instance.

```csharp
public class CompositeValidator<TEvent> : IEventValidator<TEvent>
{
    private readonly IEnumerable<IEventValidator<TEvent>> validators;

    public CompositeValidator(IEnumerable<IEventValidator<TEvent>> validators)
    {
        this.validators = validators;
    }

    public bool IsValid(TEvent @event)
    {
        return this.validators.All(validator => validator.IsValid(@event));
    }
}

container.Register(typeof(IEventValidator<>), typeof(EventValidator<>));
container.Register(typeof(IEventValidator<>), typeof(AnotherEventValidator<>));
container.RegisterDecorator(typeof(IEventValidator<>), typeof(CompositeValidator<>));

```

--------------------------------

### Registering and Resolving Scoped Services

Source: https://z4kn4fein.github.io/stashbox/docs/guides/scopes?id=service-as-scope

Demonstrates how to register a service with a scoped lifetime and resolve it within a scope. Instances resolved within the same scope are guaranteed to be the same.

```csharp
container.RegisterScoped<IJob, DbBackup>();

// create the scope with using so it'll be auto disposed.
using (var scope = container.BeginScope())
{
    IJob job = scope.Resolve<IJob>();
    IJob jobAgain = scope.Resolve<IJob>();
    // job and jobAgain are created in the 
    // same scope, so they are the same instance.
}

```

--------------------------------

### Define Services and Interfaces

Source: https://z4kn4fein.github.io/stashbox/docs/getting-started/introduction

Defines the interfaces and concrete implementations for services like ILogger, IEventBroadcaster, and IJob. This sets up the dependency structure.

```csharp
public interface IJob { void DoTheJob(); }  
  
public interface ILogger { void Log(string message); }  
  
public interface IEventBroadcaster { void Broadcast(IEvent @event); }  
  
  
public class ConsoleLogger : ILogger  
{
    public void Log(string message) => Console.WriteLine(message);  
}
  
public class MessageBus : IEventBroadcaster  
{
    private readonly ILogger logger;

    public MessageBus(ILogger logger)
    {
        this.logger = logger;
    }

    void Broadcast(IEvent @event)   
    {
        this.logger.Log($"Sending event to bus: {@event.Name}");  
        // Do the actual event broadcast.  
    }
}
  
public class DbBackup : IJob  
{
    private readonly ILogger logger;
    private readonly IEventBroadcaster eventBroadcaster;

    public DbBackup(ILogger logger, IEventBroadcaster eventBroadcaster)
    {
        this.logger = logger;
        this.eventBroadcaster = eventBroadcaster;
    }

    public void DoTheJob()   
    {
        this.logger.Log("Backing up!");  
        // Do the actual backup.  
        this.eventBroadcaster.Broadcast(new DbBackupCompleted());  
    }   
}


```

--------------------------------

### Put Instance into Scope

Source: https://z4kn4fein.github.io/stashbox/docs/guides/scopes

Add an already instantiated service to a scope. The instance's lifetime will be tracked by the given scope.

```csharp
using var scope = container.BeginScope();  
scope.PutInstanceInScope<IJob>(new DbBackup());  
```

--------------------------------

### Enabling dynamic resolution

Source: https://z4kn4fein.github.io/stashbox/docs/configuration/registration-configuration

Use `WithDynamicResolution` to indicate that the service's resolution should be handled by a dynamic `Resolve()` call. This defers instantiation until resolution time.

```csharp
container.Register<IJob, DbBackup>();  
container.Register<ILogger, ConsoleLogger>(options => options  
    .WithDynamicResolution());  
  
// new DbBackup(currentScope.Resolve<ILogger>());  
var job = container.Resolve<IJob>();  
  

```

--------------------------------

### Define a Service with a Dependency

Source: https://z4kn4fein.github.io/stashbox/docs/guides/service-resolution

Defines a `DbBackup` class that depends on `ILogger`. This is a prerequisite for demonstrating dependency overrides.

```csharp
class DbBackup : IJob  
{
    public DbBackup(ILogger logger)
    {
    }

}
```

--------------------------------

### Replacing an existing registration

Source: https://z4kn4fein.github.io/stashbox/docs/configuration/registration-configuration

Use `ReplaceExisting` to replace a previously registered service with the current one. If no existing registration is found, the new one is added.

```csharp
container.Register<ILogger, ConsoleLogger>(options => options  
    .ReplaceExisting());  

```

--------------------------------

### Self Registration (Runtime Type API)

Source: https://z4kn4fein.github.io/stashbox/docs/guides/basics

Demonstrates self-registration using the runtime type API, where the implementation type is registered without specifying a separate service type.

```csharp
container.Register(typeof(DbBackup));  
object backup = container.Resolve(typeof(DbBackup));  
```

--------------------------------

### Create and Use Nested Scopes

Source: https://z4kn4fein.github.io/stashbox/docs/guides/scopes

Illustrates creating a nested scope from an existing scope. Services resolved in the sub-scope are distinct from those in the parent scope, even if they are the same service type.

```csharp
container.RegisterScoped<IJob, DbBackup>();  
  
using (var parent = container.BeginScope())  
{  
    IJob job = parent.Resolve<IJob>();  
    IJob jobAgain = parent.Resolve<IJob>();  
    // job and jobAgain are created in the   
    // same scope, so they are the same instance.  
  
    // create a sub-scope.  
    using var sub = parent.BeginScope();  
  
    IJob subJob = sub.Resolve<IJob>();  
    // subJob is a new instance created in the sub-scope,   
    // differs from either job and jobAgain.  
}  
```

--------------------------------

### Rebuilding Singletons in Child Containers

Source: https://z4kn4fein.github.io/stashbox/docs/advanced/child-containers

Shows how to enable the re-creation of singletons in child containers using WithReBuildSingletonsInChildContainer. This allows child containers to use overridden dependencies while maintaining singleton behavior.

```csharp
interface IDependency {}  
  
class B : IDependency {}  
class C : IDependency {}  
  
class A   
{  
    public A(IDependency dependency)  
    { }  
}  
  
using (var container = new StashboxContainer(options => options.WithReBuildSingletonsInChildContainer()))  
{  
    // register 'A' as a singleton into the parent container.  
    container.RegisterSingleton<A>();  
  
    // register 'B' as a dependency into the parent container.  
    container.Register<IDependency, B>();  
  
    // 'A' gets 'B' as IDependency and will be stored  
    // in the parent container as a singleton.  
    A fromParent = container.Resolve<A>();  
  
    var child = container.CreateChildContainer();  
      
    // register 'C' as a dependency into the child container.  
    child.Register<IDependency, C>();  
  
    // a new 'A' singleton will be created in  
    // the child container with 'C' as IDependency.  
    A fromChild = child.Resolve<A>();  
} // using will dispose the parent along with the child.  

```

--------------------------------

### Register Func Factory with String Parameter

Source: https://z4kn4fein.github.io/stashbox/docs/guides/advanced-registration

Register a factory using Func<string, IJob> that accepts a connection string and resolves an ILogger. This allows runtime parameter injection for service creation.

```csharp
container.RegisterFunc<string, IJob>((connectionString, resolver) =>   
    new DbBackup(connectionString, resolver.Resolve<ILogger>()));  
  
Func<string, IJob> backupFactory = container.Resolve<Func<string, IJob>>();  
IJob dbBackup = backupFactory(Configuration["ConnectionString"]);  

```

--------------------------------

### Multiple Decorators for Service Extension

Source: https://z4kn4fein.github.io/stashbox/docs/advanced/decorators

Shows how to register multiple decorators for a single service. The decorators are applied in the order they are registered, creating a nested wrapper structure.

```csharp
container.Register<IEventProcessor, GeneralProcessor>();
container.RegisterDecorator<IEventProcessor, LoggerProcessor>();
container.RegisterDecorator<IEventProcessor, ValidatorProcessor>();

// new ValidatorProcessor(new LoggerProcessor(new GeneralProcessor()));
var processor = container.Resolve<IEventProcessor>();

```

--------------------------------

### Named Registration (Runtime Type API)

Source: https://z4kn4fein.github.io/stashbox/docs/guides/basics

Demonstrates named registration using the runtime type API, allowing multiple implementations of a service to be registered and resolved by their names.

```csharp
container.Register(typeof(IJob), typeof(DbBackup), "DbBackup");  
container.Register(typeof(IJob), typeof(StorageCleanup), "StorageCleanup");  
object cleanup = container.Resolve(typeof(IJob), "StorageCleanup");  
```

--------------------------------

### Set Constructor Selection Rule: PreferMostParameters

Source: https://z4kn4fein.github.io/stashbox/docs/configuration/container-configuration

Configure the container to prefer the constructor with the most parameters during instantiation.

```csharp
new StashboxContainer(options => options  
    .WithConstructorSelectionRule(  
        Rules.ConstructorSelection.PreferMostParameters));  
```

--------------------------------

### Register Parameterized Factory Delegate

Source: https://z4kn4fein.github.io/stashbox/docs/guides/advanced-registration

Register a service using a factory delegate that accepts a dependency (ILogger) to construct the DbBackup service.

```csharp
container.Register<IJob, DbBackup>(options => options  
    .WithFactory<ILogger>(logger => new DbBackup(logger)));  

// the container uses the factory for instantiation.  
IJob job = container.Resolve<IJob>();  

```

--------------------------------

### Implementing and Registering a Logging Interceptor

Source: https://z4kn4fein.github.io/stashbox/docs/advanced/decorators

This snippet defines a LoggingInterceptor using Castle DynamicProxy and registers it along with the service and proxy builder for interception.

```csharp
public class LoggingInterceptor : IInterceptor   
{  
    private readonly ILogger logger;  
  
    public LoggingInterceptor(ILogger logger)  
    {  
        this.logger = logger;  
    }  
  
    public void Intercept(IInvocation invocation)  
    {  
        var stopwatch = new Stopwatch();  
        stopwatch.Start();  
  
        // log before we invoke the intercepted method.  
        this.logger.Log($"Method begin: {invocation.GetConcreteMethod().Name}");  
  
        // call the intercepted method.  
        invocation.Proceed();  
  
        // log after we invoked the intercepted method and print how long it ran.  
        this.logger.Log($"Method end: {invocation.GetConcreteMethod().Name}, execution duration: {stopwatch.ElapsedMiliseconds} ms");  
    }  
}  
  
// create a DefaultProxyBuilder from the DynamicProxy library.  
var proxyBuilder = new DefaultProxyBuilder();  
  
// build a proxy for the IEventProcessor interface.  
var eventProcessorProxy = proxyBuilder.CreateInterfaceProxyTypeWithTargetInterface(  
    typeof(IEventProcessor),   
    new Type[0],   
    ProxyGenerationOptions.Default);  
  
// register the logger for LoggingInterceptor.  
container.Register<ILogger, ConsoleLogger>();  
  
// register the service that we will intercept.  
container.Register<IEventProcessor, GeneralEventProcessor>();  
  
// register the interceptor.  
container.Register<IInterceptor, LoggingInterceptor>();  
  
// register the built proxy as a decorator.  
container.RegisterDecorator<IEventProcessor>(eventProcessorProxy);  

```

--------------------------------

### Register Service with Multiple Constructors

Source: https://z4kn4fein.github.io/stashbox/docs/guides/advanced-registration

Register a Service class with multiple constructors. The container resolves a Func<int, Service> which uses the constructor accepting an int.

```csharp
class Service  
{  
    public Service(int number) { }  
    public Service(string text) { }  
}  
  
container.Register<Service>();  
  
// create the factory with an int input parameter.  
var func = constainer.Resolve<Func<int, Service>>();  
  
// the constructor with the int param   
// is used for instantiation.  
var service = func(2);  

```

--------------------------------

### Resolving Multiple Named Services

Source: https://z4kn4fein.github.io/stashbox/docs/guides/basics

Illustrates how to resolve all services registered under a specific name, returning them as an IEnumerable collection.

```csharp
container.Register<IJob, DbBackup>("StorageJobs");  
container.Register<IJob, StorageCleanup>("StorageJobs");  
container.Register<IJob, AnotherJob>();  
// jobs will be [DbBackup, StorageCleanup].  
IEnumerable<IJob> jobs = container.Resolve<IEnumerable<IJob>>("StorageJobs");  
```

--------------------------------

### Define a Composition Root Implementation

Source: https://z4kn4fein.github.io/stashbox/docs/guides/advanced-registration?id=factory-registration

Defines a class that implements ICompositionRoot to specify service registrations for a component. Dependencies can be injected into the Composition Root itself.

```csharp
class ExampleRoot : ICompositionRoot  
{
    public ExampleRoot(IDependency rootDependency)
    {
    }

    public void Compose(IStashboxContainer container)
    {
       container.Register<IServiceA, ServiceA>();
       container.Register<IServiceB, ServiceB>();
    }
}

```

--------------------------------

### Injectable Dependency in Constructor

Source: https://z4kn4fein.github.io/stashbox/docs/getting-started/glossary

Demonstrates how a class's constructor can accept dependencies that Stashbox will automatically resolve and inject.

```csharp
class Implementation : IService  
{  
    public Implementation(IDependency dependency)   
    { }  
}
```

--------------------------------

### Resolve Service with Named Dependency Override (Generic API)

Source: https://z4kn4fein.github.io/stashbox/docs/guides/service-resolution

Resolves a `DbBackup` instance, overriding the named `ILogger` dependency ("console") with a `ConsoleLogger` using the generic `Resolve` method and `Override.Of`.

```csharp
DbBackup backup = container.Resolve<DbBackup>(
    dependencyOverrides: new object[]
    {
        Override.Of<ILogger>(new ConsoleLogger(), "console"),
    });
```

--------------------------------

### Instance Registration without Disposal Tracking

Source: https://z4kn4fein.github.io/stashbox/docs/guides/basics

Demonstrates registering an instance without enabling disposal tracking, meaning Stashbox will not manage the disposal of the provided instance.

```csharp
var job = new DbBackup();  
container.RegisterInstance<IJob>(job, withoutDisposalTracking: true);  
  
// resolvedJob and job are the same.  
IJob resolvedJob = container.Resolve<IJob>();  
```

--------------------------------

### Chained Registration and Resolution

Source: https://z4kn4fein.github.io/stashbox/docs/guides/basics

Illustrates the fluent API of Stashbox, allowing multiple registrations to be chained before resolving a service.

```csharp
var job = container.Register<IJob, DbBackup>()  
    .Register<ILogger, ConsoleLogger>()  
    .Resolve<IJob>();  
```

--------------------------------

### Custom Constructor Selection Rule

Source: https://z4kn4fein.github.io/stashbox/docs/configuration/registration-configuration

Allows defining custom logic for selecting constructors based on specific criteria.

```csharp
options.WithConstructorSelectionRule(
    constructors => { /* custom constructor sorting logic */ })


```

--------------------------------

### Resolve Service with Dependency Override (Generic API)

Source: https://z4kn4fein.github.io/stashbox/docs/guides/service-resolution

Resolves a `DbBackup` instance, overriding its `ILogger` dependency with a `ConsoleLogger` using the generic `Resolve` method.

```csharp
DbBackup backup = container.Resolve<DbBackup>(
    dependencyOverrides: new object[]
    {
        new ConsoleLogger()
    });
```

--------------------------------

### Filtering Collections by Metadata

Source: https://z4kn4fein.github.io/stashbox/docs/advanced/wrappers-resolvers

Shows how to register multiple services with different metadata and then resolve collections filtered by the metadata type. Useful for selecting services based on specific criteria.

```csharp
container.Register<IService, Service1>(options => options  
    .WithMetadata("meta-1"));  
container.Register<IService, Service2>(options => options  
    .WithMetadata("meta-2"));  
container.Register<IService, Service3>(options => options  
    .WithMetadata(5));  
  
// the result is: [Service1, Service2]  
var servicesWithStringMetadata = container.Resolve<ValueTuple<IService, string>[]>();  
  
// the result is: [Service3]  
var servicesWithIntMetadata = container.Resolve<ValueTuple<IService, int>[]>();
```

--------------------------------

### Registering a Service with a Custom Lifetime

Source: https://z4kn4fein.github.io/stashbox/docs/guides/lifetimes

Register a service using a custom lifetime implementation. This allows for fine-grained control over how service instances are managed throughout their lifecycle.

```csharp
container.Register<IJob, DbBackup>(options => options.WithLifetime(new CustomLifetime()));  
```

--------------------------------

### Binding a Service to Multiple Interfaces (Specific)

Source: https://z4kn4fein.github.io/stashbox/docs/guides/advanced-registration

Register a service implementation to be resolvable by one of its interfaces or base types, in addition to its primary registration.

```csharp
container.Register<IJob, DbBackup>(options => options
    .AsServiceAlso<IScheduledJob>());

IJob job = container.Resolve<IJob>(); // DbBackup
IScheduledJob job = container.Resolve<IScheduledJob>(); // DbBackup
DbBackup job = container.Resolve<DbBackup>(); // error, not found

```

--------------------------------

### Registering Multiple Implementations for a Service

Source: https://z4kn4fein.github.io/stashbox/docs/guides/advanced-registration

Register multiple implementations for a single service type. These can be resolved as a collection or individually by name.

```csharp
container.Register<IJob, DbBackup>();
container.Register<IJob, StorageCleanup>();
container.Register<IJob, ImageProcess>();

```

--------------------------------

### Registering a service with a name

Source: https://z4kn4fein.github.io/stashbox/docs/configuration/registration-configuration

Use the `WithName` option to assign a unique identifier to a service registration. This is useful for distinguishing between multiple registrations of the same service type.

```csharp
container.Register<IJob, DbBackup>(options => options  
    .WithName("DbBackup"));  

```

```csharp
container.Register<ILogger, ConsoleLogger>(config => config  
    .WithName("Console"));  

```

--------------------------------

### Resolving All Implementations as Array

Source: https://z4kn4fein.github.io/stashbox/docs/guides/advanced-registration

Retrieve all registered implementations of a service type as an array. The order of services in the array matches their registration order.

```csharp
// jobs contain all three services in registration order.
IJob[] jobs = container.Resolve<IJob[]>();

```
Tokens:
Raw