WPF|依赖属性SetCurrentValue方法不会使绑定失效， SetValue方法会使绑定失效？是真的吗？

于 2024-10-07 18:01:12 发布
阅读量903 收藏 21
点赞数 10
分类专栏： .NET WPF Windows 文章标签： wpf
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42399932/article/details/142743822
版权
.NET 同时被 3 个专栏收录
10 篇文章 0 订阅
订阅专栏
WPF
9 篇文章 0 订阅
订阅专栏
Windows
4 篇文章 0 订阅
订阅专栏

引言

最近因为一个触发器设置的结果总是不起效果的原因，进一步去了解[依赖属性的优先级](Dependency property value precedence - WPF .NET | Microsoft Learn)。在学习这个的过程中发现对SetCurrentValue一直以来的谬误。

在WPF中依赖属性Dependency property的三个方法SetValue 、SetCurrentValue、ClearValue。

  1. SetCurrentValue 方法用于设置依赖属性的当前值，但不会覆盖该属性的值来源。这意味着，如果属性值是通过绑定、样式或触发器设置的，使用 SetCurrentValue 后，这些设置仍然有效。

然而这很容易让人以为SetValue 方法会使得数据绑定失效。就像先执行了ClearValue 一样。网上我看到的很多文章也这么说，这让我困惑了很久，但我实际操作下来，并非如此，实际上并不是。

为了验证这三个方法，我以设置按钮背景颜色为例，写了一个Demo。

其主要作用如下：

1. myButton绑定默认背景颜色的依赖属性
<Button
    x:Name="MyButton"
    Width="100"
    Height="50"
    Background="{Binding DefaultBackgroundColor,
                         Mode=TwoWay,
                         RelativeSource={RelativeSource AncestorType={x:Type local:MainWindow}}}"
    Content="MyButton" />

 public static readonly DependencyProperty DefaultBackgroundColorProperty =
     DependencyProperty.Register(
         "DefaultBackgroundColor",
         typeof(Brush),
         typeof(MainWindow),
         new PropertyMetadata(Brushes.Pink,OnDefaultBackgroundColorChanged)
     );

 private static void OnDefaultBackgroundColorChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
 {
     MessageBox.Show("DefaultBackgroundColor changed");
 }
 public static readonly DependencyProperty DefaultForegroundColorProperty =
     DependencyProperty.Register(
         "DefaultForegroundColor",
         typeof(Brush),
         typeof(MainWindow),
         new PropertyMetadata(Brushes.Gray,OnDefaultForegroundChanged)
     );
2. 按钮1使用SetValue设置myButton的背景颜色属性，并判断绑定表达式是否为空
  private void SetValueChangeBackground_Click(object sender, RoutedEventArgs e)
  {
      MyButton.SetValue(Button.BackgroundProperty, new SolidColorBrush(Colors.Green));
      IsBindingExpressionNull();
  }
  
  private void IsBindingExpressionNull()
{ 
    if (MyButton.GetBindingExpression(Button.BackgroundProperty) == null)
    {
        MessageBox.Show("BindingExpression is null");
    }
}
3. 按钮2使用SetCurrentValue设置myButton的背景颜色属性
 MyButton.SetCurrentValue(Button.BackgroundProperty, new SolidColorBrush(Colors.Orange));
IsBindingExpressionNull();
4. 按钮3 使用ClearValue 清楚背景颜色属性本地值
 // 清除本地值
 MyButton.ClearValue(Button.BackgroundProperty);
IsBindingExpressionNull();
5. 按钮4，修改依赖属性
DefaultBackgroundColor = new SolidColorBrush(Colors.LightGreen);
我使用.NET 8 做的Demo的现象如下：
  1. ClearValue执行后，绑定表达式为Null，也就是说ClearValue之后，绑定的数据表达式会被清空
  2. SetValue执行后，按钮颜色正常改变，绑定表达式不为Null。再次执行按钮4 修改依赖属性，按钮背景颜色也可以正常变化，也就是说SetValue之后数据表达式不会被清空，仍然有效。
  3. SetCurrentValue与第2点现象完全一致。

