跳至主要內容

依赖属性 DependencyProperty

SunnyFan大约 13 分钟约 3930 字

依赖属性 DependencyProperty

简介

依赖属性（DependencyProperty）是 WPF 属性系统的核心。与普通 CLR 属性不同，依赖属性支持数据绑定、样式、动画、继承、默认值等 WPF 核心功能。自定义控件时必须使用依赖属性才能参与 WPF 的属性系统。

特点

基本用法

定义依赖属性

/// <summary>
/// 自定义控件中的依赖属性
/// </summary>
public class WatermarkTextBox : TextBox
{
    // 1. 声明依赖属性（静态只读）
    public static readonly DependencyProperty WatermarkProperty =
        DependencyProperty.Register(
            name: nameof(Watermark),          // 属性名
            propertyType: typeof(string),     // 属性类型
            ownerType: typeof(WatermarkTextBox), // 所属类型
            typeMetadata: new FrameworkPropertyMetadata(
                defaultValue: "请输入...",       // 默认值
                flags: FrameworkPropertyMetadataOptions.AffectsRender, // 影响渲染
                propertyChangedCallback: OnWatermarkChanged           // 变更回调
            ));

    // 2. CLR 属性包装器
    public string Watermark
    {
        get => (string)GetValue(WatermarkProperty);
        set => SetValue(WatermarkProperty, value);
    }

    // 3. 变更回调（静态方法）
    private static void OnWatermarkChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var control = (WatermarkTextBox)d;
        var newValue = (string)e.NewValue;
        // 属性值变化时的处理逻辑
        control.UpdateWatermarkVisual(newValue);
    }

    private void UpdateWatermarkVisual(string watermark)
    {
        // 更新水印显示
    }
}

使用自定义控件

<!-- 使用自定义的 WatermarkTextBox -->
<local:WatermarkTextBox Watermark="请输入用户名"
                        Text="{Binding UserName, UpdateSourceTrigger=PropertyChanged}"
                        Width="200" Height="30"/>

注册选项

PropertyMetadata 选项

/// <summary>
/// 依赖属性注册选项详解
/// </summary>

// 基本注册
public static readonly DependencyProperty SimpleProperty =
    DependencyProperty.Register(
        "Simple", typeof(string), typeof(MyControl));

// 带默认值
public static readonly DependencyProperty WithDefaultProperty =
    DependencyProperty.Register(
        "WithDefault", typeof(int), typeof(MyControl),
        new PropertyMetadata(0)); // 默认值 0

// 带变更回调
public static readonly DependencyProperty WithCallbackProperty =
    DependencyProperty.Register(
        "WithCallback", typeof(bool), typeof(MyControl),
        new PropertyMetadata(false, OnWithCallbackChanged));

// FrameworkPropertyMetadata — 更多选项
public static readonly DependencyProperty AdvancedProperty =
    DependencyProperty.Register(
        "Advanced", typeof(double), typeof(MyControl),
        new FrameworkPropertyMetadata(
            defaultValue: 0.0,
            flags: FrameworkPropertyMetadataOptions.AffectsMeasure  // 影响布局
                   | FrameworkPropertyMetadataOptions.AffectsRender, // 影响渲染
            propertyChangedCallback: OnAdvancedChanged,
            coerceValueCallback: CoerceAdvanced    // 强制值回调
        ));

// 强制值回调 — 限制值范围
private static object CoerceAdvanced(DependencyObject d, object baseValue)
{
    var value = (double)baseValue;
    return Math.Clamp(value, 0.0, 100.0); // 限制在 0-100 之间
}

FrameworkPropertyMetadataOptions 标志

标志说明
AffectsMeasure影响测量，值变化时重新测量
AffectsArrange影响排列
AffectsRender影响渲染，值变化时重绘
Inherits属性值可被子元素继承
BindsTwoWayByDefault默认双向绑定

只读依赖属性

定义只读属性

