WPF绑定数据源学习笔记

面向已经完成基础数据绑定练习，准备继续学习数据源提供器、XML、DataContext 和 RelativeSource 的读者。
推荐环境：.NET 10 LTS + WPF。随附示例使用 net9.0-windows，以便在当前安装了 .NET 9 SDK 的电脑上直接编译。这里用到的绑定机制在 .NET 9 和 .NET 10 中没有变化。
最后更新：2026-10-19

目录

1. 基于对象方法的数据源使用
2. 基于 XML 数据的数据源使用
3. DataContext 数据源使用
4. RelativeSource 数据源使用
5. RelativeSource 对象参数说明

---

写在前面

这份笔记解决什么问题

前一篇《WPF 数据绑定学习笔记》回答的是“绑定怎样把值和界面连起来”。这一篇继续回答一个更具体的问题：

绑定表达式里的来源对象，到底从哪里来？

同样一句：

<TextBlock Text="{Binding Name}" />

在不同位置可能从 DataContext 取数据，也可能从资源里的方法返回值、XML 节点或某个祖先控件取数据。只要来源选错，界面通常不会报出醒目的错误，而是安静地显示空白。

本篇用五种来源建立一条完整路线：

来源写法	来源是什么	适合什么场景
ObjectDataProvider	某个对象方法的返回值	调用现有服务、查询方法
XmlDataProvider	XML 文档中的节点或属性	读取结构化配置、外部 XML
DataContext	元素继承来的默认来源	ViewModel、表单、列表
RelativeSource	自己、祖先或模板父控件	控件之间取属性、模板内部绑定
Source 显式来源	直接写出的对象或资源	不依赖 DataContext 的固定来源

建议的学习顺序

1. 先直接运行随附示例，把五个页签各点一遍。
2. 再回到第 1 章，从零建立一个最小项目。
3. 每完成一章，就在自己的项目中增加一个页签。
4. 最后故意改错一个类型或路径，观察“输出”窗口里的绑定错误。

绑定不是只看正确结果。能看懂失败原因，才算真正掌握。

示例项目位置

C:\Users\North\Desktop\WPF学习笔记\示例代码\WpfBindingSourceDemo

运行方式：

cd "C:\Users\North\Desktop\WPF学习笔记\示例代码\WpfBindingSourceDemo"
dotnet build
dotnet run

如果使用 Visual Studio：

1. 打开 WpfBindingSourceDemo.csproj。
2. 确认启动项目是 WpfBindingSourceDemo。
3. 按 F5 以调试方式启动。
4. 打开“输出”窗口，把显示来源切换为“调试”，绑定错误会显示在这里。

2026 年的目标框架

新项目如果安装了 .NET 10 SDK，推荐：

<TargetFramework>net10.0-windows</TargetFramework>

如果电脑上只有 .NET 9 SDK，就使用：

<TargetFramework>net9.0-windows</TargetFramework>

本篇示例已经在 .NET 9 上编译并启动验证。把目标框架改成 .NET 10 后，本文的 XAML 和 C# 代码不需要修改。

实际示例项目文件还开启了两个现代 C# 常用设置：

<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>

它们不是数据绑定的要求，但可以减少空引用问题，并让常用的 System、System.Linq 等命名空间自动可用。

先分清“来源”和“来源提供器”

这两个词很容易混在一起：

词	作用	例子
来源对象	真正提供值的对象	MainViewModel、Employee、XML 节点
来源提供器	负责创建或取出来源对象的对象	ObjectDataProvider、XmlDataProvider

例如：

<ObjectDataProvider x:Key="EmployeesFromMethod"
                    ObjectType="{x:Type services:EmployeeService}"
                    MethodName="GetEmployees"/>

这里 ObjectDataProvider 是提供器，GetEmployees() 返回的 IReadOnlyList<Employee> 才是绑定实际读取的来源。

准备一套最小数据模型

为了让五章使用同一套数据，先准备员工模型。新建 Models/Employee.cs：

using System.ComponentModel;
using System.Runtime.CompilerServices;

namespace WpfBindingSourceDemo.Models;

public class Employee : INotifyPropertyChanged
{
    private string _name = string.Empty;
    private string _department = string.Empty;
    private decimal _salary;

    public int Id { get; set; }

    public string Name
    {
        get => _name;
        set => SetField(ref _name, value);
    }

    public string Department
    {
        get => _department;
        set => SetField(ref _department, value);
    }

    public decimal Salary
    {
        get => _salary;
        set => SetField(ref _salary, value);
    }

    public event PropertyChangedEventHandler? PropertyChanged;

    private void SetField<T>(
        ref T field,
        T value,
        [CallerMemberName] string? propertyName = null)
    {
        if (EqualityComparer<T>.Default.Equals(field, value))
        {
            return;
        }

        field = value;
        PropertyChanged?.Invoke(
            this,
            new PropertyChangedEventArgs(propertyName));
    }
}

再新建 Services/EmployeeService.cs：

using System.Collections.ObjectModel;
using WpfBindingSourceDemo.Models;

namespace WpfBindingSourceDemo.Services;

public class EmployeeService
{
    private readonly ObservableCollection<Employee> _employees = new()
    {
        new() { Id = 1, Name = "张三", Department = "研发部", Salary = 12000m },
        new() { Id = 2, Name = "李四", Department = "产品部", Salary = 10500m },
        new() { Id = 3, Name = "王五", Department = "设计部", Salary = 9800m },
        new() { Id = 4, Name = "赵六", Department = "测试部", Salary = 9200m }
    };

