unity3d设计模式控制反转

来源：互联网发布：键鼠套装知乎编辑：程序博客网时间：2024/06/03 19:30

IOC英文全称：Inversion of Control中文名称：控制反转，它还有个名字叫依赖注入（Dependency Injection）。
作用：将各层的对象以松耦合的方式组织在一起，解耦，各层对象的调用完全面向接口，当系统重构的时候代码的改写量将大大减少。
理解依赖注入：
当一个类的实例需要另一个类的实例协助时，在传统的程序设计过程中，通常有调用者来创建被调用者的实例。然而采用依赖注入的方式，创建被调用者的工作不再由调用者来完成，因此叫控制反转，创建被调用者的实例的工作由IOC容器来完成，然后注入调用者，因此也称为依赖注入。

1.依赖

依赖就是有联系，有地方使用到它就是有依赖它，一个系统不可能完全避免依赖。如果你的一个类或者模块在项目中没有用到它，恭喜你，可以从项目中剔除它或者排除它了，因为没有一个地方会依赖它。下面看一个简单的示例：

?
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
/// <summary>
/// 用户播放媒体文件
/// </summary>
publicclassOperationMain
{
 
publicvoidPlayMedia()
{
MediaFile _mtype = newMediaFile();
Player _player = newPlayer();
 
_player.Play(_mtype);
}
}
/// <summary>
/// 播放器
/// </summary>
publicclassPlayer
{
publicvoidPlay(MediaFile file)
{
Console.WriteLine(file.FilePath);
}
}
/// <summary>
/// 媒体文件
/// </summary>
publicclassMediaFile
{
publicstringFilePath { get;set; }
}

上面是一个用户用播放器播放文件简单示例，用户操作是OperationMain类中的PlayMedia方法，打开一个播放器，选择一个文件来播放。先看看他们之间的依赖关系，可以简单找到有3个依赖

Player依赖MediaFile
OperationMain依赖Player
OperationMain依赖MediaFile

2.依赖倒置

需求增加了，要用不同的播放器，播放不同的文件，我们要抽象出来，减少耦合。

耦合关系就是依赖关系，如果依赖关系相当繁杂，牵一发而动全身，很难维护；依赖关系越少，耦合关系就越低，系统就越稳定，所以我们要减少依赖。

幸亏Robert Martin大师提出了面向对象设计原则—-依赖倒置原则：

A. 上层模块不应该依赖于下层模块，它们共同依赖于一个抽象。　
B. 抽象不能依赖于具象，具象依赖于抽象。

理解：A.上层是使用者，下层是被使用者，这就导致的结果是上层依赖下层了，下层变动了，自然就会影响到上层了，导致系统不稳定，甚至是牵一发而动全身。那怎么减少依赖呢？就是上层和下层都去依赖另一个抽象，这个抽象比较稳定，整个就来说就比较稳定了。

B.面向对象编程时面向抽象或者面向借口编程，抽象一般比较稳定，实现抽象的具体肯定是要依赖抽象的，抽象不应该去依赖别的具体，应该依赖抽象。

上面播放器的示例中，我们已经找到依赖关系了，现在我们要按照依赖倒置原则，来进行优化。

根据原则如下改动：

Player依赖MediaFile，好办，让Player和MediaFile都去依赖一个抽象IMediaFile
OperationMain依赖Player，好办，让OperationMain和Player都依赖一个抽象IPlayer
OperationMain依赖MediaFile，好办，让OperationMain和MediaFile都依赖一个抽象IMediaFile
IPlayer不能依赖具体MediaFile，应该依赖于具体MediaFile的抽象IMediaFile

结构很简单，于是代码大致如下：

?
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
/// <summary>
/// 用户播放媒体文件
/// </summary>
publicclassOperationMain
{
 
publicvoidPlayMedia()
{
IMediaFile _mtype = newMediaFile();
IPlayer _player = newPlayer();
 
_player.Play(_mtype);
}
}
/// <summary>
/// 播放器
/// </summary>
publicinterfaceIPlayer
{
voidPlay(IMediaFile file);
}
/// <summary>
/// 默认播放器
/// </summary>
publicclassPlayer : IPlayer
{
publicvoidPlay(IMediaFile file)
{
Console.WriteLine(file.FilePath);
}
}
/// <summary>
/// 媒体文件
/// </summary>
publicinterfaceIMediaFile
{
stringFilePath { get;set; }
}
/// <summary>
/// 默认媒体文件
/// </summary>
publicclassMediaFile : IMediaFile
{
publicstringFilePath { get;set; }
}