/// <summary>
/// 只读依赖属性 — 如 IsMouseOver、IsChecked 等
/// </summary>
public class ToggleButton : Control
{
    // 1. 使用 RegisterReadOnly
    private static readonly DependencyPropertyKey IsPressedPropertyKey =
        DependencyProperty.RegisterReadOnly(
            "IsPressed",
            typeof(bool),
            typeof(ToggleButton),
            new FrameworkPropertyMetadata(false));

    // 2. 只读属性暴露给外部
    public static readonly DependencyProperty IsPressedProperty =
        IsPressedPropertyKey.DependencyProperty;

    // 3. CLR 包装 — 只有 get
    public bool IsPressed
    {
        get => (bool)GetValue(IsPressedProperty);
        // 内部通过 Key 设置
        protected set => SetValue(IsPressedPropertyKey, value);
    }

    // 在内部逻辑中设置只读属性
    protected override void OnMouseDown(MouseButtonEventArgs e)
    {
        base.OnMouseDown(e);
        SetValue(IsPressedPropertyKey, true);
    }

    protected override void OnMouseUp(MouseButtonEventArgs e)
    {
        base.OnMouseUp(e);
        SetValue(IsPressedPropertyKey, false);
    }
}

附加属性

定义附加属性

/// <summary>
/// 附加属性 — 可以给任何元素添加属性
/// 如 Grid.Row、Canvas.Left 等都是附加属性
/// </summary>
public class WatermarkService
{
    // 注册附加属性
    public static readonly DependencyProperty WatermarkProperty =
        DependencyProperty.RegisterAttached(
            "Watermark",
            typeof(string),
            typeof(WatermarkService),
            new PropertyMetadata(string.Empty, OnWatermarkChanged));

    // Get 方法
    public static string GetWatermark(DependencyObject obj)
        => (string)obj.GetValue(WatermarkProperty);

    // Set 方法
    public static void SetWatermark(DependencyObject obj, string value)
        => obj.SetValue(WatermarkProperty, value);

    // 变更回调
    private static void OnWatermarkChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is TextBox textBox)
        {
            textBox.GotFocus -= RemoveWatermark;
            textBox.LostFocus -= ShowWatermark;

            if (!string.IsNullOrEmpty(e.NewValue?.ToString()))
            {
                textBox.GotFocus += RemoveWatermark;
                textBox.LostFocus += ShowWatermark;
                ShowWatermark(textBox, null);
            }
        }
    }

    private static void RemoveWatermark(object sender, RoutedEventArgs e)
    {
        var textBox = (TextBox)sender;
        if (textBox.Text == GetWatermark(textBox))
        {
            textBox.Text = string.Empty;
            textBox.Foreground = Brushes.Black;
        }
    }

    private static void ShowWatermark(object? sender, RoutedEventArgs? e)
    {
        var textBox = (TextBox)sender!;
        if (string.IsNullOrEmpty(textBox.Text))
        {
            textBox.Text = GetWatermark(textBox);
            textBox.Foreground = Brushes.Gray;
        }
    }
}

使用附加属性

<!-- 给任何 TextBox 添加水印 -->
<TextBox WatermarkService.Watermark="请输入用户名" Width="200"/>
<TextBox WatermarkService.Watermark="请输入密码" Width="200"/>

<!-- 给 PasswordBox 添加水印 -->
<PasswordBox WatermarkService.Watermark="请确认密码" Width="200"/>

实际应用

1. 自定义进度条

/// <summary>
/// 圆形进度条控件
/// </summary>
public class CircularProgress : Control
{
    static CircularProgress()
    {
        DefaultStyleKeyProperty.OverrideMetadata(
            typeof(CircularProgress),
            new FrameworkPropertyMetadata(typeof(CircularProgress)));
    }

    public static readonly DependencyProperty ValueProperty =
        DependencyProperty.Register(
            "Value", typeof(double), typeof(CircularProgress),
            new FrameworkPropertyMetadata(0.0, FrameworkPropertyMetadataOptions.AffectsRender,
                OnValueChanged, CoerceValue));

    public static readonly DependencyProperty MaximumProperty =
        DependencyProperty.Register(
            "Maximum", typeof(double), typeof(CircularProgress),
            new FrameworkPropertyMetadata(100.0, FrameworkPropertyMetadataOptions.AffectsRender));