    public IReadOnlyList<Employee> GetEmployees()
    {
        return _employees;
    }

    public Employee? GetTopEmployee()
    {
        return _employees
            .OrderByDescending(employee => employee.Salary)
            .FirstOrDefault();
    }

    public decimal GetAverageSalary()
    {
        return _employees.Count == 0
            ? 0
            : _employees.Average(employee => employee.Salary);
    }

    public ObservableCollection<Employee> GetEmployeeCollection()
    {
        return _employees;
    }
}

注意：Employee 使用 INotifyPropertyChanged，集合使用 ObservableCollection<T>。绑定可以负责同步，但来源对象必须能发出“值已经变化”的通知。

示例还创建了一个简单的 Models/RelativeSourceParameterRow.cs，只用于第 5 章的参数表：

namespace WpfBindingSourceDemo.Models;

public sealed class RelativeSourceParameterRow
{
    public required string Name { get; init; }

    public required string Meaning { get; init; }

    public required string Mode { get; init; }
}

required 让编译器检查对象初始化时是否填写了必要属性，适合这种只读的说明数据。

---

1. 基于对象方法的数据源使用

本节目标

学完本节，你应该能够：

• 解释 ObjectDataProvider 的作用。
• 用 ObjectType 和 MethodName 调用对象方法。
• 把方法返回的集合绑定到 ListBox 或 DataGrid。
• 把方法返回的单个对象或值绑定到 TextBlock。
• 知道 MethodParameters 和 Refresh() 什么时候使用。
• 区分“调用一次方法”和“方法结果发生变化”。

1.1 为什么需要方法数据源

假设项目里已经有这样的服务：

public IReadOnlyList<Employee> GetEmployees()

最直接的做法是在窗口构造函数里调用：

EmployeeList.ItemsSource = service.GetEmployees();

这样可以运行，但会把“取数据”和“控件赋值”写在一起。XAML 里的方法数据源提供了另一种方式：

XAML 声明调用哪个对象、哪个方法
        |
        v
ObjectDataProvider 执行方法
        |
        v
返回值成为 Binding.Source

适合使用它的场景：

• 方法返回一个固定集合。
• 方法返回一个计算结果。
• 想用纯 XAML 快速演示或搭建原型。
• 已有服务对象，暂时不想额外建立 ViewModel 属性。

如果方法结果需要频繁变化、需要复杂参数或需要异步加载，通常还是放在 ViewModel 中更清楚。

1.2 对象方法数据源的完整关系

图 1：​​ObjectDataProvider​​ * 把服务方法的结果连接到绑定目标。*

可以记成三步：

1. ObjectType 指定创建哪个类型的对象。
2. MethodName 指定调用这个对象上的哪个方法。
3. 方法的返回值成为绑定表达式的来源。

1.3 第一步：准备项目

在 PowerShell 中执行：

cd "C:\Users\North\Desktop\WPF学习笔记\示例代码"
dotnet new wpf -n WpfBindingSourceDemo -o .\WpfBindingSourceDemo --framework net9.0

如果目录里已经有项目，不要重复创建。直接打开现有项目即可。

创建后确认项目中存在：

WpfBindingSourceDemo.csproj
App.xaml
App.xaml.cs
MainWindow.xaml
MainWindow.xaml.cs

再把前面准备好的 Models/Employee.cs 和 Services/EmployeeService.cs 放进去。

1.4 第二步：在 XAML 中声明 ObjectDataProvider

打开 MainWindow.xaml，先在 Window.Resources 中声明：

<Window.Resources>
    <ObjectDataProvider x:Key="EmployeesFromMethod"
                        ObjectType="{x:Type services:EmployeeService}"
                        MethodName="GetEmployees"/>
</Window.Resources>

还需要在窗口根标签上注册 services 命名空间：

xmlns:services="clr-namespace:WpfBindingSourceDemo.Services"

逐项解释：

部分	含义
x:Key	给资源起名字，供 StaticResource 引用
ObjectType	要实例化的类型
MethodName	要调用的无参方法
GetEmployees	方法名，不带括号

注意 MethodName 写的是方法名，不是 GetEmployees()。XAML 属性值是字符串，括号不属于方法名。

1.5 第三步：绑定方法返回的集合

在页签中加入：

<ListBox ItemsSource="{Binding Source={StaticResource EmployeesFromMethod}}"
         DisplayMemberPath="Name"/>

这行绑定可以拆成：

Source = 资源 EmployeesFromMethod 的结果
Path   = 没有写，默认是来源本身
目标   = ListBox.ItemsSource

因为 GetEmployees() 返回集合，ItemsSource 会得到集合中的每个 Employee。DisplayMemberPath="Name" 告诉列表显示员工的 Name 属性。

1.6 方法返回单个对象时怎样绑定

再声明一个提供器：

<ObjectDataProvider x:Key="TopEmployeeFromMethod"
                    ObjectType="{x:Type services:EmployeeService}"
                    MethodName="GetTopEmployee"/>

绑定到返回对象的属性：

<TextBlock Text="{Binding Source={StaticResource TopEmployeeFromMethod},
                          Path=Name}"/>

这里发生了两件事：

1. 方法返回一个 Employee。
2. Path=Name 读取这个员工的姓名。

如果方法返回 decimal 这类简单值，可以不写 Path：

<ObjectDataProvider x:Key="AverageSalaryFromMethod"
                    ObjectType="{x:Type services:EmployeeService}"
                    MethodName="GetAverageSalary"/>

