public class PropertyChangedBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

public class MyViewModel : PropertyChangedBase
{
   double _myValue;

    public double MyValue
    {
        get
        {
            return _myValue;
        }
        set
        {
            if (_myValue != value)
            {
                _myValue = value;

                OnPropertyChanged("MyValue");
            }
        }
    }
}

public class ValueViewModel<T> : ViewModel
{
    T _value;

    public T Value
    {
        get
        {
            return _value;
        }
        set
        {
            if (!object.Equals(_value, value))
            {
                _value = value;

                OnPropertyChanged("Value");
            }
        }
    }
}

public class MyViewModel : ViewModel
{
    public ValueViewModel<double> MyValueViewModel { get; set; }
}

<!-- Вместо вот такого -->
<control MyValue="{Binding MyValue}"/>

<!-- Придется писать вот такое -->
<control MyValue="{Binding MyValueViewModel.Value}"/>

_FR>Ой как грусно. Устанавливать базу ради реализации одного единственного события — это

_FR>Ну вот вы и "придумали" свои собственные свойства зависимостей

If you look at the WPF/SL control architecture, you’ll notice something quite interesting: A Control’s behavior and its View are separated. The platform splits controls into two parts, the Control class (ViewModel) and the ControlTemplate (View). Yes, one reason why MVVM makes sense is because the platform itself is architected in that way. Recalling the previous point: How do you describe the interaction between the Control Class and the ControlTemplate? TemplateBinding. Of coarse, you could venture to build your own MVVM architecture by creating your VMs as descendants of Control and then defining Views as ControlTemplates (please don’t do this). But, there is a better way. DataTemplates extend the same concept by allowing Views over any type of object.

public class MyViewModel : ViewModel
{
    public ValueViewModel<double?> MyValueViewModel { get; set; }
}

...

var a = new MyViewModel();
if (a.Value.HasValue)
   Console.Write(a.MyValueViewModel.Value.Value);

public notificable decimal? Cost 
{ 
   get; 
   set; 
}

        public string Name
        {
            get { return _name; }
            set
            {
                if (_name != value) 
                {
                   _name = value;
                   OnPropertyChanged(() => Name);
                }
            }
        }

// определяем базовый класс-хелпер
class PropertyChangedBase<TOwner> {
...

// value view model proxy
public struct ValueHelper<T> {
    ValueViewModel<T> _target;

    // proxy to event
    public event EventHandler<T> ValueChanged {
        add { _target.ValueChanged += value; }
        remove { _target.ValueChanged -= value; }
    } 

    // proxy to value
    public T Value { get {return _target.Value; } set { _Target.Value = value;} }

    // чтобы связь не потерять
    public TOwner Owner { get; private set; }
}

...
}

// используем
class SomeObjType : PropertyChangedBase<SomeObjType> {
    
    ValueViewModel<double> _value;

    public ValueHelper<double> Value { get { return new ValueHelper<double>(this, _value); } } 
}

struct Bind<T> {
    public IPropertyBag Src;
    public PropertyDef<T> SrcProp;

    public IPropertyBag Dst;
    public PropertyDef<T> DstProp;
}

interface IPropertyBag {
    T this[PropertyDef<T> prop] { get; set; }
    void OnPropertyChanged(PropertyDef<T> prop);
}

   if (Comparer<T>.Default.Compare(_value, value) != 0)

MM>Подниму тему! Мне нравится этот вариант, но вот возник затык с добавлением таких фичей, как callback на изменение и, допустим, валидацию. Есть ли варианты? Возможно я пропустил их при чтении темы

interface IViewModel<T> : INotifyPropertyChanged, IEditableObject
{
   Func<T, bool> Validator { get; } 
}

class ValueViewModel<T> : IViewModel<T>
{
   public Func<T, bool> Validator { get; private set; } 
}

public class MyViewModel : ViewModel
{
    public MyViewModel()  
    {
      MyValueViewModel = new ValueViewModel<double> { Validator = a => a > 0 };
    }

    public IViewModel<double> MyValueViewModel { get; private set; }
}