让我手把手教你写一个强大、方便使用的 IOC 容器

一、介绍

　　　　1、介绍

　　　　　　　　最近无聊，也没什么事做，没事做总是要给自己找点事情做吧，毕竟人的生活在与折腾。于是，决定自己手动写一个 IOC 的框架。我们知道在 NetCore 的版本里面已经内置了 IOC 容器，它就是 ServiceCollection，一般情况下，该容器还是够用的，但是有时候还会有力不从心的时候，比如：我想要实现属性注入或者方法注入，NetCore 内置的框架就不可以实现。还有情况是，我们要实现对同一接口的多实例注入也没办法实现。当然还有其他情况，比如，没有实现 AOP 的功能。最近正好无事可做，正好利用这段时间，自己亲手写一套 IOC 的框架，当然了，要重写，肯定要比 NetCore 内置的要强，否则，也就没有写的必要了，说干就干。

　　　　2、开发环境

　　　　　　　　1）、操作系统：Windows 10 专业版本。

　　　　　　　　2）、开发工具：Visual Studio 2019 社区版，16.8.3

　　　　　　　　3）、开发语言：C#

　　　　　　　　4）、框架版本：Net 5.0，该版本是跨平台版本，但是不是长期版本，6.0 是 LTS 版本。

　　　　3、实现目标

　　　　　　　　1）、该框架可以实现构造函数注入。

　　　　　　　　2）、该框架可以实现方法注入。

　　　　　　　　3）、该框架可以实现属性注入。

　　　　　　　　4）、该框架可以实现无限层级激活。

　　　　　　　　5）、该框架可以实现注册服务的多种声明周期，分别是：Transient，Singleton，Scoped，PerThread

　　　　　　　　6）、该框架可以实现针对同一接口的多实例注册。

　　　　　　　　7）、当一个类型在实例化的时候可以增加参数。

　　　　　　　　以上就是该框架的目标，应该还不错吧。毕竟我们自己手写了框架代码，让我们会更加了解 IOC 的定义和实现。

二、手写框架

　　　　

　　　　1、我先把该框架的主要类型的代码贴出来，这个类型是核心类型，实现了我们上面定义的目标。

　　　　　　　　首先、我们为 IOC 容器定义接口，面向接口编程嘛，可不要忘记了，所以，我们先顶一个接口，类型名称：ICustomContainer。　　　　　　　　

    /// <summary>
    /// 我们定义的 IOC 容器抽象基类型，它定义了 IOC 容器的核心功能。
    /// </summary>
    public interface ICustomContainer
    {
        /// <summary>
        /// 提供服务的名称和参数构建实例以 TFrom 类型注册 TTo 实例。
        /// </summary>
        /// <typeparam name="TFrom">TTo 的基类类型。</typeparam>
        /// <typeparam name="TTo">TFrom 的子类类型。</typeparam>
        /// <param name="serviceName">要注册服务的名称。</param>
        /// <param name="lifetime">要注册的服务的生命周期。</param>        
        /// <param name="parameterValues">要注册的服务在构建实例时需要的非注入参数。</param>
        void Register<TFrom, TTo>(string serviceName, ServiceLifetime lifetime, params object[] parameterValues) where TTo : TFrom;

        /// <summary>
        /// 以指定名称解析该基类型的实例。
        /// </summary>
        /// <typeparam name="TFrom">要解析实例的基类型。</typeparam>
        /// <param name="serviceName">要解析实例的名称。</param>
        /// <returns></returns>
        TFrom Resolve<TFrom>(string serviceName);
    }

　　　　　　　　再者，就是该接口的实现类型，该类型也是该容器的核心代码。代码不是很难，大家直接看吧。
　　　　　　　　类型名称：PatrickContainer　　　　　　　　

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading;

namespace PatrickLiu.NetCore50.IOCFramework.Container
{
    /// <summary>
    /// 自定义的IOC容器实现。
    /// </summary>
    public sealed class PatrickContainer: ICustomContainer
    {
        private readonly IDictionary<string, ServiceMetadata> _Container;
        private readonly IDictionary<string, object[]> _Parameters;
        private readonly IDictionary<string, object> _ScopedContainer;


