类StrangeIOC框架依赖注入部分的简单实现

该篇文章是在我学习Unity的StrangeIOC框架时对该框架的依赖注入部分感兴趣后以自己感觉来实现此部分所写。

public class IOCContainer
    {
        private static IOCContainer _instance;
        public static IOCContainer Instance
        {
            get
            {
                if (_instance == null)
                    _instance = new IOCContainer();
                return _instance;
            }
        }

        private List<ObjectPack> packList = new List<ObjectPack>();

        public void AddPackToList(ObjectPack objectPack) 
        {
            if (!packList.Contains(objectPack)) 
            {
                packList.Add(objectPack);
            }
        }
        public ObjectPack Bind(object Instance)
        {
            ObjectPack objectPack = new ObjectPack(Instance);
            return objectPack;
        }
        public ObjectPack Bind(Type InstanceType)
        {
            ObjectPack objectPack = new ObjectPack(InstanceType);
            return objectPack;
        }
        public void GetInstanceWithoutName(object Instance,FieldInfo fieldInfo) 
        {
            IEnumerable<ObjectPack> IEnum = packList.Where(t => (t.SignType == Instance.GetType()));
            foreach (var item in IEnum)
            {
                foreach (var _item in item.InstanceType.GetInterfaces())
                {
                    if (_item.Equals(fieldInfo.FieldType)) 
                    {
                        fieldInfo.SetValue(Instance, Activator.CreateInstance(item.InstanceType));
                    }
                }
            }
        }
    }
           

public class ObjectPack

    {
        private string _name;
        private Type _signType;
        private Type _instanceType;
        private object _instance;
        public string Name
        {
            get
            {
                return _name;
            }
            private set
            {
                _name = value;
            }
        }
        public Type SignType
        {
            get
            {
                return _signType;
            }
            private set
            {
                _signType = value;
            }
        }
        public Type InstanceType
        {
            get
            {
                return _instanceType;
            }
            private set
            {
                _instanceType = value;
            }
        }
        public object Instance
        {
            get
            {
                return _instance;
            }
            private set
            {
                _instance = value;
            }
        }

        public ObjectPack(Type InstanceType)
        {
            this.InstanceType = InstanceType;
            this.Instance = null;
        }

        public ObjectPack(object Instance)
        {
            this.InstanceType = Instance.GetType();
            this.Instance = Instance;
        }

        public ObjectPack To(Type SignType)
        {
            this.SignType = SignType;
            IOCContainer.Instance.AddPackToList(this);
            return this;
        }
}
           

[AttributeUsage(AttributeTargets.Field)]
    public class InjectAttribute : Attribute
    {

    }
           

interface IPack
    {
        string Name { get; set; }
        Type SignType { get; set; }
        Type InstanceType { get; set; }
    }
           

public class InjectClass
    {
        public void InitInject() 
        {
            Type type = this.GetType();
            FieldInfo[] fieldInfos = type.GetFields();
            foreach (var item in fieldInfos)
            {
                if (item.IsDefined(typeof(InjectAttribute), true)) 
                {
                    IOCContainer.Instance.GetInstanceWithoutName(this, item);
                }
            }

        }
    }
    
           

测试部分

class Program
    {
        static void Main(string[] args)
        {
            IOCContainer.Instance.Bind(typeof(car)).To(typeof(Test));
            IOCContainer.Instance.Bind(typeof(cat)).To(typeof(Test));
            Test test = new Test();
            test.InitInject();
            test.car.Say();
            test.cat.Say();
        }
    }

    class Test : InjectClass
    {
        [Inject]
        public ICar car;
        [Inject]
        public IAnimal cat;
    }

    interface ICar
    {
        void Say();
    }

    class car : ICar
    {
        public void Say()
        {
            Console.WriteLine(this.GetType().Name);
        }
    }
    interface IAnimal
    {
        void Say();
    }

    class cat : IAnimal
    {
        public void Say()
        {
            Console.WriteLine(this.GetType().Name);
        }
    }
           

结果