<TextBlock Text="{Binding Source={StaticResource AverageSalaryFromMethod},
                          StringFormat={}{0:C0}}"/>

StringFormat 只负责显示格式，不改变来源值。

1.7 方法需要参数时怎么办

ObjectDataProvider 支持 MethodParameters。例如服务中增加：

public IReadOnlyList<Employee> GetEmployeesByDepartment(string department)
{
    return _employees
        .Where(employee => employee.Department == department)
        .ToList();
}

XAML 可以写成：

<ObjectDataProvider x:Key="DevelopmentEmployees"
                    ObjectType="{x:Type services:EmployeeService}"
                    MethodName="GetEmployeesByDepartment">
    <ObjectDataProvider.MethodParameters>
        <system:String>研发部</system:String>
    </ObjectDataProvider.MethodParameters>
</ObjectDataProvider>

同时注册：

xmlns:system="clr-namespace:System;assembly=System.Runtime"

参数必须和方法签名匹配。参数类型不正确时，提供器不会得到预期结果，调试输出里通常能看到异常信息。

1.8 为什么修改集合后界面不一定刷新

ObjectDataProvider 的方法只执行一次，返回值会成为来源。后续集合内部发生变化时，是否刷新取决于返回值本身是否能通知变化。

对比：

方法返回值	新增一项后是否自动刷新
List<Employee>	不一定，列表本身不提供集合变化通知
ObservableCollection<Employee>	会通知集合变化
每次重新调用方法	需要重新执行提供器

示例中的服务内部保存 ObservableCollection<Employee>，所以集合变化可以被观察到。若方法每次返回新的普通 List<T>，绑定不会凭空知道列表内容已经改变。

1.9 Refresh 方法的作用

如果来源对象的方法结果需要重新计算，可以调用：

if (Resources["EmployeesFromMethod"] is ObjectDataProvider provider)
{
    provider.Refresh();
}

在示例里，这段代码放在按钮事件中：

<Button Content="刷新方法结果"
        Click="RefreshObjectProvider_Click"/>

Refresh() 会重新调用提供器的方法。它不会自动监听服务内部所有字段，也不会替你把普通属性变成可通知属性。

1.10 跟做检查点

完成本节后，运行程序并确认：

检查项	预期结果
打开“对象方法”页签	列表显示张三、李四、王五、赵六
查看最高工资员工	显示张三
查看平均工资	显示格式化后的金额
点击“刷新方法结果”	方法重新执行，界面仍正常显示

如果列表为空，按顺序检查：

1. ObjectType 的命名空间是否写对。
2. MethodName 是否与方法名完全一致。
3. 方法是否是无参方法，或者是否提供了正确的 MethodParameters。
4. 返回集合是否为空。
5. “输出”窗口是否有绑定或方法调用异常。

小练习

1. 给服务增加 GetEmployeeCount()，返回员工数量，并绑定到 TextBlock。
2. 把 GetEmployees() 改成按部门查询，使用 MethodParameters 传入“研发部”。
3. 点击按钮调用 Refresh()，观察方法中的日志输出次数。

---

2. 基于 XML 数据的数据源使用

本节目标

学完本节，你应该能够：

• 用 XmlDataProvider 读取内嵌 XML。
• 用 XPath 选择节点集合。
• 用 @属性名 读取 XML 属性。
• 用子元素路径读取 XML 元素文本。
• 解释 XML 数据源的只读特性和常见限制。

2.1 什么时候使用 XML 数据源

XmlDataProvider 适合：

• 配置文件、菜单结构、离线数据包。
• 已经存在 XML 文件，不想先转换成实体类。
• 需要按 XPath 快速选取节点。
• 做 XML 结构演示或小型工具。

如果数据来自数据库、Web API 或复杂业务对象，通常优先转换为强类型对象，再绑定到属性。XML 绑定灵活，但字段类型、编辑和验证都不如实体类直观。

2.2 XML 数据源的结构

图 2：XML 使用 XPath 选节点，DataContext 使用元素树继承默认来源。

XML 里有两类常见数据：

<Employee Name="陈晨">
    <Department>研发部</Department>
</Employee>

数据	写法	XPath
XML 属性	Name="陈晨"	@Name
XML 元素文本	<Department>研发部</Department>	Department

先分清“属性”和“子元素”，后面的 XPath 才不会写错。

2.3 第一步：声明内嵌 XML

在 Window.Resources 中加入：

<XmlDataProvider x:Key="XmlEmployees"
                 XPath="Employees/Employee">
    <x:XData>
        <Employees xmlns="">
            <Employee Id="1"
                      Name="陈晨"
                      Department="研发部"
                      Salary="13000"/>
            <Employee Id="2"
                      Name="林雪"
                      Department="产品部"
                      Salary="10800"/>
            <Employee Id="3"
                      Name="周航"
                      Department="设计部"
                      Salary="9600"/>
            <Employee Id="4"
                      Name="吴越"
                      Department="测试部"
                      Salary="9000"/>
        </Employees>
    </x:XData>
</XmlDataProvider>

要点：

• x:XData 用来放置内嵌 XML 数据。
• 根元素上的 xmlns="" 清空默认 XAML 命名空间，避免 XML 被当作 XAML 对象解析。
• XPath="Employees/Employee" 选中所有 Employee 节点。
• XML 中的字段先用字符串保存，显示时由绑定完成格式化。

