MVVM Light 数据绑定

[TOC]

概述

在使用 WPF 结合 MVVM Light 框架开发客户端时，最核心的需求之一就是实现后端数据模型 (Model) 与前端界面 (View) 的实时同步。在 MVVM 模式中，视图模型 (ViewModel) 作为桥梁，负责处理这种通信。而这一切的背后，都离不开 C# 提供的一套强大的通信机制。

这篇博客将深入探讨数据绑定的基石——委托 (Delegate) 与 事件 (Event)。理解它们的工作原理，是揭开 MVVM 数据绑定神秘面纱的第一步，也是最关键的一步。

委托 (Delegate) - C# 中的“方法容器”

在数据绑定的世界里，当一个数据发生变化时，需要有一种机制去“通知”所有关心这个变化的地方。委托，就是实现这种回调通知机制的基础。

什么是委托？

可以将委托 (Delegate) 理解为一个类型安全的方法指针或引用。它本身是一个类型（与 class、struct 地位相同），定义了一种特定的方法签名，包括方法的参数类型和返回值类型。

任何与委托签名相匹配的方法，都可以被装入这个委托的实例中，然后在未来的某个时刻被调用。

让我们来看一个例子。首先，我们定义一个委托类型 GreetOperation，它规定了“一个接受 string 参数且无返回值”的方法签名。

1
2
// 1. 定义一个委托类型，它指定了方法的签名：参数为 string，返回为 void。
public delegate void GreetOperation(string name);

接着，我们定义一个符合该签名的方法 Greet。

1
2
3
4
public static void Greet(string name)
{
    Console.WriteLine($"Hello, {name}!");
}

现在，我们可以创建委托的实例，并将 Greet 方法作为参数传入。此时，变量 greetDelegate 就持有了对 Greet 方法的引用。

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 System;

namespace HelloApp
{
    // 委托类型可以定义在类外部，因为它本身就是一个类型定义。
    public delegate void GreetOperation(string name);
    
    class Program
    {
        public static void Greet(string name)
        {
            Console.WriteLine($"Hello, {name}!");
        }

        static void Main(string[] args)
        {
            // 2. 创建委托的实例，将 Greet 方法“装”进去。
            GreetOperation greetDelegate = new GreetOperation(Greet);
            
            // 3. 通过委托实例调用方法，这会执行 Greet("John")。
            greetDelegate("John"); // 输出: Hello, John!
        }
    }
}

编译后，delegate 关键字会生成一个继承自 System.MulticastDelegate 的密封类 (sealed class)，这为委托可以引用多个方法（即多播）提供了基础。

委托的利器：多播 (Multicast)

委托最强大的功能之一是它可以同时引用多个方法。通过 + 或 += 运算符，可以将多个方法添加到同一个委托实例的调用列表中。当这个委托被调用时，所有被引用的方法会按照添加的顺序依次执行。

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
using System;

namespace HelloApp
{
    public delegate void GreetOperation(string name);
    
    class Program
    {
        public static void GreetInEnglish(string name)
        {
            Console.WriteLine($"Hello, {name}!");
        }

        public static void GreetInJapanese(string name)
        {
            Console.WriteLine($"こんにちは, {name}!");
        }

        static void Main(string[] args)
        {
            // 创建一个指向 GreetInEnglish 的委托实例
            GreetOperation multiGreet = GreetInEnglish; // 可以省略 new GreetOperation()

            // 2. 使用 += 将另一个方法添加到调用列表
            multiGreet += GreetInJapanese;

            // 3. 调用委托，两个方法都会被执行
            multiGreet("John");

            // 输出:
            // Hello, John!
            // こんにちは, John!
        }
    }
}

现代 C# 的快捷方式：Action 与 Func

每次都定义一个新的委托类型显得有些繁琐。为此，.NET 提供了两个内置的泛型委托：

  • Action<T>：用于引用没有返回值 (void) 的方法。它有多个重载，如 Action (无参数), Action<T1> (一个参数), Action<T1, T2> (两个参数) 等。
  • Func<T, TResult>：用于引用有返回值的方法。最后一个泛型参数是返回值的类型。

