// Create a new container
var resolver = ObjectResolver.Create();

// Register interface->type map, default is transient(instantiate every request)
resolver.Register<IUserRepository, SqlUserRepository>();

// You can configure lifestyle - Transient, Singleton or Scoped
resolver.Register<ILogger, MailLogger>(Lifestyle.Singleton);

// Compile and Verify container(this is required step)
resolver.Compile();

// Get instance from container
var userRepository = resolver.Resolve<IUserRepository>();
var logger = resolver.Resolve<ILogger>();

public class MyType : IMyType
{
    // field injection

    [Inject]
    public IInjectTarget PublicField;

    [Inject]
    IInjectTarget PrivateField;

    // property injection

    [Inject]
    public IInjectTarget PublicProperty { get; set; }

    [Inject]
    IInjectTarget PrivateProperty { get; set; }

    // constructor injection
    // if not marked [Inject], the constructor with the most parameters is used.
    [Inject]
    public MyType(IInjectTarget x, IInjectTarget y, IInjectTarget z)
    {

    }

    // method injection

    [Inject]
    public void Initialize1()
    {
    }

    [Inject]
    public void Initialize2()
    {
    }
}

// and resolve it
var v = resolver.Resolve<IMyType>();

// Register type -> many types
resolver.RegisterCollection<IMyType>(typeof(T1), typeof(T2), typeof(T3));

resolver.Compile();

// can resolve by IEnumerbale<T> or T[] or IReadOnlyList<T>.
resolver.Resolve<IEnumerable<IMyType>>();
resolver.Resolve<IMyType[]>();
resolver.Resolve<IReadOnlyList<IMyType>>();

// can resolve other type's inject target.
public class AnotherType
{
    public AnotherType(IMyType[] targets)
    {
    }
}

// sample type of check scope
public class MyClass : IMyType, IDisposable
{
    public MyClass()
    {
        Console.WriteLine("Created");
    }

    public void Dispose()
    {
        Console.WriteLine("Disposed");
    }
}

// -----------

var resolver = ObjectResolver.Create();
resolver.Register<IMyType, MyClass>(Lifestyle.Scoped);
resolver.Compile();

using (var coResolver = resolver.BeginScope(ScopeProvider.Standard))
{
    var i1 = coResolver.Resolve<IMyType>(); // "Created"
    var i2 = coResolver.Resolve<IMyType>();

    Console.WriteLine(Object.ReferenceEquals(i1, i2)); // "True" -> same instance

    // if scope end and instantiated types is IDisposable, called Dispose.
} // "Disposed"

public class MyScopeProvider : ScopeProvider
{
    public override void Initialize(IObjectResolver resolver)
    {
        // when called from BeginScope().
    }

    protected override object GetValueFromScoped(Type type, out bool isFirstCreated)
    {
        // called per Resolve<T>.
    }
}

// sample of complex dependency type
public class ForPropertyInjection : IForPropertyInjection
{
    [Inject]
    public void OnCreate()
    {
    }
}

public class ForConstructorInjection : IForConsturctorInjection
{
    [Inject]
    public IForFieldInjection MyField;
}

public class ComplexType : IComplexType
{
    [Inject]
    public IForPropertyInjection MyProperty { get; set; }

    public ComplexType(IForConsturctorInjection instance1)
    {

    }

    [Inject]
    public void Initialize()
    {
    }
}

// for example, how to resolve ComplexType?
var v = resolver.Resolve<IComplexType>();

// This is `slow` example of complex type resolve
static IComplexType ResolveComplexType(IObjectResolver resolver)
{
    var a = resolver.Resolve<IForConsturctorInjection>();
    var b = resolver.Resolve<IForPropertyInjection>();

    var result = new ComplexType(a);
    result.MyProperty = b;
    result.Initialize();

    return result;
}

// This is actual code generation of MicroResolver, all dependency is inlined at il code generation
static IComplexType ResolveComposite()
{
    var a = new ForConstructorInjection();
    a.MyField = new ForFieldInjection();
    var b = new ForPropertyInjection();
    b.OnCreate();

    var result = new ComplexType(a);
    result.MyProperty = b;
    result.Initialize();

    return result;
}

public abstract class ObjectResolver
{
    public abstract T Resolve<T>();
}

public class ObjectResolver_Generated : ObjectResolver
{
    public override T Resolve<T>()
    {
        // too simple, of course simple is fastest.
        return Cache<T>.factory();
    }

    Cache<T>
    {
        // generated Func<T> code is see 'Dynamic IL Inlining' section.
        public Func<T> factory;
    }
}

// fastest
resolver.Resolve<T>();

// slower but framework requests this method
(T)resolver.Resolve(type);

// buckets item
struct HashTuple
{
    public Type type;
    public Func<object> factory;
}

// simplest hash table(fixed-array chaining hashtable)
private HashTuple[][] table;

// register - Func<T> -> Func<object> by delegate covariance
table[hash][index] = new Func<object>(Cache<T>.factory);

// simplest == fastest lookup
public object Resolve(Type type)
{
    var hashCode = type.GetHashCode();
    var buckets = table[hashCode & tableMaskIndex]; // table size is power of 2, fast lookup

    // .Length for loop can remove array bounds check
    for (int i = 0; i < buckets.Length; i++)
    {
        if (buckets[i].type == type)
        {
            return buckets[i].factory();
        }
    }

    throw new MicroResolverException("Type was not dound, Type: " + type.FullName);
}