UserControl依赖属性不更新问题求助

Hey Chris, let's break down why your LegendLabelControl's Text property isn't updating after the initial load—even though the binding works the first time, there are a few common WPF dependency property pitfalls that could be causing this. Here are the key areas to check:

1. Verify Your Dependency Property Registration #

The most likely culprit is a missing or incorrect PropertyChangedCallback in your dependency property registration. WPF relies on this callback to sync the control's UI when the property value changes.

Double-check that your Text dependency property is registered like this:

public static readonly DependencyProperty TextProperty =
    DependencyProperty.Register(
        nameof(Text),
        typeof(string),
        typeof(LegendLabelControl),
        new PropertyMetadata(string.Empty, OnTextPropertyChanged));

// This callback is critical—it updates your control's visible UI element
private static void OnTextPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    var control = (LegendLabelControl)d;
    // Replace "InternalTextBlock" with your control's actual text display element
    control.InternalTextBlock.Text = e.NewValue?.ToString() ?? string.Empty;
}

public string Text
{
    get => (string)GetValue(TextProperty);
    set => SetValue(TextProperty, value);
}

If you omitted the PropertyChangedCallback, or if the callback doesn't actually update the visible UI in your UserControl, the dependency property value will change but won't show up on screen.

2. Confirm INotifyPropertyChanged is Implemented Correctly #

Since the initial value displays correctly, your binding path is valid—but you need to ensure the source property (Item.StatusName) fires change notifications when it updates.

• First, check that the class containing StatusName implements INotifyPropertyChanged, and that the property setter triggers the PropertyChanged event:

  public class YourItemClass : INotifyPropertyChanged
  {
      private string _statusName;
      public string StatusName
      {
          get => _statusName;
          set
          {
              if (_statusName != value)
              {
                  _statusName = value;
                  OnPropertyChanged(nameof(StatusName));
              }
          }
      }
  
      public event PropertyChangedEventHandler PropertyChanged;
  
      protected void OnPropertyChanged(string propertyName)
      {
          PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
      }
  }
  

• Also, if you ever replace the entire Item instance in your ViewModel, make sure the Item property itself triggers PropertyChanged—otherwise, the binding won't switch to the new Item's StatusName.

3. Clean Up Your Binding Syntax #

Your XAML has a duplicate UpdateSourceTrigger=PropertyChanged (one inside the Binding markup, another as a direct control attribute). While this isn't a breaking issue, it's redundant. More importantly, ensure your binding mode is set correctly:

By default, most text properties use TwoWay binding, but if your dependency property's metadata sets BindsTwoWayByDefault = false, explicitly set the mode to OneWay (since you're only updating from ViewModel to control):

<reporting:LegendLabelControl 
    Grid.Column="1" 
    Grid.Row="3" 
    Text="{Binding Path=Item.StatusName, UpdateSourceTrigger=PropertyChanged, Mode=OneWay}"/>

4. Check for Local Value Overrides #

If you ever set the Text property directly in code (e.g., myLegendLabel.Text = "Some Value";), WPF will prioritize this local value over the binding. This breaks the binding connection, so subsequent source changes won't update the control.

You can confirm this using the WPF Snoop tool or Visual Studio's Live Property Explorer to check the Text property's value source—if it says "Local" instead of "Binding", that's the issue.

5. Ensure the DataContext Remains Consistent #

Even though the initial value works, if your LegendLabelControl's DataContext gets changed later (e.g., by a parent control or code-behind), the binding will point to a different source, so updates won't reflect your original ViewModel. Debug at runtime to verify the control's DataContext is still your intended ViewModel instance.

Start with the first two checks—dependency property registration and INotifyPropertyChanged—these are the most common causes for this exact scenario.

内容的提问来源于stack exchange，提问作者Chris