这份笔记按你给的 4 个目录重写,重点不是再解释一遍“什么是接口”,而是把四件事分开看清楚:

  1. 什么时候复用对象,什么时候重新创建对象。
  2. 构造函数一层套一层时,容器怎样递归创建。
  3. 对象已经创建后,怎样通过属性补依赖。
  4. 同一个接口有多个实现时,怎样按名字选择。

这份笔记继续使用控制台,不是因为它更“高级”,而是因为它能把对象创建过程直接打印出来。等你看懂输出,再放回 WPF 时,只是把 Program.Main 换成 App.OnStartup,把 Console.WriteLine 换成 TextBlock 的绑定。

四章主线

章节 本章只解决一个问题 做完会看到
1. IOC瞬态模式与单例模式逻辑整合 缓存到底影响了谁 两次请求是否拿到同一个对象
2. 无限层级的依赖注入逻辑处理 构造函数参数怎样递归解析 Level1 -> Level2 -> Level3
3. 属性注入逻辑处理 对象创建后怎样补属性 手动注入和容器注入的结果
4. 单接口多实现注入逻辑处理 同一个接口怎样选实现 Email 和 Sms 两个结果

示例项目地图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
示例代码/SimpleIocDemo/
├─ SimpleIocDemo.csproj 控制台项目,net48
├─ Program.cs 四章的统一入口
├─ Services/
│ ├─ IMessageService.cs 统一接口
│ ├─ MessageService.cs 普通实现
│ ├─ EmailMessageService.cs 邮件实现
│ └─ SmsMessageService.cs 短信实现
├─ ViewModels/
│ ├─ GreetingViewModel.cs 构造函数注入示例
│ ├─ Level1ViewModel.cs 三层依赖的最外层
│ ├─ Level2ViewModel.cs
│ ├─ Level3ViewModel.cs 三层依赖的最底层
│ └─ PropertyInjectionViewModel.cs 属性注入示例
└─ Ioc/
└─ MiniContainer.cs 自定义容器

项目使用 .NET Framework 4.8 和 MvvmLightLibs 5.4.1.1。SimpleIoc 的命名空间是:

1
using GalaSoft.MvvmLight.Ioc;

如果你使用别的 MvvmLight 版本,个别重载可能有差异。遇到差异时,以你项目里实际能编译的 API 为准,不要只看笔记猜。

运行方式

在 C:\Users\North\Desktop\WPFStudy 打开 PowerShell:

1
dotnet run --project .\示例代码\SimpleIocDemo\SimpleIocDemo.csproj -c Release

本次实际运行的关键输出会放在每章第 8 节和最后的“运行验证”里。时间、对象地址之类的信息不需要和笔记完全一样,重点看 True、False 和文字内容。

先把三个词说透

词 不要这样理解 应该这样理解
注册 注册时马上创建对象 只写“要这个接口时,用哪个创建方法”
解析 解析一定创建新对象 先看缓存,再决定创建还是复用
生命周期 一个类型永远只有一种模式 每次请求可以选择是否使用缓存

SimpleIoc 的 GetInstance<T>() 默认会查缓存;GetInstanceWithoutCaching<T>() 表示“这次请求不使用缓存”。这不是在注册时给类型永久贴一个“瞬态”标签,而是你在每次请求时做的选择。

控制台怎样迁移到 WPF

控制台 WPF
Program.Main App.OnStartup
Console.WriteLine TextBlock Text="{Binding ...}"
在 Main 里注册 在 App.OnStartup 里注册
把结果写到控制台 把 ViewModel 交给 window.DataContext

所以本章不写窗口,不代表这些知识不能用于 WPF。你只要记住:容器负责准备对象,窗口负责显示对象。


1. IOC瞬态模式与单例模式逻辑整合

1. 本节目标

分清两件事:

  1. GetInstance<T>() 默认会复用已经缓存的对象。
  2. GetInstanceWithoutCaching<T>() 只让“这次请求的目标对象”不使用缓存,不会自动把它内部的依赖也全部换成新的。

做完后你会看到四行 True:

1
2
3
4
无缓存服务不同:True
无缓存 ViewModel 不同:True
无缓存 ViewModel 内部服务相同:True
普通服务相同:True

2. 一句话原理

注册只是写下“怎么造”,缓存才决定“这次要不要复用”。GetInstance 像先看保温壶里有没有;GetInstanceWithoutCaching 像这次不查保温壶,重新做一杯。

3. 要改哪里

顺序 文件 类/位置 要做什么
1 ViewModels/GreetingViewModel.cs GreetingViewModel 属性区 增加只读属性,方便观察内部服务
2 Program.cs Program 类的方法区 增加 TestTransient
3 Program.cs Program.Main 调用 TestTransient

4. 第一步:先写最小观察入口

这一章没有窗口,用控制台输出当“观察界面”。打开 Program.cs,在 Program 类的 Main 方法里先保留:

1
2
3
4
5
6
private static void Main()
{
TestSimpleIoc();
TestTransient();
Console.WriteLine("全部通过");
}

TestSimpleIoc() 是上一份笔记里的基础验证,先不要删。TestTransient() 还没有写,所以此时先不要运行;下一步补上它。

5. 第二步:写最小代码

先打开 ViewModels/GreetingViewModel.cs,在 GreetingViewModel 类的属性区增加:

1
2
3
4
public IMessageService MessageService
{
get { return _messageService; }
}

