類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);
        }
    }
           

結果