C# WPF在其属性更改时通知内容更改

我已将标签内容设置为某个自定义类：

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

不会导致标签更新其视图

我知道我可以设置标签内容属性的绑定。我已经喜欢7种不同的工作方式，实现自动更新。然而，我对这种特殊的行为感兴趣，因为在某些情况下，它将为我节省大量的工作，例如需求：

标签内容始终是相同的SomeContent实例，只是其属性发生了更改。 没有标签内容绑定。标签应采用内容对象，并在修改内容时刷新。 某些属性的初始值可以在XAML中设置 某些属性可以在代码中更改，从而导致标签刷新。 我是错过了什么，还是不可能

这是我当前对SomeContent的实现：

最新答复：

我放弃将SomeContent实现为依赖属性，而是使用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>

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

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

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

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

---

我发现没有第三方代码是不可能做到的。所以我现在写了一个助手类来轻松地完成它

动态对象

主窗口代码

这是处理更新的helper类

它可以改进，并且没有经过充分测试，但它可以用于当前目的。

---

另外一个问题是，一些元素，比如TextBox，抱怨不支持某些内容，比如说很难使用ToString。。。但这是另一个故事，和我的问题无关。

某些内容的意义是什么。感觉上你是在用它来做一件可以用更好的方式实现的事情。也许是转换器？请继续阅读。注意，在some属性的PropertyChangedCallback中将d设置为SomeContent.some=e.NewValue作为字符串是毫无意义的。调用回调时，属性值已更改。无需再次注册。您是否在某处订阅PropertyChanged事件？或者你希望如何得到通知？顺便说一下，依赖项属性的CLR包装器的setter应该只调用SetValue。如果要在值更改时执行其他操作，则应在回调中执行。为依赖项属性实现INotifyPropertyChanged也是毫无意义的。这些属性已经通知了值的更改。除此之外，您的整个方法似乎都失败了。如果要编写一个控件来显示其某个属性的值，则该控件应具有一些UI元素，例如，在自定义控件的ControlTemplate中，或在UserControl的XAML中。从这里开始阅读：。这个答案毫无意义，应该删除。将属性绑定到视图模型属性不会解决此问题。不难想象，为什么仅仅在标签上设置一个绑定是不起作用的。原因很明显，当属性更改时，不应该调用ToString。感谢您的努力，但实际上我没有检查我发布的代码，事实证明它确实在工作。这不是标签的错误，而是原始代码中的内部错误。一些基本上是我设定的，就这样。它会自动更新，我在这里不需要任何binning:@Clemens我没有看到你的评论，但这实际上正在工作-当某些属性发生更改时会调用ToString。@Pawcio你不是说SomeContent.some=xyz；不会导致标签更新其视图吗？是的，我说过，但那不是真的-此处发布的代码实际上是原始代码的精简版本，在发布问题之前，我没有正确检查精简版本，对不起…：|

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

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

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

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

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

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

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

}