Lancer un événement à chaque fois que la valeur d'une propriété est modifiée ?

Question

Il y a une propriété, elle s'appelle ImageFullPath1

public string ImageFullPath1 {get; set; }

Je vais déclencher un événement chaque fois que sa valeur change. Je suis conscient de la modification INotifyPropertyChanged mais je veux le faire avec des événements.

Answer 1

Le site INotifyPropertyChanged interface est mis en œuvre avec des événements. L'interface n'a qu'un seul membre, PropertyChanged qui est un événement auquel les consommateurs peuvent s'abonner.

La version que Richard a postée n'est pas sûre. Voici comment implémenter cette interface en toute sécurité :

public class MyClass : INotifyPropertyChanged
{
    private string imageFullPath;

    protected void OnPropertyChanged(PropertyChangedEventArgs e)
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null)
            handler(this, e);
    }

    protected void OnPropertyChanged(string propertyName)
    {
        OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
    }

    public string ImageFullPath
    {
        get { return imageFullPath; }
        set
        {
            if (value != imageFullPath)
            {
                imageFullPath = value;
                OnPropertyChanged("ImageFullPath");
            }
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

Notez que cela fait les choses suivantes :

• Abstraite les méthodes de notification de changement de propriété afin que vous puissiez facilement l'appliquer à d'autres propriétés ;

• Fait une copie de la PropertyChanged délégué avant en essayant de l'invoquer (si vous ne le faites pas, cela créera une situation de concurrence).

• Met correctement en œuvre le INotifyPropertyChanged interface.

Si vous voulez en outre, créer une notification pour un spécifique en cours de modification, vous pouvez ajouter le code suivant :

protected void OnImageFullPathChanged(EventArgs e)
{
    EventHandler handler = ImageFullPathChanged;
    if (handler != null)
        handler(this, e);
}

public event EventHandler ImageFullPathChanged;

Ajoutez ensuite la ligne OnImageFullPathChanged(EventArgs.Empty) après la ligne OnPropertyChanged("ImageFullPath") .

Puisque nous avons .Net 4.5, il existe l'option CallerMemberAttribute qui permet de se débarrasser de la chaîne codée en dur pour le nom de la propriété dans le code source :

    protected void OnPropertyChanged(
        [System.Runtime.CompilerServices.CallerMemberName] string propertyName = "")
    {
        OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
    }

    public string ImageFullPath
    {
        get { return imageFullPath; }
        set
        {
            if (value != imageFullPath)
            {
                imageFullPath = value;
                OnPropertyChanged();
            }
        }
    }

Answer 2

J'utilise en grande partie les mêmes modèles qu'Aaronaught, mais si vous avez beaucoup de propriétés, il peut être intéressant d'utiliser une petite méthode magique générique pour rendre votre code un peu plus SEC

public class TheClass : INotifyPropertyChanged {
    private int _property1;
    private string _property2;
    private double _property3;

    protected virtual void OnPropertyChanged(PropertyChangedEventArgs e) {
        PropertyChangedEventHandler handler = PropertyChanged;
        if(handler != null) {
            handler(this, e);
        }
    }

    protected void SetPropertyField<T>(string propertyName, ref T field, T newValue) {
        if(!EqualityComparer<T>.Default.Equals(field, newValue)) {
            field = newValue;
            OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
        }
    }

    public int Property1 {
        get { return _property1; }
        set { SetPropertyField("Property1", ref _property1, value); }
    }
    public string Property2 {
        get { return _property2; }
        set { SetPropertyField("Property2", ref _property2, value); }
    }
    public double Property3 {
        get { return _property3; }
        set { SetPropertyField("Property3", ref _property3, value); }
    }

    #region INotifyPropertyChanged Members

    public event PropertyChangedEventHandler PropertyChanged;

    #endregion
}

En général, je fais également en sorte que la méthode OnPropertyChanged soit virtuelle pour permettre aux sous-classes de la surcharger afin d'attraper les changements de propriété.

Answer 3

Le déclenchement d'un événement lorsqu'une propriété est modifiée est précisément ce que fait INotifyPropertyChanged. L'implémentation de INotifyPropertyChanged ne nécessite qu'un seul membre, à savoir l'événement PropertyChanged. Tout ce que vous implémenterez vous-même sera probablement identique à cette implémentation, il n'y a donc aucun avantage à ne pas l'utiliser.

Answer 4

public event EventHandler ImageFullPath1Changed;

public string ImageFullPath1
{
    get
    {
        // insert getter logic
    }
    set
    {
        // insert setter logic       

        // EDIT -- this example is not thread safe -- do not use in production code
        if (ImageFullPath1Changed != null && value != _backingField)
            ImageFullPath1Changed(this, new EventArgs(/*whatever*/);
    }
}                        

Cela dit, je suis tout à fait d'accord avec Ryan. Ce scénario est précisément la raison pour laquelle INotifyPropertyChanged existe.

Answer 5

Si vous modifiez votre propriété pour utiliser un champ de sauvegarde (au lieu d'une propriété automatique), vous pouvez procéder comme suit :

public event EventHandler ImageFullPath1Changed;
private string _imageFullPath1 = string.Empty;

public string ImageFullPath1 
{
  get
  {
    return imageFullPath1 ;
  }
  set
  {
    if (_imageFullPath1 != value)
    { 
      _imageFullPath1 = value;

      EventHandler handler = ImageFullPathChanged;
      if (handler != null)
        handler(this, e);
    }
  }
}