        /// <summary>
        /// 初始化类型的新实例，实例化容器。
        /// </summary>
        public PatrickContainer()
        {
            _Container = new ConcurrentDictionary<string, ServiceMetadata>();
            _Parameters = new ConcurrentDictionary<string, object[]>();
            _ScopedContainer = new Dictionary<string, object>();
        }

        /// <summary>
        /// 可以创建子作用域。
        /// </summary>
        /// <returns></returns>
        public PatrickContainer CreateScoped()
        {
            return new PatrickContainer(_Container, _Parameters, new Dictionary<string, object>());
        }

        /// <summary>
        /// 通过是有构造函数初始化容器。
        /// </summary>
        /// <param name="container"></param>
        /// <param name="parameters"></param>
        /// <param name="scopedContainer"></param>
        private PatrickContainer(IDictionary<string, ServiceMetadata> container, IDictionary<string, object[]> parameters, IDictionary<string, object> scopedContainer)
        {
            this._Container = container;
            this._Parameters = parameters;
            this._ScopedContainer = scopedContainer;
        }

        /// <summary>
        /// 以 TFrom 类型注册 TTo 实例。
        /// </summary>
        /// <typeparam name="TFrom">TTo 的基类类型</typeparam>
        /// <typeparam name="TTo">TFrom 的子类类型。</typeparam>
        public void Register<TFrom, TTo>() where TTo : TFrom
        {
            Register<TFrom, TTo>(null, ServiceLifetime.Transient, null);
        }

        /// <summary>
        /// 以 TFrom 类型注册 TTo 实例。
        /// </summary>
        /// <typeparam name="TFrom">TTo 的基类类型</typeparam>
        /// <typeparam name="TTo">TFrom 的子类类型。</typeparam>
        /// <param name="lifetime">要注册的服务的生命周期。</param>
        public void Register<TFrom, TTo>(ServiceLifetime lifetime) where TTo : TFrom
        {
            Register<TFrom, TTo>(null, lifetime, null);
        }

        /// <summary>
        /// 提供服务构建实例所需参数来以 TFrom 类型注册 TTo 实例。
        /// </summary>
        /// <typeparam name="TFrom">TTo 的基类类型</typeparam>
        /// <typeparam name="TTo">TFrom 的子类类型。</typeparam>
        /// <param name="parameterValues">要注册的服务在构建实例时需要的非注入参数。</param>
        public void Register<TFrom, TTo>(params object[] parameterValues) where TTo : TFrom
        {
            Register<TFrom, TTo>(null, ServiceLifetime.Transient, parameterValues);
        }

        /// <summary>
        /// 提供服务的名称构建实例来以 TFrom 类型注册 TTo 实例。
        /// </summary>
        /// <typeparam name="TFrom">TTo 的基类类型</typeparam>
        /// <typeparam name="TTo">TFrom 的子类类型。</typeparam>
        /// <param name="serviceName">要注册服务的名称。</param>
        public void Register<TFrom, TTo>(string serviceName) where TTo : TFrom
        {
            Register<TFrom, TTo>(serviceName, ServiceLifetime.Transient, null);
        }

        /// <summary>
        /// 提供服务的名称构建实例来以 TFrom 类型注册 TTo 实例。
        /// </summary>
        /// <typeparam name="TFrom">TTo 的基类类型</typeparam>
        /// <typeparam name="TTo">TFrom 的子类类型。</typeparam>
        /// <param name="serviceName">要注册服务的名称。</param>
        /// <param name="lifetime">要注册的服务的生命周期。</param>
        public void Register<TFrom, TTo>(string serviceName, ServiceLifetime lifetime) where TTo : TFrom
        {
            Register<TFrom, TTo>(serviceName, lifetime, null);
        }

