Is there an event that will raise when a variable has changed?

Question

I know that the proper course of action is to create a class, make an event in said class, then use said class in another part of the program where the variable would be changed (e.g. Use said class in the equal button of a calculator, so that an event handler knows that a variable has been changed because an event would be fired). But, trying to streamline my code, I'm looking for a way to monitor a variable directly without an infinite loop/timer and raise an event when it changes. Is there such a thing? If not, are there any other alternatives aside for the one I mentioned?

Here is what I'm trying to mention:

Code that changes a variable -> Another piece of code (not a loop) watching for changes then throws an event if there are changes -> Event handler

Can you use [property changed notification](https://msdn.microsoft.com/en-us/library/ms743695(v=vs.110).aspx)? — oleksii, Apr 13 '15 at 10:33
Is this in Winforms or WPF or just plain code (No UI, no dispatcher)? — DrKoch, Apr 13 '15 at 10:37

Florian Schmidinger · Accepted Answer · 2015-04-13T13:47:13.280

You can't do it with fields but with properties:

class SomeClass : INotifyPropertyChanged
{
    private string someProperty;
    public string SomeProperty 
    {
        get { return someProperty; }
        set { someProperty = value; OnPropertyChanged(); }
    }

    private void OnPropertyChanged([CallerMemberName] string propertyName = "")
    {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }

    public event PropertyChangedEventHandler PropertyChanged = delegate {};
}

Edit (.net 4.0)

class SomeClass : INotifyPropertyChanged
{
    private string someProperty;
    public string SomeProperty 
    {
        get { return someProperty; }
        set { someProperty = value; OnPropertyChanged("SomeProperty"); }
    }

    private void OnPropertyChanged(string propertyName)
    {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }

    public event PropertyChangedEventHandler PropertyChanged = delegate {};
}

Edit (Winforms example)

public partial class Form1 : Form
{
    private SomeClass theObject = new SomeClass(); //keep a reference of the object.

    public Form1()
    {
        InitializeComponent();
    }

    private void Form1_Load(object sender, EventArgs e)
    {
       //here we do the binding... we want the 'Text' Property of the control to change if the 'SomeProperty' changes OnPropertyChanged
        textBox1.DataBindings.Add("Text",theObject,"SomeProperty",false,DataSourceUpdateMode.OnPropertyChanged);
    }

    private void button1_Click(object sender, EventArgs e)
    {
        theObject.SomeProperty = "This works!"; //just a test button that changes the property...
    }
}

This is a WPF techinque. Does not work the same in Winforms or other code — DrKoch, Apr 13 '15 at 10:38
You should only raise the event when the property actually changes value `if (value != someProperty) { /* set field, and fire event */ }` — Maarten, Apr 13 '15 at 11:17
@Maarten this is a matter of the requirements... most of the time i can live without — Florian Schmidinger, Apr 13 '15 at 11:19
@Maarten but of course you are right. it would avoid the firing of unnecessary events ... — Florian Schmidinger, Apr 13 '15 at 11:23
Unfortunately, I'm using .NET 4. But, I'll keep this as reference when I go to .NET 4.5. — Aloha, Apr 13 '15 at 13:20

score 1 · Answer 2 · edited May 23 '17 at 11:50

Though I know that it is an often undesired practice here at Stack Overflow, you may find my project NMF Expressions interesting: http://nmfexpressions.codeplex.com/

Basically, the project aims to allow you to write such as follows:

var myObservedVariable = Observable.Expression(() => whatever you want)

In this scenario, myObservedVariable will be of INotifyValue<T> which provides a ValueChanged event. Alternatively, you can use the query syntax. Alternatively, you may have a look at other similar frameworks like Obtics, BindableLINQ or ContinuousLINQ. A comparison of the latter was done in Bindable Linq vs. Continuous Linq.

However, this only works under pretty strong assumptions like all the object models that you are working with completely support INotifyPropertyChanged and INotifyCollectionChanged.

score 1 · Answer 3 · answered Apr 13 '15 at 11:19

1

In addition to @Florian's answer, you can inject an implementation of the INotifyPropertyChanged interface at compile time using Fody.PropertyChanged.

answered Apr 13 '15 at 11:19

Maarten

22,527
3
47
68

Is there an event that will raise when a variable has changed?

3 Answers3