Implementieren von INotifyPropertyChanged - gibt es einen besseren Weg?

Question

Microsoft hätte etwas Flottes für INotifyPropertyChanged wie bei den automatischen Eigenschaften, geben Sie einfach {get; set; notify;} Ich halte das für sehr sinnvoll. Oder gibt es dabei irgendwelche Komplikationen?

Können wir selbst so etwas wie "notify" in unseren Eigenschaften implementieren. Gibt es eine anmutige Lösung für die Implementierung von INotifyPropertyChanged in Ihrer Klasse oder die einzige Möglichkeit, dies zu tun, besteht darin, die PropertyChanged Ereignis in jeder Eigenschaft.

Wenn nicht, können wir etwas schreiben, um den Code automatisch zu generieren, der die PropertyChanged Veranstaltung?

Answer 1

Ohne etwas wie Postsharp zu verwenden, verwendet die Minimalversion, die ich verwende, etwas wie:

public class Data : INotifyPropertyChanged
{
    // boiler-plate
    public event PropertyChangedEventHandler PropertyChanged;
    protected virtual void OnPropertyChanged(string propertyName)
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
    }
    protected bool SetField<T>(ref T field, T value, string propertyName)
    {
        if (EqualityComparer<T>.Default.Equals(field, value)) return false;
        field = value;
        OnPropertyChanged(propertyName);
        return true;
    }

    // props
    private string name;
    public string Name
    {
        get { return name; }
        set { SetField(ref name, value, "Name"); }
    }
}

Jede Eigenschaft ist dann einfach etwas wie:

private string name;
public string Name
{
    get { return name; }
    set { SetField(ref name, value, "Name"); }
}

die nicht sehr groß ist; sie kann auch als Basisklasse verwendet werden, wenn Sie wollen. Die bool Rückkehr von SetField sagt Ihnen, ob es ein No-op war, falls Sie eine andere Logik anwenden wollen.

---

oder noch einfacher mit C# 5:

protected bool SetField<T>(ref T field, T value,
    [CallerMemberName] string propertyName = null)
{...}

die wie folgt aufgerufen werden kann:

set { SetField(ref name, value); }

mit dem der Compiler die "Name" automatisch.

---

C# 6.0 macht die Implementierung einfacher:

protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
{
    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}

---

...und jetzt mit C#7:

protected void OnPropertyChanged(string propertyName)
   => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));

protected bool SetField<T>(ref T field, T value,[CallerMemberName] string propertyName =  null)
{
    if (EqualityComparer<T>.Default.Equals(field, value)) return false;
    field = value;
    OnPropertyChanged(propertyName);
    return true;
}

private string name;
public string Name
{
    get => name;
    set => SetField(ref name, value);
}

---

Und mit C# 8 und nullbaren Referenztypen würde es wie folgt aussehen:

public event PropertyChangedEventHandler? PropertyChanged;

protected void OnPropertyChanged(string propertyName) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));

protected bool SetField<T>(ref T field, T value, [CallerMemberName] string propertyName = "")
{
    if (EqualityComparer<T>.Default.Equals(field, value)) return false;
    field = value;
    OnPropertyChanged(propertyName);
    return true;
}

private string name;
public string Name
{
    get => name;
    set => SetField(ref name, value);
}

Answer 2

Ab .Net 4.5 gibt es endlich eine einfache Möglichkeit, dies zu tun.

.Net 4.5 führt ein neues Attribut für Anruferinformationen ein.

private void OnPropertyChanged<T>([CallerMemberName]string caller = null) {
     // make sure only to call this if the value actually changes

     var handler = PropertyChanged;
     if (handler != null) {
        handler(this, new PropertyChangedEventArgs(caller));
     }
}

Es ist wahrscheinlich eine gute Idee, der Funktion auch einen Vergleicher hinzuzufügen.

EqualityComparer<T>.Default.Equals

Weitere Beispiele aquí y aquí

Siehe auch Anruferinformationen (C# und Visual Basic)

Answer 3

Mir gefällt Marcs Lösung sehr gut, aber ich denke, sie kann leicht verbessert werden, um die Verwendung einer "magischen Zeichenkette" zu vermeiden (die das Refactoring nicht unterstützt). Anstatt den Eigenschaftsnamen als Zeichenkette zu verwenden, ist es einfach, einen Lambda-Ausdruck daraus zu machen:

private string name;
public string Name
{
    get { return name; }
    set { SetField(ref name, value, () => Name); }
}

Fügen Sie einfach die folgenden Methoden zu Marcs Code hinzu, dann klappt's:

protected virtual void OnPropertyChanged<T>(Expression<Func<T>> selectorExpression)
{
    if (selectorExpression == null)
        throw new ArgumentNullException("selectorExpression");
    MemberExpression body = selectorExpression.Body as MemberExpression;
    if (body == null)
        throw new ArgumentException("The body must be a member expression");
    OnPropertyChanged(body.Member.Name);
}

protected bool SetField<T>(ref T field, T value, Expression<Func<T>> selectorExpression)
{
    if (EqualityComparer<T>.Default.Equals(field, value)) return false;
    field = value;
    OnPropertyChanged(selectorExpression);
    return true;
}

Übrigens, dies wurde inspiriert durch dieser Blogbeitrag .

Answer 4

Außerdem gibt es Fody die eine AddINotifyPropertyChangedInterface Add-In, mit dem Sie dies schreiben können:

[AddINotifyPropertyChangedInterface]
public class Person 
{        
    public string GivenNames { get; set; }
    public string FamilyName { get; set; }
}

...und zur Kompilierzeit Benachrichtigungen über geänderte Eigenschaften einfügt.

Answer 5

Ich denke, die Leute sollten ein wenig mehr auf die Leistung achten; es wirkt sich wirklich auf die Benutzeroberfläche aus, wenn viele Objekte gebunden werden müssen (denken Sie an ein Raster mit mehr als 10.000 Zeilen), oder wenn sich der Wert des Objekts häufig ändert (Echtzeit-Überwachungsanwendung).

Ich habe verschiedene Umsetzungen, die ich hier und anderswo gefunden habe, miteinander verglichen; sehen Sie sich das an Leistungsvergleich von INotifyPropertyChanged-Implementierungen .

---

Hier ein kleiner Einblick in das Ergebnis