A tiny IoC container, does exactly what you want, and only that.

Container.Global is a static instance of IContainer. You can use this as your entry point.

Use either of these methods to register a concrete type as an abstract type:

void IContainer.Register<TAbstract, TConcrete>(ServiceLifetime serviceLifetime = ServiceLifetime.Singleton);
void IContainer.Register(Type abstract, Type concrete, ServiceLifetime serviceLifetime = ServiceLifetime.Singleton);

You can tell NanoIoC to construct a concrete type for an abstract type in a custom way, using either of these methods:

void Register(Type abstractType, Func<IResolverContainer, object> ctor, ServiceLifetime serviceLifetime);
void Register<TAbstract>(this IContainer container, Func<IResolverContainer, TAbstract> ctor, ServiceLifetime serviceLifetime = ServiceLifetime.Singleton);

You will typically want to put your registrations inside an IContainerRegistry.

NanoIoC will find all IContainerRegistrys in all assemblies in the application's base directory (excluding those that start with the System namespace)

To run all the registries, use:

void IContainer.RunAllRegistries();

You can create TypeProcessors that scan all types allowing you to auto-wire them up.

NanoIoC will find all TypeProcesors in all assemblies in the application's base directory (excluding those that start with the System namespace)

For example:

void IContainer.RunAllTypeProcessors();

Where one of your TypeProcessors might look like:

public class ExampleTypeProcessor : ITypeProcessor
{
	public void Process(Type type, IContainer container)
	{
		if(typeof(MyInterface).IsAssignableFrom(type) && type != typeof(MyInterface))
			container.Register(typeof(MyInterface), type, ServiceLifetime.Singleton);
	}
}

Use either of these methods:

T IContainer.Resolve<T>();
object IContainer.Resolve(Type type);

You can resolve concrete types that aren't registered, as long as all their dependencies are registered or directly constructable.

You can get all registered types:

IEnumerable<T> IContainer.ResolveAll<T>()
IEnumerable IContainer.ResolveAll(Type type);

You can resolve the container itself as either IContainer or its read-only method subset; IResolverContainer, for example:

sealed class MyClass
{
	// take a dependency on a read-only version of the container
	public MyClass(IResolverContainer container)
	{
	}
}

You can inject existing instances:

void IContainer.Inject<T>(T instance, ServiceLifetime lifetime = ServiceLifetime.Singleton);
void IContainer.Inject(object instance, Type type, ServiceLifetime lifetime);

You can ask NanoIoC for the dependency graph for a given type. This will return a graph of all the types dependencies, and their dependencies and so on. Note that this cannot traverse custom constructor registrations, and so the graph will have a leaf node at that point.

GraphNode DependencyGraph(Type type);