Question

how can I implement analog of bind / unbind like in jQuery?

class MyDataType<T>
{
    private List<T> data;
    ...
    public void Add(T value)
    {
        data.Add(value);
    }
    ...
}

...
MyDataTypeObject.Bind("Add",()=>Console.WriteLine("OnAdd"));
...
MyDataTypeObject.UnBind("Add");
...

Answer 1

You could do this using Castle DynamicProxy. First, create abstract base class that contains the Bind() and Unbind() methods and a dictionary to hold the invocations:

public abstract class BindableBase
{
    private readonly Dictionary<string, Action> m_boundMethods =
        new Dictionary<string, Action>();

    protected Dictionary<string, Action> BoundMethods
    {
        get { return m_boundMethods; }
    }

    public void Bind(string method, Action action)
    {
        if (!m_boundMethods.ContainsKey(method))
            m_boundMethods.Add(method, null);

        m_boundMethods[method] += action;

    }

    public void Unbind(string method, Action action)
    {
        if (m_boundMethods.ContainsKey(method))
        {
            m_boundMethods[method] -= action;

            if (m_boundMethods[method] == null)
                m_boundMethods.Remove(method);
        }
    }
}

Then create concrete class that implements BindableBase. You need to make any methods you want to intercept virtual:

public class Foo<T> : BindableBase
{
    private readonly List<T> m_data = new List<T>();

    public virtual void Add(T value)
    {
        m_data.Add(value);
    }
}

Then create the interceptor that intercepts calls to any virtual methods and call the appropriate delegate from the dictionary:

class Interceptor : IInterceptor
{
    private static readonly PropertyInfo BoundMethodsProperty =
        typeof(BindableBase).GetProperty(
            "BoundMethods", BindingFlags.Instance | BindingFlags.NonPublic);

    public void Intercept(IInvocation invocation)
    {
        var boudMethods =
            (Dictionary<string, Action>)BoundMethodsProperty.GetValue(
                invocation.InvocationTarget, null);

        invocation.Proceed();

        string method = invocation.Method.Name;

        Action action;
        if (boudMethods.TryGetValue(method, out action))
            action();
    }
}

Finally, it’s just a matter of generating the proxy and using it:

var proxyGenerator = new ProxyGenerator();
Foo<int> foo = proxyGenerator.CreateClassProxy<Foo<int>>(new Interceptor());
foo.Bind("Add", LogAdd);
foo.Add(42);
foo.Unbind("Add", LogAdd);
foo.Add(43);