依赖注入的理解

实际业务中，new 应该是自己创造的。而买来的应该从外部传入进来
依赖注入容器

• 这就是一个容器，用来存储数据，可以用来存储属性

internal class BreakfastMaker
    {
        //从零开始写一个依赖注入容器
        static void Main(string[] args)
        {
            _container = new Container();

            //初始化
            Init();

            Use();
        }

        private static void Use()
        {
            //Foo foo = (Foo)_container.Get(typeof(Foo));
            //使用改造的泛型
            Foo foo = _container.Get<Foo>();
            Console.WriteLine(foo.Name);
        }

        private static void Init()
        {
            Foo foo = new Foo();
            //使用泛型 这里的<Foo>也可以去掉，因为传入参数foo可以自己推出来
            _container.Set<Foo>(foo);
            //_container.Set(typeof(Foo), foo);
        }

        //
        //静态方法只能使用静态字段
        //
        private static Container _container;
    }

    //
    // 定义一个类，这个类仅仅用来测试
    //
    public class Foo
    {
        public string Name { get; set; }
    }


    //类似哆啦A梦的口袋，可以存进很多东西，需要的时候随时能拿
    public class Container
    {
        //
        //定义一个泛型
        //
        public void Set<T>(T obj)
        {
            Set(typeof(T), obj);
        }

        public void Set(Type type,object obj)
        {
            InnerDictionary[type] = obj;
        }

        //
        //改造成一个泛型的方法
        //
        public T Get<T>()
        {
            return (T)Get(typeof(T));
        }

        public object Get(Type type)
        {
            return InnerDictionary[type];
        }

        //
        // 存放
        // 只有get意味着建立后不能被修改
        //
        private Dictionary<Type, object> InnerDictionary { get; } = new Dictionary<Type, object>();
    }