Bindable

Bindable.cs

using System;
public class Bindable<T>
{
    private T _value;
    public T Value
    {
        get { return _value; }
        set
        {
            _value = value;
            OnUpdated(value);
        }
    }


    public Action<T> OnUpdated = delegate { };


    public Bindable(T value)
    {
        Value = value;
    }


    public static explicit operator Bindable<T>(T t)
    {
        return new Bindable<T>(t);
    }


    public static implicit operator T(Bindable<T> bindable)
    {
        return bindable.Value;
    }
}

This is a quick utility class I use which saves me adding signals to a model which serve just one purpose: listening to a simple value change.

Create a binded value:
private Bindable myInt;

Listen to a value change:
myInt.OnUpdated += MyCallback

Remove a listener:
myInt.OnUpdated -= MyCallback

Updating a value is the same as anything else:
myInt = 5;
myOtherInt = myInt;

It's possible you'll run in to contravariance issues with this in the current mono subset, so I try to limit it to simple data structures.

nice

ok while I said this was nice before, sadly it doesn't work. I'm just wondering did you test it?

The problem is that the
public static implicit operator Bindable(T t)
{
return new Bindable(t);
}

Always creates a new Bindable, so when you write the line:
myInt = 5;

this loses the old Bindable myInt, and is the equialent of writing
myInt = new Bindable(5);

so... the OnUpdated method of the original myint never gets called since it is now null and disposed and myInt is a whole new Bindable.

Really the way this needs to be written is something like this:

public class Bindable
{
private T _value;
public T Value
{
get { return _value; }
set
{
_value = value;
OnUpdated(value);
}
}

    public Action<T> OnUpdated = delegate { };


    public Bindable(T value)
    {
        Value = value;
    }

}

and set the value of everything using the now public value property.

Yup all of this is correct. Sorry I haven't updated this in a while. I've swapped to an explicit operator and letting Value be public. It's not possible to do an extension implicit operator in the current version of C#, although it could happen in the future. Ultimately that's what we want (We want a ref to the Bindable class and assign a value).

It's all syntactic sugar that I wanted, but couldn't quite achieve. I'll update the gist.