Beste Weg, um notify-Eigenschaft ändern, wenn das Feld in Abhängigkeit von einem anderen

Einer Weg ist, rufen Sie OnPropertyChanged mehrfach:

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

Dies ist nicht sehr einfach zu warten, jedoch. Eine weitere option ist das hinzufügen eines setter zu Ihr kommen-nur-Eigenschaft, und legen Sie es von der anderen Eigenschaft:

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");
    }
}

Gibt es keinen integrierten Mechanismus für die Verwendung von Parametern zu verdeutlichen, dass diese Beziehung zwischen Eigenschaften, es wäre jedoch möglich, erstellen Sie eine helper-Klasse, könnte es für Sie tun.

Habe ich eine ganz einfache Beispiel, wie das Aussehen könnte hier:

[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;
}

Dies ist nicht sonderlich robust (zum Beispiel, könnten Sie schaffen eine zirkuläre Abhängigkeit zwischen Eigenschaften und die Eigenschaft verändert würde, stecken in einer unendlichen Rekursion situation). Es kann auch einfacher gemacht, mit einige .NET 4.5 und C#6 Funktionen, aber das überlasse ich allen, die als übung für den Leser. Es wird wahrscheinlich auch nicht handhaben Vererbung sehr gut.

Um diese Klasse zu verwenden:

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 );
    }
}

InformationsquelleAutor Kyle

Obwohl in dieser Lösung die Veranstaltung ist nachwievor von den setter (also nicht genau was die Frage ist), gibt es eine schöne, überschaubare Weise für die Darstellung von Abhängigkeiten. Könnte jemand es nützlich finden.

Die Lösung ist, erstellen Sie einen benutzerdefinierten wrapper für die Auslösung von INotifyPropertyChanged events. Statt der Aufruf von OnPropertyChanged manuell definieren wir folgende mathods (vorzugsweise innerhalb einer Basisklasse, die wir zur späteren Wiederverwendung):

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);
    }
}

Diese Klasse bietet uns eine Möglichkeit der Einstellung einen Wert von einem bestimmten Bereich, ohne die Notwendigkeit zur Eingabe des namens einer proparty der call kommt von.

Wir haben auch eine Klasse definieren, die ermöglichen wird, verwenden Sie zum definieren von abhängigen Eigenschaften (Instanz dieser Klasse zurück SetPropertyValue mathod).

public class ViewModelPropertyChange
{
    private readonly ViewModelBase _viewModel;

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

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

        return this;
    }
}

Es einfach speichert eine Referenz auf ein Objekt, das geändert wird und macht es möglich, zum übertragen einer Veranstaltung zur nächsten-Eigenschaften.

Mit diesem können wir das erstellen einer Klasse, abgeleitet von ViewModelBase wie diese:

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;
    }
}

InformationsquelleAutor Tomasz