Unity

概述

依赖注入（Dependency Injection, DI）是一种设计模式，可以帮助你在 Unity 中编写更松耦合、可测试的代码。以下是一个简单的 Unity C# 依赖注入模式的 Demo，逐步讲解实现过程。

我们将创建一个简单的例子：一个 Player 类依赖于 IWeapon 接口，通过依赖注入来提供具体的武器实现（比如 Sword 或 Gun）。

步骤 1：定义接口

首先，创建一个武器接口 IWeapon，让不同的武器实现它。

1
2
3
4
5
// IWeapon.cs
public interface IWeapon
{
    void Attack();
}

步骤 2：实现具体类

创建两个具体的武器类，实现 IWeapon 接口。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Sword.cs
public class Sword : IWeapon
{
    public void Attack()
    {
        UnityEngine.Debug.Log("使用剑攻击！");
    }
}

// Gun.cs
public class Gun : IWeapon
{
    public void Attack()
    {
        UnityEngine.Debug.Log("使用枪射击！");
    }
}

步骤 3：创建依赖类

创建一个 Player 类，通过构造函数注入 IWeapon。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Player.cs
public class Player
{
    private readonly IWeapon _weapon;

    // 构造函数注入
    public Player(IWeapon weapon)
    {
        _weapon = weapon;
    }

    public void PerformAttack()
    {
        _weapon.Attack();
    }
}

步骤 4：手动注入依赖

在 Unity 的 MonoBehaviour 中手动创建对象并注入依赖。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// GameController.cs
using UnityEngine;

public class GameController : MonoBehaviour
{
    private Player _player;

    void Start()
    {
        // 手动注入 Sword 作为依赖
        IWeapon sword = new Sword();
        _player = new Player(sword);

        // 测试攻击
        _player.PerformAttack();
    }
}

步骤 5：使用简单的 DI 容器（可选）

手动注入适用于简单场景，但如果项目变复杂，可以使用一个简单的 DI 容器。以下是一个基础实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// SimpleDIContainer.cs
using System;
using System.Collections.Generic;

public class SimpleDIContainer
{
    private Dictionary<Type, object> _dependencies = new Dictionary<Type, object>();

    // 注册依赖
    public void Register<T>(object implementation)
    {
        _dependencies[typeof(T)] = implementation;
    }

    // 解析依赖
    public T Resolve<T>()
    {
        return (T)_dependencies[typeof(T)];
    }
}

// GameControllerWithDI.cs
using UnityEngine;

public class GameControllerWithDI : MonoBehaviour
{
    private Player _player;
    private SimpleDIContainer _container;

    void Awake()
    {
        // 初始化容器并注册依赖
        _container = new SimpleDIContainer();
        _container.Register<IWeapon>(new Gun()); // 这里可以切换为 Sword
    }

    void Start()
    {
        // 通过容器解析依赖
        IWeapon weapon = _container.Resolve<IWeapon>();
        _player = new Player(weapon);

        // 测试攻击
        _player.PerformAttack();
    }
}

运行结果：输出 “使用枪射击！”。你可以轻松切换 new Gun() 为 new Sword() 来改变行为。

完整项目结构

1
2
3
4
5
6
7
8
Assets/
├── Scripts/
│   ├── IWeapon.cs
│   ├── Sword.cs
│   ├── Gun.cs
│   ├── Player.cs
│   ├── SimpleDIContainer.cs
│   └── GameControllerWithDI.cs

优点

松耦合：Player 不直接依赖 Sword 或 Gun，只需依赖 IWeapon 接口。

可测试性：可以轻松为 Player 注入模拟（Mock）武器进行单元测试。

灵活性：通过修改注入的依赖，可以改变 Player 的行为。

扩展建议

使用现有 DI 框架：对于大型项目，可以考虑 Unity 支持的 DI 框架，如 Zenject（现更名为 Extenject）或 VContainer，它们提供了更强大的功能。

单例模式：将 DI 容器实现为单例，确保整个游戏只有一个实例。

属性注入：除了构造函数注入，还可以实现属性注入或方法注入。

测试代码

将 GameControllerWithDI 挂载到一个空 GameObject 上，运行场景即可看到效果。你可以尝试切换 Sword 和 Gun，观察输出的变化。