使用 Action<string>，我们可以重写第一个例子，而无需定义 GreetOperation 委托：

1
2
3
4
5
// 无需再手动定义 GreetOperation
// public delegate void GreetOperation(string name);

Action<string> greetDelegate = Greet;
greetDelegate("John");

在现代 C# 编程中，除非有特殊的语义化需求，否则推荐优先使用 Action 和 Func。

事件 (Event) - 更安全的委托

虽然委托很强大，但如果直接将其作为 public 成员暴露给外部类，会存在一些风险：

  1. 外部可以清空订阅列表：外部代码可以通过 myObject.MyDelegate = null; 将所有订阅者移除。
  2. 外部可以直接调用委托：外部代码可以随时随地触发通知，这破坏了类的封装性，通知应该由类自身在特定时机发出。

为了解决这些问题，C# 引入了 事件 (event) 关键字。

什么是事件？

事件可以看作是对委托的一层封装，它为委托提供了更安全的访问机制。事件本身不是一个类型，而是类的成员，它像一个“公告板”，外部代码可以向它“订阅”（+=）或“取消订阅”（-=），但只有类的内部才能“发布公告”（触发事件）。

这种模式被称为发布-订阅模式 (Publisher-Subscriber Pattern)。

事件的实践

让我们用事件来重构之前的例子。

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
using System;

namespace HelloApp
{
    // 定义用于事件的委托类型（或直接使用 Action<string>）
    public delegate void GreetOperation(string name);

    class Notifier
    {
        // 1. 在类中定义事件。
        // event 关键字限制了外部访问，只能 += 和 -=
        // '?' 表示这是一个可空的引用类型 (Nullable Reference Type)
        public event GreetOperation? OnGreeting;

        public void Greet(string name)
        {
            Console.WriteLine($"Hello, {name}!");
        }

        public void Greet2(string name)
        {
            Console.WriteLine($"Nice to meet you, {name}!");
        }

        // 2. 只有类的内部可以触发事件。
        public void RaiseGreeting(string name)
        {
            Console.WriteLine("I'm about to raise the greeting event!");
            // 3. 使用 ?.Invoke() 安全地触发事件。
            // 如果 OnGreeting 为 null (没有任何订阅者)，则不会执行 Invoke，避免了异常。
            OnGreeting?.Invoke(name);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var notifier = new Notifier();

            // 4. 从外部订阅事件
            notifier.OnGreeting += notifier.Greet;
            notifier.OnGreeting += notifier.Greet2;

            // 下面这行代码会产生编译错误，因为事件不能在外部直接调用
            // notifier.OnGreeting?.Invoke("John"); // Error!

            // 必须通过类本身的方法来触发
            notifier.RaiseGreeting("John");
        }
    }
}

在上面的代码中，我们遇到了两次 ?，它们含义不同：

  1. public event GreetOperation? OnGreeting;：这里的 ? 是 可空引用类型修饰符。它告诉编译器，OnGreeting 这个事件变量在没有订阅者时，其值为 null 是正常的，请不要为此产生编译警告。
  2. OnGreeting?.Invoke(name);：这里的 ?. 是 null 条件运算符。它是一个语法糖，等价于 if (OnGreeting != null) { OnGreeting.Invoke(name); }。这是一种线程安全的、简洁的检查方式，确保只有在至少有一个订阅者时才触发事件。

数据绑ンの魔法 - INotifyPropertyChanged 接口

我们已经知道，当数据变化时需要一种“通知”机制。在 WPF 的 MVVM 世界里，这种机制有一个标准化的实现方式，它就是 .NET 框架提供的核心接口：INotifyPropertyChanged。

数据绑定的基本图景