        /// <summary>
        /// 提供服务的名称和参数构建实例以 TFrom 类型注册 TTo 实例。
        /// </summary>
        /// <typeparam name="TFrom">TTo 的基类类型</typeparam>
        /// <typeparam name="TTo">TFrom 的子类类型。</typeparam>
        /// <param name="serviceName">要注册服务的名称。</param>
        /// <param name="lifetime">要注册的服务的生命周期。</param>        
        /// <param name="parameterValues">要注册的服务在构建实例时需要的非注入参数。</param>
        public void Register<TFrom, TTo>(string serviceName, ServiceLifetime lifetime, params object[] parameterValues) where TTo : TFrom
        {
            string key;
            if (string.IsNullOrEmpty(serviceName) || string.IsNullOrWhiteSpace(serviceName))
            {
                key = typeof(TFrom).FullName;
                if (!_Container.ContainsKey(key))
                {
                    _Container.Add(key, new ServiceMetadata() { ServiceType = typeof(TTo), Lifetime = lifetime });
                }
            }
            else
            {
                key = string.Format("{0}_{1}", typeof(TFrom).FullName, serviceName);
                if (!_Container.ContainsKey(key))
                {
                    _Container.Add(key, new ServiceMetadata() { ServiceType = typeof(TTo), Lifetime = lifetime });
                }
            }
            if (parameterValues != null && parameterValues.Length > 0)
            {
                _Parameters.Add(key, parameterValues);
            }
        }

        /// <summary>
        /// 以指定类型解析该类型的实例。
        /// </summary>
        /// <typeparam name="TFrom">要解析实例的基类型。</typeparam>
        /// <returns></returns>
        public TFrom Resolve<TFrom>()
        {
            return Resolve<TFrom>(null);
        }

        /// <summary>
        /// 以指定名称解析该基类型的实例。
        /// </summary>
        /// <typeparam name="TFrom">要解析实例的基类型。</typeparam>
        /// <param name="serviceName">要解析实例的名称。</param>
        /// <returns></returns>
        public TFrom Resolve<TFrom>(string serviceName)
        {
            return (TFrom)Create(typeof(TFrom), serviceName);
        }


        /// <summary>
        /// 通过递归实现解析实例对象。
        /// </summary>
        /// <param name="baseType">服务的基类型。</param>
        /// <param name="serviceName">服务实例的名称。</param>
        /// <returns></returns>
        private object Create(Type baseType, string serviceName = null)
        {
            #region 处理关键字

            string keyword;

            if (string.IsNullOrEmpty(serviceName) || string.IsNullOrWhiteSpace(serviceName))
            {
                keyword = string.Format("{0}", baseType.FullName);
            }
            else
            {
                keyword = string.Format("{0}_{1}", baseType.FullName, serviceName);
            }

            #endregion

            Type targetType = null; ServiceLifetime lifetime = ServiceLifetime.Transient;
            if (_Container.ContainsKey(keyword))
            {
                targetType = _Container[keyword].ServiceType;
                lifetime = _Container[keyword].Lifetime;
            }
            else if (keyword.IndexOf('_') != -1)
            {
                if (_Container.ContainsKey(keyword.Split('_')[0]))
                {
                    keyword = keyword.Split('_')[0];
                    targetType = _Container[keyword].ServiceType;
                    lifetime = _Container[keyword].Lifetime;
                }
            }
            else
            {
                throw new Exception("类型还未注册!");
            }

            #region 生命周期

            switch (lifetime)
            {
                case ServiceLifetime.Transient:
                    break;
                case ServiceLifetime.Singleton:
                    if (_Container[keyword].SingletonInstance != null)
                    {
                        return _Container[keyword].SingletonInstance;
                    }
                    break;
                case ServiceLifetime.Scoped:
                    if (_ScopedContainer.ContainsKey(keyword))
                    {
                        return _ScopedContainer[keyword];
                    }
                    break;
                case ServiceLifetime.PerThread:
                    var objInstance = CallContext.GetData($"{keyword}{Thread.CurrentThread.ManagedThreadId}");
                    if (objInstance != null)
                    {
                        return objInstance;
                    }
                    break;
                default:
                    break;
            }

            #endregion

            #region 选择构造函数

            ConstructorInfo ctor = null;

            //1、通过特性约束
            ctor = targetType.GetConstructors().FirstOrDefault(c => c.IsDefined(typeof(SelectedConstructorAttribute), true));