这个属性只用来观察“ViewModel 里面到底拿到了哪个服务”,不参与业务。把它放在 Text 属性后面,类的右花括号前面。

再打开 Program.cs,在 Program 类的方法区加入 TestTransient:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
private static void TestTransient()
{
var ioc = SimpleIoc.Default;
ioc.Reset();
ioc.Register<IMessageService, MessageService>();
ioc.Register<GreetingViewModel>();

var serviceA = ioc.GetInstanceWithoutCaching<IMessageService>();
var serviceB = ioc.GetInstanceWithoutCaching<IMessageService>();
Console.WriteLine("无缓存服务不同:" + (serviceA != serviceB));

var viewModelA = ioc.GetInstanceWithoutCaching<GreetingViewModel>();
var viewModelB = ioc.GetInstanceWithoutCaching<GreetingViewModel>();
Console.WriteLine("无缓存 ViewModel 不同:" +
(viewModelA != viewModelB));
Console.WriteLine("无缓存 ViewModel 内部服务相同:" +
(viewModelA.MessageService == viewModelB.MessageService));

var normalA = ioc.GetInstance<IMessageService>();
var normalB = ioc.GetInstance<IMessageService>();
Console.WriteLine("普通服务相同:" + (normalA == normalB));
}

6. 第三步:连接并运行

确认 Program.cs 顶部有这些命名空间:

1
2
3
using GalaSoft.MvvmLight.Ioc;
using SimpleIocDemo.Services;
using SimpleIocDemo.ViewModels;

然后运行:

1
dotnet run --project .\示例代码\SimpleIocDemo\SimpleIocDemo.csproj -c Release

你应该看到:

1
2
3
4
无缓存服务不同:True
无缓存 ViewModel 不同:True
无缓存 ViewModel 内部服务相同:True
普通服务相同:True

这四行分别说明:

  1. 直接请求服务两次,得到两个不同对象。
  2. 直接请求 ViewModel 两次,得到两个不同 ViewModel。
  3. 两个 ViewModel 内部拿到的 IMessageService 却是同一个。
  4. 用普通 GetInstance 请求服务两次,得到同一个对象。

7. 关键代码逐段看

代码 你要看出的意思
ioc.Register<IMessageService, MessageService>() 登记“接口对应哪个实现”,此时还没有创建对象
GetInstanceWithoutCaching<IMessageService>() 这次请求不查缓存,直接创建
GetInstanceWithoutCaching<GreetingViewModel>() 不缓存 ViewModel 本身,但它的构造函数参数仍按各自规则解析
viewModelA.MessageService == viewModelB.MessageService 检查两个 ViewModel 内部是否共用了同一个服务
GetInstance<IMessageService>() 这次请求会查缓存,所以第二次复用第一次的对象

本章最容易误解的一点是:GetInstanceWithoutCaching<GreetingViewModel>() 只影响 GreetingViewModel 这个“你直接请求的类型”。容器给 GreetingViewModel 补构造函数参数时,仍然会按 IMessageService 自己的规则去拿服务;如果服务已经被缓存,两个 ViewModel 就会共用它。

这不是 bug,而是生命周期要“逐类型看”的结果。以后你看到“外层是新的,内层却是旧的”,先问自己:我改变的是哪一层的获取方式?

8. 运行后应该看到什么

本章对应的真实输出是:

1
2
3
4
无缓存服务不同:True
无缓存 ViewModel 不同:True
无缓存 ViewModel 内部服务相同:True
普通服务相同:True

如果第一行是 False,先检查是不是把 GetInstanceWithoutCaching 写成了 GetInstance。如果第三行是 False,先检查服务是不是被注册成了每次都新建,或者你是否在两次 ViewModel 之间做了额外清理。

9. 对应配图

单例与瞬态的生命周期对比

先看左边:第一次创建对象 A,放进缓存,第二次直接拿 A。再看右边:每次都不查缓存,所以得到 A、B 两个不同对象。最后看图片底部那句提醒:请求类型是瞬态,不代表它内部的依赖也自动变成瞬态。

10. 跟做检查点

  • GreetingViewModel 有只读的 MessageService 属性。
  • TestTransient 在 Program 类的方法区,不在 Main 里面。
  • TestTransient 开头调用了 ioc.Reset()。
  • 能说出 GetInstance 和 GetInstanceWithoutCaching 的区别。
  • 能解释为什么 ViewModel 不同、内部服务却相同。

11. 常见错误

现象 原因 解决
两次服务仍然相同 用了 GetInstance 检查方法名有没有 WithoutCaching
第一行就报“未注册” 忘记注册接口或 ViewModel 先 Register,再获取
结果受上一次测试影响 没有 Reset 每个独立测试开头重置容器
以为内部服务也会变新 把“目标类型瞬态”误解成“整条依赖链瞬态” 逐个类型检查获取方式和缓存状态
把属性写进了方法 位置放错 放回 GreetingViewModel 的属性区

12. 小练习

只改一处:把 TestTransient 里第一次 GetInstanceWithoutCaching<IMessageService>() 改成 GetInstance<IMessageService>(),再运行。

你会看到“无缓存服务不同”变成 False。这不是代码坏了,而是你亲手把“每次新建”换成了“使用缓存”。做完后改回来。

13. 小结与迁移

这一章只要记住一句话:

注册决定“怎么造”,获取方式决定“这次要不要用缓存”。

