C#: crea un evento para cuando cambien los valores de campo de un objeto

Question

Hola chicos, ¿hay alguna manera de crear un evento que se active cuando cambien los atributos/valores de campo de un objeto? Por ejemplo, si el objeto tiene un campo llamado

private int number; 

Y el usuario realiza una acción que actualizar ese número, un evento sería fuego que actualizar todos los cuadros de texto en el formulario para mostrar los valores actuales de campo?

EDIT: Lo sentimos, sí propiedades se han creado para cada campo

Answer 1

la convierten en una propiedad en lugar de un campo, e implementar INotifyPropertyChanged en su clase:

class YourClass : INotifyPropertyChanged 
{ 

    private int _number; 
    public int Number 
    { 
     get { return _number; } 
     private set 
     { 
      _number = value; 
      OnPropertyChanged("Number"); 
     } 
    } 

    public event PropertyChangedEventHandler PropertyChanged; 

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

} 

continuación, se puede escuchar de forma explícita para el evento PropertyChanged, o utilizar un enlace de datos que controlará automáticamente

Answer 2

suena como usted debe comprobar fuera de la interfaz INotifyPropertyChanged. Sin embargo, no funciona para los campos, y tendrá que implementarlo manualmente.

Answer 3

¿Dónde vas a usar esto?

Si va a utilizar esto en una aplicación cliente, entonces implementing INotifyPropertyChanged es la forma recomendada de trabajar.

Answer 4

Debe usar captadores y definidores definidos por el usuario (es decir, propiedades) para activar manualmente el evento. Mira a este código, que debe ser bastante simple:

// We declare a delegate to handle our event 

delegate void StateChangedEventHandler(object sender, StateChangedEventArgs e); 

// We declare event arguments class to specify, which value has changed to which value. 

public class StateChangedEventArgs: EventArgs 
{ 
    string propertyName; 

    object oldValue; 
    object newValue; 

    /// <summary> 
    /// This is a constructor. 
    /// </summary> 
    public StateChangedEventArgs(string propertyName, object oldValue, object newValue) 
    { 
     this.propertyName = propertyName; 

     this.oldValue = oldValue; 
     this.newValue = newValue; 
    } 
} 

/// <summary> 
/// Our class that we wish to notify of state changes. 
/// </summary> 
public class Widget 
{ 
    private int x; 

    public event StateChangedEventHandler StateChanged; 

    // That is the user-defined property that fires the event manually; 

    public int Widget_X 
    { 
     get { return x; } 
     set 
     { 
      if (x != value) 
      { 
       int oldX = x; 
       x = value; 

       // The golden string which fires the event: 
       if(StateChanged != null) StateChanged.Invoke(this, new StateChangedEventArgs("x", oldX, x); 
      } 
     } 
    } 
} 

Nuestra variable miembro se define privada, por lo que nadie fuera de la clase Widget puede acceder a ella; se ven obligados a utilizar la propiedad Widget_X, y una vez que lo hacen, hay dos casos:

• consiguen la variable x. Nada que hacer.
• Establecieron la variable x en el mismo valor que tenía antes. Nada que hacer. Lo revisamos dentro del setter.
• Establecen la variable x y la cambian. Ahí es donde disparamos el evento.

Es fundamental comprobar si tenemos algún controlador de eventos registrado (es decir, nuestro evento no es nulo) antes de invocar el evento. En otro caso, obtendremos una excepción.