如何避免WPF UserControl关联依赖属性更新时重复调用LoadCustomer？

场景与问题 #

有一个UserControl，包含Customer和Company两个独立的依赖属性，绑定到列表的SelectedItem（列表中每个对象都对应这两个属性）。当切换SelectedItem时：

• 若仅单个属性变化，只会触发对应回调，LoadCustomer调用一次（符合预期）；
• 若两个属性同时变化，会先后触发OnCustomerChanged和OnCompanyChanged，导致LoadCustomer被调用两次——第一次传入新Customer+旧Company，第二次才是完整的新值，这是需要避免的情况。

初始代码 #

public class YourUserControl : UserControl
{
    public static readonly DependencyProperty CustomerProperty =
        DependencyProperty.Register("Customer", typeof(string), typeof(YourUserControl), 
        new PropertyMetadata(OnCustomerChanged));

    public static readonly DependencyProperty CompanyProperty =
        DependencyProperty.Register("Company", typeof(string), typeof(YourUserControl), 
        new PropertyMetadata(OnCompanyChanged));

    public string Customer
    {
        get { return (string)GetValue(CustomerProperty); }
        set { SetValue(CustomerProperty, value); }
    }

    public string Company
    {
        get { return (string)GetValue(CompanyProperty); }
        set { SetValue(CompanyProperty, value); }
    }

    private static void OnCustomerChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var control = (YourUserControl)d;
        control.LoadCustomer(control.Customer, control.Company);
    }

    private static void OnCompanyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var control = (YourUserControl)d;
        control.LoadCustomer(control.Customer, control.Company);
    }

    private void LoadCustomer(string customer, string company)
    {
        // 根据customer和company的新值加载客户的逻辑
    }
}

现有计时器规避方案 #

通过DispatcherTimer延迟调用，确保两个属性都更新完成后再执行LoadCustomer，但这种方法依赖固定延迟，不够高效：

public class YourUserControl : UserControl
{
    public static readonly DependencyProperty CustomerProperty =
        DependencyProperty.Register("Customer", typeof(string), typeof(YourUserControl), 
        new PropertyMetadata(OnCustomerChanged));

    public static readonly DependencyProperty CompanyProperty =
        DependencyProperty.Register("Company", typeof(string), typeof(YourUserControl), 
        new PropertyMetadata(OnCompanyChanged));

    private DispatcherTimer timer;

    public string Customer
    {
        get { return (string)GetValue(CustomerProperty); }
        set { SetValue(CustomerProperty, value); }
    }

    public string Company
    {
        get { return (string)GetValue(CompanyProperty); }
        set { SetValue(CompanyProperty, value); }
    }

    private static void OnCustomerChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var control = (YourUserControl)d;
        control.ResetTimer();
    }

    private static void OnCompanyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var control = (YourUserControl)d;
        control.ResetTimer();
    }

    private void ResetTimer()
    {
        if (timer == null)
        {
            timer = new DispatcherTimer(TimeSpan.FromMilliseconds(100), DispatcherPriority.Normal, TimerElapsed, Dispatcher);
        }
        else
        {
            timer.Stop();
            timer.Start();
        }
    }

    private void TimerElapsed(object sender, EventArgs e)
    {
        timer.Stop();
        LoadCustomer(Customer, Company);
    }

    private void LoadCustomer(string customer, string company)
    {
        // 根据customer和company的新值加载客户的逻辑
    }
}

更高效的解决方案 #

方案1：利用WPF调度优先级延迟执行 #

WPF中，依赖属性的变更回调会在同一个Dispatcher队列中按顺序执行。通过Dispatcher.InvokeAsync指定低优先级（如Background），可以确保所有属性变更完成后再调用LoadCustomer，无需固定延迟：

public class YourUserControl : UserControl
{
    public static readonly DependencyProperty CustomerProperty =
        DependencyProperty.Register("Customer", typeof(string), typeof(YourUserControl), 
        new PropertyMetadata(OnCustomerChanged));

    public static readonly DependencyProperty CompanyProperty =
        DependencyProperty.Register("Company", typeof(string), typeof(YourUserControl), 
        new PropertyMetadata(OnCompanyChanged));

    private bool _isUpdatePending;

    public string Customer
    {
        get { return (string)GetValue(CustomerProperty); }
        set { SetValue(CustomerProperty, value); }
    }

    public string Company
    {
        get { return (string)GetValue(CompanyProperty); }
        set { SetValue(CompanyProperty, value); }
    }

    private static void OnCustomerChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var control = (YourUserControl)d;
        control.ScheduleLoadCustomer();
    }

    private static void OnCompanyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var control = (YourUserControl)d;
        control.ScheduleLoadCustomer();
    }

    private void ScheduleLoadCustomer()
    {
        if (!_isUpdatePending)
        {
            _isUpdatePending = true;
            // 用Background优先级，确保所有属性变更回调执行完毕后再执行
            Dispatcher.InvokeAsync(() =>
            {
                _isUpdatePending = false;
                LoadCustomer(Customer, Company);
            }, DispatcherPriority.Background);
        }
    }

    private void LoadCustomer(string customer, string company)
    {
        // 根据customer和company的新值加载客户的逻辑
    }
}

方案2：合并为单个依赖属性（根源优化） #

如果Customer和Company总是作为一个整体使用，直接定义包含这两个属性的模型类，将依赖属性合并为单个对象，从根源避免多属性变更的问题：

// 定义关联属性的模型类
public class CustomerCompanyPair
{
    public string Customer { get; set; }
    public string Company { get; set; }
}

// 修改UserControl
public class YourUserControl : UserControl
{
    public static readonly DependencyProperty CustomerCompanyProperty =
        DependencyProperty.Register("CustomerCompany", typeof(CustomerCompanyPair), typeof(YourUserControl), 
        new PropertyMetadata(OnCustomerCompanyChanged));

    public CustomerCompanyPair CustomerCompany
    {
        get { return (CustomerCompanyPair)GetValue(CustomerCompanyProperty); }
        set { SetValue(CustomerCompanyProperty, value); }
    }

    private static void OnCustomerCompanyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var control = (YourUserControl)d;
        var pair = control.CustomerCompany;
        if (pair != null)
        {
            control.LoadCustomer(pair.Customer, pair.Company);
        }
    }

    private void LoadCustomer(string customer, string company)
    {
        // 根据customer和company的新值加载客户的逻辑
    }
}

方案优势 #

• 方案1：无固定延迟，利用WPF调度机制确保所有属性更新完成后执行，效率更高，不会有不必要的等待；
• 方案2：从设计层面优化，将关联属性封装为单个对象，代码更简洁，逻辑更清晰，彻底避免多属性回调的冲突。

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