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 RegisterAllAsSingleton(Type registrationType, IEnumerable<Type> implementationList) { _container.RegisterMultiple(registrationType, implementationList).AsSingleton(); } 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 ); } } }