    public static readonly DependencyProperty StrokeThicknessProperty =
        DependencyProperty.Register(
            "StrokeThickness", typeof(double), typeof(CircularProgress),
            new FrameworkPropertyMetadata(10.0, FrameworkPropertyMetadataOptions.AffectsRender));

    public static readonly DependencyProperty ProgressColorProperty =
        DependencyProperty.Register(
            "ProgressColor", typeof(Brush), typeof(CircularProgress),
            new FrameworkPropertyMetadata(Brushes.Green));

    public double Value
    {
        get => (double)GetValue(ValueProperty);
        set => SetValue(ValueProperty, value);
    }

    public double Maximum
    {
        get => (double)GetValue(MaximumProperty);
        set => SetValue(MaximumProperty, value);
    }

    public double StrokeThickness
    {
        get => (double)GetValue(StrokeThicknessProperty);
        set => SetValue(StrokeThicknessProperty, value);
    }

    public Brush ProgressColor
    {
        get => (Brush)GetValue(ProgressColorProperty);
        set => SetValue(ProgressColorProperty, value);
    }

    private static void OnValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        // 值变化时触发动画或其他逻辑
    }

    private static object CoerceValue(DependencyObject d, object baseValue)
    {
        var control = (CircularProgress)d;
        var value = (double)baseValue;
        return Math.Clamp(value, 0, control.Maximum);
    }
}
<!-- 使用 -->
<local:CircularProgress Value="75" Maximum="100"
                         StrokeThickness="12"
                         ProgressColor="#4CAF50"
                         Width="120" Height="120"/>

2. 绑定到命令的附加属性

/// <summary>
/// 让 ListView/DataGrid 的双击触发命令
/// </summary>
public class ItemDoubleClickService
{
    public static readonly DependencyProperty CommandProperty =
        DependencyProperty.RegisterAttached(
            "Command", typeof(ICommand), typeof(ItemDoubleClickService),
            new PropertyMetadata(null, OnCommandChanged));

    public static ICommand GetCommand(DependencyObject obj)
        => (ICommand)obj.GetValue(CommandProperty);

    public static void SetCommand(DependencyObject obj, ICommand value)
        => obj.SetValue(CommandProperty, value);

    private static void OnCommandChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is ListView listView)
        {
            listView.PreviewMouseDoubleClick -= OnDoubleClick;
            if (e.NewValue is ICommand)
            {
                listView.PreviewMouseDoubleClick += OnDoubleClick;
            }
        }
    }

    private static void OnDoubleClick(object sender, MouseButtonEventArgs e)
    {
        var listView = (ListView)sender;
        var command = GetCommand(listView);
        var selectedItem = listView.SelectedItem;

        if (command?.CanExecute(selectedItem) == true)
        {
            command.Execute(selectedItem);
        }
    }
}

依赖属性 vs CLR 属性

特性依赖属性CLR 属性
数据绑定支持不支持
样式/模板支持不支持
动画支持不支持
值继承支持不支持
变更通知自动回调需 INotifyPropertyChanged
内存按类型存储，节省内存每个实例一份
默认值统一管理需手动初始化

3. 依赖属性的值优先级

WPF 依赖属性有一套严格的值优先级系统，理解它对调试属性值至关重要。

优先级从高到低（1 最高）：
1. 强制值回调（CoerceValueCallback）
2. 属性系统动画值
3. 本地值（XAML 或代码中直接设置的值）
4. TemplateParent 模板中的值
5. Implicit Style 隐式样式
6. Style Triggers 样式触发器
7. Template Triggers 模板触发器
8. Style Setters 样式设置器
9. 默认样式（Theme Style）触发器
10. 默认样式设置器
11. 属性值继承（Inheritance）
12. 默认值（PropertyMetadata 中的 defaultValue）
// 演示值优先级
public class PriorityDemo : Control
{
    public static readonly DependencyProperty StatusProperty =
        DependencyProperty.Register(
            "Status", typeof(string), typeof(PriorityDemo),
            new FrameworkPropertyMetadata("默认值", FrameworkPropertyMetadataOptions.Inherits));

