WPF属性更改时通知内容更改

Question

我已经将标签Content设置为一些自定义类：

<Label>
    <local:SomeContent x:Name="SomeContent" some="abc" />
</Label>

这将在视图中正确显示“ abc”。 但是我不知道如何通知Label内容属性已更改，即：

SomeContent.some = "xyz";

不会导致标签更新其视图。

我知道我可以将绑定设置为标签的Content属性。 我已经喜欢7种不同的工作方法来实现自动更新。 但是，我对这种特殊的行为很感兴趣，因为在某些情况下它可以为我节省大量的工作，即要求是：

• 标签内容始终是相同的SomeContent实例，只是其属性被更改。
• 没有标签内容绑定。 标签应带有内容对象，并在修改内容时刷新。
• 可以在XAML中设置some属性的初始值
• 可以在代码中更改some属性，从而导致标签刷新。

我是否缺少某些东西，还是不可能？

这是我当前对SomeContent实现：

public class SomeContent : DependencyObject, INotifyPropertyChanged {

    public static readonly DependencyProperty someProperty =
        DependencyProperty.Register(nameof(some), typeof(string),
            typeof(SomeContent),
            new PropertyMetadata("", onDPChange)
    );

    private static void onDPChange(DependencyObject d, DependencyPropertyChangedEventArgs e) {
        //throw new NotImplementedException();
        (d as SomeContent).some = e.NewValue as String;
    }

    public event PropertyChangedEventHandler PropertyChanged;

    public string some {
        get => (string)GetValue(someProperty);
        set {
            SetValue(someProperty, value);
            PropertyChanged?.Invoke(this,
                new PropertyChangedEventArgs(nameof(some))
            );
        }
    }


    public override string ToString() => some;
}

Answer 1

我发现没有第三方代码是不可能做到的。 因此，我编写了一个帮助程序类以使其现在变得容易。

动态物体

public class SomeContent : IChangeNotifer {
    public event Action<object> MODIFIED;

    private string _some;
    public string some {
        get => _some;
        set {
            _some = value;
            MODIFIED?.Invoke(this);
        }
    }

    public override string ToString() => some;
}

您可以将其添加到xmal文件，它将自动更新。 唯一的附加步骤是在下面的元素中添加UIReseter ，这些元素假定是自动更新的，但是对于树中的多个内容来说只需要一个即可。

用法

<Window x:Class="DependencyContentTest.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:DependencyContentTest"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <StackPanel>
        <local:UIReseter />
        <Label>
            <local:SomeContent x:Name="SomeContent" some="abcd" />
        </Label>
        <Grid>
            <Label>
                <local:SomeContent x:Name="nested" some="nyest"/>
            </Label>
        </Grid>
    </StackPanel>
</Window>

MainWindow代码

public partial class MainWindow : Window {

    private Timer t;

    public MainWindow() {
        InitializeComponent();
        t = new Timer(onTimer, null, 5000, Timeout.Infinite);
        MouseDown += (s,e) => { SomeContent.some = "iii"; };
    }

    private void onTimer(object state) {
        Dispatcher.Invoke(() => {
            SomeContent.some = "aaaa";
            nested.some = "xxx";
        });
    }
}

这是处理更新的助手类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using H = System.Windows.LogicalTreeHelper;
using FE = System.Windows.FrameworkElement;
using DO = System.Windows.DependencyObject;
using System.Reflection;
using System.Windows.Markup;

namespace DependencyContentTest
{
    public interface IChangeNotifer {
        /// <summary>Dispatched when this object was modified.</summary>
        event Action<object> MODIFIED;
    }

    /// <summary>This element tracks nested <see cref="IChangeNotifer"/> descendant objects (in logical tree) of this object's parent element and resets a child in it's panel property.
    /// Only static (XAML) objects are supported i.e. object added to the tree dynamically at runtime will not be tracked.</summary>
    public class UIReseter : UIElement {

        public int searchDepth { get; set; } = int.MaxValue;

        protected override void OnVisualParentChanged(DO oldParent){
            if (VisualParent is FE p) p.Loaded += (s, e)  =>  bind(p);
        }