内嵌 XML 在 XAML 编辑器里可能出现蓝色波浪线，这通常只是编辑器对 x:XData 的类型推断提示。只要项目能够构建并正常显示数据，就说明运行时的 XML 结构有效。

2.4 第二步：绑定节点集合

<ListBox ItemsSource="{Binding Source={StaticResource XmlEmployees}}">
    <ListBox.ItemTemplate>
        <DataTemplate>
            <Grid Margin="4,8">
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="100"/>
                    <ColumnDefinition Width="*"/>
                    <ColumnDefinition Width="150"/>
                </Grid.ColumnDefinitions>

                <TextBlock Text="{Binding XPath=@Name}"
                           FontWeight="SemiBold"/>
                <TextBlock Grid.Column="1"
                           Text="{Binding XPath=@Department}"
                           Foreground="#5D6B82"/>
                <TextBlock Grid.Column="2"
                           Text="{Binding XPath=@Salary,
                                            StringFormat={}{0:C0}}"
                           HorizontalAlignment="Right"/>
            </Grid>
        </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>

ItemsSource 得到的是节点集合。模板中的每一项是一个 Employee XML 节点，所以模板里的绑定使用 XPath，而不是普通对象属性路径。

2.5 第三步：理解 XPath 绑定

常用 XPath 对照：

写法	含义
Employees/Employee	选择 Employees 下的所有 Employee
@Name	当前节点的 Name 属性
@Department	当前节点的 Department 属性
Name	当前节点的 Name 子元素
Employee[1]	第一个 Employee 元素
Employee[@Department='研发部']	按属性筛选

示例数据把字段写成属性，因此模板里必须写 @Name。如果写成 XPath=Name，绑定会去找名为 Name 的子元素，而不是属性，结果通常是空白。

2.6 读取外部 XML 文件

如果 XML 已经保存在文件中，可以把 Source 指向文件：

<XmlDataProvider x:Key="XmlFromFile"
                 Source="Data/employees.xml"
                 XPath="Employees/Employee"/>

文件路径要相对于应用程序工作目录或使用正确的 URI。部署时还要确认 XML 文件已被复制到输出目录。

在项目文件中可加入：

<ItemGroup>
    <None Update="Data/employees.xml">
        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
</ItemGroup>

内嵌 XML 适合演示，外部文件适合真实配置。两者绑定语法相同，差别在数据从哪里加载。

2.7 XML 数据源的编辑限制

XmlDataProvider 擅长读取，不等于天然适合编辑表单。

常见情况：

操作	难度
显示 XML 节点	简单
按 XPath 读取字段	简单
直接修改节点并写回文件	需要额外代码
类型转换和业务验证	不如实体类直接

如果界面需要频繁新增、删除、校验和保存员工，建议先把 XML 解析为 Employee 对象，再使用普通对象绑定。

2.8 跟做检查点

运行程序，打开“XML”页签：

检查项	预期结果
列表是否显示四名员工	陈晨、林雪、周航、吴越
部门是否显示	研发部、产品部、设计部、测试部
工资是否显示	右对齐的金额

如果复制一份模板做试验，把 @Name 改成 Name，姓名会变为空白。这是因为示例字段是 XML 属性，不是子元素。不要害怕看到空白，先查看“输出”窗口，再把代码改回来。

小练习

1. 在 XML 中增加一名员工，确认列表自动出现。
2. 把 XPath 改成只选研发部员工。
3. 把字段从 XML 属性改成子元素，再把绑定从 @Name 改成 Name。

---

3. DataContext 数据源使用

本节目标

学完本节，你应该能够：

• 在窗口级设置 DataContext。
• 解释 DataContext 的继承。
• 在局部元素上覆盖 DataContext。
• 区分 DataContext、Source 和 Path。
• 使用双向绑定编辑员工信息。
• 排查“为什么绑定没有值”的常见原因。

3.1 DataContext 是默认来源

DataContext 是 FrameworkElement 上的依赖属性，也是绑定系统最常用的默认来源。

<TextBlock Text="{Binding Name}" />

这行没有写 Source，WPF 会沿着元素树向上寻找最近的 DataContext，再从它身上读取 Name。

TextBlock
   |
   v
最近的 DataContext
   |
   v
DataContext.Name

3.2 第一步：建立 MainViewModel

新建 ViewModels/MainViewModel.cs：

using System.ComponentModel;
using System.Runtime.CompilerServices;
using WpfBindingSourceDemo.Models;
using WpfBindingSourceDemo.Services;

namespace WpfBindingSourceDemo.ViewModels;

public class MainViewModel : INotifyPropertyChanged
{
    private string _windowTitle = "WPF 绑定数据源实验台";
    private string _displayName = "DataContext 示例";
    private Employee? _selectedEmployee;

    public MainViewModel()
    {
        EmployeeService = new EmployeeService();
        Employees = EmployeeService.GetEmployees();
        SelectedEmployee = Employees.FirstOrDefault();
    }

    public EmployeeService EmployeeService { get; }

    public IReadOnlyList<Employee> Employees { get; }

    public Employee? SelectedEmployee
    {
        get => _selectedEmployee;
        set
        {
            if (ReferenceEquals(_selectedEmployee, value))
            {
                return;
            }

            _selectedEmployee = value;
            OnPropertyChanged();
        }
    }

    public string WindowTitle
    {
        get => _windowTitle;
        set => SetField(ref _windowTitle, value);
    }

    public string DisplayName
    {
        get => _displayName;
        set => SetField(ref _displayName, value);
    }