让我们先描绘一幅数据绑定的宏观图像。整个流程涉及三个关键角色：

  1. ViewModel (发布者)：数据的持有者。当其内部数据（例如一个用户名字段）发生变化时，它有责任向外界“广播”一个通知。
  2. View (订阅者)：UI 界面。它“收听”来自 ViewModel 的广播。
  3. WPF 绑定引擎 (邮差)：WPF 框架的核心部分 (System.Windows.Data.Binding)。它负责监听 ViewModel 的通知，一旦收到，就立即从 ViewModel 获取最新的数据，并更新到 View 上对应的 UI 元素。

这个“广播”和“收听”的约定，就是通过 INotifyPropertyChanged 接口来建立的。

契约：INotifyPropertyChanged 接口

接口在 C# 中定义了一套必须被遵守的“契约”。任何类只要实现了 INotifyPropertyChanged 接口，就等于向外界承诺：“嘿，我会提供一个名为 PropertyChanged 的事件。当你关心我的属性变化时，请订阅它。”

这个接口的定义极其简单：

1
2
3
4
5
6
public interface INotifyPropertyChanged
{
    // 它只包含一个成员：一个名为 PropertyChanged 的事件。
    // 这个事件使用的委托类型是 PropertyChangedEventHandler。
    event PropertyChangedEventHandler? PropertyChanged;
}

任何一个 ViewModel 类，只要继承这个接口并实现其要求，WPF 的数据绑定引擎就能识别并与之交互。

手动实现 INotifyPropertyChanged (原理剖析)

为了彻底理解其工作原理，我们先手动实现一次。假设我们有一个 MainViewModel，它包含一个 Title 属性。

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 System.ComponentModel;

public class MainViewModel : INotifyPropertyChanged
{
    // 1. 实现接口要求的事件
    public event PropertyChangedEventHandler? PropertyChanged;

    private string _title = "Default Title";
    public string Title
    {
        get => _title;
        set
        {
            // 2. 检查值是否真的改变了，避免不必要的通知和潜在的死循环
            if (_title != value)
            {
                _title = value;
                
                // 3. 直接、明确地触发事件，通知 "Title" 属性已变更
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Title)));
            }
        }
    }
}

我们在 set 访问器内部直接调用了 PropertyChanged?.Invoke。这是整个通知机制最核心、最原始的形态。

让我们把这行核心代码拆开来看：PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Title)));

  • PropertyChanged?：这用到了之前提到过的 null 条件运算符。PropertyChanged 是一个事件，如果没有订阅者，它就是 null。? 确保了只有在事件不为 null（即至少有一个订阅者）时，才会继续执行后面的 .Invoke，从而避免了 NullReferenceException。

  • .Invoke(sender, e)：这是触发事件的标准方法。它需要两个参数：

    • sender: 事件的发送方。我们传入 this，表示就是当前这个 ViewModel 实例的属性发生了变化。
    • e: 事件的参数，一个 PropertyChangedEventArgs 对象。它携带了关于事件的额外信息。

  • new PropertyChangedEventArgs(nameof(Title))：我们创建了一个事件参数对象。它的构造函数需要一个字符串，这个字符串至关重要，它告知绑定引擎具体是哪一个属性发生了变化。

    • nameof(Title): 这里的 nameof 是一个 C# 编译器关键字，它会在编译时获取 Title 这个属性的名称并生成字符串 "Title"。相比于手动硬编码 "Title"，使用 nameof 的优势在于：如果以后使用重构工具将 Title 属性改名为 Header，IDE 会自动把 nameof(Title) 变成 nameof(Header)。

绑定引擎何时订阅事件？

我们可能疑惑，我们只看到了触发事件的代码，却从未写过 viewModel.PropertyChanged += ... 这样的订阅代码。那么绑定引擎是在何时、如何订阅的呢？

答案是：当我们在 XAML 中声明一个绑定时，WPF 绑定引擎会自动完成订阅。

例如，当 XAML 解析器遇到这样一行代码：

1
<TextBlock Text="{Binding Title}" />