    public string Status
    {
        get => (string)GetValue(StatusProperty);
        set => SetValue(StatusProperty, value);
    }

    // 读取当前属性值的基础值（忽略动画）
    public string GetBaseValue()
    {
        return (string)GetBaseValue(StatusProperty);
    }

    // 检查属性是否有本地值
    public bool HasLocalValue()
    {
        return ReadLocalValue(StatusProperty) != DependencyProperty.UnsetValue;
    }

    // 清除本地值，恢复到低优先级的值
    public void ClearLocalValue()
    {
        ClearValue(StatusProperty);
    }
}

4. 共享依赖属性

多个类可以共享同一个依赖属性，减少重复定义。

// 基类定义依赖属性
public class BaseControl : Control
{
    public static readonly DependencyProperty CornerRadiusProperty =
        DependencyProperty.Register(
            "CornerRadius", typeof(CornerRadius), typeof(BaseControl),
            new FrameworkPropertyMetadata(new CornerRadius(0), FrameworkPropertyMetadataOptions.AffectsRender));

    public CornerRadius CornerRadius
    {
        get => (CornerRadius)GetValue(CornerRadiusProperty);
        set => SetValue(CornerRadiusProperty, value);
    }
}

// 子类通过 AddOwner 共享该属性（无需重新注册）
public class EnhancedButton : Button
{
    // 共享 BaseControl 的 CornerRadius 属性
    public static readonly DependencyProperty CornerRadiusProperty =
        BaseControl.CornerRadiusProperty.AddOwner(
            typeof(EnhancedButton),
            new FrameworkPropertyMetadata(new CornerRadius(4), FrameworkPropertyMetadataOptions.AffectsRender));

    public CornerRadius CornerRadius
    {
        get => (CornerRadius)GetValue(CornerRadiusProperty);
        set => SetValue(CornerRadiusProperty, value);
    }
}

5. 依赖属性与验证

public class ValidatedControl : Control
{
    public static readonly DependencyProperty ProgressProperty =
        DependencyProperty.Register(
            "Progress", typeof(double), typeof(ValidatedControl),
            new FrameworkPropertyMetadata(0.0, FrameworkPropertyMetadataOptions.AffectsRender,
                null,                    // PropertyChangedCallback
                CoerceProgress,          // CoerceValueCallback
                true),                   // 是否用于动画
            ValidateProgress);           // ValidateValueCallback（静态验证）

    public double Progress
    {
        get => (double)GetValue(ProgressProperty);
        set => SetValue(ProgressProperty, value);
    }

    // ValidateValueCallback — 全局验证（不持有实例引用）
    // 在 Coerce 之前执行，返回 false 会抛出 ArgumentException
    private static bool ValidateProgress(object value)
    {
        var d = (double)value;
        return !double.IsNaN(d) && !double.IsInfinity(d);
    }

    // CoerceValueCallback — 实例级强制值（可以访问实例其他属性）
    private static object CoerceProgress(DependencyObject d, object baseValue)
    {
        var control = (ValidatedControl)d;
        var value = (double)baseValue;
        return Math.Clamp(value, 0, control.Maximum);
    }

    public static readonly DependencyProperty MaximumProperty =
        DependencyProperty.Register(
            "Maximum", typeof(double), typeof(ValidatedControl),
            new FrameworkPropertyMetadata(100.0, OnMaximumChanged));

    public double Maximum
    {
        get => (double)GetValue(MaximumProperty);
        set => SetValue(MaximumProperty, value);
    }

    // Maximum 变化时需要重新强制 Progress 的值
    private static void OnMaximumChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        ((ValidatedControl)d).CoerceValue(ProgressProperty);
    }
}

6. 依赖属性的多线程安全

WPF 的依赖属性系统本身不是线程安全的，必须在 UI 线程上操作依赖属性。

public class ThreadSafeControl : Control
{
    public static readonly DependencyProperty DataProperty =
        DependencyProperty.Register(
            "Data", typeof(string), typeof(ThreadSafeControl),
            new PropertyMetadata(string.Empty, OnDataChanged));

