Лучший способ уведомить об изменении свойства, когда поле зависит от другого

Один из способов — просто вызвать OnPropertyChanged несколько раз:

public MyClass Item
{
    get
    {
        return _item;
    }
    protected set
    {
        _item = value;
        OnPropertyChanged("Item");
        OnPropertyChanged("Field");
    }
}

Однако это не очень ремонтопригодно. Другой вариант — добавить установщик к свойству только для получения и установить его из другого свойства:

public MyClass Item
{
    get
    {
        return _item;
    }
    protected set
    {
        _item = value;
        OnPropertyChanged("Item");
        Field = _item.Field;
    }
}

public object Field
{
    get
    {
        return _field;
    }
    private set
    {
        _field = value;
        OnPropertyChanged("Field");
    }
}

Не существует встроенного механизма использования атрибутов для указания этой связи между свойствами, однако можно было бы создать вспомогательный класс, который мог бы сделать это за вас.

Я сделал действительно простой пример того, как это может выглядеть здесь:

[AttributeUsage( AttributeTargets.Property )]
public class DepondsOnAttribute : Attribute
{
    public DepondsOnAttribute( string name )
    {
        Name = name;
    }

    public string Name { get; }
}

public class PropertyChangedNotifier<T> : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    public PropertyChangedNotifier( T owner )
    {
        mOwner = owner;
    }

    public void OnPropertyChanged( string propertyName )
    {
        var handler = PropertyChanged;
        if( handler != null ) handler( mOwner, new PropertyChangedEventArgs( propertyName ) );

        List<string> dependents;
        if( smPropertyDependencies.TryGetValue( propertyName, out dependents ) )
        {
            foreach( var dependent in dependents ) OnPropertyChanged( dependent );
        }
    }

    static PropertyChangedNotifier()
    {
        foreach( var property in typeof( T ).GetProperties() )
        {
            var dependsOn = property.GetCustomAttributes( true )
                                    .OfType<DepondsOnAttribute>()
                                    .Select( attribute => attribute.Name );

            foreach( var dependency in dependsOn )
            {
                List<string> list;
                if( !smPropertyDependencies.TryGetValue( dependency, out list ) )
                {
                    list = new List<string>();
                    smPropertyDependencies.Add( dependency, list );
                }

                if (property.Name == dependency)
                    throw new ApplicationException(String.Format("Property {0} of {1} cannot depends of itself", dependency, typeof(T).ToString()));

                list.Add( property.Name );
            }
        }
    }

    private static readonly Dictionary<string, List<string>> smPropertyDependencies = new Dictionary<string, List<string>>();

    private readonly T mOwner;
}

Это не очень надежно (например, вы можете создать циклическую зависимость между свойствами, и измененное свойство застрянет в ситуации бесконечной рекурсии). Его также можно упростить, используя некоторые возможности .NET 4.5 и C#6, но я оставлю все это в качестве упражнения для читателя. Вероятно, он также не очень хорошо справляется с наследованием.

Чтобы использовать этот класс:

public class Example : INotifyPropertyChanged
{
    private MyClass _item;
    private PropertyChangedNotifier<Example> _notifier;

    public Example()
    {
        _notifier = new PropertyChangedNotifier<Example>( this );
    }

    public event PropertyChangedEventHandler PropertyChanged
    {
        add { _notifier.PropertyChanged += value; }
        remove { _notifier.PropertyChanged -= value; }
    }

    public MyClass Item
    {
        get
        {
            return _item;
        }
        protected set
        {
            _item = value;
            OnPropertyChanged("Item");
        }
    }

    [DependsOn( "Item" )]
    public object Field
    {
        get
        {
            return _item.Field;
        }
    }
    protected void OnPropertyChanged(string propertyName)
    {
        _notifier.OnPropertyChanged( propertyName );
    }
}

Насколько я знаю, встроенного метода для этого нет. Я обычно делаю так:

public class Foo : INotifyPropertyChanged
{
    private Bar _bar1;

    public Bar Item
    {
        get { return _bar1; }
        set 
        { 
             SetField(ref _bar1, value); 
             ItemChanged();
        }
    }

    public string MyString
    {
        get { return _bar1.Item; }
    }

    private void ItemChanged()
    {
        OnPropertyChanged("MyString");
    }
}

public class Bar
{
    public string Item { get; set; }
}

Таким образом, у вас нет логики уведомления внутри свойства. На мой взгляд, так удобнее в сопровождении, и понятно, что делает метод.

Кроме того, я предпочитаю использовать этот метод, который я нашел где-то на SO, вместо жестко запрограммированного имени в классе (если имя свойства меняется, оно ломается).

OnPropertyChanged("MyString"); становится OnPropertyChanged(GetPropertyName(() => MyString));

где GetPropertyName это:

public static string GetPropertyName<T>(Expression<Func<T>> propertyLambda)
{
    if (propertyLambda == null) throw new ArgumentNullException("propertyLambda");

    var me = propertyLambda.Body as MemberExpression;

    if (me == null)
    {
        throw new ArgumentException("You must pass a lambda of the form: '() => Class.Property' or '() => object.Property'");
    }

    return me.Member.Name;
}

После этого каждый раз, когда я меняю свойство как имя, мне придется переименовывать свойство везде, где у меня есть GetPropertyName, вместо того, чтобы искать жестко заданные строковые значения.

Мне также любопытен встроенный способ сделать зависимость, поэтому я добавляю туда избранное :)

Несмотря на то, что в этом решении событие по-прежнему распространяется из установщика (так что это не совсем то, о чем идет речь), оно обеспечивает хороший, более управляемый способ представления зависимостей. Кто-то может найти это полезным.

Решение состоит в том, чтобы создать пользовательскую оболочку для запуска событий INotifyPropertyChanged. Вместо того, чтобы вызывать OnPropertyChanged вручную, мы можем определить следующие методы (желательно внутри базового класса, который мы будем использовать позже):

public abstract class ViewModelBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    internal void OnPropertyChanged(string propertyName)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    protected ViewModelPropertyChange SetPropertyValue<T>(ref T property, T value, [CallerMemberName] string propertyName = null)
    {
        property = value;
        OnPropertyChanged(propertyName);

        return new ViewModelPropertyChange(this);
    }
}

Этот класс предоставляет нам способ установки значения данного поля без необходимости указывать имя стороны, от которой исходит вызов.

Мы также должны определить класс, который позволит использовать для определения зависимых свойств (экземпляр этого класса возвращается из метода SetPropertyValue).

public class ViewModelPropertyChange
{
    private readonly ViewModelBase _viewModel;

    public ViewModelPropertyChange(ViewModelBase viewModel)
    {
        _viewModel = viewModel;
    }

    public ViewModelPropertyChange WithDependent(string name)
    {
        _viewModel.OnPropertyChanged(name);

        return this;
    }
}

Он просто хранит ссылку на объект, который изменяется, и позволяет распространить событие на следующие свойства.

При этом мы можем создать класс, производный от ViewModelBase, следующим образом:

class OurViewModel : ViewModelBase
{
    private int _partOne;
    public int PartOne
    {
        get => _partOne;
        set => SetPropertyValue(ref _partOne, value)
            .WithDependent(nameof(Total));
    }

    private int _partTwo;
    public int PartTwo
    {
        get => _partTwo;
        set => SetPropertyValue(ref _partTwo, value)
            .WithDependent(nameof(Total))
            .WithDependent(nameof(PartTwoPlus2));
    }

    public int Total {
        get => PartOne + PartTwo;
    }

    public int PartTwoPlus2 {
        get => PartTwo + 2;
    }
}