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

控制反转（ioc）和依赖注入（di）是面向对象编程中解决对象依赖关系的核心设计思想，目的是降低代码耦合度，提高可维护性和可测试性。下面从概念、关系、实现原理到代码示例逐步说明。

一、控制反转（ioc：inversion of control）

概念

控制反转是一种设计原则，核心是 “反转对象的创建和依赖管理的控制权”：

传统程序中，对象的创建和依赖关系（如 a 依赖 b，a 会直接new b()）由对象自身控制（主动创建依赖）。
ioc 原则下，这种控制权被 “反转” 给外部容器（如 ioc 容器），对象只需声明自己需要什么依赖，由容器负责创建并 “推送” 依赖给它（被动接收依赖）。

举个生活例子

传统方式：你（对象 a）想吃汉堡，需要自己买菜、做面包、煎肉饼（自己创建所有依赖）。
ioc 方式：你（对象 a）只需告诉餐厅（容器）“我要汉堡”，餐厅负责准备所有材料并做好汉堡给你（容器创建并提供依赖）。

二、依赖注入（di：dependency injection）

概念

依赖注入是实现 ioc 原则的具体方式，核心是 “将对象的依赖通过外部传递（注入）给它，而非对象自己创建”。简单说：依赖注入 = 谁依赖谁 + 谁注入谁 + 注入什么

“谁依赖谁”：应用程序中的对象（如 service）依赖于其他对象（如 repository）。
“谁注入谁”：ioc 容器将依赖对象注入到被依赖对象中。
“注入什么”：被依赖的具体实现（如userrepository注入到userservice）。

ioc 与 di 的关系

ioc 是设计原则（目标）：反转控制权，解耦依赖。
di 是实现手段（方法）：通过注入的方式实现 ioc。可以理解为：“ioc 是思想，di 是技术”。

三、实现原理

ioc/di 的核心是ioc 容器（如 c# 中的 autofac、unity 等），其工作流程可分为 3 步：

注册（register）：告诉容器 “某个接口（抽象）对应哪个具体实现类”。例如：container.register<ilogger, filelogger>() 表示 “ilogger接口由filelogger类实现”。
解析（resolve）：当需要某个对象时，容器根据注册信息，通过反射创建对象，并自动解析其依赖关系。
注入（inject）：容器将解析出的依赖对象，通过构造函数、属性或方法等方式，注入到目标对象中。

四、c# 代码示例

下面通过 “用户服务（userservice）依赖日志组件（ilogger）” 的场景，对比传统方式和 di 方式的区别，并模拟一个简单的 ioc 容器。

1. 传统方式（无 ioc/di）：紧耦合

// 日志接口
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] 用户 张三 已添加
    }
}

问题：

userservice直接依赖filelogger（具体实现），而非ilogger（抽象），违反 “依赖倒置原则”。
若要替换日志实现（如改为databaselogger），必须修改userservice的代码，耦合度极高，难以维护和测试。

2. 依赖注入（di）方式：松耦合

通过构造函数注入（最常用的注入方式），将依赖从外部传递给userservice：

// 新增一个数据库日志实现
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则输出对应内容）
    }
}

改进：

userservice仅依赖ilogger接口（抽象），与具体实现（filelogger/databaselogger）解耦。
替换日志实现时，只需修改注入的对象，无需改动userservice代码，符合 “开闭原则”。

3. 模拟 ioc 容器：自动管理依赖

当项目复杂（依赖层级深，如 a 依赖 b，b 依赖 c），手动注入会非常繁琐。此时需要 ioc 容器自动处理依赖。下面模拟一个极简的 ioc 容器：

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] 用户 李四 已添加
    }
}

容器工作流程：

注册：register<ilogger, filelogger>() 告诉容器 “ilogger用filelogger实现”。
解析：调用resolve<userservice>()时，容器通过反射分析userservice的构造函数，发现依赖ilogger。
注入：容器先解析ilogger（根据注册找到filelogger），创建filelogger实例，再注入到userservice的构造函数中，最终返回userservice实例。