    public string Data
    {
        get => (string)GetValue(DataProperty);
        set => SetValue(DataProperty, value);
    }

    // 从后台线程安全更新依赖属性
    public void UpdateFromBackgroundThread(string newData)
    {
        if (Dispatcher.CheckAccess())
        {
            Data = newData;
        }
        else
        {
            Dispatcher.BeginInvoke(new Action(() => Data = newData),
                System.Windows.Threading.DispatcherPriority.DataBind);
        }
    }

    // 使用 DispatcherTimer 定时更新（自动在 UI 线程执行）
    private readonly DispatcherTimer _timer;

    public ThreadSafeControl()
    {
        _timer = new DispatcherTimer
        {
            Interval = TimeSpan.FromSeconds(1)
        };
        _timer.Tick += (s, e) =>
        {
            // 这里在 UI 线程上执行，可以直接操作依赖属性
            Data = DateTime.Now.ToString("HH:mm:ss");
        };
        _timer.Start();
    }

    private static void OnDataChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        // 该回调在 UI 线程上执行
        var control = (ThreadSafeControl)d;
        control.InvalidateVisual();
    }
}

7. 属性变更回调链与依赖联动

当多个属性之间存在联动关系时，需要正确处理回调顺序避免无限递归。

public class RangeSlider : Control
{
    // Minimum, Maximum, LowValue, HighValue 四个属性需要联动
    public static readonly DependencyProperty MinimumProperty =
        DependencyProperty.Register("Minimum", typeof(double), typeof(RangeSlider),
            new FrameworkPropertyMetadata(0.0, OnMinimumChanged));

    public static readonly DependencyProperty MaximumProperty =
        DependencyProperty.Register("Maximum", typeof(double), typeof(RangeSlider),
            new FrameworkPropertyMetadata(100.0, OnMaximumChanged));

    public static readonly DependencyProperty LowValueProperty =
        DependencyProperty.Register("LowValue", typeof(double), typeof(RangeSlider),
            new FrameworkPropertyMetadata(0.0, null, CoerceLowValue));

    public static readonly DependencyProperty HighValueProperty =
        DependencyProperty.Register("HighValue", typeof(double), typeof(RangeSlider),
            new FrameworkPropertyMetadata(100.0, null, CoerceHighValue));

    public double Minimum { get => (double)GetValue(MinimumProperty); set => SetValue(MinimumProperty, value); }
    public double Maximum { get => (double)GetValue(MaximumProperty); set => SetValue(MaximumProperty, value); }
    public double LowValue { get => (double)GetValue(LowValueProperty); set => SetValue(LowValueProperty, value); }
    public double HighValue { get => (double)GetValue(HighValueProperty); set => SetValue(HighValueProperty, value); }

    private static void OnMinimumChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var slider = (RangeSlider)d;
        slider.CoerceValue(LowValueProperty);   // Minimum 变化时重新约束 LowValue
        slider.CoerceValue(HighValueProperty);  // 同时约束 HighValue
    }

    private static void OnMaximumChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var slider = (RangeSlider)d;
        slider.CoerceValue(HighValueProperty);
        slider.CoerceValue(LowValueProperty);
    }

    private static object CoerceLowValue(DependencyObject d, object baseValue)
    {
        var slider = (RangeSlider)d;
        var value = (double)baseValue;
        // LowValue 不能小于 Minimum，也不能大于 HighValue
        return Math.Clamp(value, slider.Minimum, slider.HighValue);
    }

    private static object CoerceHighValue(DependencyObject d, object baseValue)
    {
        var slider = (RangeSlider)d;
        var value = (double)baseValue;
        // HighValue 不能大于 Maximum，也不能小于 LowValue
        return Math.Clamp(value, slider.LowValue, slider.Maximum);
    }
}

8. 自定义附加属性 — 输入验证服务

/// <summary>
/// 为 TextBox 提供输入验证的附加属性服务
/// </summary>
public static class InputValidationService
{
    public static readonly DependencyProperty RegexPatternProperty =
        DependencyProperty.RegisterAttached(
            "RegexPattern", typeof(string), typeof(InputValidationService),
            new PropertyMetadata(string.Empty, OnRegexPatternChanged));

