You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Radarr/NzbDrone.Common/Composition/Container.cs

109 lines
3.1 KiB

using System;
using System.Collections.Generic;
using System.Linq;
using TinyIoC;
namespace NzbDrone.Common.Composition
{
public class Container : IContainer
{
private readonly TinyIoCContainer _container;
private readonly List<Type> _loadedTypes;
public Container(TinyIoCContainer container, List<Type> loadedTypes)
{
_container = container;
_loadedTypes = loadedTypes;
_container.Register<IContainer>(this);
}
public void Register<TService, TImplementation>()
where TImplementation : class, TService
where TService : class
{
_container.Register<TService, TImplementation>();
}
public TinyIoCContainer TinyContainer { get { return _container; } }
public void Register<T>(T instance) where T : class
{
_container.Register<T>(instance);
}
public T Resolve<T>() where T : class
{
return _container.Resolve<T>();
}
public object Resolve(Type type)
{
return _container.Resolve(type);
}
public void Register(Type serviceType, Type implementationType)
{
_container.Register(serviceType, implementationType);
}
public void Register<TService>(Func<IContainer, TService> factory) where TService : class
{
_container.Register((c, n) =>
{
return factory(this);
});
}
public void RegisterSingleton<TService, TImplementation>()
where TImplementation : class, TService
where TService : class
{
_container.Register<TService, TImplementation>().AsSingleton();
}
public void RegisterSingleton<T>() where T : class
{
_container.Register<T, T>().AsSingleton();
}
public void RegisterSingleton(Type service, Type implementation)
{
_container.Register(service, implementation).AsSingleton();
}
public IEnumerable<T> ResolveAll<T>() where T : class
{
return _container.ResolveAll<T>();
}
public IEnumerable<object> ResolveAll(Type type)
{
return _container.ResolveAll(type);
}
public void Register(Type registrationType, object instance)
{
_container.Register(registrationType, instance);
}
public void RegisterAll(Type registrationType, IEnumerable<Type> implementationList)
{
_container.RegisterMultiple(registrationType, implementationList);
}
public bool IsTypeRegistered(Type type)
{
return _container.CanResolve(type);
}
public IEnumerable<Type> GetImplementations(Type contractType)
{
return _loadedTypes
.Where(implementation =>
contractType.IsAssignableFrom(implementation) &&
!implementation.IsInterface &&
!implementation.IsAbstract
);
}
}
}