            if (ctor == null)
            {
                //2、参数最多的
                ctor = targetType.GetConstructors().OrderByDescending(c => c.GetParameters().Length).First();
            }

            #endregion

            #region 核心创建对象代码

            IList<object> parameters = new List<object>();
            var values = _Parameters.ContainsKey(keyword) ? _Parameters[keyword] : null;
            int index = 0;
            foreach (var parameter in ctor.GetParameters())
            {
                if (values != null && values.Length > 0 && parameter.IsDefined(typeof(ConstantPatameterAttribute), true))
                {
                    parameters.Add(values[index++]);
                }
                else
                {
                    var parameterType = parameter.ParameterType;
                    var instance = Create(parameterType, serviceName);
                    parameters.Add(instance);
                }
            }
            object oIntance = Activator.CreateInstance(targetType, parameters.ToArray());

            #endregion

            #region 属性注入

            Type propertyType = null;
            foreach (var property in targetType.GetProperties().Where(p => p.IsDefined(typeof(InjectionPropertyAttribute), true)))
            {
                propertyType = property.PropertyType;
                var propInstance = Create(propertyType);
                property.SetValue(oIntance, propInstance);
            }

            #endregion

            #region 方法注入

            foreach (var methodInfo in targetType.GetMethods().Where(p => p.IsDefined(typeof(InjectionMethodAttribute), true)))
            {
                IList<object> methodParameters = new List<object>();
                values = _Parameters.ContainsKey(keyword) ? _Parameters[keyword] : null;
                index = 0;
                foreach (var parameter in methodInfo.GetParameters())
                {
                    if (values != null && values.Length > 0 && parameter.IsDefined(typeof(ConstantPatameterAttribute)))
                    {
                        methodParameters.Add(values[index++]);
                    }
                    else
                    {
                        var methodParaType = parameter.ParameterType;
                        var paraInstance = Create(methodParaType, serviceName);
                        methodParameters.Add(paraInstance);
                    }
                }
                methodInfo.Invoke(oIntance, methodParameters.ToArray());
            }

            #endregion

            #region 生命周期

            switch (lifetime)
            {
                case ServiceLifetime.Transient:
                    break;
                case ServiceLifetime.Singleton:
                    if (_Container[keyword].SingletonInstance == null)
                    {
                        _Container[keyword].SingletonInstance = oIntance;
                    }
                    break;
                case ServiceLifetime.Scoped:
                    if (!_ScopedContainer.ContainsKey(keyword))
                    {
                        _ScopedContainer.Add(keyword, oIntance);
                    }
                    break;
                case ServiceLifetime.PerThread:
                    CallContext.SetData($"{keyword}{Thread.CurrentThread.ManagedThreadId}", oIntance);
                    break;
                default:
                    break;
            }

            #endregion

            return oIntance;
        }
    }
}

　　　　　　　　当然了，还有一些其他的辅助类型，这么大的框架，还是要需要一些辅助类型的，接下来我们一一介绍。

　　　　2、ConstantPatameterAttribute类型

　　　　　　　　该类型是一个标记特性，用于标注不需要注入而进行传递的参数，可以使用该属性。

using System;

namespace PatrickLiu.NetCore50.IOCFramework.Container
{
    /// <summary>
    /// 该类型定义了在服务初始化的时候需要从外界出入的参数，如果参数被标注，则说明改参数所需要的参数从外界传入。该类型是密封类型，不可以被继承。
    /// </summary>
    [AttributeUsage(AttributeTargets.Parameter|AttributeTargets.GenericParameter,AllowMultiple =false,Inherited =true)]
    public sealed class ConstantPatameterAttribute:Attribute
    {
    }
}

　　　　3、InjectionMethodAttribute 类型

　　　　　　　　该类型也是一个标记特性，用于标记方法，可以通过方法实现注入。

using System;

namespace PatrickLiu.NetCore50.IOCFramework.Container
{
    /// <summary>
    /// 该类型定义了方法注入的特性类型，该类型是密封类型，不可以被继承。它也是一个标识类型。
    /// </summary>
    [AttributeUsage(AttributeTargets.Method,AllowMultiple =false,Inherited =true)]
    public sealed class InjectionMethodAttribute:Attribute
    {
    }
}