绑定引擎会执行以下步骤：

  1. 找到当前 TextBlock 的 DataContext（通常就是我们的 ViewModel 实例）。
  2. 通过反射检查 DataContext 对象的类型是否实现了 INotifyPropertyChanged 接口。
  3. 如果实现了，绑定引擎就会自动用 += 运算符来订阅 PropertyChanged 事件。
  4. 从此，每当 ViewModel 的 Title 属性变化并触发事件时，绑定引擎就会收到通知，并自动更新 TextBlock 的 Text 属性。

MVVM Light 的优雅实现：ViewModelBase 与 Set 方法

手动为每一个属性编写 set 访问器中的通知逻辑是非常繁琐和重复的。这正是 MVVM Light 这类框架的价值所在——它将这些模板化的代码封装了起来。

在 MVVM Light 中，我们通常让 ViewModel 继承 ViewModelBase 类。

1
2
3
4
5
6
7
8
9
public class MainViewModel: ViewModelBase
{
    private float _temperature;
    public float temperature
    {
        get => _temperature;
        set => Set(ref _temperature, value);
    }
}

ViewModelBase (或其基类 ObservableObject) 已经为我们实现了 INotifyPropertyChanged 接口。它提供的 SetProperty (或 Set) 方法是一个通用的辅助方法，其内部逻辑与我们之前手动实现的过程完全一样：

  1. 比较新值与旧值：检查传入的 value 是否与当前的字段 _title 相等。
  2. 更新字段：如果值不相等，则将新值赋给字段。
  3. 触发通知：调用内部的 RaisePropertyChanged 方法，并利用 [CallerMemberName] 特性自动获取属性名 "Title"，最终触发 PropertyChanged 事件。

这种方式极大地简化了代码，让我们能更专注于业务逻辑本身。

流程总览：一次完整的绑定更新过程

下面是一个时序图，清晰地展示了从用户操作到 UI 更新的整个闭环。

sequenceDiagram
    participant View as View (UI)
    participant BindingEngine as WPF Binding Engine
    participant ViewModel as MainViewModel
    
    Note over View, ViewModel: 初始化: BindingEngine已订阅ViewModel的PropertyChanged事件

    View->>ViewModel: 用户操作触发Command (e.g., ChangeTitleCommand)
    ViewModel->>ViewModel: Command执行, 调用 Title 的 set 访问器
    Note right of ViewModel: Title = "New Value";

    ViewModel->>ViewModel: set => SetProperty(ref _title, "New Value")
    Note right of ViewModel: SetProperty内部: 
1. 比较新旧值
2. 更新_title字段
3. 调用RaisePropertyChanged("Title")

    ViewModel-->>BindingEngine: 触发 PropertyChanged 事件 (sender: this, e: PropertyChangedEventArgs("Title"))
    
    BindingEngine->>ViewModel: 收到通知, 读取 Title 属性的新值
    Note right of BindingEngine: Get new value: "New Value"

    BindingEngine->>View: 更新UI控件的属性 (e.g., TextBlock.Text)
    Note left of View: UI 界面刷新显示 "New Value"

数据

双向绑定原理

sequenceDiagram
    participant UDP as UDP数据源
    participant Model as FirstPageModel : ObservableObject
    participant VM as FirstPageViewModel : ViewModelBase
    participant View as XAML View

    UDP->>Model: Temperature 属性 setter 被调用 (85)
    Model-->>Model: 调用 Set(ref _temperature, 85)
    Model-->>Model: RaisePropertyChanged("Temperature")
    Model->>Model: 触发 INotifyPropertyChanged.PropertyChanged("Temperature")

    Model->>VM: VM 订阅到 PropertyChanged("Temperature")
    VM-->>VM: RaisePropertyChanged("TemperatureText")
    VM->>VM: 触发 INotifyPropertyChanged.PropertyChanged("TemperatureText")

    VM->>View: 通知绑定引擎属性变化
    View-->>View: Binding 引擎重新取 TemperatureText
    View-->>View: UI 刷新显示 "85.0 ℃"