WPF：Application更新MyClass后Window未收到PropertyChanged通知的问题

Hey there, let's figure out how to fix this binding refresh issue you're facing.

The core problem here is that when your Application swaps out the entire MyClass instance, your Window's controls are still hooked up to the old instance. Even though MyClass implements INotifyPropertyChanged, that interface only handles updates to properties within a single instance—it doesn't help when you replace the instance itself.

Let's go through a few reliable fixes:

1. Wrap MyClass in a ViewModel with an Observable Property #

The cleanest approach for most WPF apps is to use a viewmodel (or a shared service) that holds your MyClass instance and raises a PropertyChanged event when the instance is replaced.

First, create a simple wrapper class (this could be part of your Application's logic or a dedicated viewmodel):

public class AppState : INotifyPropertyChanged
{
    private MyClass _activeMyClass;
    public MyClass ActiveMyClass
    {
        get => _activeMyClass;
        set
        {
            if (_activeMyClass != value)
            {
                _activeMyClass = value;
                OnPropertyChanged(nameof(ActiveMyClass));
            }
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

Then, in your Application, keep an instance of this AppState, and update the ActiveMyClass property whenever you need a new MyClass instance:

// Inside your Application class
public AppState CurrentState { get; } = new AppState();

// When you need to refresh MyClass
CurrentState.ActiveMyClass = new MyClass(/* pass your updated data here */);

In your Window, set the DataContext to this AppState instance, and bind your controls to the ActiveMyClass sub-properties:

<!-- Example XAML binding -->
<TextBox Text="{Binding ActiveMyClass.MyFirstProperty}" />
<TextBlock Text="{Binding ActiveMyClass.MySecondProperty}" />

Now, when ActiveMyClass is replaced, the PropertyChanged event from AppState tells the bindings to switch to the new instance. Plus, any property changes on the new MyClass will still fire their own PropertyChanged notifications as expected.

2. Manually Update the Window's DataContext #

If you prefer a simpler, more direct approach (great for small apps), you can explicitly refresh the Window's DataContext whenever the Application updates the MyClass instance.

First, expose the current MyClass instance from your Application:

// In your Application class
public MyClass CurrentMyClass { get; set; }

// When updating the instance
CurrentMyClass = new MyClass(/* new data */);
// Notify the Window to update its DataContext
var mainWindow = Application.Current.MainWindow as YourWindowType;
mainWindow?.UpdateMyClassBinding();

Then add a method to your Window to refresh the DataContext:

public void UpdateMyClassBinding()
{
    DataContext = (Application.Current as YourAppType).CurrentMyClass;
}

This works, but keep in mind you'll need to call UpdateMyClassBinding every time you replace the MyClass instance—so it's less scalable for larger apps with frequent updates.

3. Use an Event to Decouple Application and Window #

For a more loosely coupled setup, have your Application raise an event whenever the MyClass instance changes, then have the Window listen for that event to refresh its binding source.

In your Application class:

// Define an event for when MyClass is updated
public event EventHandler<MyClass> MyClassInstanceUpdated;

// When replacing the instance
var newMyClass = new MyClass(/* updated data */);
CurrentMyClass = newMyClass;
// Raise the event to notify listeners
MyClassInstanceUpdated?.Invoke(this, newMyClass);

In your Window, hook into this event when it loads, and update the DataContext when the event fires:

public YourWindowType()
{
    InitializeComponent();
    var app = Application.Current as YourAppType;
    app.MyClassInstanceUpdated += OnMyClassUpdated;
}

private void OnMyClassUpdated(object sender, MyClass newInstance)
{
    DataContext = newInstance;
}

// Don't forget to unsubscribe when the window closes to avoid memory leaks
protected override void OnClosed(EventArgs e)
{
    base.OnClosed(e);
    var app = Application.Current as YourAppType;
    app.MyClassInstanceUpdated -= OnMyClassUpdated;
}

This keeps your Application and Window from being tightly linked, which is better for maintainability.

Quick Sanity Check #

Before diving into any of these, double-check your XAML bindings to make sure you haven't accidentally set Mode=OneTime—that would lock the binding to the initial instance and ignore all updates:

<!-- ❌ This won't update after the first load -->
<TextBlock Text="{Binding MyProperty, Mode=OneTime}" />

<!-- ✅ This will update as expected -->
<TextBlock Text="{Binding MyProperty}" />

Any of these approaches should fix your issue—let me know if you need help working through the details of any one of them!

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