(精华)2020年10月19日 设计模式案例 手写IOC容器

定义IOC特性

/// <summary>
/// IOC类型过滤特性
/// </summary>
[AttributeUsage(AttributeTargets.Class)]
public class IOCService :Attribute
{
    public IOCService()
    {

    }
}
/// <summary>
/// IOC属性过滤特性
/// </summary>
[AttributeUsage(AttributeTargets.Property)]
class IOCInject : Attribute
{
    public IOCInject()
    {

    }
}

IOC工厂类

/// <summary>
/// IOC抽象工厂
/// </summary>
public abstract class IOCFactory
{
    /// <summary>
    /// IOC抽象工厂方法
    /// </summary>
    /// <param name="typeName"></param>
    /// <returns></returns>
    public abstract object GetObject(string typeName);
}
/// <summary>
/// 默认IOC工厂(IOC工厂实现类)
/// </summary>
class DefaultIOCFactory
{
    /// <summary>
    /// 1、IOC容器(存储对象)
    /// </summary>
    private Dictionary<string, object> iocContainer = new Dictionary<string, object>();

    /// <summary>
    /// 1、IOC tyoe容器(用于存储对象实例类型)
    /// </summary>
    private Dictionary<string, Type> iocTypeContainer = new Dictionary<string, Type>();

    /// <summary>
    /// 2、加载程序集
    /// </summary>
    public DefaultIOCFactory()
    {
        // 1、加载程序集
        Assembly assembly = Assembly.LoadFile(@"D:\ruanmou-demo-.net\MyIOC\bin\Debug\MyIOC.exe");

        // 2、使用反射从程序集获取对象类型
        Type[] types = assembly.GetTypes();

        // 3、创建对象
        foreach (var type in types)
        {
            // 3.1 过滤对象(哪些对象被加载到IOC容器)
            IOCService iOCService = (IOCService)type.GetCustomAttribute(typeof(IOCService));
            if (iOCService != null)
            {
                iocTypeContainer.Add(type.Name, type);
            }
        }
    }

    /// <summary>
    /// 2、创建对象
    /// typeName type名字
    /// </summary>
    /// <returns></returns>
    public object GetObject(string typeName)
    {
        // 如果对象重复，直接取
        if (iocContainer.ContainsKey(typeName))
        {
            object _obejctValue = iocContainer[typeName];
            return _obejctValue;
        }
        else
        {
            // 1、取Type进行创建
            if (!iocTypeContainer.ContainsKey(typeName))
            {
                throw new Exception("对象不存在");
            }
            Type type = iocTypeContainer[typeName];

            // 2、创建对象 如果 student 对象 === teacher
            object _obejct = Activator.CreateInstance(type);
           
            // 3、对象依赖 怎么依赖 （循环依赖）构造函数（无法做到循环依赖）
            PropertyInfo[] propertyInfos = type.GetProperties();
            foreach (var propertyInfo in propertyInfos)
            {
                // 过滤属性特性
                IOCInject iOCInject = (IOCInject)propertyInfo.GetCustomAttribute(typeof(IOCInject));
                if (iOCInject != null)
                {
                    // 3.1 获取属性类型进行创建 (Teacher)
                    string propertyTypeName = propertyInfo.PropertyType.Name;

                    // 3.2 创建依赖对象(递归创建) [所有的属性都需要创建对象进行依赖 int double]
                    object _PropertyObejct = GetObject(propertyTypeName);

                    // 3.3 反射属性设置
                    propertyInfo.SetValue(_obejct, _PropertyObejct);
                }
            }
            // 4、存储对象
            iocContainer.Add(type.Name, _obejct);

            // 5、返回对象
            return _obejct;
        }

    }
}

创建对象类

/// <summary>
/// 对象创建策略
/// </summary>
public interface IObjectCreateStrategy
{
    /// <summary>
    /// 创建对象
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    public object CreateObject(Type type);
}

windows版创建实例类

/// <summary>
/// Activator 对象创建策略
/// </summary>
public class ActivatorObjectCreateStrategy : IObjectCreateStrategy
{
    public object CreateObject(Type type)
    {
       return  Activator.CreateInstance(type);
    }
}

liunx版创建实例类

/// <summary>
/// Assembly 对象创建策略
/// </summary>
public class AssemblyObjectCreateStrategy : IObjectCreateStrategy
{
    public object CreateObject(Type type)
    {
        return type.Assembly.CreateInstance(type.FullName);
    }
}