    public static string GetRegexPattern(DependencyObject obj)
        => (string)obj.GetValue(RegexPatternProperty);
    public static void SetRegexPattern(DependencyObject obj, string value)
        => obj.SetValue(RegexPatternProperty, value);

    public static readonly DependencyProperty IsValidProperty =
        DependencyProperty.RegisterAttached(
            "IsValid", typeof(bool), typeof(InputValidationService),
            new PropertyMetadata(true));

    public static bool GetIsValid(DependencyObject obj)
        => (bool)obj.GetValue(IsValidProperty);
    public static void SetIsValid(DependencyObject obj, bool value)
        => obj.SetValue(IsValidProperty, value);

    public static readonly DependencyProperty ErrorMessageProperty =
        DependencyProperty.RegisterAttached(
            "ErrorMessage", typeof(string), typeof(InputValidationService),
            new PropertyMetadata(string.Empty));

    public static string GetErrorMessage(DependencyObject obj)
        => (string)obj.GetValue(ErrorMessageProperty);
    public static void SetErrorMessage(DependencyObject obj, string value)
        => obj.SetValue(ErrorMessageProperty, value);

    private static void OnRegexPatternChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is TextBox textBox)
        {
            textBox.TextChanged -= ValidateInput;
            if (!string.IsNullOrEmpty(e.NewValue as string))
            {
                textBox.TextChanged += ValidateInput;
            }
        }
    }

    private static void ValidateInput(object sender, TextChangedEventArgs e)
    {
        var textBox = (TextBox)sender;
        var pattern = GetRegexPattern(textBox);
        if (string.IsNullOrEmpty(pattern)) return;

        var regex = new Regex(pattern);
        var isValid = regex.IsMatch(textBox.Text);
        SetIsValid(textBox, isValid);

        textBox.BorderBrush = isValid ? Brushes.Gray : Brushes.Red;
        textBox.ToolTip = isValid ? null : GetErrorMessage(textBox);
    }
}
<!-- 使用示例 -->
<TextBox InputValidationService.RegexPattern="^\d+$"
         InputValidationService.ErrorMessage="只能输入数字"
         Width="200"/>
<!-- 在绑定中引用验证结果 -->
<TextBlock Text="输入无效" Foreground="Red">
    <TextBlock.Style>
        <Style TargetType="TextBlock">
            <Setter Property="Visibility" Value="Collapsed"/>
            <Style.Triggers>
                <DataTrigger Binding="{Binding (local:InputValidationService.IsValid), ElementName=txtPhone}" Value="False">
                    <Setter Property="Visibility" Value="Visible"/>
                </DataTrigger>
            </Style.Triggers>
        </Style>
    </TextBlock.Style>
</TextBlock>

9. 依赖属性的性能优化

// 1. 使用 FrameworkPropertyMetadataOptions 精确标记影响范围
// 错误：值变化时不必要的布局重计算
public static readonly DependencyProperty TextColorProperty =
    DependencyProperty.Register("TextColor", typeof(Brush), typeof(MyControl),
        new FrameworkPropertyMetadata(Brushes.Black, FrameworkPropertyMetadataOptions.AffectsMeasure));
// 正确：颜色变化只需重绘，不需要重新测量
public static readonly DependencyProperty TextColorFixedProperty =
    DependencyProperty.Register("TextColorFixed", typeof(Brush), typeof(MyControl),
        new FrameworkPropertyMetadata(Brushes.Black, FrameworkPropertyMetadataOptions.AffectsRender));

// 2. 批量更新属性时使用 Begin/End 范围减少重排
public void UpdateMultipleProperties()
{
    using (var scope = new UpdateScope(this))
    {
        Width = 200;
        Height = 100;
        Background = Brushes.White;
        FontSize = 14;
        // 所有变更在 scope 结束时统一生效
    }
}

// 3. 避免在 PropertyChangedCallback 中同步调用其他属性的 SetValue
// 优先使用 CoerceValue 而不是直接 SetValue，避免不必要的属性变更循环