源码

通过查看源码，发现SetCurrentValue 和SetValue都执行方法SetValueCommon，只是入参coerceWithCurrentValue不同，// SetValue时为false 和SetCurrentValue时为true。

并且推测当SetValue的value入参等于DependencyProperty.UnsetValue时，应当会和ClearValueCommon执行相同的方法。

以下是测试代码，实际测试结果也是如此，此时绑定表达式为Null。


        private void SetValueChangeBackgroundUnsetValue_Click(object sender, RoutedEventArgs e)
        {
            MyButton.SetValue(Button.BackgroundProperty, DependencyProperty.UnsetValue);  //查看源码发现，UnsetValue时才会是清除本地值，并且 ClearValue
            IsBindingExpressionNull();
        }
SetValueCommon
        /// <summary>
        ///     The common code shared by all variants of SetValue
        /// </summary>
        // Takes metadata from caller because most of them have already retrieved it
        //  for their own purposes, avoiding the duplicate GetMetadata call.
        private void SetValueCommon(
            DependencyProperty  dp,
            object              value,
            PropertyMetadata    metadata,
            bool                coerceWithDeferredReference,
            bool                coerceWithCurrentValue, // SetValue时为false 和SetCurrentValue时为true
            OperationType       operationType,
            bool                isInternal)
        {
            if (IsSealed)
            {
                throw new InvalidOperationException(SR.Get(SRID.SetOnReadOnlyObjectNotAllowed, this));
            }
 
            Expression newExpr = null;
            DependencySource[] newSources = null;
 
            EntryIndex entryIndex = LookupEntry(dp.GlobalIndex);
 
            // Treat Unset as a Clear
            if( value == DependencyProperty.UnsetValue )
            {
                Debug.Assert(!coerceWithCurrentValue, "Don't call SetCurrentValue with UnsetValue");
                // Parameters should have already been validated, so we call
                //  into the private method to avoid validating again.
                ClearValueCommon(entryIndex, dp, metadata);
                return;
            }
 
            // Validate the "value" against the DP.
            bool isDeferredReference = false;
            bool newValueHasExpressionMarker = (value == ExpressionInAlternativeStore);
 
            // First try to validate the value; only after this validation fails should we
            // do the more expensive checks (type checks) for the less common scenarios
            if (!newValueHasExpressionMarker)
            {
                bool isValidValue = isInternal ? dp.IsValidValueInternal(value) : dp.IsValidValue(value);
 
                // for properties of type "object", we have to always check for expression & deferredreference
                if (!isValidValue || dp.IsObjectType)
                {
                    // 2nd most common is expression
                    newExpr = value as Expression;
                    if (newExpr != null)
                    {
                        // For Expressions, perform additional validation
                        // Make sure Expression is "attachable"
                        if (!newExpr.Attachable)
                        {
                            throw new ArgumentException(SR.Get(SRID.SharingNonSharableExpression));
                        }
 
                        // Check dispatchers of all Sources
                        // CALLBACK
                        newSources = newExpr.GetSources();
                        ValidateSources(this, newSources, newExpr);
                    }
                    else
                    {
                        // and least common is DeferredReference
                        isDeferredReference = (value is DeferredReference);
                        if (!isDeferredReference)
                        {
                            if (!isValidValue)
                            {
                                // it's not a valid value & it's not an expression, so throw
                                throw new ArgumentException(SR.Get(SRID.InvalidPropertyValue, value, dp.Name));
                            }
                        }
                    }
                }
            }
 
            // Get old value
            EffectiveValueEntry oldEntry;
            if (operationType == OperationType.ChangeMutableDefaultValue)
            {
                oldEntry = new EffectiveValueEntry(dp, BaseValueSourceInternal.Default);
                oldEntry.Value = value;
            }
            else
            {
                oldEntry = GetValueEntry(entryIndex, dp, metadata, RequestFlags.RawEntry);
            }
 
            // if there's an expression in some other store, fetch it now
            Expression currentExpr =
                    (oldEntry.HasExpressionMarker)  ? _getExpressionCore(this, dp, metadata)
                  : (oldEntry.IsExpression)         ? (oldEntry.LocalValue as Expression)
                  :                                   null;
 
            // Allow expression to store value if new value is
            // not an Expression, if applicable
 
            bool handled = false;
            if ((currentExpr != null) && (newExpr == null))
            {
                // Resolve deferred references because we haven't modified
                // the expression code to work with DeferredReference yet.
                if (isDeferredReference)
                {
                    value = ((DeferredReference) value).GetValue(BaseValueSourceInternal.Local);
                }
 
                // CALLBACK
                handled = currentExpr.SetValue(this, dp, value);
                entryIndex = CheckEntryIndex(entryIndex, dp.GlobalIndex);
            }
 
            // Create the new effective value entry
            EffectiveValueEntry newEntry;
             if (handled)                                                                                                                                                                                        )
            {
                // If expression handled set, then done
                if (entryIndex.Found)
                {
                    newEntry = _effectiveValues[entryIndex.Index];
                }
                else
                {
                    // the expression.SetValue resulted in this value being removed from the table;
                    // use the default value.
                    newEntry = EffectiveValueEntry.CreateDefaultValueEntry(dp, metadata.GetDefaultValue(this, dp));
                }
 
                coerceWithCurrentValue = false; // expression already handled the control-value
            }
            else
            {
                 // allow a control-value to coerce an expression value, when the
                // expression didn't handle the value
                if (coerceWithCurrentValue && currentExpr != null)
                {
                    currentExpr = null;
                }
 
                newEntry = new EffectiveValueEntry(dp, BaseValueSourceInternal.Local);
 
                // detach the old expression, if applicable
                if (currentExpr != null)
                {
                    // CALLBACK
                    DependencySource[] currentSources = currentExpr.GetSources();
 
                    UpdateSourceDependentLists(this, dp, currentSources, currentExpr, false);  // Remove
 
                    // CALLBACK
                    currentExpr.OnDetach(this, dp);
                    currentExpr.MarkDetached();
                    entryIndex = CheckEntryIndex(entryIndex, dp.GlobalIndex);
                }
 
                // attach the new expression, if applicable
                if (newExpr == null)
                {
                    // simple local value set
                    newEntry.HasExpressionMarker = newValueHasExpressionMarker;
                    newEntry.Value = value;
                }
                else
                {
                    Debug.Assert(!coerceWithCurrentValue, "Expression values not supported in SetCurrentValue");
 
                    // First put the expression in the effectivevalueentry table for this object;
                    // this allows the expression to update the value accordingly in OnAttach
                    SetEffectiveValue(entryIndex, dp, dp.GlobalIndex, metadata, newExpr, BaseValueSourceInternal.Local);
 
                    // Before the expression is attached it has default value
                    object defaultValue = metadata.GetDefaultValue(this, dp);
                    entryIndex = CheckEntryIndex(entryIndex, dp.GlobalIndex);
                    SetExpressionValue(entryIndex, defaultValue, newExpr);
                    UpdateSourceDependentLists(this, dp, newSources, newExpr, true);  // Add
 
                    newExpr.MarkAttached();
 
                    // CALLBACK
                    newExpr.OnAttach(this, dp);
 
                    // the attach may have added entries in the effective value table ...
                    // so, update the entryIndex accordingly.
                    entryIndex = CheckEntryIndex(entryIndex, dp.GlobalIndex);
 
                    newEntry = EvaluateExpression(
                            entryIndex,
                            dp,
                            newExpr,
                            metadata,
                            oldEntry,
                            _effectiveValues[entryIndex.Index]);
 
                    entryIndex = CheckEntryIndex(entryIndex, dp.GlobalIndex);
                }
            }
 
            UpdateEffectiveValue(
                entryIndex,
                dp,
                metadata,
                oldEntry,
                ref newEntry,
                coerceWithDeferredReference,
                coerceWithCurrentValue,
                operationType);
        }
