Como acionar evento quando o valor de uma variável é alterado?

Atualmente estou criando um aplicativo em c # usando o Visual Studio. Eu quero criar algum código para que, quando uma variável tiver um valor igual a 1, um certo código seja executado. Eu sei que posso usar uma instrução if, mas o problema é que o valor será alterado em um processo asynchronous, portanto, tecnicamente a instrução if pode ser ignorada antes que o valor seja alterado.

É possível criar um manipulador de events para que, quando o valor da variável for alterado, um evento seja acionado? Se sim, como posso fazer isso?

É completamente possível que eu tenha entendido mal como uma declaração if funciona! Qualquer ajuda seria muito apreciada.

Parece que você quer criar uma propriedade.

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

Isso permite que você execute algum código sempre que o valor da propriedade for alterado. Você poderia criar um evento aqui, se quisesse.

Você pode usar um setter de propriedade para gerar um evento sempre que o valor de um campo for alterado.

Você pode ter seu próprio delegado EventHandler ou usar o famoso delegado System.EventHandler.

Geralmente há um padrão para isso:

  1. Defina um evento público com um delegado do manipulador de events (que possui um argumento do tipo EventArgs).
  2. Defina um método virtual protegido chamado OnXXXXX (OnMyPropertyValueChanged por exemplo). Nesse método, você deve verificar se o delegado do manipulador de events é nulo e, se não, pode chamá-lo (significa que há um ou mais methods anexados à delegação do evento).
  3. Chame esse método protegido sempre que quiser notificar os assinantes de que algo foi alterado.

Aqui está um exemplo

 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(); } } 

A vantagem dessa abordagem é permitir que outras classs que desejem herdar da sua turma alterem o comportamento, se necessário.

Se você deseja capturar um evento em um encadeamento diferente que está sendo gerado, deve ter cuidado para não alterar o estado dos objects definidos em outro encadeamento, o que fará com que uma exceção de encadeamento cruzado seja lançada. Para evitar isso, você pode usar um método Invoke no object que você deseja alterar seu estado para certificar-se de que a alteração está acontecendo no mesmo segmento que o evento foi gerado ou no caso de você estar lidando com um Windows Form você pode usar um BackgourndWorker para fazer coisas em um thread paralela de maneira simples e fácil.

A estrutura .NET, na verdade, fornece uma interface que você pode usar para notificar os assinantes quando uma propriedade foi alterada: System.ComponentModel.INotifyPropertyChanged. Essa interface tem um evento PropertyChanged. É geralmente usado no WPF para binding, mas eu achei útil em camadas de negócios como uma maneira de padronizar a notificação de mudança de propriedade.

Em termos de segurança de thread eu colocaria uma trava no setter para que você não tenha nenhuma condição de corrida.

Aqui estão meus pensamentos no código :):

 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 } } } 

Espero que isso seja útil 🙂

é só usar uma propriedade

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