miniautofac

Simple IoC container for Microsoft .NET

Description

MiniAutFac was created in order to understand how reflection and original AutoFac work. It is not dedicated for complex projects (see http://code.google.com/p/autofac/ instead) - rather for educational purposes and simple solutions.

Features

Simple code
Lightweight (about 30 kb)
Resolving constructors parameters
Detecting circular dependencies (only throws exception)
Attribute-based registration
AutoFac-like lifetime scopes

Releases

1.4.0

Proper instance registering when using predicate on assembly

1.3.8

Additional parameters when resolving

1.3.7

Open generic support

1.3.6

Invlaid version on nuget, fix.

1.3.5

Fixed small bug when resolving keyed services with IEnumerable.

1.3.4

Validating type of instance factory result at resolve time (not while registering) when object is used as a return type

1.3.3

Resolving services by a key

1.3.2

Resolving Lazy - instances are resolved only when Value is called.

1.3.1

Registering type via value factory

1.3.0

Parameters (named and evaluted paramteres)
Registering own instance factory for type
Simple modules
Fixed bug: when resolving enumerable within nested liftime scope and resolved instance was disposed incorrectly

1.2.2

Fixed invalid assembly version inside nuget package.

1.2.1

Fixed bug when resolving IEnumerable regstired per lifetime scope

1.2

Removed registering from namespace (found it useless and not efficient)
Registering multiple classes / types chosen with predicate within assemblies
Registering multiple items

1.1

First release
Base features

Usage

Self-registering

var builder = new ContainerBuilder();
builder.Register<Foo>();

var resolver = builder.Build();
var fooInstance = resolver.Resolve<Foo>()

Registering class as class

var builder = new ContainerBuilder();
builder.Register<Bar>().As<Foo>();

var resolver = builder.Build();
var fooInstance = resolver.Resolve<Foo>(); // fooInstance.GetType() == typeof(Bar)

Registering type wth implict registration

public class Foo: IFoo {
}
...
var builder = new ContainerBuilder() { ResolveImplicit = true };
builder.Register<Foo>();

var resolver = builder.Build();
var fooInstance = resolver.Resolve<IFoo>(); // fooInstance.GetType() == typeof(Foo)

Registering multiple classes and resolving:

var builder = new ContainerBuilder();
builder.Register<Foo1>().As<IFoo>();
builder.Register<Foo2>().As<IFoo>();

IEnumerable<IFoo> fooInstances = builder.Build().Resolve<IEnumerable<IFoo>>();

Attribute-based registration

[ContainerType(typeof(Bar))]
[ContainerType(typeof(IFoo))]
class Foo: Bar, IFoo
{
}

...

var builder = new ContainerBuilder();
builder.Register();
var container = builder.Build();

var instance1 = container.Resolve<Bar>();
var instance2 = container.Resolve<IFoo>();

Registering type as implemented interfaces

var builder = new ContainerBuilder();
builder.Register<Foo>().AsImplementedInterfaces();

var cnt = builder.Build();
var instance = cnt.Resolve<IFoo>();

Registering multiple types with one registration

var bld = new ContainerBuilder();
bld.Register(type => typeof(IFoo).IsAssignableFrom(type), 
                            Assembly.GetExecutingAssembly()).As<IFoo>();

var container = bld.Build();
var foos = container.Resolve<IEnumerable<IFoo>>();

Lifetime scopes

After building container, you can create many nested lifetime scopes that manages a life cycle of registered instances.

var builder = new ContainerBuilder();
builder.Register<Foo>().PerLifetimeScope();

using (var container = builder.Build())
{
    var foo = container.Resolve<Foo>();
    
    var scope = container.BeginLifetimeScope();
    var nextFoo = scope.Resolve<Foo>();
    
    var anotherFoo = container.Resolve<Foo>();
    
    // when container is disposed, it disposes also all child scopes
}

// references foo and anotherFoo are the same, but they are different to nextFoo 
//(it was created in other scope).

Possible scopes so far:

SingleInstance - single instance per container (shared among all nested lifetime scopes)
PerDependency - instance created every Resolve request
PerLifetimeScope - instance shared among single lifetime scope

Named paramter

You can tells the resolvable to to apply own buult instance as parameter, when resolving:

public class Foo
{
    public Foo(string parameter1) 
    {
    }
}

var builder = new ContainerBuilder();
builder.Register<Foo>()
       .WithNamedParameter("paramter1", "value");
var cnt = builder.Build();
var fooInst = cnt.Resolve<Foo>();

Evaluated parameter

You can create own instance factory for paramter:

var builder = new ContainerBuilder();
builder.Register<Foo>().WithEvalutedParameter(
                           "logger", 
                           requesingType => new Logger(requestingType));
var foo = builder.Build().Resolve<Foo>();

Own instnace factory

bld.Register<Foo>().As(ctx =>
                             {
                                 // some other methods
                                 return new Logger(ctx.RequestingType); 
                                   // Requesting type is type, that request that instance
                                   // when f.e. injected as construcot parameter. Can be null, if type
                                   // resolved directly
                              }).PerLifetimeScope();

Registering type via value factory

var bld = new ContainerBuilder();
var bInst = new ClassB();
bld.Register(context => bInst).As<InterfaceForClassB>();

Registering open generic

var bld = new ContainerBuilder();
bld.Register(typeof(GenericClass<>)).As(typeof(IGenericClass<>));
var cnt = bld.Build();

var inst = cnt.Resolve<IGenericClass<string>>();

Resolving additional parameters

var bld = new ContainerBuilder();
bld.Register(typeof(SomeClass)).As(typeof(SomeClass));
var cnt = bld.Build();

var inst = cnt.Resolve<SomeClass>(new NamedParameter("SomeParam", someInstanceOfParameter));

Lazy support

var builder = new ContainerBuilder();
builder.Register<Bar>();

var cnt = builder.Build();
var result = cnt.Resolve<Lazy<Bar>>(); 

result.Value // that causes resolution in fact

pwasiewicz/MiniAutoFac