        private void bind(FE parent, int dl = 0) {
            if (parent == null || dl > searchDepth) return;
            var chs = H.GetChildren(parent);
            foreach (object ch in chs) {
                if (ch is UIReseter r && r != this) throw new Exception($@"There's overlapping ""{nameof(UIReseter)}"" instance in the tree. Use single global instance of check ""{nameof(UIReseter.searchDepth)}"" levels.");
                if (ch is IChangeNotifer sc) trackObject(sc, parent);
                else bind(ch as FE, ++dl);
            }
        }

        private Dictionary<IChangeNotifer, Reseter> tracked = new Dictionary<IChangeNotifer, Reseter>();
        private void trackObject(IChangeNotifer sc, FE parent) {
            var cp = getContentProperty(parent);
            if (cp == null) return;
            var r = tracked.nev(sc, () => new Reseter {
                child = sc,
                parent = parent,
                content = cp,
            });
            r.track();
        }

        private PropertyInfo getContentProperty(FE parent) {
            var pt = parent.GetType();
            var cp = parent.GetType().GetProperties(
                BindingFlags.Public |
                BindingFlags.Instance
            ).FirstOrDefault(i => Attribute.IsDefined(i,
                typeof(ContentPropertyAttribute)));
            return cp ?? pt.GetProperty("Content");
        }

        private class Reseter {
            public DO parent;
            public IChangeNotifer child;
            public PropertyInfo content;
            private bool isTracking = false;

            /// <summary>Function called by <see cref="IChangeNotifer"/> on <see cref="IChangeNotifer.MODIFIED"/> event.</summary>
            /// <param name="ch"></param>
            public void reset(object ch) {
                if(! isChildOf(child, parent)) return;
                //TODO: Handle multi-child parents
                content.SetValue(parent, null);
                content.SetValue(parent, child);
            }

            public void track() {
                if (isTracking) return;
                child.MODIFIED += reset;
            }

            private bool isChildOf(IChangeNotifer ch, DO p) {
                if(ch is DO dch) {
                    if (H.GetParent(dch) == p) return true;
                    child.MODIFIED -= reset; isTracking = false;
                    return false;
                }
                var chs = H.GetChildren(p);
                foreach (var c in chs) if (c == ch) return true;
                child.MODIFIED -= reset; isTracking = false;
                return false;
            }
        }
    }

    public static class DictionaryExtension {
        public static V nev<K,V>(this Dictionary<K,V> d, K k, Func<V> c) {
            if (d.ContainsKey(k)) return d[k];
            var v = c(); d.Add(k, v); return v;
        }
    }

}

可以对其进行改进，并且尚未经过全面测试，但是可以用于当前目的。 另一个问题是，诸如TextBox之类的某些元素哭诉不支持SomeContent ，就像很难使用ToString() ...但这是另一回事，与我的问题无关。

Answer 2

更新的答案：

我会放弃将SomeContent实现为Dependency属性，而改用UserControl：

<UserControl x:Class="WpfApp1.SomeContent"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:local="clr-namespace:WpfApp1"
             mc:Ignorable="d" 
             d:DesignHeight="450" d:DesignWidth="800">
    <Grid>
            <TextBlock Text="{Binding some, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type local:SomeContent}}}"/>
    </Grid>
</UserControl>

然后在后面的代码中：

/// <summary>
/// Interaction logic for SomeContent.xaml
/// </summary>
public partial class SomeContent : UserControl
{
    public static readonly DependencyProperty someProperty =
        DependencyProperty.Register(nameof(some), typeof(string),
            typeof(SomeContent),
            new PropertyMetadata("")
        );

    public string some
    {
        get => (string)GetValue(someProperty);
        set => SetValue(someProperty, value);
    }

    public SomeContent()
    {
        InitializeComponent();
    }
}

接下来，实现一个实现INotifyPropertyChanged的视图模型：

public class MyViewModel : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    private string _somePropertyOnMyViewModel;
    public string SomePropertyOnMyViewModel
    {
        get => _somePropertyOnMyViewModel;
        set { _somePropertyOnMyViewModel = value; OnPropertyChanged(); }
    }
    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

然后在视图中创建MyViewModel的实例，并将其分配给视图的DataContext：

public class MyView : Window
{
    public MyView()
    {
        InitializeComponent();
        DataContext = new MyViewModel();
    }
}

然后，最后，在MyView中，使用我在原始答案中提供的标记：

<Label>
    <local:SomeContent x:Name="SomeContent" some="{Binding 
SomePropertyOnMyViewModel" />
</Label>