上面代码进行了抽象，可以看到，目的是减少了依赖，但是看上去依赖关系增加了，如用户PlayMedia方法，依赖还增加了依赖接口和具体的实现，但是接口是稳定的，可以不考虑，具体的实现才是变动的，这个依赖还是要的，要播放文件，必定要用到具体的播放器和具体文件。

3.控制反转(IoC)

现实生活中，是具体的播放器和具体的媒体文件没有关系，你给它一个Mp3文件他可以播放，给它一个Mp4文件它也可以播放，你删掉你的媒体文件，播放器照样在，具体什么播放器，播放什么文件，控制权全部是我们用户自己。

上面的示例中基本实现了隔离，具体的播放器跟具体的媒体隔离了，具体的播放器只跟媒体接口和播放器接口有关。但是PlayMedia的方法里面的具体对象，写死了，控制权非常小，如果我想用百度影音播放呢，我想换一首音乐呢，只能重新改代码，那控制怎么进行转移呢？

我们可以通过反射来创建，把具体的文件名写在配置文件里，这时候客户端代码也不用变了，只需要改配置文件就好了，稳定性又有了提高，如下：

?
1
2
3
4
5
6
7
publicvoidPlayMedia()
{
IMediaFile _mtype = Assembly.Load(ConfigurationManager.AppSettings["AssemName"]).CreateInstance(ConfigurationManager.AppSettings["MediaName"]);
IPlayer _player = Assembly.Load(ConfigurationManager.AppSettings["AssemName"]).CreateInstance(ConfigurationManager.AppSettings["PlayerName"]);
 
_player.Play(_mtype);
}

这个具对象是哪一个，全由配置文件来控制了，这个具体对象的控制权交给了配置文件了，这也是人们常说的控制反转。

控制反转IoC是Inversion of Control的缩写，是说对象的控制权进行转移，转移到第三方，比如转移交给了IoC容器，它就是一个创建工厂，你要什么对象，它就给你什么对象，有了IoC容器，依赖关系就变了，原先的依赖关系就没了，它们都依赖IoC容器了，通过IoC容器来建立它们之间的关系。

4.依赖注入(DI)

上面说到控制反转，是一个思想概念，但是也要具体实现的，上面的配置文件也是一种实现方式。依赖注入提出了具体的思想。

依赖注入DI是Dependency Injection缩写，它提出了“哪些东东的控制权被反转了，被转移了？”，它也给出了答案：“依赖对象的创建获得被反转”。

所谓依赖注入，就是由IoC容器在运行期间，动态地将某种依赖关系注入到对象之中。

上面的示例中，哪些要依赖注入，依赖对象需要获得实例的地方，即 PlayMedia方法，需要IPlayer具体对象和IMediaFile的具体对象，找到了地方就从这里下手，为了灵活的控制这两个对象，必须是外面能够控制着两个对象的实例化，提供对外的操作是必要的，可以是属性，可以是方法，可以是构造函数，总之别的地方可以控制它，下面将会使用Unity来注入，使用的是构造函数注入，代码如下：

?
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
47
48
49
50
/// <summary>
/// 用户播放媒体文件
/// </summary>
publicclassOperationMain
{
IMediaFile _mtype;
IPlayer _player;
 
publicOperationMain(IPlayer player, IMediaFile mtype)
{
_player = player;
_mtype = mtype;
}
 
publicvoidPlayMedia()
{
_player.Play(_mtype);
}
}
/// <summary>
/// 播放器
/// </summary>
publicinterfaceIPlayer
{
voidPlay(IMediaFile file);
}
/// <summary>
/// 默认播放器
/// </summary>
publicclassPlayer : IPlayer
{
publicvoidPlay(IMediaFile file)
{
Console.WriteLine(file.FilePath);
}
}
/// <summary>
/// 媒体文件
/// </summary>
publicinterfaceIMediaFile
{
stringFilePath { get;set; }
}
/// <summary>
/// 默认媒体文件
/// </summary>
publicclassMediaFile : IMediaFile
{
publicstringFilePath { get;set; }
}

给 OperationMain类一个构造函数，因为Unity有一个构造函数注入，调用代码如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
staticUnityContainer container = newUnityContainer();
staticvoidinit()
{
container.RegisterType<IPlayer, Player>();
container.RegisterType<IMediaFile, MediaFile>();
}
staticvoidMain(string[] args)
{
 
init();
 
OperationMain op1 = container.Resolve<OperationMain>();
op1.PlayMedia();
OperationMain op3 = container.Resolve<OperationMain>();
op3.PlayMedia();
 
//普通方式
OperationMain op2 = newOperationMain(newPlayer(),newMediaFile());
op2.PlayMedia();
 
Console.Read();
}

0 0