    public event PropertyChangedEventHandler? PropertyChanged;

    private void SetField<T>(
        ref T field,
        T value,
        [CallerMemberName] string? propertyName = null)
    {
        if (EqualityComparer<T>.Default.Equals(field, value))
        {
            return;
        }

        field = value;
        OnPropertyChanged(propertyName);
    }

    private void OnPropertyChanged(
        [CallerMemberName] string? propertyName = null)
    {
        PropertyChanged?.Invoke(
            this,
            new PropertyChangedEventArgs(propertyName));
    }
}

MainViewModel 负责页面状态：当前选中员工、窗口标题、显示名称。业务数据仍交给 EmployeeService。

如果跟着做的是随附项目，MainViewModel 还包含 RelativeSourceParameterRows，供第 5 章的参数表使用。那部分只是普通的只读集合，不影响本章的 DataContext 演示。

3.3 第二步：在窗口上设置 DataContext

在 MainWindow.xaml 的根标签下写：

<Window.DataContext>
    <viewModels:MainViewModel/>
</Window.DataContext>

并在根标签注册：

xmlns:viewModels="clr-namespace:WpfBindingSourceDemo.ViewModels"

这样窗口内的绑定默认都从 MainViewModel 读取：

<TextBlock Text="{Binding WindowTitle}"/>
<TextBlock Text="{Binding DisplayName}"/>

3.4 第三步：观察 DataContext 的继承

DataContext 会沿元素树向下继承：

<Window>
    <Grid>
        <StackPanel>
            <TextBlock Text="{Binding DisplayName}"/>
        </StackPanel>
    </Grid>
</Window>

Grid 和 StackPanel 没有单独设置 DataContext，它们会继续使用窗口上的 MainViewModel。所以 TextBlock 的 Binding 仍然能找到 DisplayName。

继承的不是控件，而是“默认来源”。每个元素的绑定都可以继续向上找最近的 DataContext。

3.5 第四步：局部覆盖 DataContext

在员工编辑区，把来源切换为当前选中的员工：

<StackPanel DataContext="{Binding SelectedEmployee}">
    <TextBox Text="{Binding Name,
                           Mode=TwoWay,
                           UpdateSourceTrigger=PropertyChanged}"/>
    <TextBox Text="{Binding Department,
                           Mode=TwoWay,
                           UpdateSourceTrigger=PropertyChanged}"/>
</StackPanel>

这里的 DataContext="{Binding SelectedEmployee}" 有一个关键点：

右边的 Binding 先相对于外层 DataContext 求值
求值结果是 Employee
再把 Employee 设为 StackPanel 的 DataContext

于是内部的 {Binding Name} 就变成“当前 Employee 的 Name”，不再从 MainViewModel 找 Name。

3.6 第五步：区分 DataContext 和 Source

两种写法都能绑定同一个员工，但来源选择方式不同：

<!-- 依赖默认来源 -->
<TextBlock DataContext="{Binding SelectedEmployee}"
           Text="{Binding Name}"/>

<!-- 显式指定来源 -->
<TextBlock Text="{Binding Source={StaticResource TopEmployeeFromMethod},
                          Path=Name}"/>

写法	来源确定方式	适合
{Binding Name}	当前元素继承的 DataContext	页面和 ViewModel
Source=...	明确写出资源或对象	固定来源、跨层引用
ElementName=...	按元素名找来源	同一界面控件互绑
RelativeSource=...	按元素关系找来源	自己、祖先、模板

不要把所有绑定都写成 Source。页面级数据通常让 DataContext 负责，局部固定来源再用 Source，代码会更容易维护。

如果显式来源是一个已经创建的对象，也可以用 x:Reference 引用命名元素：

<TextBlock x:Name="EmployeeSummary"
           Text="{Binding Source={x:Reference EmployeeSummary},
                          Path=Tag}"
           Tag="命名元素作为来源"/>

x:Reference 和 ElementName 都能按名字找元素。前者常用于资源或模板中的引用，后者在普通页面绑定中更直观。

3.7 第六步：为什么修改 TextBox 后列表也会变

示例的编辑区使用双向绑定：

Mode=TwoWay
UpdateSourceTrigger=PropertyChanged

含义：

设置	作用
Mode=TwoWay	界面和来源双向同步
UpdateSourceTrigger=PropertyChanged	每次输入就写回来源
Employee.Name 的 setter	发出 PropertyChanged

三者缺一不可：

1. 只写 Mode=TwoWay，默认可能在失焦时才写回。
2. 没有通知，列表不会知道员工姓名已经变化。
3. 没有 setter，来源值根本不会被更新。

3.8 DataContext 常见错误

错误	现象	修正
忘记设置 DataContext	绑定没有值	在窗口或父元素设置来源
局部覆盖后仍写外层属性	找不到属性	检查当前元素的最近 DataContext
绑定路径大小写错误	输出窗口提示找不到属性	C# 属性名区分大小写
把普通字段当属性绑定	找不到成员	使用公开属性，不用字段
忘记通知	首次有值，修改后不更新	实现 INotifyPropertyChanged
在错误层级设置 DataContext	一部分绑定正常，一部分空白	从目标元素向上找最近的来源

3.9 跟做检查点

运行程序，打开“DataContext”页签：

检查项	预期结果
修改 DisplayName	“当前显示”同步变化
选择不同员工	下方编辑区切换到对应员工
修改姓名	上方列表中的姓名同步变化
修改部门	列表中的部门同步变化
修改工资	列表中的工资同步变化

