在C＃中绑定/取消绑定

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 can mimic it but only for predefined methods using Events.

class MyDataType<T>
{
    EventHandler<EventArgs> OnAdded;

    private RaiseOnAdded() 
    {
        var onAdded = OnAdded
        if(onAdded != null) 
        {
           onAdded(this, new EventArgs());
        } 
    }

    private List<T> data;
    ...
    public void Add(T value)
    {
        data.Add(value);
        RaiseOnAdded(); // <-- Add knows to call OnAdded(..) 
    }
    ...
}

var hander = (s, e)=>Console.WriteLine("OnAdd"));

MyDataTypeObject.OnAdded  += handler;

MyDataTypeObject.OnAdded  -= handler;

Answer 2

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