// 4. 使用默认值减少内存占用
// 依赖属性的值按"稀疏存储"模式管理
// 只有设置了本地值的属性才占用额外的 Hashtable 空间
// 默认值在 Register 时指定，所有实例共享同一个默认值对象

// 5. 注意引用类型默认值的陷阱
// 错误：所有实例共享同一个 List 引用
public static readonly DependencyProperty ItemsProperty =
    DependencyProperty.Register("Items", typeof(List<string>), typeof(MyControl),
        new PropertyMetadata(new List<string>()));  // 危险！共享引用

// 正确：在回调中初始化
public static readonly DependencyProperty ItemsFixedProperty =
    DependencyProperty.Register("ItemsFixed", typeof(List<string>), typeof(MyControl),
        new PropertyMetadata(null, (d, e) =>
        {
            if (e.NewValue == null)
                ((MyControl)d).SetValue(ItemsFixedProperty, new List<string>());
        }));

优点

缺点

总结

依赖属性是 WPF 自定义控件的基础。掌握注册方式、变更回调、强制值回调和附加属性，就能构建灵活的自定义控件。业务 ViewModel 中使用普通属性 + INotifyPropertyChanged 即可；自定义控件中才需要依赖属性。

关键知识点

  • 先分清主题属于界面层、ViewModel 层、线程模型还是设备接入层。
  • WPF 文章真正的价值在于把 UI、数据、命令、线程和资源关系讲清楚。
  • 上位机场景里，稳定性和异常恢复常常比界面花哨更重要。
  • WPF 主题往往要同时理解依赖属性、绑定、可视树和命令系统。

项目落地视角

  • 优先明确 DataContext、绑定路径、命令源和线程切换位置。
  • 涉及设备时，补齐超时、重连、日志、告警和资源释放策略。
  • 复杂控件最好提供最小可运行页面，便于后续复用和排障。
  • 优先确认 DataContext、绑定路径、命令触发点和资源引用来源。

常见误区

  • 把大量逻辑堆进 code-behind，导致页面难测难维护。
  • 在后台线程直接操作 UI，或忽略 Dispatcher 切换。
  • 只验证正常路径，不验证设备掉线、权限缺失和资源泄漏。
  • 在 code-behind 塞太多状态与业务逻辑。

进阶路线

  • 继续向 MVVM 工具链、控件可复用性、性能优化和视觉树诊断深入。
  • 把主题放回真实设备流程，思考启动、连接、采集、显示、告警和恢复。
  • 沉淀成控件库、通信层和诊断工具，提高整套客户端的复用度。
  • 继续补齐控件库、主题系统、诊断工具和启动性能优化。

适用场景

  • 当你准备把《依赖属性 DependencyProperty》真正落到项目里时，最适合先在一个独立模块或最小样例里验证关键路径。
  • 适合桌面业务系统、监控看板、工控上位机和设备交互界面。
  • 当系统需要同时处理复杂 UI、后台任务和硬件通信时，这类主题尤为关键。

落地建议

  • 优先明确 View、ViewModel、服务层和设备层边界，避免代码隐藏过重。
  • 涉及实时刷新时，提前设计 UI 线程切换、节流和资源释放。
  • 对硬件通信、日志、告警和异常恢复建立标准流程。

排错清单

  • 先检查 DataContext、绑定路径、INotifyPropertyChanged 和命令状态是否正常。
  • 排查 Dispatcher 调用、死锁、后台线程直接操作 UI 的问题。
  • 出现内存增长时，优先检查事件订阅、图像资源和窗口生命周期。

复盘问题

  • 如果把《依赖属性 DependencyProperty》放进你的当前项目，最先要验证的输入、输出和失败路径分别是什么？
  • 《依赖属性 DependencyProperty》最容易在什么规模、什么边界条件下暴露问题？你会用什么指标或日志去确认？
  • 相比默认实现或替代方案，采用《依赖属性 DependencyProperty》最大的收益和代价分别是什么？

延伸阅读

Copyright © 2026 SunnyFan