如果切换员工后编辑框仍显示上一个人的内容，优先检查 SelectedEmployee 是否发出通知，以及编辑区的 DataContext 是否绑定到 SelectedEmployee。

小练习

1. 给 MainViewModel 增加 Greeting 属性，并绑定到标题。
2. 在编辑区外层增加一个 Border，观察 DataContext 是否继续继承。
3. 把局部 DataContext 改成 SelectedEmployee.Name，观察哪些绑定会失效，再改回来。

---

4. RelativeSource 数据源使用

本节目标

学完本节，你应该能够：

• 用 RelativeSource Self 读取元素自己的属性。
• 用 FindAncestor 查找指定类型的祖先。
• 用 AncestorLevel 选择第几个匹配祖先。
• 用 TemplatedParent 在模板内部读取控件属性。
• 知道 PreviousData 的用途和限制。
• 判断什么时候应该用 RelativeSource，什么时候直接用 ElementName。

4.1 RelativeSource 解决什么问题

ElementName 需要一个名字：

<TextBlock Text="{Binding ElementName=TitleBox, Path=Text}"/>

但有些场景没有方便的名字：

• 模板内部的元素不知道外面控件的名字。
• 子元素需要读取祖先窗口或容器的属性。
• 元素要读取自己的另一个属性。

RelativeSource 用“关系”描述来源，而不是写对象名：

自己        -> Self
某个祖先    -> FindAncestor
模板父控件  -> TemplatedParent
前一个数据  -> PreviousData

4.2 常见的查找路线

图 3：​​Self​​ 、​​FindAncestor​​ * 和 ​​TemplatedParent​​ * 对应不同的来源关系。

4.3 Self：来源就是元素自己

<TextBlock Text="{Binding RelativeSource={RelativeSource Self},
                          Path=Tag}"
           Tag="Self 示例：TextBlock 读取自己的 Tag"/>

含义：

来源 = 当前 TextBlock
路径 = Tag
目标 = Text

Self 适合：

• 一个属性依赖同一个元素的另一个属性。
• 控件内部需要显示自身配置。
• 用 Tag 暂存演示值。

注意：Self 查找的是目标元素本身，不是父元素。AncestorType 不要和 Self 混用。

4.4 FindAncestor：向上找祖先

查找最近的窗口：

<TextBlock Text="{Binding RelativeSource={RelativeSource FindAncestor,
                                                  AncestorType={x:Type Window}},
                          Path=Title}"/>

关系可以画成：

TextBlock
   |
   v
Border
   |
   v
StackPanel
   |
   v
Window  <- 第一个匹配的 Window

AncestorType 表示“要找什么类型”，不是“直接父元素”。WPF 会从当前元素开始向上查找，直到找到匹配类型的祖先。

4.5 AncestorLevel：第几个匹配祖先

看两层 Border：

<Border Tag="外层 Border">
    <Border Tag="内层 Border">
        <TextBlock Text="{Binding RelativeSource={RelativeSource FindAncestor,
                                                          AncestorType={x:Type Border},
                                                          AncestorLevel=2},
                                  Path=Tag}"/>
    </Border>
</Border>

查找顺序：

顺序	元素	AncestorLevel
1	内层 Border	1
2	外层 Border	2

因此 AncestorLevel=2 读到的是外层 Border 的 Tag。

AncestorLevel 不是“向上跳两层”，而是“找到的第二个匹配类型祖先”。这个区别很重要。

4.6 TemplatedParent：模板内部读取控件

先定义一个按钮模板：

<Style x:Key="RelativeTemplateButton"
       TargetType="Button">
    <Setter Property="Template">
        <Setter.Value>
            <ControlTemplate TargetType="Button">
                <Border Background="#EAF1FF"
                        BorderBrush="#2F6FED"
                        BorderThickness="1"
                        CornerRadius="8"
                        Padding="16">
                    <TextBlock Text="{Binding RelativeSource={RelativeSource TemplatedParent},
                                              Path=Content}"
                               Foreground="#174EA6"
                               FontWeight="SemiBold"/>
                </Border>
            </ControlTemplate>
        </Setter.Value>
    </Setter>
</Style>

再使用：

<Button Content="模板中的 Content"
        Style="{StaticResource RelativeTemplateButton}"/>

模板里的 TextBlock 不是按钮本身，而是按钮模板生成的内容。通过 TemplatedParent，它可以访问应用模板的 Button，再读取 Content。

适合场景：

• 自定义控件模板。
• 模板内部显示控件已有属性。
• 不想通过 TemplateBinding 时，使用更灵活的绑定路径。

TemplatedParent 通常只在 ControlTemplate 内部有意义。在普通页面元素上使用它，往往找不到合适的父控件。

4.7 PreviousData：前一个数据项

PreviousData 用于数据项之间比较，例如显示当前值和上一项的差异：

<TextBlock Text="{Binding RelativeSource={RelativeSource PreviousData},
                          Path=Salary}"/>

它通常出现在 ItemsControl 的 ItemTemplate 中。第一项没有前一项，绑定结果可能为空，需要自己处理。对普通初学者项目，先把 Self、FindAncestor 和 TemplatedParent 用熟，再尝试 PreviousData。

4.8 跟做检查点

打开“RelativeSource”页签：

检查项	预期结果
Self 区域	显示 TextBlock 自己的 Tag
查找 Window	显示窗口标题
两层 Border	显示“外层 Border”
模板按钮	显示按钮的 Content

如果祖先查找失败：

