C#中控制反转和依赖注入原理及实现

// 日志接口
public interface ILogger
{
    void Log(string message);
}

// 日志实现（文件日志）
public class FileLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($"[FileLogger] {message}");
    }
}

// 用户服务（依赖ILogger）
public class UserService
{
    // 传统方式：自己创建依赖（紧耦合！如果要换数据库日志，必须修改这里）
    private ILogger _logger = new FileLogger(); 

    public void AddUser(string username)
    {
        // 业务逻辑：添加用户
        _logger.Log($"用户 {username} 已添加"); // 使用日志
    }
}

// 调用
class Program
{
    static void Main()
    {
        UserService userService = new UserService();
        userService.AddUser("张三"); 
        // 输出：[FileLogger] 用户 张三 已添加
    }
}

// 新增一个数据库日志实现
public class DatabaseLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($"[DatabaseLogger] {message}");
    }
}

// 修改UserService：通过构造函数接收依赖（依赖抽象，不依赖具体实现）
public class UserService
{
    private ILogger _logger;

    // 构造函数注入：依赖由外部传入，而非自己创建
    public UserService(ILogger logger)
    {
        _logger = logger; // 接收注入的日志对象
    }

    public void AddUser(string username)
    {
        _logger.Log($"用户 {username} 已添加");
    }
}

// 调用：手动注入依赖（简单场景下可手动管理，复杂场景用容器）
class Program
{
    static void Main()
    {
        // 1. 创建依赖对象（可替换为DatabaseLogger）
        ILogger logger = new FileLogger(); 
        // ILogger logger = new DatabaseLogger(); 

        // 2. 注入到UserService
        UserService userService = new UserService(logger); 
        userService.AddUser("张三"); 
        // 输出：[FileLogger] 用户 张三 已添加（换DatabaseLogger则输出对应内容）
    }
}

using System;
using System.Collections.Generic;
using System.Reflection;

// 模拟IoC容器
public class SimpleIocContainer
{
    // 存储注册信息：key=接口类型，value=实现类型
    private Dictionary<Type, Type> _registry = new Dictionary<Type, Type>();

    // 注册：接口 -> 实现
    public void Register<TInterface, TImplementation>() 
        where TImplementation : TInterface
    {
        _registry[typeof(TInterface)] = typeof(TImplementation);
    }

    // 解析：根据接口类型创建对象，并自动注入依赖
    public T Resolve<T>()
    {
        return (T)Resolve(typeof(T));
    }

    private object Resolve(Type type)
    {
        // 1. 如果是具体类型，直接创建（递归终止条件）
        if (!type.IsInterface)
        {
            return CreateInstance(type);
        }

        // 2. 如果是接口，查找注册的实现类型
        if (!_registry.TryGetValue(type, out Type implementationType))
        {
            throw new Exception($"未注册接口 {type.Name} 的实现");
        }

        // 3. 创建实现类的实例（并递归注入其依赖）
        return CreateInstance(implementationType);
    }

    // 通过反射创建对象，并注入构造函数依赖
    private object CreateInstance(Type type)
    {
        // 获取类型的构造函数（简化处理：取第一个构造函数）
        ConstructorInfo ctor = type.GetConstructors()[0];
        // 获取构造函数的参数（依赖）
        ParameterInfo[] parameters = ctor.GetParameters();

        // 递归解析每个参数的依赖（如UserService的构造函数参数是ILogger，解析ILogger）
        object[] parameterInstances = new object[parameters.Length];
        for (int i = 0; i < parameters.Length; i++)
        {
            parameterInstances[i] = Resolve(parameters[i].ParameterType);
        }

        // 创建对象（传入解析好的依赖）
        return ctor.Invoke(parameterInstances);
    }
}

// 使用模拟容器
class Program
{
    static void Main()
    {
        // 1. 创建容器并注册依赖
        SimpleIocContainer container = new SimpleIocContainer();
        container.Register<ILogger, FileLogger>(); // 注册ILogger -> FileLogger
        // container.Register<ILogger, DatabaseLogger>(); // 可随时切换实现

        // 2. 从容器解析UserService（容器自动注入ILogger）
        UserService userService = container.Resolve<UserService>();

        // 3. 调用方法
        userService.AddUser("李四"); 
        // 输出：[FileLogger] 用户 李四 已添加
    }
}