ClearValueCommon
/// <summary>
        ///     The common code shared by all variants of ClearValue
        /// </summary>
        private void ClearValueCommon(EntryIndex entryIndex, DependencyProperty dp, PropertyMetadata metadata)
        {
            if (IsSealed)
            {
                throw new InvalidOperationException(SR.Get(SRID.ClearOnReadOnlyObjectNotAllowed, this));
            }
 
            // Get old value
            EffectiveValueEntry oldEntry = GetValueEntry(
                                        entryIndex,
                                        dp,
                                        metadata,
                                        RequestFlags.RawEntry);
 
            // Get current local value
            // (No need to go through read local callback, just checking
            // for presence of Expression)
            object current = oldEntry.LocalValue;
 
            // Get current expression
            Expression currentExpr = (oldEntry.IsExpression) ? (current as Expression) : null;
 
            // Inform value expression of detachment, if applicable
            if (currentExpr != null)
            {
                // CALLBACK
                DependencySource[] currentSources = currentExpr.GetSources();
 
                UpdateSourceDependentLists(this, dp, currentSources, currentExpr, false);  // Remove
 
                // CALLBACK
                currentExpr.OnDetach(this, dp);
                currentExpr.MarkDetached();
                entryIndex = CheckEntryIndex(entryIndex, dp.GlobalIndex);
            }
 
            // valuesource == Local && value == UnsetValue indicates that we are clearing the local value
            EffectiveValueEntry newEntry = new EffectiveValueEntry(dp, BaseValueSourceInternal.Local);
 
            // Property is now invalid
            UpdateEffectiveValue(
                    entryIndex,
                    dp,
                    metadata,
                    oldEntry,
                    ref newEntry,
                    false /* coerceWithDeferredReference */,
                    false /* coerceWithCurrentValue */,
                    OperationType.Unknown);
        }

