How to add a callback to a webform Project

Question

I want to add a common callback function to all the methods of an object. I found this SO question but in that aproach, I would have to modify every function of the class. I would like to define some beforeFilter method that get trigered before every method call. I know I could use Action delegates for that but I don't know how.

UPDATE: As an example, what I want would be something like this

Class MyClass

    Sub MyCallback
        'callback code...
    End Sub

    'Rest of tyhe code

End Class

As you can see, the ideal would be to add a simple (or more than one) method to get trigered before all the rest of the methods. Maybe with some base class or an interface, I don't know (that's why I ask for).

Some other option that I think it might be posible is to clone the object and define a new class instead to add code to the existing one. So in that Class use the Object to get access to the methods trhough the Type

Class NewClass

     Sub AddCallback(Obj As Object, Callback As Action)
          'Add the callback here
     End Sub
End Class

I'm just guessing, maybe some of my option are even unviable, so please help my on this

Closest approach

What I have for now, is this method

Sub RunWithCallback(beforFilter As Action, f As Action)

    beforeFilter()
    f()

End Sub

(This means a lot of overloads for the RunWithCallback to manage Sub's and Functions with Actions and Funcs delegates, with different number of parameters) To use this, I would have to run this Sub instead of calling any of the Object methods (passing ByRef parameter to catch returning value in functions). Something like this

Public Sub DoNothing()
    Debug.WriteLine("Callback working!")
End Sub

Public Sub BeforeFilter()
    Debug.WriteLine("Testing callback...")
End Sub

'To run the above function    
RunWithCallback(AddressOf BeforeFilter, AddressOf DoNothing)

I think there should be a better solution to this, something that allow to avoid calling the same sub, and avoid the overloads, some kind of dynamic extension method for the object Class

Answer 1

Here is an example how delegates work and how u can use them:

public class MyClass
{
    // MyDelegate callback holder
    private MyDelegate _myDelegate;

    // Singleton holder
    private static volatile MyClass _instance;

    ///<summary>
    /// Instance property
    ///</summary>
    public static MyClass Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = new MyClass();
            }
            _instance.MyCallbacks(_instance.MyDelegateCallback, _instance.MyDelegateCallback1);
            return _instance;
        }
    }

    ///<summary>
    /// Instance multi-callback caller
    ///</summary>
    ///<param name="callbacks">calbacks to call</param>
    ///<returns>MyClass</returns>
    public static MyClass Instance(params MyDelegate[] callbacks)
    {
        if (_instance == null)
        {
            _instance = new MyClass();
        }
        _instance.MyCallbacks(callbacks);
        return _instance;
    }

    ///<summary>
    /// MyClass constructor
    ///</summary>
    private MyClass()
    {
        // Define the callback
        MyDelegate = MyDelegateCallback;
    }

    ///<summary>
    /// MyDelegate property, here u can change the callback to any function which matches the structure of MyDelegate 
    ///</summary>
    public MyDelegate MyDelegate
    {
        get
        {
            return _myDelegate;
        }
        set
        {
            _myDelegate = value;
        }
    }

    ///<summary>
    /// Call all given callbacks
    ///</summary>
    ///<param name="callbacks">callbacks u want to call</param>
    public void MyCallbacks(params MyDelegate[] callbacks)
    {
        if (callbacks != null)
        {
            foreach (MyDelegate callback in callbacks)
            {
                if (callback != null)
                {
                    callback.Invoke(null);
                }
            }
        }
    }

    ///<summary>
    /// RunTest, if u call this method the defined callback will be raised
    ///</summary>
    public void RunTest()
    {
        if (_myDelegate != null)
        {
            _myDelegate.Invoke("test");
        }
    }

    ///<summary>
    /// MyDelegateCallback, the callback we want to raise
    ///</summary>
    ///<param name="obj"></param>
    private void MyDelegateCallback(object obj)
    {
        System.Windows.MessageBox.Show("Delegate callback called!");
    }

    ///<summary>
    /// MyDelegateCallback1, the callback we want to raise
    ///</summary>
    ///<param name="obj"></param>
    private void MyDelegateCallback1(object obj)
    {
        System.Windows.MessageBox.Show("Delegate callback (1) called!");
    }
}

///<summary>
/// MyDelegate, the delegate function
///</summary>
///<param name="obj"></param>
public delegate void MyDelegate(object obj);

I updated my answer, have a look at MyCallbacks(params MyDelegate[] callbacks). It will call different callbacks which match the structure of MyDelegate.
Edit:
Added MyClass.Instance & MyClass.Instance(params MyDelegate[] callbacks).

Answer 2

Have you ever considered to use an Aspect library? Up to your question it seems like you really can solve your problem with this approach.

For example, you can use the PostSharp library here, simply derive the OnMethodBoundaryAspect class, and handle the four available main events:

• OnEntry
• OnExit
• OnSuccess
• OnException

or two additional:

• OnResume
• OnYield

or any of them. The simple schema is this:

int MyMethod(object arg0, int arg1)
{
    OnEntry();
    try
    {
        // YOUR CODE HERE 
        OnSuccess();
        return returnValue;
    }
    catch ( Exception e )
    {
        OnException();
    }
    finally
    {
        OnExit();
    }
}

So you can easily call the Callback function (and you can extract runtime-passed parameters in OnSuccess method:

public override void OnSuccess(MethodExecutionArgs args)
{
    CallBack(GetValueYouNeed(args));
}

Simple version of PostSharp is a free-licence distributed and well documented, so I strongly suggest you to investigate this approach.