如何在WPF/XAML中正确使用INotifyPropertyChanged

Question

我有一个自定义对象，我试图将其绑定到控件。在该自定义对象上，我实现了 INotifyPropertyChanged 接口。我已成功绑定到我的对象以及该对象上的属性。

我不知道如何从那里走下去。我已经为此工作了 2 天，但仍然无法让它工作。

我的假设是，当我更改绑定到控件的属性时，该属性中设置的值将显示在控件中。但是，无论我如何更改属性，UI 的更新都不会超出其初始值。

我以这种方式实现了 INotifyPropertyChanged： 实现 INotifyPropertyChanged 的​​基类

所以我的基类是这样的：

[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
}

我从上面的类继承，并在我的派生类中对我的属性执行此操作：

    public virtual string Name
    {
        get
        {
            return m_strName;
        }
        set
        {
            m_strName = value;
            RaisePropertyChanged("Name");
        }
    }

我的 XAML 看起来像这样（缩写版本）：

<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 事件处理程序。

在我的窗口的构造函数中，我填充了 SizingProject 并设置了它的 Name 属性。

为了测试这一点，我还在窗口上有一个按钮，该按钮会触发一个事件，将 Name 属性设置为不同于原来的属性。但是，当名称属性更改时，什么也不会发生。我已追溯到 BindableObject，并且 PropertyChanged 事件始终设置为 null，因此不会设置和运行任何处理程序。这是为什么呢？

我认为通过实现 INotifyPropertyChanged 并在绑定中使用该类型会强制 WPF 自动设置该事件处理程序，然后会发生正确的行为？对我来说，我从未见过这种行为。

---

我想通了这个问题。我需要做的是为我的属性 SizingProject 创建一个 DependencyProperty。我这样做之后，一切都很好。

        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);
        }
    }

Answer 1

在我的机器上工作。不过，缓存有点古怪。我要么为每种类型创建静态只读版本，要么在需要之前忘记缓存（过早优化等）。

我创建了一个示例项目。主窗口如下所示：

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

我正在绑定到 MyObject 的实例，该实例是我在 xaml 中创建的（如果您不熟悉的话，您可以在代码隐藏中执行此操作）。

下面是 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");
        }
    }
}

它是如何协同工作的：

1. 创建窗口
2. MyObject 的实例被实例化并设置为 Window.DataContext
3. TextBlock 绑定到 MyOutProperty< /em>
4. 文本框绑定到 MyInProperty
5. 用户在文本框中键入“X”
6. MyInProperty 设置为“X”
7. MyOutProperty 设置为“The下面的文本框显示：“X”'
8. MyOutProperty 的 Set 方法调用 RaisePropertyChanged 传入“MyOutProperty”
9. TextBlock 将按预期更新。

我怀疑您的问题不在于您的基类，而在于您的子类的实现或您的绑定。

为了帮助调试您的绑定，按照此链接中的信息进行配置Visual Studio 用于详细绑定跟踪输出（最终出现在“输出”窗口或“立即”窗口中，如果您已配置）。