WPF INotifyPropertyChanged für verknüpfte schreibgeschützte Eigenschaften

Question

Ich versuche zu verstehen, wie die Benutzeroberfläche zu aktualisieren ist, wenn ich eine schreibgeschützte Eigenschaft habe, die von einer anderen Eigenschaft abhängig ist, so dass Änderungen an einer Eigenschaft beide UI-Elemente aktualisieren (in diesem Fall) eine Textbox und eine nur-Lese-Textbox. zum Beispiel:

public class raz : INotifyPropertyChanged 
{ 

    int _foo; 
    public int foo 
    { 
    get 
    { 
     return _foo; 
    } 
    set 
    { 
     _foo = value; 
     onPropertyChanged(this, "foo"); 
    } 
    } 

    public int bar 
    { 
    get 
    { 
     return foo*foo; 
    } 
    } 

    public raz() 
    { 

    } 

    public event PropertyChangedEventHandler PropertyChanged; 
    private void onPropertyChanged(object sender, string propertyName) 
    { 
    if(this.PropertyChanged != null) 
    { 
     PropertyChanged(sender, new PropertyChangedEventArgs(propertyName)); 
    } 
    } 
} 

Mein Verständnis ist, dass Bar wird nicht automatisch die Benutzeroberfläche aktualisiert, wenn foo modifiziert Was ist der richtige Weg, auf diese Weise

Answer 1

One zu tun.? zeigen an, dass die Bar geändert wurde, ist ein Anruf zu onPropertyChanged(this, "bar") im foo Setter hinzuzufügen. Hässlich wie die Hölle, ich weiß, aber da hast du es.

Wenn foo in einer Vorgängerklasse definiert ist oder Sie anderweitig keinen Zugriff auf die Implementierung des Setter haben, können Sie das PropertyChanged-Ereignis abonnieren, so dass Sie auch eine Änderung "foo" sehen können feuern Sie eine "bar" Änderungsbenachrichtigung ab. Das Abonnieren von Ereignissen auf Ihrer eigenen Objektinstanz ist gleichermaßen hässlich, aber es wird die Aufgabe erledigen.

Answer 2

Abhängig von den Kosten der Berechnung und wie häufig Sie erwarten, dass es verwendet wird, kann es vorteilhaft sein, es zu einer privaten Set-Eigenschaft zu machen und den Wert zu berechnen, wenn foo festgelegt wird, anstatt die bar zu berechnen bekommen heißt. Dies ist im Grunde eine Caching-Lösung, und Sie können dann die Benachrichtigung über die Änderung von Eigenschaften als Teil des privaten Setter bar tun. Ich bevorzuge diesen Ansatz im Allgemeinen, hauptsächlich weil ich AOP (über Postsharp) verwende, um die tatsächliche INotifyPropertyChanged Boilerplate zu implementieren.

-Dan

Answer 3

könnten Sie einfach

OnPropertyChanged(this, "bar"); 

von überall in dieser Klasse nennen ... Sie kalt, auch so gehen:

public raz() 
    { 
     this.PropertyChanged += new PropertyChangedEventHandler(raz_PropertyChanged); 
    } 

    void raz_PropertyChanged(object sender, PropertyChangedEventArgs e) 
    { 
     if(e.PropertyName == "foo") 
     { 
      onPropertyChanged(this, "bar"); 
     } 
    } 

Answer 4

Wenn dies ein ernstes Problem (mit "ernst", ich meine, Sie haben eine nicht-triviale Anzahl von abhängigen schreibgeschützten Eigenschaften), können Sie eine Abhängigkeitskarte erstellen, zB:

private static Dictionary<string, string[]> _DependencyMap = 
    new Dictionary<string, string[]> 
{ 
    {"Foo", new[] { "Bar", "Baz" } }, 
}; 

und dann verweisen sie in OnPropertyChanged:

PropertyChanged(this, new PropertyChangedEventArgs(propertyName)) 
if (_DependencyMap.ContainsKey(propertyName)) 
{ 
    foreach (string p in _DependencyMap[propertyName]) 
    { 
     PropertyChanged(this, new PropertyChangedEventArgs(p)) 
    } 
} 