　　　　4、InjectionPropertyAttribute 类型。

　　　　　　该类型也是一个标记特性，用于标记正在属性上，可以通过属性实现注入。

using System;

namespace PatrickLiu.NetCore50.IOCFramework.Container
{
    /// <summary>
    /// 该特性是一个实现属性注入的特性类，该类型是密封的。它是一个标识属性。
    /// </summary>
    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
    public sealed class InjectionPropertyAttribute : Attribute
    {
    }
}

　　　　5、SelectedConstructorAttribute 类型

　　　　　　在我们构建类型实例的时候，可以通过该特性选择通过哪个构造函数创建实例。默认情况是选择参数最多的构造函数，也可以通过该特性选择构造函数。

using System;

namespace PatrickLiu.NetCore50.IOCFramework.Container
{
    /// <summary>
    /// 选择构造函数。
    /// </summary>
    [AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = true)]
    public sealed class SelectedConstructorAttribute : Attribute
    {
    }
}

　　　　6、ServiceLifetime 枚举类型。

　　　　　　我们可以实现对注册服务的生命周期的管理，类型简单，不多说了。

namespace PatrickLiu.NetCore50.IOCFramework.Container
{
    /// <summary>
    /// 服务的生命周期。
    /// </summary>
    public enum ServiceLifetime
    {
        /// <summary>
        /// 瞬时服务实例。
        /// </summary>
        Transient,

        /// <summary>
        /// 单例服务实例。
        /// </summary>
        Singleton,

        /// <summary>
        /// 作用域服务实例。
        /// </summary>
        Scoped,

        /// <summary>
        /// 线程服务实例。
        /// </summary>
        PerThread
    }
}

　　　　7、ServiceMetadata 类型。

　　　　　　　　用于定义注册服务的对象。

using System;

namespace PatrickLiu.NetCore50.IOCFramework.Container
{
    /// <summary>
    /// 该类型定义了注册服务的元数据。
    /// </summary>
    public sealed class ServiceMetadata
    {
        /// <summary>
        /// 获取或者设置注册服务的类型。
        /// </summary>
        public Type ServiceType { get; set; }

        /// <summary>
        /// 获取或者设置注册服务的生命周期。
        /// </summary>
        public ServiceLifetime Lifetime { get; set; }

        /// <summary>
        /// 获取或者设置单件的服务实例。
        /// </summary>
        public Object SingletonInstance { get; set; }
    }
}

　　　　　　8、CallContext类型。

　　　　　　　　在NetCore 环境中，没有CallContext 类型，所以只能自己实现一个，可以实现基于线程来管理注册服务的生命周期。

using System.Collections.Concurrent;
using System.Threading;

namespace PatrickLiu.NetCore50.IOCFramework.Container
{
    /// <summary>
    /// Provides a way to set contextual data that flows with the call and async context of a test or invocation.
    /// </summary>
    public static class CallContext
    {
        private static ConcurrentDictionary<string, AsyncLocal<object>> state = new ConcurrentDictionary<string, AsyncLocal<object>>();

        /// <summary>
        /// Stores a given object and associates it with the specified name.
        /// </summary>
        /// <param name="name">The name with which to associate the new item in the call context.</param>
        /// <param name="data">The object to store in the call context.</param>
        public static void SetData(string name, object data) =>
            state.GetOrAdd(name, _ => new AsyncLocal<object>()).Value = data;

        /// <summary>
        /// Retrieves an object with the specified name from the <see cref="CallContext"/>.
        /// </summary>
        /// <param name="name">The name of the item in the call context.</param>
        /// <returns>The object in the call context associated with the specified name, or <see langword="null"/> if not found.</returns>
        public static object GetData(string name) =>
            state.TryGetValue(name, out AsyncLocal<object> data) ? data.Value : null;
    }

