Add arguments one by one to a delegate then execute it

Question

Yesterday I wanted to create an ExceptionHandler class to which for example we could pass:

the exception
the method where that happened
the parameters given to that method

The ExceptionHandler would implement a custom business logic and re-execute automatically (or not) the method with the same parameters.

The closest solution I found was by using a delegate like this

private void button1_Click(object sender, EventArgs e)
{
    InvokeMyMethod(Test, "string", 1);
    InvokeMyMethod(TestN, "other string", 3, Color.Red);
}

public delegate void MyMethodDelegate(params object[] args);

public void InvokeMyMethod(MyMethodDelegate method, params object[] args)
{
    method.DynamicInvoke(args);
}

public void Test(params object[] args)
{
    if (args.Length < 2) return;
    MessageBox.Show(string.Format("{0}{1}", args[0], args[1]));
}

public void TestN(params object[] args)
{
    // or, whatewer
    if (args.Length < 3) return;
    MessageBox.Show(string.Format("{0}{1}{2}", args[0], args[1], args[2]));
}

However this solution is still not perfect because of the methods' signature. I don't want all my methods receive a unique parameter params object[] args, moreover this is often not possible directly for example with all UI related events (Winform, ASP.NET, WPF or whatever).

So I'd like to know if there is a way to pass one by one arguments to a delegate and then execute the function only when we are ready?

For example here is an imaginary code with non-existing methods AddArgument and Execute

public void InvokeMyMethod(MyMethodDelegate method, params object[] args)
{
    foreach(var arg in args)
    {
        method.AddArgument(arg);
    }
    method.Execute();
}

By this way all our functions could keep their original signature and receive multiple arguments instead of an array.

Sounds like the "builder" pattern. https://en.wikipedia.org/wiki/Builder_pattern — Enigmativity, Oct 28 '16 at 03:24
Hum ok I didn't know the name of this pattern and how to search it on Google. I will read about this. thanks — Jérôme MEVEL, Oct 28 '16 at 03:27

PMV · Accepted Answer · 2016-10-28T04:01:54.913

Your original code isn't far off at all. You can get rid of requiring all the called methods have the same signature as long as you make InvokeMyMethod just take the abstract Delegate class and you explicitly specify the delegate type when you call the function (it won't infer the type). We can take advantage of the fact that there are generic delegate types in C# so we don't need to declare every possible set of method signatures that we want to use.

If you wanted to call functions with a return value you'd need to use Func<> in place of Action<>.

private void button1_Click(object sender, EventArgs e)
{
    InvokeMyMethod((Action<string,int>) Test, "string", 1);
    InvokeMyMethod((Action<string,int,Color>) TestN, "other string", 3, Color.Red);
}

public void InvokeMyMethod(Delegate method, params object[] args)
{
    method.DynamicInvoke(args);
}

public void Test(string s, int i)
{
    MessageBox.Show(string.Format("{0}{1}", s, i));
}

public void TestN(string s, int i, Color c)
{
    // or, whatewer
    MessageBox.Show(string.Format("{0}{1}{2}", s, i , c);
}

I know I just copy pasted the original code from the source. But that doesn't answer to the question. I'm blocked because `DynamicInvoke` is waiting for a single parameter of type `object[]` instead of being able to accept an unknown number of parameters as described in my imaginary code example — Jérôme MEVEL, Oct 28 '16 at 03:33
@JérômeMével Ah, sorry, now I see what you were asking. Gave some more helpful code for you. — PMV, Oct 28 '16 at 03:49

Add arguments one by one to a delegate then execute it

1 Answers1