Mode对SetValue的影响

在wpf - 依赖属性SetValue（）和SetCurrentValue（）之间的区别是什么 - 堆栈溢出 — wpf - What’s the difference between Dependency Property SetValue() & SetCurrentValue() - Stack Overflow上看到和Mode还有关系，于是我又测试了一下：
在这里插入图片描述

将按钮的绑定方式改为OneWay,发现SetValue执行后，绑定为Null，绑定被销毁。

<Button
    x:Name="MyButton"
    Width="100"
    Height="50"
    Background="{Binding DefaultBackgroundColor,
                         Mode=OneWay,
                         RelativeSource={RelativeSource AncestorType={x:Type local:MainWindow}}}"
    Content="MyButton" />

总结

就我的测试Demo来看，

  1. ClearValue会使得数据绑定失效。
  2. SetCurrentValue和官方文档所述一致，不会覆盖该属性的值来源，如果属性值是通过绑定、样式或触发器设置的，使用 SetCurrentValue 后，这些设置仍然有效。
  3. SetValue 设置的依赖属性为DependencyProperty.UnsetValue，会和ClearValue的表现一致。
  4. SetValue在Mode=TwoWay时，和SetCurrentValue表现一致，数据绑定不会失效。
  5. SetValue 在Mode=OneWay时。数据绑定也会失效。

参考

  1. What’s the difference between Dependency Property SetValue() & SetCurrentValue()
  2. Dependency property value precedence - WPF .NET | Microsoft Learn
  3. 源码