放回 WPF 时,页面 ViewModel 是每次打开都新建,还是整个应用只保留一个,就对应不同的获取策略。先想清楚页面生命周期,再决定注册和解析方式。


2. 无限层级的依赖注入逻辑处理

1. 本节目标

让容器自动创建一条三层依赖链:

1
Level1ViewModel -> Level2ViewModel -> Level3ViewModel

你只请求 Level1ViewModel,容器会自己把后面的 Level2 和 Level3 补上。做完后看到:

1
三层依赖:Level1 -> Level2 -> Level3

这里的“无限层级”不是“无限循环”。它的意思是:只要构造函数参数还有依赖,容器就继续往下解析;如果依赖形成环,就必须停下来报错。

2. 一句话原理

容器看到构造函数需要参数,就去找这个参数类型的登记;如果那个类型也有构造函数参数,就继续往下找,直到最底层没有参数为止。这像装配线:先装最里面的零件,再一层层往外装。

3. 要改哪里

顺序 文件 类/位置 要做什么
1 ViewModels/Level3ViewModel.cs Level3ViewModel 类 写最底层,没有依赖
2 ViewModels/Level2ViewModel.cs 构造函数 依赖 Level3ViewModel
3 ViewModels/Level1ViewModel.cs 构造函数 依赖 Level2ViewModel
4 Program.cs TestNestedDependencies 注册三层并请求最外层

4. 第一步:先把入口接上

打开 Program.cs,在 Program 类的 Main 方法里加入这一行:

1
TestNestedDependencies();

现在这个方法还没有写,所以先不要运行。下一步从最底层开始写类。

5. 第二步:从最底层往上写

新建 ViewModels/Level3ViewModel.cs。在 Level3ViewModel 类里写:

1
2
3
4
5
6
7
8
9
10
namespace SimpleIocDemo.ViewModels
{
public class Level3ViewModel
{
public string Text
{
get { return "Level3"; }
}
}
}

再新建 ViewModels/Level2ViewModel.cs。在 Level2ViewModel 的字段区、构造函数和属性区分别写:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
namespace SimpleIocDemo.ViewModels
{
public class Level2ViewModel
{
private readonly Level3ViewModel _next;

public Level2ViewModel(Level3ViewModel next)
{
_next = next;
}

public string Text
{
get { return "Level2 -> " + _next.Text; }
}
}
}

最后新建 ViewModels/Level1ViewModel.cs。它的写法和 Level2 一样,只是依赖换成 Level2ViewModel:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
namespace SimpleIocDemo.ViewModels
{
public class Level1ViewModel
{
private readonly Level2ViewModel _next;

public Level1ViewModel(Level2ViewModel next)
{
_next = next;
}

public string Text
{
get { return "Level1 -> " + _next.Text; }
}
}
}

6. 第三步:注册三层并请求最外层

打开 Program.cs,在 Program 类的方法区加入:

1
2
3
4
5
6
7
8
9
10
11
private static void TestNestedDependencies()
{
var ioc = SimpleIoc.Default;
ioc.Reset();
ioc.Register<Level1ViewModel>();
ioc.Register<Level2ViewModel>();
ioc.Register<Level3ViewModel>();

var level1 = ioc.GetInstance<Level1ViewModel>();
Console.WriteLine("三层依赖:" + level1.Text);
}

运行:

1
dotnet run --project .\示例代码\SimpleIocDemo\SimpleIocDemo.csproj -c Release

你应该看到:

1
三层依赖:Level1 -> Level2 -> Level3

7. 关键代码逐段看

代码 意思
Level2ViewModel(Level3ViewModel next) 创建 Level2 前,必须先准备 Level3
Level1ViewModel(Level2ViewModel next) 创建 Level1 前,必须先准备 Level2
Register<Level1ViewModel>() 让容器知道最外层也可以由它创建
GetInstance<Level1ViewModel>() 只请求最外层,内部依赖由容器递归补上
_next.Text 把下一层的结果拼到自己这一层

容器不是只写死了三层。它的思路是:看构造函数有哪些参数,对每个参数调用解析;如果参数自己还有构造函数参数,就继续递归。你把三层换成五层,只要每层都注册好,请求代码仍然只写 GetInstance<Level1ViewModel>()。

那“无限”什么时候应该停?两种情况必须停:

  1. 参数类型没有注册:应该抛出“未注册”异常,而不是悄悄塞 null。
  2. 依赖形成环:例如 A 依赖 B,B 又依赖 A,必须检测并报错,不能无限递归。

本笔记的自定义容器 MiniContainer 已经在内部用 _creating 集合做循环检查;附录会看到完整写法。SimpleIoc 的循环依赖处理以你实际版本为准,初学阶段不要让类之间互相依赖。

8. 运行后应该看到什么

本章对应输出:

1
三层依赖:Level1 -> Level2 -> Level3

如果只看到 Level1 -> 后面没有内容,通常是 Level2 没有拿到 Level3,或者某一层没有注册。如果程序直接卡住或栈溢出,先检查是否存在循环依赖。

9. 对应配图

三层依赖的递归解析

先看左边的“你只请求 Level1”,再顺着箭头看容器如何发现 Level2、Level3,最后看右边的五步:读构造函数、解析参数、继续递归、从底层创建、把 Level1 交给你。

