Evénement NotifyPropertyChanged où les arguments d'événement contiennent l'ancienne valeur

Comme indiqué par les réponses, j'ai dû mettre en place mon propre solution. Pour le bénéfice des autres, je vous ai présenté ici:

L'Étendue Événement PropertyChanged

Cet événement a été spécialement conçu pour être compatible avec les anciennes propertyChanged événements. Il peut être utilisé de façon interchangeable avec le simple PropertyChangedEventArgs par les appelants. Bien sûr, dans de tels cas, il est de la responsabilité du gestionnaire d'événements pour vérifier si le passé PropertyChangedEventArgs peut être abattu à un PropertyChangedExtendedEventArgs, si ils veulent l'utiliser. Pas passer n'est nécessaire si tous qu'ils sont intéressés à la PropertyName propriété.

public class PropertyChangedExtendedEventArgs<T> : PropertyChangedEventArgs
{
    public virtual T OldValue { get; private set; }
    public virtual T NewValue { get; private set; }

    public PropertyChangedExtendedEventArgs(string propertyName, T oldValue, T newValue)
        : base(propertyName)
    {
        OldValue = oldValue;
        NewValue = newValue;
    }
}

L'Étendue PropertyChanged Interface

Si, le programmeur a voulu créer un événement qui forces la notification propriétés à inclure une ancienne valeur et la nouvelle valeur, ils ont besoin d'implémenter l'interface suivante:

//Summary: Notifies clients that a property value is changing, but includes extended event infomation
/* The following NotifyPropertyChanged Interface is employed when you wish to enforce the inclusion of old and
 * new values. (Users must provide PropertyChangedExtendedEventArgs, PropertyChangedEventArgs are disallowed.) */
public interface INotifyPropertyChangedExtended<T>
{
    event PropertyChangedExtendedEventHandler<T> PropertyChanged;
}

public delegate void PropertyChangedExtendedEventHandler<T>(object sender, PropertyChangedExtendedEventArgs<T> e);

---

Exemple 1

L'utilisateur peut maintenant spécifier un plus avancées NotifyPropertyChanged méthode qui permet d'accesseurs de propriété à passer dans leur ancienne valeur:

public String testString
{
    get { return testString; }
    set
    {
        String temp = testString;
        testValue2 = value;
        NotifyPropertyChanged("TestString", temp, value);
    }
}

Où votre nouveau NotifyPropertyChanged méthode ressemble à ceci:

protected void NotifyPropertyChanged<T>(string propertyName, T oldvalue, T newvalue)
{
    OnPropertyChanged(this, new PropertyChangedExtendedEventArgs<T>(propertyName, oldvalue, newvalue));
}

Et OnPropertyChanged est toujours la même:

public virtual void OnPropertyChanged(object sender, PropertyChangedEventArgs e)
{
    PropertyChangedEventHandler handler = PropertyChanged;
    if (handler != null)
        handler(sender, e);
}

Exemple 2

Ou si vous préférez utiliser des expressions lambda et de faire disparaître codée en dur le nom de propriété des chaînes entièrement, vous pouvez utiliser les éléments suivants:

public String TestString
{
    get { return testString; }
    private set { SetNotifyingProperty(() => TestString, ref testString, value); }
}

Qui est pris en charge par la suite de magic:

protected void SetNotifyingProperty<T>(Expression<Func<T>> expression, ref T field, T value)
{
    if (field == null || !field.Equals(value))
    {
        T oldValue = field;
        field = value;
        OnPropertyChanged(this, new PropertyChangedExtendedEventArgs<T>(GetPropertyName(expression), oldValue, value));
    }
}
protected string GetPropertyName<T>(Expression<Func<T>> expression)
{
    MemberExpression memberExpression = (MemberExpression)expression.Body;
    return memberExpression.Member.Name;
}

Performance

Si la performance est un sujet de préoccupation, voir à cette question: La mise en œuvre de NotifyPropertyChanged sans chaînes magiques.

En résumé, la charge est minime. L'ajout de l'ancienne valeur et de passer à l'étendue de l'événement est d'environ 15% de ralentissement, en permettant encore de l'ordre de un million de notifications de propriété par seconde, et de passer à des expressions lambda est un 5 fois le ralentissement permettant d'environ une centaine de milliers de notifications de propriété par seconde. Ces chiffres sont loin d'être en mesure de former un goulot d'étranglement dans une INTERFACE utilisateur pilotée par l'application.

Si vous ne voulez ancienne valeur, vous pouvez invoquer l'événement avant de changer la valeur de la propriété. Mais que serait un départ de la façon dont cet événement est utilisé normalement, je voudrais donc créer une interface dédiée et args.