Faster.Ioc is an IoC container for Microsoft .NET. It manages dependencies between classes so that applications stay easy to change as they grow in size and complexity.
Faster.Ioc is an incredibly fast Ioc container with endless possibilities. Faster.ioc supports the following:
- Scoped lifetimes (Singleton, Transient, Scoped)
- Multi registrations, no more pesky factories...
- Conditional overrides
- Ienumerable
- Asp.net core features
- Open and closed generics
- Child containers
- Store registrations by key
- Retrieve all registrations of the same interface
- Will always resolve constructor with largest parameters
- Install nuget package Faster.Ioc to your project
dotnet add package Faster.Ioc
- Create a Container
var container = new Container();
//add registrations with different lifetimes
container.Register<IAnimal, Cow>(Lifetime.Singleton);
container.Register<IAnimal, Horse>(Lifetime.Transient);
container.Register<IAnimal, Bull>(Lifetime.Scoped);
// register by key
container.Register<IAnimal, Goose>(Lifetime.Scoped, "Goose")
// will always resolve the first registration of IAnimal, which in this case is a Cow
var cow = container.Resolve<IAnimal>();
// Resolve by key
var goose = container.Resolve("Goose");
//Cow, Horse and Bull
var animals = container.Resolve<IEnumerable<IAnimal>>()- Conditional - overriding a parameter with a different implementation
var container = new Container();
container.Register<IAnimal, Cow>(Lifetime.Singleton);
container.Register<IAnimal, Horse>(Lifetime.Transient);
//Create override of Farm which be default, since it has an IAnimal parameter would resolve a Cow, but now it will resolve a Horse
//Types used in an override need to be registered!
container.RegisterOverride<IFarm, Farm>(() => new Farm(New Horse()));
// will always resolve the first registration of IAnimal, which in this case is a Cow
var cow = container.Resolve<IFarm>();
public class Farm
{
public Animal{get; set;}
public Farm(IAnimal animal)
{
Animal = animal;
}
}- Ienumerable
var container = new Container();
container.Register<IAnimal, Cow>(Lifetime.Singleton);
container.Register<IAnimal, Horse>(Lifetime.Singleton);
//Create override of Farm which be default, since it has an IAnimal parameter would resolve a Cow, but now it will resolve a Horse
//Types used in an override need to be registered!
container.Register<IFarm, Farm>();
public class Farm
{
public IEnumerable<IAnimal> {get; private set;}
public Farm(IEnumerable<IAnimal> animals)
{
Animals = animals;
}
}- OpenGenerics
var container = new Container();
container.Register<>(typeof(IGeneric<>, Generic<>)Lifetime.Singleton);
container.Register<IFarm, Farm>();
public class Farm
{
public Generic<IAnimal> { get; private set;}
public Farm(IGeneric<IAnimal> animals)
{
Animals = animals;
}
}- Closed Generics
var container = new Container();
container.Register<>(typeof(IGeneric<int>, Generic<int>)Lifetime.Singleton);
container.Register<IFarm, Farm>();
public class Farm
{
public Generic<int> { get; private set;}
public Farm(IGeneric<int> animals)
{
Animals = animals;
}
}- Scoped Lifetime
Container container = new Container();
container.Register<IDisposeableOne>(() => new DisposeableOne(), Lifetime.Scoped);
using (var factory = container.CreateScope())
{
//Act
var instance = factory.ServiceProvider.GetService(typeof(IDisposeableOne));
var instance2 = factory.ServiceProvider.GetService(typeof(IDisposeableOne));
//Assert
Assert.IsTrue(instance == instance2);
}The lifetime of objects implementing IDisposable interface is something to keep in mind. The Container will keep track of all objects implementing IDisposable (Singletons and transient). By default Faster.Map will dispose all objects at shutdown or when .Dispose() is called. This is also when the memory is released by the garbage collector, all references stored in the Container will be gone. If this is troublesome you can either use a Scoped lifetimes or a ChildContainer