10. 跟做检查点

  • 三个 ViewModel 都在 SimpleIocDemo.ViewModels 命名空间。
  • 每一层都只通过构造函数接收下一层,没有自己 new。
  • 三个类型都调用了 Register。
  • 最终只请求 Level1ViewModel。
  • 输出完整显示 Level1 -> Level2 -> Level3。

11. 常见错误

现象 原因 解决
报“未注册 Level3ViewModel” 只注册了 Level1 和 Level2 三层都要注册
一直转圈或栈溢出 依赖形成环 改成单向依赖,或引入接口/工厂打破环
构造函数选错 一个类有多个构造函数 初学阶段只保留一个明确构造函数
输出为空 Text 属性没有拼上下一层 检查 _next.Text 是否写对
层级一多就混乱 把所有创建都塞进一个类 让每层只关心自己的直接依赖

12. 小练习

只增加一层:新建 Level4ViewModel,让 Level3ViewModel 依赖它,并在 Program.cs 中注册 Level4ViewModel。

观察重点:Program.cs 里的请求代码不用改,仍然只请求 Level1ViewModel。如果输出多出 Level4,说明你已经理解了递归解析。

13. 小结与迁移

这一章的核心判断方法是:

看到构造函数参数,就问:“这个参数类型注册了吗?它自己还需要什么?它会不会反过来依赖我?”

放回 WPF 时,MainViewModel 依赖页面 ViewModel,页面 ViewModel 依赖服务,也可以按同样思路注册。依赖方向要清楚;层级深不一定是问题,循环依赖和职责混乱才是问题。


3. 属性注入逻辑处理

1. 本节目标

分清两种注入方式:

  1. 构造函数注入:对象一创建,依赖就通过构造函数传进去。
  2. 属性注入:对象先创建,再把依赖赋给一个可写属性。

你会先手动给属性赋值,再给自定义容器加一个很小的 InjectProperties 方法。做完后看到:

1
2
3
SimpleIoc 自动属性注入:False
手动属性注入:Hello from SimpleIoc
自定义容器属性注入:Hello from SimpleIoc

2. 一句话原理

构造函数注入像“出厂时就装好电池”;属性注入像“先把外壳做出来,再从电池仓把电池放进去”。属性注入不是自动魔法:属性必须可写,容器还要知道这个属性类型该创建什么。

3. 要改哪里

顺序 文件 类/位置 要做什么
1 ViewModels/PropertyInjectionViewModel.cs PropertyInjectionViewModel 类 写一个可写的服务属性
2 Program.cs TestPropertyInjection 先观察 SimpleIoc 不自动注入,再手动注入
3 Ioc/MiniContainer.cs MiniContainer 方法区 增加 InjectProperties
4 Program.cs TestMiniContainer 用自定义容器验证属性注入

4. 第一步:把测试入口接上

打开 Program.cs,在 Program 类的 Main 方法里加入:

1
TestPropertyInjection();

下一步再写 TestPropertyInjection 和对应的 ViewModel。

5. 第二步:写带可写属性的 ViewModel

新建 ViewModels/PropertyInjectionViewModel.cs。在类里写:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
using SimpleIocDemo.Services;

namespace SimpleIocDemo.ViewModels
{
public class PropertyInjectionViewModel
{
public IMessageService MessageService { get; set; }

public string Text
{
get
{
return MessageService == null
? "属性还没有被注入"
: MessageService.GetMessage();
}
}
}
}

最关键的是 public IMessageService MessageService { get; set; }。get 表示外面可以读,set 表示外面可以写;没有 set,容器就算想注入也放不进去。

再在 Program.cs 的方法区加入:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private static void TestPropertyInjection()
{
var ioc = SimpleIoc.Default;
ioc.Reset();
ioc.Register<IMessageService, MessageService>();
ioc.Register<PropertyInjectionViewModel>();

var viewModel = ioc.GetInstance<PropertyInjectionViewModel>();
Console.WriteLine("SimpleIoc 自动属性注入:" +
(viewModel.MessageService != null));

var manual = new PropertyInjectionViewModel();
manual.MessageService = ioc.GetInstance<IMessageService>();
Console.WriteLine("手动属性注入:" + manual.Text);
}

运行后你会看到:

1
2
SimpleIoc 自动属性注入:False
手动属性注入:Hello from SimpleIoc

第一行是 False,不是失败,而是当前 MvvmLightLibs 5.4.1.1 的实际行为:它主要自动处理构造函数注入,不会自动把这个 MessageService 属性塞进去。

6. 第三步:给自定义容器补上属性注入

打开 Ioc/MiniContainer.cs,在 MiniContainer 类的方法区加入 InjectProperties:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public void InjectProperties(object instance)
{
var properties = instance.GetType()
.GetProperties()
.Where(property =>
property.CanWrite &&
IsRegistered(property.PropertyType));

foreach (var property in properties)
{
property.SetValue(
instance,
Resolve(property.PropertyType),
null);
}
}

这段代码需要 System.Linq,文件顶部已经有:

1
using System.Linq;

然后在 Program.cs 的 TestMiniContainer 方法末尾加入:

1
2
3
4
5
6
container.Register<IMessageService, MessageService>();
container.Register<PropertyInjectionViewModel, PropertyInjectionViewModel>();
var propertyViewModel =
container.Resolve<PropertyInjectionViewModel>();
container.InjectProperties(propertyViewModel);
Console.WriteLine("自定义容器属性注入:" + propertyViewModel.Text);

运行后你会看到:

1
自定义容器属性注入:Hello from SimpleIoc

