IoC.AspNetCore 1.1.0-beta222

Simple, powerful and fast IoC container

IoC.Container provides the following benefits:

• One of the fastest, almost as fast as operators new
• Produces minimal memory trafic
• Powerful auto-wiring
  • Checks the auto-wiring configuration at the compile time
  • Allows to not change a code design to use IoC
  • Clear generic types' mapping
  • The simple text metadata is supported
  • Flexible autowiring configuration (as example a custom Aspect Oriented Autowiring)
• Fully extensible and supports custom containers/lifetimes
• Reconfigurable on-the-fly
• Supports concurrent and asynchronous resolving
• Does not need additional dependencies
• Supports ASP.NET Core
• Supports Windows Presentation Foundation
• Supports Universal Windows Platform
• Supports Windows Communication Foundation

NuGet packages:

• IoC.Container
  • 
• IoC.Container.Source (embedding in code)
  • 
• IoC.AspNetCore
  • 
• IoC.AspNetCore.Source (embedding in code)
  • 

Supported platforms:

• .NET 4.0+
• .NET Core 1.0+
• .NET Standard 1.0+
• UWP 10+

Schrödinger's cat shows how it works

The reality is that

Let's create an abstraction

interface IBox<out T> { T Content { get; } }

interface ICat { bool IsAlive { get; } }

Here is our implementation

class CardboardBox<T> : IBox<T>
{
    public CardboardBox(T content) => Content = content;

    public T Content { get; }

    public override string ToString() => Content.ToString();
}

class ShroedingersCat : ICat
{
    public bool IsAlive => new Random().Next(2) == 1;

    public override string ToString() => $"Is alive: {IsAlive}";
}

It is important to note that our abstraction and our implementation do not know anything about IoC containers

Add the package reference

IoC.Container ships entirely as NuGet packages. Using NuGet packages allows you to optimize your application to include only the necessary dependencies.

• Package Manager

  Install-Package IoC.Container
  

• .NET CLI

  dotnet add package IoC.Container
  

Let's glue all together

class Glue : IConfiguration
{
  public IEnumerable<IDisposable> Apply(IContainer container)
  {
    yield return container.Bind<IBox<TT>>().To<CardboardBox<TT>>();
    yield return container.Bind<ICat>().To<ShroedingersCat>();
  }
}

Just configure the container and check it works as expected

using (var container = Container.Create().Using<Glue>())
{
    var box = container.Resolve<IBox<ICat>>();
    Console.WriteLine(box);

    // Func
    var func = container.Resolve<Func<IBox<ICat>>>();
    Console.WriteLine(func());

    // Async
    box = await container.Resolve<Task<IBox<ICat>>>();
    Console.WriteLine(box);

    // Async value
    box = await container.Resolve<ValueTask<IBox<ICat>>>();
    Console.WriteLine(box);

    // Tuple<,>
    var tuple = container.Resolve<Tuple<IBox<ICat>, ICat>>();
    Console.WriteLine(tuple.Item1 + ", " + tuple.Item2);

    // ValueTuple(,,)
    var valueTuple = container.Resolve<(IBox<ICat> box, ICat cat, IBox<ICat> anotherBox)>();
    Console.WriteLine(valueTuple.box + ", " + valueTuple.cat + ", " + valueTuple.anotherBox);

    // Lazy
    var lazy = container.Resolve<Lazy<IBox<ICat>>>();
    Console.WriteLine(lazy.Value);

    // Enumerable
    var enumerable = container.Resolve<IEnumerable<IBox<ICat>>>();
    Console.WriteLine(enumerable.Single());

    // List
    var list = container.Resolve<IList<IBox<ICat>>>();
    Console.WriteLine(list[0]);
}

Under the hood

Actually these resolvers are represented just as a set of operators new which allow to create (or to get) required instances.

var box = new CardboardBox<ShroedingersCat>(new ShroedingersCat());

There is only one difference - these resolvers are wrapped to compiled lambda-functions and an each call of these lambda-functions spends some minimal time in the operator call, but in actual scenarios it is not required to make these calls each time to create instances. When some dependencies are injected to an instance they are injected without any lambdas at all but just as a minimal set of instruction to create these dependencies:

new ShroedingersCat()

Thus this IoC container makes the minimal impact in terms of perfomrance and of memory trafic on a creation of instances of classes and might be used everywhere and everytime in accordance with the SOLID principles.

ASP.NET Core

Add the package reference

• Package Manager

  Install-Package IoC.AspNetCore
  

• .NET CLI

  dotnet add package IoC.AspNetCore
  

Change IoC container and configure it at Startup

public IServiceProvider ConfigureServices(IServiceCollection services)
{
  services.AddMvc().AddControllersAsServices();

  // Create container
  var container = Container.Create().Using(new AspNetCoreFeature(services));

  // Configure container
  container.Using<Glue>();

  // Resolve IServiceProvider
  return container.Resolve<IServiceProvider>();
}

For more information see this sample.

Class References

• .NET 4.0
• .NET 4.5
• .NET Standard 1.0
• .NET Core 2.0
• UWP 10.0

Why this one?

The results of the comparison tests for some popular IoC containers like Castle Windsor, Autofac, Unity, Ninject ...