Dies ist nicht von Natur aus viel anders als nur mehrere Putting OnPropertyChanged Anrufe in der Foo Setter, da man die Abhängigkeit der Karte für jeden neuen abhängig aktualisieren müssen Eigenschaft, die Sie hinzufügen.

Aber es macht es möglich, eine PropertyChangeDependsOnAttribute nachträglich zu implementieren und Reflektion verwenden, um den Typ zu scannen und die Abhängigkeitskarte zu erstellen. So würde Ihre Eigenschaft etwa wie folgt aussehen:

Answer 5

Wenn Sie nur Bar für UI-Zwecke verwenden, können Sie es vollständig aus Ihrem Modell entfernen. Sie könnten das UI-Element an die Eigenschaft foo binden und einen benutzerdefinierten Wertkonverter verwenden, um das Ergebnis von foo in foo * foo zu ändern.

In WPF gibt es oft eine Menge Möglichkeiten, um das gleiche zu erreichen. Oft gibt es keinen richtigen Weg, nur eine persönliche Präferenz.

Answer 6

Ich bin ziemlich sicher, dass es in einer deklarativen Art möglich sein muss, aber mein erster Versuch, dieses Problem zu lösen, war ein Misserfolg. Die Lösung, die ich erreichen möchte, verwendet Lambda Expressions, um dies zu definieren. Da Ausdrücke analysiert werden können (??), sollte es möglich sein, die Ausdrücke zu analysieren und an alle NotifyPropertyChanged-Ereignisse anzuhängen, um über Änderungen von abhängigen Daten benachrichtigt zu werden.

in ContinousLinq, das funktioniert hervorragend für Sammlungen.

private SelfUpdatingExpression<int> m_fooExp = new SelfUpdatingExpression<int>(this,()=> Foo * Foo); 

public int Foo 
{ 
    get 
    { 
     return m_fooExp.Value; 
    } 
} 

aber unfortionatly i fehle auf fundamentional wissen, wie in Ausdrücken und Linq :(

Answer 7

Ich weiß, dies ist eine alte Frage, aber es ist das erste Google-Ergebnis von „NotifyPropertyChanged verknüpfter Eigenschaften“, so dass ich denke, es ist angemessen, diese Antwort hinzufügen, so dass es einige konkrete Code ist

I Robert Rossney Vorschlag verwendet und ein benutzerdefiniertes Attribut erstellt, verwendet es dann in einem Property Veranstaltung Basisansicht Modell

Die Attributklasse..:

Und in meinem Basisansicht Modell (das alle anderen Modelle WPF Ansicht erben von):

public abstract class BaseViewModel : INotifyPropertyChanged 
{ 
    protected Dictionary<string, List<string>> DependencyMap; 

    protected BaseViewModel() 
    { 
     DependencyMap = new Dictionary<string, List<string>>(); 

     foreach (var property in GetType().GetProperties()) 
     { 
      var attributes = property.GetCustomAttributes<DependsOnPropertyAttribute>(); 
      foreach (var dependsAttr in attributes) 
      { 
       if (dependsAttr == null) 
        continue; 

       var dependence = dependsAttr.Dependence; 
       if (!DependencyMap.ContainsKey(dependence)) 
        DependencyMap.Add(dependence, new List<string>()); 
       DependencyMap[dependence].Add(property.Name); 
      } 
     } 
    } 

    public event PropertyChangedEventHandler PropertyChanged; 
    protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null) 
    { 
     var handler = PropertyChanged; 
     if (handler == null) 
      return; 

     handler(this, new PropertyChangedEventArgs(propertyName)); 

     if (!DependencyMap.ContainsKey(propertyName)) 
      return; 

     foreach (var dependentProperty in DependencyMap[propertyName]) 
     { 
      handler(this, new PropertyChangedEventArgs(dependentProperty)); 
     } 
    } 
} 

Dies ermöglicht es mir jetzt Eigenschaften leicht wie so, markieren:

public int NormalProperty 
{ 
    get {return _model.modelProperty; } 
    set 
    { 
     _model.modelProperty = value; 
     OnPropertyChanged(); 
    } 
} 

[DependsOnProperty(nameof(NormalProperty))] 
public int CalculatedProperty 
{ 
    get { return _model.modelProperty + 1; } 
}