Come triggersre l’evento quando viene modificato il valore di una variabile?

Attualmente sto creando un’applicazione in C # usando Visual Studio. Voglio creare del codice in modo che quando una variabile ha un valore di 1, viene eseguita una determinata parte di codice. So che posso usare un’istruzione if, ma il problema è che il valore verrà modificato in un processo asincrono, quindi tecnicamente l’istruzione if potrebbe essere ignorata prima che il valore sia cambiato.

È ansible creare un gestore di eventi in modo che quando il valore della variabile cambia un evento viene triggersto? Se è così, come posso fare questo?

È del tutto ansible che avrei potuto fraintendere come funziona un’istruzione if! Qualsiasi aiuto sarebbe molto apprezzato.

Mi sembra che tu voglia creare una proprietà.

public int MyProperty { get { return _myProperty; } set { _myProperty = value; if (_myProperty == 1) { // DO SOMETHING HERE } } } private int _myProperty; 

Questo ti permette di eseguire del codice ogni volta che cambia il valore della proprietà. Potresti organizzare un evento qui, se lo volessi.

Puoi usare un setter di proprietà per generare un evento ogni volta che il valore di un campo sta per cambiare.

Puoi avere il tuo delegato EventHandler o puoi usare il famoso delegato System.EventHandler.

Di solito c’è uno schema per questo:

  1. Definire un evento pubblico con un delegato gestore eventi (che ha un argomento di tipo EventArgs).
  2. Definire un metodo virtuale protetto chiamato OnXXXXX (OnMyPropertyValueChanged ad esempio). In questo metodo è necessario verificare se il delegato del gestore di eventi è nullo e se non è ansible chiamarlo (significa che ci sono uno o più metodi collegati alla delega dell’evento).
  3. Chiama questo metodo protetto ogni volta che vuoi avvisare gli abbonati che qualcosa è cambiato.

Ecco un esempio

 private int _age; //#1 public event System.EventHandler AgeChanged; //#2 protected virtual void OnAgeChanged() { if (AgeChanged != null) AgeChanged(this,EventArgs.Empty); } public int Age { get { return _age; } set { //#3 _age=value; OnAgeChanged(); } } 

Il vantaggio di questo approccio è che consente alle altre classi che desiderano ereditare dalla class di modificare il comportamento se necessario.

Se si desidera rilevare un evento in un thread diverso da esso generato, è necessario fare attenzione a non modificare lo stato degli oggetti definiti in un altro thread che causerà il lancio di un’eccezione cross-thread. Per evitare ciò, è ansible utilizzare un metodo Invoke sull’object per cui si desidera modificare lo stato per assicurarsi che la modifica avvenga nello stesso thread in cui è stato generato l’evento o nel caso in cui si abbia a che fare con un Windows Form. può usare un BackgourndWorker per fare cose in un thread parallelo semplice e facile.

.NET framework fornisce in realtà un’interfaccia che è ansible utilizzare per la notifica ai sottoscrittori quando una proprietà è stata modificata: System.ComponentModel.INotifyPropertyChanged. Questa interfaccia ha un evento PropertyChanged. Solitamente è utilizzato in WPF per il binding ma l’ho trovato utile nei livelli aziendali come un modo per standardizzare le notifiche di modifica delle proprietà.

In termini di sicurezza del filo, inserisco una serratura sotto il setter in modo da non correre in nessuna condizione di gara.

Ecco i miei pensieri nel codice :):

 public class MyClass : INotifyPropertyChanged { private object _lock; public int MyProperty { get { return _myProperty; } set { lock(_lock) { //The property changed event will get fired whenever //the value changes. The subscriber will do work if the value is //1. This way you can keep your business logic outside of the setter if(value != _myProperty) { _myProperty = value; NotifyPropertyChanged("MyProperty"); } } } } private NotifyPropertyChanged(string propertyName) { //Raise PropertyChanged event } public event PropertyChangedEventHandler PropertyChanged; } public class MySubscriber { private MyClass _myClass; void PropertyChangedInMyClass(object sender, PropertyChangedEventArgs e) { switch(e.PropertyName) { case "MyProperty": DoWorkOnMyProperty(_myClass.MyProperty); break; } } void DoWorkOnMyProperty(int newValue) { if(newValue == 1) { //DO WORK HERE } } } 

Spero che questo sia utile 🙂

basta usare una proprietà

 int _theVariable; public int TheVariable{ get{return _theVariable;} set{ _theVariable = value; if ( _theVariable == 1){ //Do stuff here. } } }