Nita.
关注
专栏目录
WPF 为用户控件的依赖属性绑定失效的解决办法
qq_40197926的博客
07-08 1663
解决wpf依赖属性绑定失效问题
第四章：WPF依赖/附加属性，数据绑定(一)
鲤籽鲲的博客
11-18 7374
WPF 依赖属性，附加属性，数据绑定，数据转换
C#（WPF）自定义控件中的依赖属性绑定，依赖事件绑定
weixin_45526252的博客
10-28 1845
WPF 自定义控件中的依赖属性，依赖事件（获取，设置组合控件内的某个控件的属性）
WPF 自定义控件的依赖属性的绑定方法
热门推荐
LanPst的专栏
02-18 1万+
首先一些人觉得WPF中前台的代码应该在前台创建，尽量不要在后台用代码创建。另外如果前台重复代码过多，编写起来非常繁琐而且修改更是头痛。因此使用用户控件的方法把经常使用的前台模块制作成控件，当然用法和普通控件基本相同。 注意的地方已经用红色标记，代码如下：   控件后台代码： public partial class UC_ReagentWellTextBlock : UserControl
WPF不可对属性绑定赋值，否则会导致绑定失效
sdhongjun的专栏
08-26 834
在WPF中若某控件属性已先行绑定，在程序中不可以对其执行赋值操作，否则会导致绑定失效。 如在XAML中将按钮绑定到BC_Visual属性： <Button x:Name="btnVisual" Content="视 觉 检 测" Height="40" FontSize="16" IsEnabled="{Binding Path=BC_Visual}"/> 若在程序中执行如下代码后会导致绑定自动解除： btnVisual.IsEnabled = true; ...
WPF依赖属性优先级
三千幻想乡
03-08 1128
在上篇文“依赖属性概述”中提到了依赖属性优先级，虽然知道了局部值具有最高优先级，但是细节上略去太多。这就导致了在实际遇到问题时，可能知道是优先级导致的，但不知道此时应该怎么处理。因此，有必要进一步学习优先级。原文地址这章是相当复杂了，如果对WPF和依赖属性没有一定了解，看原文根本看不懂。我觉得第一遍只要了解有优先级那么一回事儿，大致记一下设置属性的优先级顺序。后面遇到具体问题再细细分析。
WPF绑定失效的一种可能原因
qq_29881799的博客
06-05 1232
WPF绑定失效的一种可能原因
WPF 用户控件UserControl 依赖属性绑定
灰太澜的博客
08-06 8629
前言 被询问的多了，所以写个记录下（下次就可以直接扔链接了）。先给示例代码 public string Text { get { return (string)GetValue(TextProperty); } set { SetValue(TextProperty, value); } } // Using a DependencyProperty as the backing stor
【WPF绑定2】 INotifyPropertyChanged Or 依赖属性
songhuangong123的博客
11-05 1476
在上一节，我们介绍了ListBox的基础绑定版，简单来说就是将一个数组结构赋值给了listbox的ItemsSource属性，就实现了绑定。 这次我们来看看，当属性绑定数据源之后，当数据源发生改变时，如何让属性跟随变换。 首先我们需要定义一个类Status，并实现接口 INotifyPropertyChanged 看名字就知道了它就是起一个通知的作用！ 这个接口只定义了一个事件 // // 摘要: // 通知客户端属性值已更改。 public interface INotifyProper
C#中WPF依赖属性的正确学习方法
08-25
`GetValue`和`SetValue`方法允许你读取和设置依赖属性的值，它们是`DependencyObject`类（所有WPF对象的基类）的一部分。 3. **依赖属性的优势** - **数据绑定**：依赖属性可以直接与数据源绑定，使UI动态更新。 ...
WPF基于MVVM框架的命令和属性绑定
04-02
在本文中，我们将深入探讨如何在Windows Presentation Foundation (WPF) 中使用Model-View-ViewModel (MVVM)设计模式，特别是在结合MVVMLight框架时，如何实现字段属性的绑定和命令绑定。MVVM是一种用于构建用户界面...
WPF基础知识绑定、样式、依赖属性教程
03-17
**WPF基础知识绑定、样式、依赖属性教程** WPF（Windows Presentation Foundation）是微软.NET Framework中的一个组件，用于构建丰富的、交互式的用户界面。在WPF中，数据绑定、样式和依赖属性是三个核心概念，它们...
WPF绑定静态变量的示例代码（二）加上IValueConverter
09-19
在本文中，我们将深入探讨如何在Windows Presentation Foundation (WPF) 中绑定静态变量，并通过使用IValueConverter接口来实现动态更新控件的显示。WPF是.NET Framework的一部分，它为构建丰富的桌面应用程序提供了...
利用redis实现分布式定时任务
weixin_42759398的博客
09-29 655
如果是微服务，两个服务都有定时，那么就出问题了，但是上分布式定时任务框架太麻烦怎么办，那么就用redis加个锁，谁先抢到锁谁执行。但是写起来还要改定时任务代码，贼麻烦，直接用切面 环绕的那种，然后抢到锁执行就行.
WPF RadioButton 绑定boolean值
明耀的博客
09-30 744
切记:RadioButton 不能有GroupName属性。
wpf实现新用户页面引导
weixin_51786302的博客
10-04 443
wpf 实现新用户页面引导
WPF下使用FreeRedis操作RedisStream实现简单的消息队列
5653325的专栏
10-02 1436
高效消费者组：允许多个消费者组从同一数据流的不同部分消费数据，每个消费者组都能独立地处理消息，这样可以并行处理和提高效率。阻塞操作：消费者可以设置阻塞操作，这样它们会在流中有新数据添加时被唤醒并开始处理，这有助于减少资源消耗并提高响应速度。数据持久化：它可以将数据持久化到内存（配置本地持久化后会写入到存储设备）中进行保存，等待消费。多生产者多消费者：Redis Streams能够在多个生产者和消费者之间建立一个数据通道，使得数据的流动和处理更加灵活。扩展性和异步通信。
jdk-1.8(8u211-windows-x64)
最新发布
10-07
jdk-8u211-windows-x64
WPF DataGrid
06-02
WPF DataGrid 是 WPF（Windows Presentation Foundation）框架中的一个控件，它允许您显示和编辑表格数据。下面是一些关于 WPF DataGrid 的常见问题和答案： 1. 如何创建 WPF DataGrid？ 您可以在 XAML 中使用以下代码创建 WPF DataGrid： ``` <DataGrid ItemsSource="{Binding YourData}"> <DataGrid.Columns> <DataGridTextColumn Header="Column1" Binding="{Binding Property1}" /> <DataGridTextColumn Header="Column2" Binding="{Binding Property2}" /> <DataGridTextColumn Header="Column3" Binding="{Binding Property3}" /> </DataGrid.Columns> </DataGrid> ``` 2. 如何将数据绑定到 WPF DataGrid？ 您可以在 XAML 中使用以下代码将数据绑定到 WPF DataGrid： ``` <DataGrid ItemsSource="{Binding YourData}"> ... </DataGrid> ``` 其中，“YourData”是您要绑定的数据集合。 3. 如何在 WPF DataGrid 中添加列？ 您可以在 XAML 中使用“DataGrid.Columns”元素添加列。例如，以下代码将添加一个名为“Column1”的文本列： ``` <DataGrid.Columns> <DataGridTextColumn Header="Column1" Binding="{Binding Property1}" /> </DataGrid.Columns> ``` 4. 如何在 WPF DataGrid 中编辑数据？ WPF DataGrid 允许您直接在表格中编辑数据。只需将“IsReadOnly”属性设置为“False”，就可以启用编辑模式。例如，以下代码将启用编辑模式： ``` <DataGrid IsReadOnly="False"> ... </DataGrid> ``` 5. 如何在 WPF DataGrid 中添加行？ 您可以在代码中使用“Items.Add()”方法添加行。例如，以下代码将添加一个新行： ``` YourData.Add(new YourDataItem { Property1 = "Value1", Property2 = "Value2", Property3 = "Value3" }); ``` 其中，“YourData”是您要绑定的数据集合，“YourDataItem”是数据项的类型。 希望这些信息对您有所帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值