1. 确认 AncestorType 类型正确。
2. 确认目标元素确实在该类型的子树中。
3. 确认 AncestorLevel 没有超过实际匹配数量。
4. 查看“输出”窗口中的绑定错误。

小练习

1. 把 AncestorLevel 从 2 改成 1，观察显示变化。
2. 把 AncestorType 从 Window 改成 Grid，确认能否找到最近的 Grid 祖先。
3. 把模板中的 TemplatedParent 绑定改成 TemplateBinding Content，比较两种写法。

---

5. RelativeSource 对象参数说明

本节目标

学完本节，你应该能够：

• 说出 RelativeSource 常用参数的含义。
• 根据查找方式选择正确参数。
• 写出 Self、FindAncestor、TemplatedParent 的完整语法。
• 识别参数与模式不匹配的错误。
• 用调试输出定位祖先查找失败。

5.1 RelativeSource 的参数表

参数	含义	适用模式
Mode	选择查找方式	所有写法
AncestorType	指定祖先类型	FindAncestor
AncestorLevel	选择第几个匹配祖先	FindAncestor
TemplatedParent	指向套用模板的控件	TemplatedParent
PreviousData	指向数据项中的前一项	PreviousData

不要把这张表当成“每个绑定都要写全部参数”。大多数写法只需要两三个参数。

5.2 Mode 参数

Mode 决定查找策略：

Mode	来源
Self	当前元素
FindAncestor	当前元素的祖先
TemplatedParent	模板的父控件
PreviousData	数据集合中的前一个数据项

最简写法：

<TextBlock Text="{Binding RelativeSource={RelativeSource Self},
                          Path=Tag}"
           Tag="自己"/>

当 Mode 是 FindAncestor 时，通常必须同时给出 AncestorType。

5.3 AncestorType 参数

<TextBlock Text="{Binding RelativeSource={RelativeSource FindAncestor,
                                                  AncestorType={x:Type Window}},
                          Path=Title}"/>

AncestorType 的值是类型，不是字符串名字。因此要写：

AncestorType={x:Type Window}

如果写成了别的类型，绑定会找不到祖先。找不到时通常不会抛出显眼的异常，而是让目标属性保持默认值。

5.4 AncestorLevel 参数

<TextBlock Text="{Binding RelativeSource={RelativeSource FindAncestor,
                                                  AncestorType={x:Type Border},
                                                  AncestorLevel=2},
                          Path=Tag}"/>

AncestorLevel 从最近的匹配祖先开始计数，默认是 1。

对比：

AncestorLevel=1 -> 最近的 Border
AncestorLevel=2 -> 第二近的 Border
AncestorLevel=3 -> 第三近的 Border

如果祖先层级不够，绑定失败。

5.5 TemplatedParent 参数

<TextBlock Text="{Binding RelativeSource={RelativeSource TemplatedParent},
                          Path=Content}"/>

它只应该在模板内部使用。模板外的元素通常没有“模板父控件”这个概念。

如果只是想读取控件已有属性，TemplateBinding 更短：

<TextBlock Text="{TemplateBinding Content}"/>

两者区别可以先这样理解：

写法	特点
TemplateBinding	简短，常用于模板属性转发
RelativeSource TemplatedParent	更灵活，可以继续写复杂路径和绑定选项

5.6 PreviousData 参数

<TextBlock Text="{Binding RelativeSource={RelativeSource PreviousData},
                          Path=Name}"/>

PreviousData 依赖数据项上下文，通常放在 ItemsControl 的模板中。第一项没有前一项，绑定结果需要允许为空。

5.7 常用完整写法

<!-- 当前元素自己 -->
<TextBlock Text="{Binding RelativeSource={RelativeSource Self},
                          Path=Tag}"/>

<!-- 模板父控件 -->
<TextBlock Text="{Binding RelativeSource={RelativeSource TemplatedParent},
                          Path=Content}"/>

<!-- 最近的 Window -->
<TextBlock Text="{Binding RelativeSource={RelativeSource FindAncestor,
                                                  AncestorType={x:Type Window},
                                                  AncestorLevel=1},
                          Path=Title}"/>

<!-- 前一个数据项 -->
<TextBlock Text="{Binding RelativeSource={RelativeSource PreviousData},
                          Path=Name}"/>

5.8 参数与模式匹配表

你写了什么	是否正确	说明
Self + Path	正确	读取自己另一个属性
FindAncestor + AncestorType	正确	按类型向上查找
FindAncestor + AncestorLevel	正确	指定第几个匹配祖先
Self + AncestorType	错误	Self 不需要祖先类型
TemplatedParent + AncestorType	通常错误	模板父控件不是按祖先查找
只写 FindAncestor	不完整	缺少 AncestorType，通常找不到目标
模板外写 TemplatedParent	通常无效	没有模板父控件

5.9 常见错误与排查

错误一：把 AncestorLevel 当成层级数

错误理解：

向上跳两层

正确理解：

找到第二个类型匹配的祖先

如果中间还有其他类型，它们不会占用 AncestorLevel 的计数。

错误二：在普通元素上使用 TemplatedParent

<!-- 错误示例：不在 ControlTemplate 内 -->
<TextBlock Text="{Binding RelativeSource={RelativeSource TemplatedParent},
                          Path=Content}"/>

这个 TextBlock 没有模板父控件，绑定通常不会得到想要的值。把它放进 ControlTemplate，或改用 ElementName / DataContext。

错误三：祖先不存在

