如何用反射实现依赖注入 动态创建和组装对象实例

依赖注入的核心思想是将对象创建和依赖管理交由外部容器处理，通过反射机制在运行时动态创建对象并解析构造函数参数，利用类型映射实现接口与实现的绑定，结合递归解析和缓存机制完成实例的自动组装，同时通过维护解析栈防止循环依赖，最终实现一个支持transient和singleton生命周期的简易di容器，尽管功能简单，但完整展现了主流di框架的核心原理。

依赖注入（DI）的核心思想是将对象的创建和依赖关系的管理从代码中剥离出来，交由外部容器处理。利用反射机制，我们可以在运行时动态创建对象、解析依赖并自动组装实例，从而实现一个简易的依赖注入容器。以下是实现的关键思路和步骤。

一、通过反射动态创建对象

在没有依赖的情况下，创建对象很简单：

var instance = new MyClass();

但使用反射，我们可以在运行时根据类型信息创建实例：

Type type = typeof(MyClass);
object instance = Activator.CreateInstance(type);

更进一步，如果构造函数有参数，反射也能处理：

ConstructorInfo ctor = type.GetConstructor(new[] { typeof(IService) });
object[] args = { /* 已创建的依赖实例 */ };
object instance = ctor.Invoke(args);

二、自动解析构造函数依赖

大多数依赖注入框架优先使用构造函数注入。我们可以用反射获取类型最长的构造函数（通常包含最多依赖），然后递归解析其参数类型。

public object CreateInstance(Type type)
{
    // 查找最长的构造函数（最常用的注入方式）
    ConstructorInfo ctor = type.GetConstructors()
        .OrderByDescending(c => c.GetParameters().Length)
        .First();

    ParameterInfo[] parameters = ctor.GetParameters();

    // 递归解析每个参数（依赖）
    object[] args = parameters.Select(p =>
    {
        return Resolve(p.ParameterType); // 递归获取依赖实例
    }).ToArray();

    return ctor.Invoke(args);
}

Resolve

CreateInstance

三、维护一个类型映射和实例缓存

为了支持接口到实现类的映射（如

IService

ServiceA

Bika.ai

打造您的AI智能体员工团队

下载

Dictionary _registrations = new();
Dictionary _singletons = new();

注册示例：

public void Register() where TypeTo : TypeFrom
{
    _registrations[typeof(TypeFrom)] = typeof(TypeTo);
}

支持生命周期管理：

• Transient：每次创建新实例
• Singleton：首次创建后缓存实例

public object Resolve(Type serviceType)
{
    // 如果是单例且已创建，直接返回
    if (_singletons.ContainsKey(serviceType))
        return _singletons[serviceType];

    Type implType = _registrations.ContainsKey(serviceType)
        ? _registrations[serviceType]
        : serviceType;

    object instance = CreateInstance(implType);

    // 若是单例，缓存
    if (/* 是单例注册 */)
        _singletons[serviceType] = instance;

    return instance;
}

四、处理循环依赖

反射 + 递归容易在循环依赖时导致栈溢出，比如 A 依赖 B，B 又依赖 A。

简单防范策略：

• 在

  Resolve

  过程中维护一个“正在解析”的类型栈
• 每次开始解析前检查是否已存在，若存在则抛出异常

HashSet _resolving = new();

public object Resolve(Type serviceType)
{
    if (_resolving.Contains(serviceType))
        throw new InvalidOperationException($"Circular dependency detected: {serviceType}");

    _resolving.Add(serviceType);

    // ...解析逻辑...

    _resolving.Remove(serviceType); // 完成后移除
    return instance;
}

五、完整简化示例（C#）

public class SimpleDIContainer
{
    private Dictionary _registrations = new();
    private Dictionary _singletons = new();
    private HashSet _resolving = new();

    public void Register() where TTo : TFrom
    {
        _registrations[typeof(TFrom)] = typeof(TTo);
    }

    public void RegisterSingleton() where TTo : TFrom
    {
        Register();
        // 提前标记为单例（或首次创建时缓存）
    }

    public T Resolve()
    {
        return (T)Resolve(typeof(T));
    }

    public object Resolve(Type serviceType)
    {
        if (_singletons.ContainsKey(serviceType))
            return _singletons[serviceType];

        if (_resolving.Contains(serviceType))
            throw new Exception($"Circular dependency: {serviceType}");

        _resolving.Add(serviceType);

        try
        {
            Type implType = _registrations.ContainsKey(serviceType)
                ? _registrations[serviceType]
                : serviceType;

            var ctor = implType.GetConstructors()
                .OrderByDescending(c => c.GetParameters().Length)
                .First();

            var parameters = ctor.GetParameters();
            var args = parameters.Select(p => Resolve(p.ParameterType)).ToArray();

            var instance = ctor.Invoke(args);

            if (_registrations.ContainsValue(implType) && /* 注册为 singleton */)
            {
                _singletons[serviceType] = instance;
            }

            return instance;
        }
        finally
        {
            _resolving.Remove(serviceType);
        }
    }
}

使用方式：

var container = new SimpleDIContainer();
container.Register();
container.Register();

var service = container.Resolve(); // 自动组装依赖

基本上就这些。虽然没有主流框架（如 Autofac、Microsoft.Extensions.DependencyInjection）那样高效和健壮，但它展示了反射 + 递归解析 + 类型映射是如何实现依赖注入的核心机制的。理解这些原理，有助于更好地使用现代 DI 框架，也能在特定场景下实现轻量级容器。