Question

I have the following WPF code. You can see in the comments there that I have a problem with my OnValueChanged handler. I need the code there to differentiate between a Value set from the UI (through various bindings) and one set from the manager class. I had hoped that DependencyPropertyChangedEventArgs would have some kind of source that I could use to differentiate this, but I don’t see anything like that. Ideas? Is there some way to set a WPF DependencyProperty without triggering its PropertyChanged handler? Thanks for your time.

public class GaugeBaseControl : UserControl
{
    protected readonly AssetModelManager Manager;
    public GaugeBaseControl(AssetModelManager mgr)
    {
        Manager = mgr;
        if(mgr != null)
            mgr.TelemetryValueChanged += MgrOnTelemetryValueChanged; // coming on background thread
    }

    private void MgrOnTelemetryValueChanged(KeyValuePair<string, object> keyValuePair)
    {
        if(_localTelemetryId != keyValuePair.Key)
            return;

        Dispatcher.Invoke(DispatcherPriority.Normal, new Action(() =>
        {
            if (!Equals(Value, keyValuePair.Value))
                Value = keyValuePair.Value;
        }));
    }

    private static void OnValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var gbc = (GaugeBaseControl) d;
        var id = gbc.TelemetryId;
        if (!string.IsNullOrEmpty(id))
        {
            // this is the problem:
            // I need to always set gbc.Manager[id] if this event was triggered from the UI (even when equal)
            // however, if it was triggered by TelemetryValueChanged then we don't want to go around in circles
            if (!Equals(gbc.Manager[id], e.NewValue))
                gbc.Manager[id] = e.NewValue;
        }
    }

    private string _localTelemetryId; // to save us a cross-thread check
    private static void OnTelemetryIdChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var gbc = (GaugeBaseControl)d;
        var tid = gbc.TelemetryId;
        gbc._localTelemetryId = tid;
        gbc.Value = string.IsNullOrEmpty(tid) ? null : gbc.Manager[tid];
    }

    public static readonly DependencyProperty TelmetryIdProperty = DependencyProperty.Register("TelemetryId", typeof(string), typeof(GaugeBaseControl), new PropertyMetadata(OnTelemetryIdChanged));
    public static readonly DependencyProperty ValueProperty = DependencyProperty.Register("Value", typeof(object), typeof(GaugeBaseControl), new PropertyMetadata(OnValueChanged));

    public object Value
    {
        get { return GetValue(ValueProperty); }
        set { SetValue(ValueProperty, value);}
    }

    public string TelemetryId
    {
        get { return (string)GetValue(TelmetryIdProperty); }
        set { SetValue(TelmetryIdProperty, value); }
    }
}

Answer 1

It seems a bit hackish, but it is the best shot i could come up with without changing the architecture. You could stop listening on the TelemetryValueChanged event while doing your internal update to stop the roundtrip like so:

internal void SetManagerIdInternal(string id, object value)
{
    if(mgr != null)
    {
        mgr.TelemetryValueChanged -= MgrOnTelemetryValueChanged;
        mgr[id] = value;
        mgr.TelemetryValueChanged += MgrOnTelemetryValueChanged;
    }
}

And use it like this:

if (!Equals(gbc.Manager[id], e.NewValue))
    SetManagerIdInternal(id, e.NewValue);

You could also use a private field to just skip doing work without unregistering/reregistering the event in MgrOnTelemetryValueChanged wich might be better performance wise, but i haven’t tested it.