在依赖对象上使用 INPC 来支持内置转换行为是错误/不好的吗?

我们有一个DependencyObject，它将Value属性定义为DP。它还定义一个 Presets 集合，该集合表示某些预定义值的友好名称。

我们的 UI 应该的工作方式是绑定到 Value 属性时，如果值与预设匹配，则显示友好名称，否则我们直接显示值。

使用转换器是出局的，因为没有可靠的方法来传递预设（按项目定义，它们不共享）和执行双向绑定，所以我们的想法是在对象上公开一个 FriendlyValue 属性并将其用于 UI 中的绑定，让它在内部处理转换。

由于 FriendlyValue

依赖于已经存在的 Value DependencyProperty，我们认为我们只是将转换逻辑包装在 CLR getters/setter 中，但这意味着当实际的值 DP 更改时，它需要通知 UI FriendlyValue 也已更新，并且由于 FriendlyValue 是 CLR 属性，我们需要为该特定属性支持 INPC。

我的问题是，这是处理此问题的正确/建议方法，还是我应该使用第二个 DP，监视其更改处理程序并相应地设置其他属性，添加状态变量以阻止一个设置另一个，然后设置第一个，然后再次更新另一个，等等。

下面是对象属性的代码...

public static readonly DependencyProperty PresetsProperty = DependencyProperty.Register(
    "Presets",
    typeof(List<Preset>),
    typeof(MyObject),
    new UIPropertyMetadata(null));
public List<Preset> Presets
{
    get { return (List<Preset>)GetValue(PresetsProperty); }
    set { SetValue(PresetsProperty, value); }
}
public static readonly DependencyProperty ValueProperty = DependencyProperty.Register(
    "Value",
    typeof(string),
    typeof(MyObject),
    new UIPropertyMetadata(null, (s,e) => {
        var myObject = (MyObject)s;
        myObject.OnPropertyChanged("FriendlyValue");
    }));
public string Value
{
    get { return (string)GetValue(ValueProperty); }
    set { SetValue(ValueProperty, value); }
}

public string FriendlyValue
{
    get
    {
        var foundPreset = Presets.FirstOrDefault(preset => preset.Value == this.Value);
        return (foundPreset != null)
            ? foundPreset.FriendlyName
            : this.Value;
    }
    set
    {
        var foundPreset = Presets.FirstOrDefault(preset => preset.FriendlyName == value);
        this.Value = (foundPreset != null)
            ? foundPreset.Value
            : value;
        // Note: We don't raise INPC notification here.  It's raised in the Value's change handler
    }
}
#region INotifyPropertyChanged Members
    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged(string propertyName)
    {
        if(PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
#endregion

那么，这是否被认为是内置转换器行为的良好做法？

using Preset = Tuple<string, string>;
public class MyObject : DependencyObject
{
    private readonly IList<Tuple<string, string>> _presets = new List<Preset> {
        new Preset("1", "good"),
        new Preset("2", "bad"),
    };
    public static readonly DependencyProperty ValueProperty = DependencyProperty.Register(
        "Value", typeof(string), typeof(MyObject),
        new PropertyMetadata(null,
            (o, e) => ((MyObject)o).ValuePropertyChanged((string)e.NewValue)));
    private static readonly DependencyProperty FriendlyValueProperty = DependencyProperty.Register(
        "FriendlyValue", typeof(string), typeof(MyObject),
        new PropertyMetadata(null,
            (o, e) => ((MyObject)o).FriendlyValuePropertyChanged((string)e.NewValue)));
    public string Value
    {
        get { return (string)GetValue(ValueProperty); }
        set { SetValue(ValueProperty, value); }
    }
    public string FriendlyValue
    {
        get { return (string)GetValue(FriendlyValueProperty); }
        set { SetValue(FriendlyValueProperty, value); }
    }
    private void ValuePropertyChanged (string newValue)
    {
        var preset = _presets.FirstOrDefault(p => p.Item1 == newValue);
        FriendlyValue = preset != null ? preset.Item2 : newValue;
    }
    private void FriendlyValuePropertyChanged (string newValue)
    {
        var preset = _presets.FirstOrDefault(p => p.Item2 == newValue);
        Value = preset != null ? preset.Item1 : newValue;
    }
}