7. 关键代码逐段看

代码 意思
GetProperties() 拿到对象所有公开属性
property.CanWrite 属性有没有 set,能不能被赋值
IsRegistered(property.PropertyType) 这个属性需要的类型有没有登记
Resolve(property.PropertyType) 按属性类型取一个对象
SetValue(instance, value, null) 把取到的对象放进属性

为什么先讲手动注入,再讲自动注入?因为手动版本能让你看清顺序:

  1. 先有对象。
  2. 再拿到依赖。
  3. 再把依赖赋给属性。

自动版本只是把第 2、3 步交给容器循环处理。你先懂顺序,再看反射代码就不会觉得它是凭空出现的。

属性注入适合“可选依赖”或“稍后补充”的场景。如果对象离开某个依赖就无法工作,优先用构造函数注入,因为依赖关系更清楚,也不容易出现“忘记给属性赋值”的半成品对象。

8. 运行后应该看到什么

本章对应的真实输出是:

1
2
3
SimpleIoc 自动属性注入:False
手动属性注入:Hello from SimpleIoc
自定义容器属性注入:Hello from SimpleIoc

第一行告诉你“当前版本不自动做”,后两行告诉你“手动和自定义逻辑都能做到”。

9. 对应配图

构造函数注入与属性注入的对比

先看左边:对象创建时,依赖从构造函数参数进来。再看右边:对象先创建,属性暂时是 null,然后再给属性赋值。图片底部提醒你:当前示例的 SimpleIoc 不会自动填充这个属性。

10. 跟做检查点

  • MessageService 属性有公开的 set。
  • IMessageService 已经注册。
  • 手动注入时,先创建 ViewModel,再给属性赋值。
  • InjectProperties 放在 MiniContainer 类内部,不是放在 Program 里。
  • 运行结果里能看到 False 和两个 Hello from SimpleIoc。

11. 常见错误

现象 原因 解决
属性一直是 null 属性没有 set,或没有调用注入 改成 { get; set; },并确认调用 InjectProperties
报“未注册” 属性类型没有登记 先 Register<IMessageService, MessageService>()
自动注入仍然是 False 以为 SimpleIoc 会自动做属性注入 当前示例版本需要手动注入,或使用自定义容器逻辑
InjectProperties 编译不过 把方法写到了类外面 放回 MiniContainer 的右花括号里面
属性注入后仍然为空 属性类型没有注册,或属性不可写 同时检查 Register 和 set

12. 小练习

给 PropertyInjectionViewModel 再加一个属性:

1
public string Title { get; set; }

然后在手动注入的地方给它赋值为 "属性注入示例",并在控制台打印出来。这个练习只改一处,目的是让你熟悉“对象创建后,再补属性”的顺序。

13. 小结与迁移

这一章要记住:

构造函数注入适合“对象离不开这个依赖”;属性注入适合“对象可以先存在,依赖稍后再补”。

放回 WPF 时,页面 ViewModel 的必需服务优先从构造函数进来;可选功能再考虑属性。不要把属性注入当成“可以少写构造函数”的捷径。


4. 单接口多实现注入逻辑处理

1. 本节目标

同一个接口 IMessageService 有两个实现:

1
2
EmailMessageService
SmsMessageService

你要让容器根据一个“名字”决定拿哪一个实现。做完后看到:

1
2
多实现 Email:Email
多实现 Sms:Sms

2. 一句话原理

接口只规定“能做什么”,多个类可以给出不同做法。注册时加一个 key,就像给每个实现贴标签;解析时说出标签,就能拿到对应实现。

3. 要改哪里

顺序 文件 类/位置 要做什么
1 Services/IMessageService.cs 接口 保留统一接口
2 Services/EmailMessageService.cs 类 写邮件实现
3 Services/SmsMessageService.cs 类 写短信实现
4 Program.cs TestMultipleImplementations 用 key 注册和获取

4. 第一步:把测试入口接上

打开 Program.cs,在 Main 里加入:

1
TestMultipleImplementations();

下一步再写两个实现和测试方法。

5. 第二步:写两个实现

接口不变:

1
2
3
4
5
6
7
namespace SimpleIocDemo.Services
{
public interface IMessageService
{
string GetMessage();
}
}

新建 Services/EmailMessageService.cs:

1
2
3
4
5
6
7
8
9
10
namespace SimpleIocDemo.Services
{
public class EmailMessageService : IMessageService
{
public string GetMessage()
{
return "Email";
}
}
}

再新建 Services/SmsMessageService.cs:

1
2
3
4
5
6
7
8
9
10
namespace SimpleIocDemo.Services
{
public class SmsMessageService : IMessageService
{
public string GetMessage()
{
return "Sms";
}
}
}

两个类都实现同一个接口,所以对调用方来说,拿到的都是“能 GetMessage() 的服务”。

6. 第三步:用 key 注册并获取

打开 Program.cs,在 Program 类的方法区加入:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private static void TestMultipleImplementations()
{
var ioc = SimpleIoc.Default;
ioc.Reset();
ioc.Register<IMessageService>(
() => new EmailMessageService(), "Email");
ioc.Register<IMessageService>(
() => new SmsMessageService(), "Sms");

var email = ioc.GetInstance<IMessageService>("Email");
var sms = ioc.GetInstance<IMessageService>("Sms");
Console.WriteLine("多实现 Email:" + email.GetMessage());
Console.WriteLine("多实现 Sms:" + sms.GetMessage());
}

