微型Ioc容器-代码理解Ioc

[clonalman]

直接上代码（c#）:

容器接口：IDependencyInjectionContainer.cs

    public interface IDependencyInjectionContainer: IServiceProvider
    {
        void Register<TService>(string key, Func<TService> factory);
        void Register<TService, TResult>(string key, Func<TService, TResult> factory);
        void Register<TService>(Func<TService> factory);
        void Register<TService>(Func<IDependencyInjectionContainer, TService> factory);
        void Unregister(object instance);
        TService Resolve<TService>();
        TService Resolve<TService>(string key);
        TService[] ResolveAll<TService>();
    }

接口实现：

DependencyInjectionContainer.cs

internal class DependencyInjectionContainer : IDependencyInjectionContainer, IServiceProvider
    {
        private readonly IDictionary<string, object> factories = new Dictionary<string, object>();

        public void Register<TService>(Func<IDependencyInjectionContainer, TService> factory)
        {
            Register(() => factory(this));
        }

        public void Register<TService>(Func<TService> factory)
        {
            Register(typeof(TService).AssemblyQualifiedName, factory);
        }

        public void Register<TService, TResult>(string key, Func<TService, TResult> factory)
        {
            Register(key, () => factory(Resolve<TService>()));
        }

        public void Register<TService>(string key, Func<TService> factory)
        {
            factories[key] = factory;
        }

        public void Unregister(object instance)
        {
            if (factories.ContainsKey(instance.GetType().AssemblyQualifiedName))
            {
                factories.Remove(instance.GetType().AssemblyQualifiedName);
            }
            else
            {
                IDependencyInjectionContainer container = Resolve<IDependencyInjectionContainer>();
                if (container != null)
                {
                    container.Unregister(instance);
                }
            }
        }

        public TService Resolve<TService>()
        {
            object obj;
            if (factories.TryGetValue(typeof(TService).AssemblyQualifiedName, out obj))
            {
                return ((Func<TService>)obj)();
            }
            else
            {
                IDependencyInjectionContainer container = Resolve<IDependencyInjectionContainer>();
                if (container != null)
                {
                    return container.Resolve<TService>();
                }
            }
            return default(TService);
        }

        public TService Resolve<TService>(string key)
        {
            object obj;
            if (factories.TryGetValue(key, out obj))
            {
                return ((Func<TService>)obj)();
            }
            else
            {
                IDependencyInjectionContainer container = Resolve<IDependencyInjectionContainer>();
                if (container != null)
                {
                    return container.Resolve<TService>(key);
                }
            }
            return default(TService);
        }

        public TService[] ResolveAll<TService>()
        {
            List<TService> services = new List<TService>();
            foreach (Func<TService> obj in factories.Values.OfType<Func<TService>>())
            {
                services.Add(obj());
            }
            IDependencyInjectionContainer container = Resolve<IDependencyInjectionContainer>();
            if (container != null)
            {
                services.AddRange(container.ResolveAll<TService>());
            }
            return services.ToArray();
        }

        public object GetService(Type serviceType)
        {
            object obj;
            if (factories.TryGetValue(serviceType.AssemblyQualifiedName, out obj))
            {
                Delegate deleg = (Delegate)obj;
                if (deleg != null)
                {
                    return deleg.DynamicInvoke();
                }
            }
            else
            {
                IDependencyInjectionContainer container = Resolve<IDependencyInjectionContainer>();
                if (container != null)
                {
                    return container.GetService(serviceType);
                }
            }
            return null;
        }
    }

访问入口：

DI.cs

    public static class DI
    {
        static DI()
        {
            Current = new DependencyInjectionContainer();
            RegisterCoreDependencies(Current);
        }

        public static IDependencyInjectionContainer Current
        {
            get;
            private set;
        }

        private static void RegisterCoreDependencies(IDependencyInjectionContainer di)
        {

        }
    }

这个是一个微型Ioc容器，可作为独立IOC容器或与其他容器如(Windsor、Spring)一起使用，让您的系统对第三放容器变得透明。

使用方法：

示例1、

DI.Current.Register<IQueryService, User>(User.Identity.Name, (service) => service.Query<User>().SingleOrDefault(p => p.UserName == User.Identity.Name));

User user = DI.Current..Resolve<User>(User.Identity.Name) ;

示例2、

public class AService: IAService {}

public class BService: IBService {

public BService() { }

public BService(IAService service) { A = service; }

public AService A { get; set; }

}

DI.Current.Register<IAService>("A", () => new AService());

DI.Current.Register<IAService, IBService>("B", (a) => new BService(a)); //构造器注入

或

DI.Current.Register<IAService, IBService>("B", (a) => new BService() { A = a }); //属性注入

IBService B = DI.Current..Resolve<IBService>("B");

或

IBService B = DI.Current..Resolve<IBService>();