<TextBlock Text="{Binding RelativeSource={RelativeSource FindAncestor,
                                                  AncestorType={x:Type ListView}},
                          Path=Tag}"/>

如果当前元素根本不在 ListView 内，绑定找不到祖先。先检查元素树，再检查类型。

错误四：附加属性路径没有括号

绑定附加属性时，路径通常要加括号：

<TextBlock Text="{Binding RelativeSource={RelativeSource Self},
                          Path=(local:MyAttached.Value)}"/>

普通属性直接写名字，附加属性用 (类型.属性)。

错误五：只看界面，不看输出

绑定失败往往不会弹窗。打开“输出”窗口，筛选 System.Windows.Data Error，通常会看到：

Cannot find source for binding with reference
Cannot find governing FrameworkElement or FrameworkContentElement

先读错误，再改 XAML，比盲目尝试快很多。

5.10 跟做检查点

打开“参数说明”页签：

检查项	预期结果
参数表是否显示	五条参数及其适用模式
常用写法是否完整	四种写法都能看到
复制 RelativeSource 写法	参数组合与模式保持一致
检查 AncestorType	只和 FindAncestor 配合

想观察失败情况，可以把练习副本中的 AncestorType 改成不存在的类型。对应文本会为空，调试时可以在“输出”窗口看到绑定错误。不要直接改随附项目里的可用示例。

小练习

1. 做一个 Self 绑定，让 TextBlock 显示自己的 FontSize。
2. 做两个嵌套 Grid，用 AncestorLevel 读取外层 Grid 的 Tag。
3. 在一个简单 ControlTemplate 中分别使用 TemplateBinding 和 TemplatedParent，比较结果。

---

完整示例结构

本篇示例项目的主要文件：

文件	作用
Models/Employee.cs	员工模型，提供属性变化通知
Models/RelativeSourceParameterRow.cs	第 5 章参数表的行模型
Services/EmployeeService.cs	提供员工集合、最高工资和平均工资
ViewModels/MainViewModel.cs	页面状态、选中员工、参数表数据
MainWindow.xaml	五个页签和所有绑定示例
MainWindow.xaml.cs	刷新 ObjectDataProvider 的事件处理

MainWindow.xaml 的关键部分

窗口级 DataContext：

<Window.DataContext>
    <viewModels:MainViewModel/>
</Window.DataContext>

对象方法数据源：

<ObjectDataProvider x:Key="EmployeesFromMethod"
                    ObjectType="{x:Type services:EmployeeService}"
                    MethodName="GetEmployees"/>

XML 数据源：

<XmlDataProvider x:Key="XmlEmployees"
                 XPath="Employees/Employee">
    <x:XData>
        <Employees xmlns="">
            <Employee Id="1"
                      Name="陈晨"
                      Department="研发部"
                      Salary="13000"/>
        </Employees>
    </x:XData>
</XmlDataProvider>

MainWindow.xaml.cs 的完整代码

using System.Windows;
using System.Windows.Data;

namespace WpfBindingSourceDemo;

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    private void RefreshObjectProvider_Click(
        object sender,
        RoutedEventArgs e)
    {
        if (Resources["EmployeesFromMethod"] is ObjectDataProvider provider)
        {
            provider.Refresh();
        }
    }
}

---

运行检查表

检查项	预期结果
执行 dotnet build	显示 0 个错误
启动程序	出现五个页签
页签 1 查看列表	显示四名员工
页签 1 查看最高工资	显示张三
页签 1 点击刷新	方法重新执行，界面正常
页签 2 查看 XML 列表	显示四名 XML 员工
页签 2 检查部门	显示 XML 属性值
页签 3 修改 DisplayName	当前显示同步变化
页签 3 选择员工	编辑区切换
页签 3 修改姓名	列表同步更新
页签 4 查看 Self	显示自己的 Tag
页签 4 查看祖先	显示窗口标题或外层 Border
页签 4 查看模板按钮	显示按钮 Content
页签 5 查看参数表	五条参数说明完整

---

三个综合练习

练习一：做一个对象方法查询面板

要求：

• 服务增加按部门查询的方法。
• 用 ObjectDataProvider.MethodParameters 传入部门。
• 用按钮重新执行查询。
• 在界面显示结果数量。

这个练习可以检验“方法参数”和“提供器刷新”。

练习二：把 XML 数据转成员工对象

要求：

• 读取 XML 节点。
• 转换为 Employee 集合。
• 用普通属性绑定显示。
• 修改员工对象时，界面能通知变化。

完成后比较 XML 直接绑定和对象绑定的差异。

练习三：做一个 RelativeSource 小实验台

要求：

• 用 Self 显示自身属性。
• 用 FindAncestor 显示窗口标题。
• 用 AncestorLevel 读取外层容器。
• 用 TemplatedParent 在模板中显示控件内容。

每完成一个，就在旁边写一句“来源是谁”，比只看结果更有帮助。

---

结语

数据源看起来有五种入口，实际上可以归为三个问题：

来源对象是谁？
绑定怎样找到它？
它变化时，绑定怎样知道？

对象方法数据源由 ObjectDataProvider 创建和调用；XML 数据源由 XmlDataProvider 和 XPath 读取；DataContext 提供默认来源并沿元素树继承；RelativeSource 按元素关系查找自己、祖先或模板父控件。

初学时不要急着把所有写法都背下来。先让每个页签跑起来，再故意改错路径、类型和层级，观察输出窗口。能把“为什么没有值”查清楚，你对 WPF 数据绑定的理解就已经向前走了一大步。