运行:

1
dotnet run --project .\示例代码\SimpleIocDemo\SimpleIocDemo.csproj -c Release

你应该看到:

1
2
多实现 Email:Email
多实现 Sms:Sms

7. 关键代码逐段看

代码 意思
() => new EmailMessageService() 工厂:容器真正需要时才创建
"Email" 这个实现的 key,也就是标签
Register<IMessageService>(factory, key) 同一个接口可以登记多个带 key 的实现
GetInstance<IMessageService>("Email") 按 key 选择具体实现
GetInstance<IMessageService>("Sms") 换一个 key,拿到另一个实现

为什么这里用工厂,而不是直接写两个 Register<IMessageService, ...>?因为两个实现对应同一个接口,如果只按类型注册,后一次可能覆盖前一次,你也无法清楚表达“我要哪一个”。key 让“接口类型”和“具体实现”之间多了一层选择。

你也可以把它想成菜单:IMessageService 是“饮料”这个类别,"Email" 和 "Sms" 是两个菜名。你说菜名,厨房才知道做哪一道。

8. 运行后应该看到什么

本章对应的真实输出是:

1
2
多实现 Email:Email
多实现 Sms:Sms

如果两个都输出同一个结果,先检查两次注册的 key 是否写成了同一个字符串,或者获取时是否都用了同一个 key。

9. 对应配图

单接口多实现的 key 选择

先看中间的 IMessageService,再顺着两条箭头看 "Email" 和 "Sms" 两个 key 分别指向哪个实现。底部提醒你:获取时的 key 必须和注册时一致。

10. 跟做检查点

  • 两个实现类都写了 : IMessageService。
  • 两次注册使用了不同的 key。
  • 获取时的 key 和注册时完全一致,包括大小写。
  • 没有忘记 ioc.Reset()。
  • 输出分别是 Email 和 Sms。

11. 常见错误

现象 原因 解决
两个结果一样 两次注册用了同一个 key 改成不同的 key
报“未找到 key” 获取时字符串拼错 逐字对照注册和获取
报“未注册” 只写了实现类,没有注册接口 用 Register<IMessageService>(..., key)
想改一个实现却改到另一个 两个类名很像 先看类名,再看 key,再看返回值
工厂里直接 new 了错误类型 复制后忘记改类名 检查 () => new ... 里的类

12. 小练习

新增一个 WeChatMessageService,返回 "WeChat",然后用 key "WeChat" 注册并获取。

这个练习只增加一个实现,目的是让你体会:调用方仍然只认识 IMessageService,变化被挡在注册区。

13. 小结与迁移

这一章要记住:

单接口多实现时,接口负责统一用法,key 负责选择具体实现。

放回 WPF 时,同一个“通知服务”可能对应邮件、短信、站内信。页面只依赖 INotificationService,具体用哪个实现由组合根或配置决定。不要把选择逻辑散落到每个按钮事件里。


运行验证

在项目根目录执行:

1
dotnet run --project .\示例代码\SimpleIocDemo\SimpleIocDemo.csproj -c Release

本次实际运行的完整输出是:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
SimpleIoc 单例:True
SimpleIoc ViewModel 单例:True
SimpleIoc 注入:Hello from SimpleIoc
SimpleIoc 已创建:True
SimpleIoc 反注册:True
SimpleIoc 工厂:True
无缓存服务不同:True
无缓存 ViewModel 不同:True
无缓存 ViewModel 内部服务相同:True
普通服务相同:True
三层依赖:Level1 -> Level2 -> Level3
SimpleIoc 自动属性注入:False
手动属性注入:Hello from SimpleIoc
多实现 Email:Email
多实现 Sms:Sms
自定义容器单例:True
自定义容器注入:Hello from SimpleIoc
自定义容器反注册:True
自定义容器重置:True
自定义容器属性注入:Hello from SimpleIoc
全部通过

其中 SimpleIoc 自动属性注入:False 是刻意保留的真实结果,用来说明当前 MvvmLight 版本不会自动做属性注入,而不是程序失败。

本次对参考代码的调整

参考项目的结构可以沿用,但自定义容器 MiniContainer 做了两处增强:

原写法 可能出现的问题 本次写法
只查工厂和缓存 循环依赖时可能一直递归 增加 _creating 集合,检测到环就抛异常
参数直接 Resolve 参数没注册时错误不够明确 先判断参数类型是否注册,再给出清楚提示

这两处增强不改变四章的主线,只是让“无限层级”有一个明确的停止条件。完整代码在附录。

最终检查清单

  • 四个章节标题和顺序与目录完全一致。
  • 每章都先写最小示例,再运行,再解释。
  • 能区分单例请求和瞬态请求。
  • 能解释三层构造函数依赖是怎么递归创建的。
  • 能说出手动属性注入和自动属性注入的区别。
  • 能用 key 选择同一个接口的不同实现。
  • 每章都有真实存在的本地图片。
  • 所有示例都来自实际项目,并且项目可以运行。

附录:完整示例代码

下面是 示例代码/SimpleIocDemo 当前实际使用的完整文件。正文为了循序渐进,只展示了关键片段;附录方便你在漏抄或报错时对照。

项目文件:SimpleIocDemo.csproj
1
2
3
4
5
6
7
8
9
10
11
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net48</TargetFramework>
<LangVersion>7.3</LangVersion>
</PropertyGroup>