    /// <summary>
    /// 可以测试
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public static class CallContext<T>
    {
        static ConcurrentDictionary<string, AsyncLocal<T>> state = new ConcurrentDictionary<string, AsyncLocal<T>>();

        /// <summary>
        /// Stores a given object and associates it with the specified name.
        /// </summary>
        /// <param name="name">The name with which to associate the new item in the call context.</param>
        /// <param name="data">The object to store in the call context.</param>
        public static void SetData(string name, T data) =>
            state.GetOrAdd(name, _ => new AsyncLocal<T>()).Value = data;

        /// <summary>
        /// Retrieves an object with the specified name from the <see cref="CallContext"/>.
        /// </summary>
        /// <typeparam name="T">The type of the data being retrieved. Must match the type used when the <paramref name="name"/> was set via <see cref="SetData{T}(string, T)"/>.</typeparam>
        /// <param name="name">The name of the item in the call context.</param>
        /// <returns>The object in the call context associated with the specified name, or a default value for <typeparamref name="T"/> if none is found.</returns>
        public static T GetData(string name) =>
            state.TryGetValue(name, out AsyncLocal<T> data) ? data.Value : default(T);
    }
}

三、测试代码

　　　　我们为了更好的测试我们写的IOC容器，我另外建立两个独立的类库项目和一个控制台应用程序。当然了，引用关系别忘记了。

　　　　1、我们定义的接口类库，里面包含了测试用到的所有接口类型。很简单，不多说。

　　　　　　　　

　　　　　　　　 以下就是我们接口的代码了。　　　　　　　　

    /// <summary>
    /// ServiceA的服务接口
    /// </summary>
    public interface IServiceA
    {
        void Show();
    }

    public interface IServiceB
    {
        void Show();
    }

    public interface IServiceC
    {
        void Show();
    }

    public interface IServiceD
    {
        void Show();
    }

    public interface IServiceE
    {
        void Show();
    }

    public interface IServiceF
    {
        void Show();
    }

　　　　2、第一步我们定义了接口类库，这里我们定义实现了接口类库的服务类库，很简单，不多说。

　　　　　　　　

