What kind of function should I use?

Question

I’m trying to develop an application where when the value of a bool variable changes to false it must run a script. Should I use background_work to do this? If so, how should I use it? And if not, how should I do it?

Answer 1

Avoid doing this. Look for other alternatives first.

The reason for this recommendation comes from the simple fact that you must avoid, to the maximum extent possible, actively verifying a condition .

Active checks typically consume more resources (cpu) than passive checks, because you will eventually have to have a periodic check (for example within a loop) of a given state.

Passive checks, on the other hand, usually use techniques where there is a notification when a certain condition is met, meaning that there may not even be a check whether the condition is already met.

This is not to say that you should always use passive checks. Depending on the implementation passive checks may also have associated costs, such as context exchange It’s not exactly a cheap operation. But if you can choose between having the CPU to be used exhaustively to check a given state over a long period of time or doing a passive check you should choose the passive check.

You can resort to various passive verification techniques.

Using events (notification mechanism):

public class DadosDoEvento : EventArgs
{
    public string Dados { get; set; }
}

public class PublicadorDeEventos{
    public event EventHandler<DadosDoEvento> Evento; 

    protected virtual void OnEvento(OMeuEvento e)
    {
        Evento?.Invoke(this, e);
    }
    /*Um método qualquer que chame OnEvento */
}

var publicador = new PublicadorDeEventos();
publicador.Evento += (src, args) => Console.WriteLine(args.Dados);

Using events (synchronization mechanism):

public class PublicadorDeEventos{

    public ManualResetEvent Evento{ get { return new ManualResetEvent(false); } }

    /*Um método qualquer que chame Evento.Set();*/
}

var publicador = new PublicadorDeEventos();
publicador.Evento.WaitOne();

Using INotifyPropertyChanged:

I did not put this approach in my initial response because it is a specific scenario of the use of events (notification mechanism) and, in my opinion, it is not so simple to use. But this does not mean that it does not have its merit (maybe it is subject to another question), but I leave here an example:

public class Modelo : INotifyPropertyChanged
{
    private string _dados;
    public string Dados { 
        get {return _dados;}
        set {
            _dados = value;
            OnPropertyChanged(nameof(Dados));
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged(
        [CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

var modelo = new Modelo();
modelo.PropertyChanged += (sender, args) => {
    if (args.PropertyName == "Dados")
    {
        Console.WriteLine("Os dados mudaram vou executar o meu script aqui");
    }
} 

Which one should you use? I personally prefer to choose the first one. Usually the second alternative provides a harder-to-use API, and it doesn’t solve all cases. You need to be careful in choosing the proper synchronization mechanism and in special cases implement your own synchronization mechanism.