如何在 WPF/XAML 中正确使用 INotifyPropertyChanged [英] How to use INotifyPropertyChanged correctly in WPF/XAML
问题描述
我有一个试图绑定到控件的自定义对象.在那个自定义对象上，我实现了 INotifyPropertyChanged 接口.我已成功绑定到我的对象和该对象上的一个属性.
I have a custom object that I am trying to bind to a control. On that custom object I have implemented the INotifyPropertyChanged interface. I have successfully bound to my object and a property on that object.
我不知道如何从那里开始.我已经为此工作了 2 天，但仍然无法让它工作.
What I can't figure out is how to go from there. I've been working on this for 2 days now and I still cannot get it working.
我的假设是，当我更改绑定到控件的属性时，该属性中设置的值将显示在控件中.但是，无论我如何更改属性，UI 都不会更新到超出其初始值的范围.
My assumption was that when I would change the property bound to the control that the value set in that property would then show up in the control. However, no matter how much I change the property, the UI is never updated beyond it's initial value.
我以这种方式实现了 INotifyPropertyChanged:实现 INotifyPropertyChanged 的基类
I have implemented INotifyPropertyChanged in this manner: A base class which implements INotifyPropertyChanged
所以我的基类是这样的:
So my base class is this:
[Serializable]
public abstract class BindableObject : INotifyPropertyChanged
{
#region Data
private static readonly Dictionary<string, PropertyChangedEventArgs> eventArgCache;
private const string ERROR_MSG = "{0} is not a public property of {1}";
#endregion // Data
#region Constructors
static BindableObject()
{
eventArgCache = new Dictionary<string, PropertyChangedEventArgs>();
}
protected BindableObject()
{
}
#endregion // Constructors
#region Public Members
/// <summary>
/// Raised when a public property of this object is set.
/// </summary>
[field: NonSerialized]
public event PropertyChangedEventHandler PropertyChanged;
/// <summary>
/// Returns an instance of PropertyChangedEventArgs for
/// the specified property name.
/// </summary>
/// <param name="propertyName">
/// The name of the property to create event args for.
/// </param>
public static PropertyChangedEventArgs
GetPropertyChangedEventArgs(string propertyName)
{
if (String.IsNullOrEmpty(propertyName))
throw new ArgumentException(
"propertyName cannot be null or empty.");
PropertyChangedEventArgs args;
// Get the event args from the cache, creating them
// and adding to the cache if necessary.
lock (typeof(BindableObject))
{
bool isCached = eventArgCache.ContainsKey(propertyName);
if (!isCached)
{
eventArgCache.Add(
propertyName,
new PropertyChangedEventArgs(propertyName));
}
args = eventArgCache[propertyName];
}
return args;
}
#endregion // Public Members
#region Protected Members
/// <summary>
/// Derived classes can override this method to
/// execute logic after a property is set. The
/// base implementation does nothing.
/// </summary>
/// <param name="propertyName">
/// The property which was changed.
/// </param>
protected virtual void AfterPropertyChanged(string propertyName)
{
}
/// <summary>
/// Attempts to raise the PropertyChanged event, and
/// invokes the virtual AfterPropertyChanged method,
/// regardless of whether the event was raised or not.
/// </summary>
/// <param name="propertyName">
/// The property which was changed.
/// </param>
protected void RaisePropertyChanged(string propertyName)
{
this.VerifyProperty(propertyName);
PropertyChangedEventHandler handler = this.PropertyChanged;
if (handler != null)
{
// Get the cached event args.
PropertyChangedEventArgs args =
GetPropertyChangedEventArgs(propertyName);
// Raise the PropertyChanged event.
handler(this, args);
}
this.AfterPropertyChanged(propertyName);
}
#endregion // Protected Members
#region Private Helpers
[Conditional("DEBUG")]
private void VerifyProperty(string propertyName)
{
Type type = this.GetType();
// Look for a public property with the specified name.
PropertyInfo propInfo = type.GetProperty(propertyName);
if (propInfo == null)
{
// The property could not be found,
// so alert the developer of the problem.
string msg = string.Format(
ERROR_MSG,
propertyName,
type.FullName);
Debug.Fail(msg);
}
}
#endregion // Private Helpers
}
我从上面的那个类继承，在我的派生类中，我在我的财产上这样做:
I inherit from that class above and in my derived class I do this on my property:
public virtual string Name
{
get
{
return m_strName;
}
set
{
m_strName = value;
RaisePropertyChanged("Name");
}
}
我的 XAML 看起来像这样(缩写版):
My XAML looks like this (abbreviated version):
<Window x:Class="PSSPECApplication.Windows.Project"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:System="clr-namespace:System;assembly=mscorlib"
DataContext="{Binding SizingProject, RelativeSource={RelativeSource Self}}">
<StackPanel VerticalAlignment="Center">
<TextBox Name="txtProjectName" Text="{Binding Name}" />
</StackPanel>
您可以看到窗口的数据上下文是一个名为 SizingProject 的属性.SizingProject 是派生类型(派生自 BindableObject)，其中包含 Name 属性并引发 PropertyChanged 事件处理程序.
You can see that the window's data context is a property called SizingProject. SizingProject is of the derived type (derived from BindableObject) and has the Name property in it and Raises the PropertyChanged event handler.
在我窗口的构造函数中，我填充了 SizingProject 并设置了它的 Name 属性.
In my window's constructor I populate SizingProject and it's Name property is set.
为了测试这一点，我在窗口上还有一个按钮，它会触发一个事件，将 Name 属性设置为与原来不同的值.但是，当 name 属性更改时，什么也不会发生.我已经追溯到 BindableObject 并且 PropertyChanged 事件始终设置为 null，因此没有设置和运行处理程序.这是为什么?
To test this I also have a button on the window that fires an event that sets the Name property to something other than what it is originally. However when the name property is changed, nothing ever happens. I have traced back to the BindableObject and the PropertyChanged event is always set to null, so no handler is ever set and run. Why is this?
我认为通过实现 INotifyPropertyChanged 并在绑定中使用该类型会强制 WPF 自动设置该事件处理程序，然后会发生正确的行为?对我来说，我从未见过这种行为.
I thought by implementing INotifyPropertyChanged and using that type in a binding forces WPF to set that event handler automatically and then the correct behavior happens? For me, I never see that behavior.
我发现了这个问题.我需要做的是为我的属性 SizingProject 创建一个 DependencyProperty.在我这样做之后，一切正常.
I figured out the issue. What I needed to do was to create a DependencyProperty for my property SizingProject. After I did that, everything worked fine.
public static readonly DependencyProperty SizingProjectProperty =
DependencyProperty.Register("SizingProject", typeof(Sizing.Project), typeof(Project), new UIPropertyMetadata());
public Sizing.Project SizingProject
{
get
{
return (Sizing.Project)GetValue(Project.SizingProjectProperty);
}
set
{
SetValue(Project.SizingProjectProperty, value);
}
}
推荐答案
适用于我的机器.虽然，缓存有点古怪.我要么为每种类型创建静态只读版本，要么在需要之前忘记缓存(过早优化等等).
Works on my machine. Although, the cache is kind of wacky. I'd either create static readonly versions per type or forget about caching until required (premature optimization and all).
我创建了一个示例项目.主窗口如下所示:
I created a sample project. The main window looks like this:
<Window x:Class="INPCTest.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:this="clr-namespace:INPCTest"
Title="MainWindow" Height="350" Width="525">
<Window.DataContext>
<this:MyObject />
</Window.DataContext>
<Grid>
<Grid.RowDefinitions>
<RowDefinition />
<RowDefinition />
</Grid.RowDefinitions>
<TextBlock
Text="{Binding MyOutProperty}" />
<TextBox
Grid.Row="1"
Text="{Binding MyInProperty, UpdateSourceTrigger=PropertyChanged}" />
</Grid>
</Window>
我正在绑定到我在 xaml 中创建的 MyObject 的一个实例(如果这对您来说不熟悉，您可以在代码隐藏中执行此操作).
I'm binding to an instance of MyObject, which I create in the xaml (you can do this in the codebehind if this isn't a familiar thing to you).
这是 MyObject 的代码:
Here's the code for MyObject:
class MyObject : BindableObject
{
private string _in;
private string _out;
public string MyOutProperty
{
get { return _out; }
set { _out = value; this.RaisePropertyChanged("MyOutProperty"); }
}
public string MyInProperty
{
get { return _in; }
set
{
_in = value;
MyOutProperty = "The textbox below says: "" + value + """;
this.RaisePropertyChanged("MyInProperty");
}
}
}
如何协同工作:
- 创建窗口
- MyObject 的实例被实例化并设置为
Window.DataContext - TextBlock 绑定到 MyOutProperty
- TextBox 绑定到 MyInProperty
- 用户在文本框中输入X"
- MyInProperty 设置为X"
- MyOutProperty 设置为下面的文本框说:X"
- MyOutProperty's Set 方法调用 RaisePropertyChanged 传入MyOutProperty"
- TextBlock 按预期更新.
- Window is created
- Instance of MyObject is instantiated and set to
Window.DataContext - TextBlock is bound to MyOutProperty
- TextBox is bound to MyInProperty
- User types 'X' in the Textbox
- MyInProperty is set with 'X'
- MyOutProperty is set with 'The textbox below says: "X"'
- MyOutProperty's Set method calls RaisePropertyChanged passing in "MyOutProperty"
- The TextBlock gets updated as expected.
我怀疑您的问题不在于您的基类，而在于您的子类的实现或在您的绑定中.
I suspect your issue isn't with your base class, it is either with the implementation of your child classes OR in your bindings.
为了帮助调试您的绑定，遵循此链接中的信息 为详细绑定跟踪输出配置 Visual Studio(如果您已配置，则在输出窗口或立即窗口中结束).
To help debug your bindings, follow the information at this link to configure visual studio for verbose binding trace output (ends up in the Output window or Immediate window, if you've configured that).
这篇关于如何在 WPF/XAML 中正确使用 INotifyPropertyChanged的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