　　　　　　　　以下是实现代码，很简单，不多说。
　　　　　　　　

    /// <summary>
    /// 自定义类型的服务。
    /// </summary>
    public class MyServiceA : IServiceA
    {
        public MyServiceA()
        {
            Console.WriteLine("MyServiceA is Created");
        }        

        /// <summary>
        /// 方法执行
        /// </summary>
        public void Show()
        {
            Console.WriteLine("MyServiceA-show()");
        }
    }

    /// <summary>
    /// 自定义类型服务第二版本。
    /// </summary>
    public sealed class MyServiceA2 : IServiceA
    {
        private IServiceF _IServiceF;

        /// <summary>
        /// 构造函数
        /// </summary>
        public MyServiceA2()
        {
            Console.WriteLine("MyServiceA2 is created");
        }

        /// <summary>
        /// 方法注入。
        /// </summary>
        /// <param name="service"></param>
        [InjectionMethod]
        public void MethodInjection(IServiceF service)
        {
            _IServiceF = service;
        }

        /// <summary>
        /// 方法执行。
        /// </summary>
        public void Show()
        {
            Console.WriteLine("MyServiceA2--Show()");
        }
    }

    public class MyServiceA3 : IServiceA
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="age"></param>
        /// <param name="name"></param>
        /// <param name="school"></param>        
        public MyServiceA3([ConstantPatameter]int age, [ConstantPatameter] string name, [ConstantPatameter] string school)
        {
            Console.WriteLine($"{age}{name}{school} MyServiceA3 is created");
        }


        public void Show()
        {
            Console.WriteLine("MyServiceA3-Show() is executed!");
        }
    }

    public class MyServiceA4 : IServiceA
    {
        private IServiceF _IServiceF;

        public MyServiceA4()
        {
            Console.WriteLine("");
        }

        /// <summary>
        /// 方法注入
        /// </summary>
        /// <param name="service">注入服务</param>
        /// <param name="age"></param>
        /// <param name="name"></param>
        [InjectionMethod]
        public void MethodInjection(IServiceF service,[ConstantPatameter]int age,[ConstantPatameter]string name)
        {
            _IServiceF = service;
            Console.WriteLine($"{name} 今年 {age} 岁了。");
        }

        public void Show()
        {
            Console.WriteLine("MyServiceA4--show() executing");
        }
    }

    /// <summary>
    /// 
    /// </summary>
    public class MyServiceB : IServiceB
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="serviceC"></param>
        /// <param name="serviceE"></param>
        public MyServiceB(IServiceC serviceC,IServiceE serviceE)
        {
            Console.WriteLine("MyServiceB is created");
        }

        /// <summary>
        /// 
        /// </summary>
        public void Show()
        {
            Console.WriteLine("MyServiceB-Show()");
        }
    }

    /// <summary>
    /// 
    /// </summary>
    public class MyServiceC : IServiceC
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="serviceD"></param>
        public MyServiceC(IServiceD serviceD)
        {
            Console.WriteLine("MyServiceC is created");
        }

        /// <summary>
        /// 
        /// </summary>
        public void Show()
        {
            Console.WriteLine("MyServiceC-Show()");
        }
    }

    /// <summary>
    /// 自定义类型的服务。
    /// </summary>
    public class MyServiceD : IServiceD
    {
        /// <summary>
        /// 构造函数
        /// </summary>
        public MyServiceD()
        {
            Console.WriteLine("MyServiceD is created");
        }

        /// <summary>
        /// 方法执行。
        /// </summary>
        public void Show()
        {
            Console.WriteLine("MyServiceD--show()");
        }
    }

    /// <summary>
    /// 自定义服务类型。
    /// </summary>
    public class MyServiceE : IServiceE
    {
        /// <summary>
        /// 构造函数
        /// </summary>
        public MyServiceE()
        {
            Console.WriteLine("MyServiceE is created");
        }

        /// <summary>
        /// 属性注入
        /// </summary>
        [InjectionProperty]
        public IServiceF ServiceF { get; set; }

        /// <summary>
        /// 方法执行。
        /// </summary>
        public void Show()
        {
            Console.WriteLine("MyServiceE-Show()");
        }
    }

    /// <summary>
    /// 自定义类型服务。
    /// </summary>
    public sealed class MyServiceF : IServiceF
    {
        /// <summary>
        /// 构造函数
        /// </summary>
        public MyServiceF()
        {
            Console.WriteLine("MyServiceF is created!");
        }

        /// <summary>
        /// 方法执行。
        /// </summary>
        public void Show()
        {
            Console.WriteLine("MyServiceF--Show()");
        }
    }

　　　　3、这个代码就是我们控制台项目，用来做测试的，很简单，不多说了。
　　　　　　