<ItemGroup>
<PackageReference Include="MvvmLightLibs" Version="5.4.1.1" />
</ItemGroup>
</Project>
程序入口:Program.cs
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
using System;
using GalaSoft.MvvmLight.Ioc;
using SimpleIocDemo.Ioc;
using SimpleIocDemo.Services;
using SimpleIocDemo.ViewModels;

namespace SimpleIocDemo
{
internal static class Program
{
private static void Main()
{
TestSimpleIoc();
TestTransient();
TestNestedDependencies();
TestPropertyInjection();
TestMultipleImplementations();
TestMiniContainer();
Console.WriteLine("全部通过");
}

private static void TestNestedDependencies()
{
var ioc = SimpleIoc.Default;
ioc.Reset();
ioc.Register<Level1ViewModel>();
ioc.Register<Level2ViewModel>();
ioc.Register<Level3ViewModel>();

var level1 = ioc.GetInstance<Level1ViewModel>();
Console.WriteLine("三层依赖:" + level1.Text);
}

private static void TestPropertyInjection()
{
var ioc = SimpleIoc.Default;
ioc.Reset();
ioc.Register<IMessageService, MessageService>();
ioc.Register<PropertyInjectionViewModel>();

var viewModel = ioc.GetInstance<PropertyInjectionViewModel>();
Console.WriteLine("SimpleIoc 自动属性注入:" + (viewModel.MessageService != null));

var manual = new PropertyInjectionViewModel();
manual.MessageService = ioc.GetInstance<IMessageService>();
Console.WriteLine("手动属性注入:" + manual.Text);
}

private static void TestMultipleImplementations()
{
var ioc = SimpleIoc.Default;
ioc.Reset();
ioc.Register<IMessageService>(() => new EmailMessageService(), "Email");
ioc.Register<IMessageService>(() => new SmsMessageService(), "Sms");

var email = ioc.GetInstance<IMessageService>("Email");
var sms = ioc.GetInstance<IMessageService>("Sms");
Console.WriteLine("多实现 Email:" + email.GetMessage());
Console.WriteLine("多实现 Sms:" + sms.GetMessage());
}

private static void TestTransient()
{
var ioc = SimpleIoc.Default;
ioc.Reset();
ioc.Register<IMessageService, MessageService>();
ioc.Register<GreetingViewModel>();

var serviceA = ioc.GetInstanceWithoutCaching<IMessageService>();
var serviceB = ioc.GetInstanceWithoutCaching<IMessageService>();
Console.WriteLine("无缓存服务不同:" + (serviceA != serviceB));

var viewModelA = ioc.GetInstanceWithoutCaching<GreetingViewModel>();
var viewModelB = ioc.GetInstanceWithoutCaching<GreetingViewModel>();
Console.WriteLine("无缓存 ViewModel 不同:" + (viewModelA != viewModelB));
Console.WriteLine("无缓存 ViewModel 内部服务相同:" +
(viewModelA.MessageService == viewModelB.MessageService));

var normalA = ioc.GetInstance<IMessageService>();
var normalB = ioc.GetInstance<IMessageService>();
Console.WriteLine("普通服务相同:" + (normalA == normalB));
}

private static void TestSimpleIoc()
{
var ioc = SimpleIoc.Default;
ioc.Reset();
ioc.Register<IMessageService, MessageService>();
ioc.Register<GreetingViewModel>();

var first = ioc.GetInstance<IMessageService>();
var second = ioc.GetInstance<IMessageService>();
var viewModel = ioc.GetInstance<GreetingViewModel>();
var secondViewModel = ioc.GetInstance<GreetingViewModel>();

Console.WriteLine("SimpleIoc 单例:" + (first == second));
Console.WriteLine("SimpleIoc ViewModel 单例:" + (viewModel == secondViewModel));
Console.WriteLine("SimpleIoc 注入:" + viewModel.Text);
Console.WriteLine("SimpleIoc 已创建:" + ioc.ContainsCreated<IMessageService>());

ioc.Unregister<IMessageService>();
Console.WriteLine("SimpleIoc 反注册:" + !ioc.IsRegistered<IMessageService>());

ioc.Register<IMessageService>(() => new MessageService());
var factoryService = ioc.GetInstance<IMessageService>();
Console.WriteLine("SimpleIoc 工厂:" + (factoryService.GetMessage() == "Hello from SimpleIoc"));
}

private static void TestMiniContainer()
{
var container = new MiniContainer();
container.Register<IMessageService, MessageService>();
container.Register<GreetingViewModel, GreetingViewModel>();

var first = container.Resolve<GreetingViewModel>();
var second = container.Resolve<GreetingViewModel>();

Console.WriteLine("自定义容器单例:" + (first == second));
Console.WriteLine("自定义容器注入:" + first.Text);

container.Unregister<IMessageService>();
Console.WriteLine("自定义容器反注册:" + !container.IsRegistered<IMessageService>());

container.Reset();
Console.WriteLine("自定义容器重置:" + !container.IsRegistered<GreetingViewModel>());

container.Register<IMessageService, MessageService>();
container.Register<PropertyInjectionViewModel, PropertyInjectionViewModel>();
var propertyViewModel = container.Resolve<PropertyInjectionViewModel>();
container.InjectProperties(propertyViewModel);
Console.WriteLine("自定义容器属性注入:" + propertyViewModel.Text);
}
}
}
接口:Services/IMessageService.cs
1
2
3
4
5
6
7
namespace SimpleIocDemo.Services
{
public interface IMessageService
{
string GetMessage();
}
}
普通实现:Services/MessageService.cs
1
2
3
4
5
6
7
8
9
10
namespace SimpleIocDemo.Services
{
public class MessageService : IMessageService
{
public string GetMessage()
{
return "Hello from SimpleIoc";
}
}
}
邮件实现:Services/EmailMessageService.cs
1
2
3
4
5
6
7
8
9
10
namespace SimpleIocDemo.Services
{
public class EmailMessageService : IMessageService
{
public string GetMessage()
{
return "Email";
}
}
}
短信实现:Services/SmsMessageService.cs
1
2
3
4
5
6
7
8
9
10
namespace SimpleIocDemo.Services
{
public class SmsMessageService : IMessageService
{
public string GetMessage()
{
return "Sms";
}
}
}
问候 ViewModel:ViewModels/GreetingViewModel.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
using SimpleIocDemo.Services;