class Program
    {
        static void Main(string[] args)
        {
            //最简单版本
            {
                PatrickContainer container = new PatrickContainer();
                container.Register<IServiceA, MyServiceA>();

                var instance = container.Resolve<IServiceA>();
                instance.Show();
            }
            //可以多层依赖，可以包含属性注入
            {
                PatrickContainer container = new PatrickContainer();
                container.Register<IServiceA, MyServiceA>();
                container.Register<IServiceB, MyServiceB>();
                container.Register<IServiceC, MyServiceC>();
                container.Register<IServiceD, MyServiceD>();
                container.Register<IServiceE, MyServiceE>();
                container.Register<IServiceF, MyServiceF>();

                var instance = container.Resolve<IServiceB>();
                instance.Show();
            }
            //单接口多实例，也包含方法注入
            {
                PatrickContainer container = new PatrickContainer();
                container.Register<IServiceA, MyServiceA>("A");
                container.Register<IServiceA, MyServiceA2>("A2");
                container.Register<IServiceF, MyServiceF>();

                var instance = container.Resolve<IServiceA>("A");
                instance.Show();
                instance = container.Resolve<IServiceA>("A2");
                instance.Show();
            }
            //构造函数参数、方法参数
            {
                PatrickContainer container = new PatrickContainer();
                
                container.Register<IServiceA, MyServiceA3>(20,"zhangfei","涞源第一中学");
                
                var instance = container.Resolve<IServiceA>();
                instance.Show();
            }
            {
                PatrickContainer container = new PatrickContainer();

                container.Register<IServiceA, MyServiceA4>(20, "张飞");
                container.Register<IServiceF, MyServiceF>();

                var instance = container.Resolve<IServiceA>();
                instance.Show();
            }
            //声明周期
            {
                //单例
                PatrickContainer container = new PatrickContainer();
                container.Register<IServiceA, MyServiceA>(ServiceLifetime.Singleton);


                var instance = container.Resolve<IServiceA>();
                var instance2 = container.Resolve<IServiceA>();

                Console.WriteLine(Object.ReferenceEquals(instance,instance2));//True
            }
            //
            {
                //瞬时
                PatrickContainer container = new PatrickContainer();
                container.Register<IServiceA, MyServiceA>(ServiceLifetime.Transient);


                var instance = container.Resolve<IServiceA>();
                var instance2 = container.Resolve<IServiceA>();

                Console.WriteLine(Object.ReferenceEquals(instance, instance2));//False
            }
            {
                //作用域
                PatrickContainer container = new PatrickContainer();
                container.Register<IServiceA, MyServiceA>(ServiceLifetime.Scoped);


                var instance = container.Resolve<IServiceA>();
                var instance2 = container.Resolve<IServiceA>();

                Console.WriteLine(Object.ReferenceEquals(instance, instance2));//True

                var container2 = container.CreateScoped();
                var objedd=container2.Resolve<IServiceA>();
                var objedd2=container2.Resolve<IServiceA>();

                /Console.WriteLine(Object.ReferenceEquals(objedd, objedd2));//True

                Console.WriteLine(Object.ReferenceEquals(instance, objedd2));//False
                Console.ReadLine();
            }
            {
                //线程
                PatrickContainer container = new PatrickContainer();
                container.Register<IServiceA, MyServiceA>(ServiceLifetime.PerThread);

                IServiceA instance = null;
                IServiceA instance2 = null;
                IServiceA instance3 = null;
                IServiceA instance4 = null;
                IServiceA instance5 = null;
                IServiceA instance6 = null;

                Task.Run(()=> {
                    Console.WriteLine($"instance，当前线程的ID:{Thread.CurrentThread.ManagedThreadId}");
                    instance = container.Resolve<IServiceA>();
                });

                Task.Run(() => {
                    Console.WriteLine($"instance2，当前线程的ID:{Thread.CurrentThread.ManagedThreadId}");
                    instance2 = container.Resolve<IServiceA>();
                });

                Task.Run(() => {
                    Console.WriteLine($"instance3 和 instance4，当前线程的ID:{Thread.CurrentThread.ManagedThreadId}");
                    instance3 = container.Resolve<IServiceA>();
                    instance4 = container.Resolve<IServiceA>();
                });

                Task.Run(() => {
                    Console.WriteLine($"instance5，当前线程的ID:{Thread.CurrentThread.ManagedThreadId}");
                    instance5 = container.Resolve<IServiceA>();
                }).ContinueWith(t=> {
                    Console.WriteLine($"instance6，当前线程的ID:{Thread.CurrentThread.ManagedThreadId}");
                    instance6 = container.Resolve<IServiceA>();
                });

                Thread.Sleep(1000);

                Console.WriteLine(Object.ReferenceEquals(instance, instance2));//False
                Console.WriteLine(Object.ReferenceEquals(instance, instance3));//False
                Console.WriteLine(Object.ReferenceEquals(instance, instance4));//False
                Console.WriteLine(Object.ReferenceEquals(instance2, instance3));//False
                Console.WriteLine(Object.ReferenceEquals(instance2, instance4));//False
                Console.WriteLine(Object.ReferenceEquals(instance3, instance4));//True

                Console.WriteLine(Object.ReferenceEquals(instance5, instance6));//False                
            }
            
            Console.Read();
        }
    }

四、结束
　　　　好了，今天就写到这里了，实话实说，这个有难度吗？其实没什么难度。这些代码都是可以直接使用的，我经过测试的，（我也有可能没有测试到的），如果大家感觉不错，可以拿去使用，好好的测试一下，也可以增加自己的东西，功能挺强大的，使用挺方便的。不忘初心，继续努力。