namespace SimpleIocDemo.ViewModels
{
public class GreetingViewModel
{
private readonly IMessageService _messageService;

public GreetingViewModel(IMessageService messageService)
{
_messageService = messageService;
}

public string Text
{
get { return _messageService.GetMessage(); }
}

public IMessageService MessageService
{
get { return _messageService; }
}
}
}
三层依赖 Level1:ViewModels/Level1ViewModel.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
namespace SimpleIocDemo.ViewModels
{
public class Level1ViewModel
{
private readonly Level2ViewModel _next;

public Level1ViewModel(Level2ViewModel next)
{
_next = next;
}

public string Text
{
get { return "Level1 -> " + _next.Text; }
}
}
}
三层依赖 Level2:ViewModels/Level2ViewModel.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
namespace SimpleIocDemo.ViewModels
{
public class Level2ViewModel
{
private readonly Level3ViewModel _next;

public Level2ViewModel(Level3ViewModel next)
{
_next = next;
}

public string Text
{
get { return "Level2 -> " + _next.Text; }
}
}
}
三层依赖 Level3:ViewModels/Level3ViewModel.cs
1
2
3
4
5
6
7
8
9
10
namespace SimpleIocDemo.ViewModels
{
public class Level3ViewModel
{
public string Text
{
get { return "Level3"; }
}
}
}
属性注入 ViewModel:ViewModels/PropertyInjectionViewModel.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
using SimpleIocDemo.Services;

namespace SimpleIocDemo.ViewModels
{
public class PropertyInjectionViewModel
{
public IMessageService MessageService { get; set; }

public string Text
{
get
{
return MessageService == null
? "属性还没有被注入"
: MessageService.GetMessage();
}
}
}
}
自定义容器:Ioc/MiniContainer.cs
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
using System;
using System.Collections.Generic;
using System.Linq;

namespace SimpleIocDemo.Ioc
{
public class MiniContainer
{
private readonly Dictionary<Type, Func<object>> _factories =
new Dictionary<Type, Func<object>>();

private readonly Dictionary<Type, object> _singletons =
new Dictionary<Type, object>();

private readonly HashSet<Type> _creating =
new HashSet<Type>();

public void Register<TInterface, TImplementation>()
where TImplementation : TInterface
{
_factories[typeof(TInterface)] = () => CreateInstance(typeof(TImplementation));
}

public void Register<TInterface>(Func<TInterface> factory)
{
_factories[typeof(TInterface)] = () => factory();
}

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

public bool IsRegistered<T>()
{
return _factories.ContainsKey(typeof(T));
}

public void Unregister<T>()
{
_factories.Remove(typeof(T));
_singletons.Remove(typeof(T));
}

public void Reset()
{
_factories.Clear();
_singletons.Clear();
_creating.Clear();
}

public void InjectProperties(object instance)
{
var properties = instance.GetType()
.GetProperties()
.Where(property => property.CanWrite && IsRegistered(property.PropertyType));

foreach (var property in properties)
{
property.SetValue(instance, Resolve(property.PropertyType), null);
}
}

private object Resolve(Type type)
{
object existing;
if (_singletons.TryGetValue(type, out existing))
{
return existing;
}

if (_creating.Contains(type))
{
throw new InvalidOperationException(
"检测到循环依赖:" + type.Name);
}

Func<object> factory;
if (!_factories.TryGetValue(type, out factory))
{
throw new InvalidOperationException(
"未注册类型:" + type.FullName);
}

_creating.Add(type);
try
{
var instance = factory();
_singletons[type] = instance;
return instance;
}
finally
{
_creating.Remove(type);
}
}

private bool IsRegistered(Type type)
{
return _factories.ContainsKey(type);
}

private object CreateInstance(Type type)
{
var constructors = type.GetConstructors();
if (constructors.Length == 0)
{
throw new InvalidOperationException(
"类型没有公开构造函数:" + type.FullName);
}

var constructor = constructors
.OrderByDescending(item => item.GetParameters().Length)
.First();

var parameters = constructor.GetParameters()
.Select(parameter =>
{
if (!IsRegistered(parameter.ParameterType))
{
throw new InvalidOperationException(
"类型 " + type.Name + " 需要 "
+ parameter.ParameterType.Name
+ ",但它还没有注册。");
}

return Resolve(parameter.ParameterType);
})
.ToArray();

return constructor.Invoke(parameters);
}
}
}