Using generics in dotnet for functions with any number of arguments?

Question

I would like to have a function that can "wrap" any other function call. In this particular case, it would allow me to write some more generic transaction handling around some specific operations.

I can write this for any particular number of arguments, e.g. for one argument:

Public Shared Sub WrapFunc(Of T)(ByVal f As Action(Of T), ByVal arg As T)
    ' Test some stuff, start transaction
    f(arg)
    ' Test some stuff, end transaction
End Sub

... but I was hoping to have this handle any number of arguments without having to have duplicate code for 0 args, 1 arg, 2 args, etc.

Is there a way of doing this?

[Edit] Thanks to Robert Fraser for the c# code. For reference, here's a translation to VB:

[Edit2] Corrected code. Unfortunately, there doesn't seem to be a way around having the separate "ActAsFunc" functions in vb. On the plus side, those are hidden from anyone using the closures and the closures are re-usable.

Public Shared Sub WrapFunc(ByVal f As Action)
    _WrapFunc(f)
End Sub
Public Shared Sub WrapFunc(Of T1)(ByVal f As Action(Of T1), ByVal arg1 As T1)
    _WrapFunc(Closure(f, arg1))
End Sub
Public Shared Sub WrapFunc(Of T1, T2)(ByVal f As Action(Of T1, T2), ByVal arg1 As T1, ByVal arg2 As T2)
    _WrapFunc(Closure(f, arg1, arg2))
End Sub

Private Shared Sub _WrapFunc(ByVal f As Action)
    ' Test some stuff, start transaction
    f()
    ' Test some stuff, end transaction
End Sub

Private Shared Function Closure(Of T1)(ByVal f As Action(Of T1), ByVal arg1 As T1) As Action
    Return New Action(Function() _ActAsFunc(f, arg1))
End Function
Private Shared Function Closure(Of T1, T2)(ByVal f As Action(Of T1, T2), ByVal arg1 As T1, ByVal arg2 As T2) As Action
    Return New Action(Function() _ActAsFunc(f, arg1, arg2))
End Function

Private Shared Function _ActAsFunc(Of T1)(ByVal f As Action(Of T1), ByVal arg1 As T1) As Object
    f(arg1) : Return Nothing
End Function
Private Shared Function _ActAsFunc(Of T1, T2)(ByVal f As Action(Of T1, T2), ByVal arg1 As T1, ByVal arg2 As T2) As Object
    f(arg1, arg2) : Return Nothing
End Function

Answer 1

Nope. I wish there was, too; I do this all time.

Internally, MS uses text templates/code generation tools to generate the repetitive code. An option in C# is to create closures around the arguments and then just pass them to another function as a no-argument System.Action; I'm not sure if VB.NET support this.

Here's what I do in C#; hopefully someone with VB.NET experience can translate this:

public void add(Action action, EventFlags flags) { addInternal(action, flags); }
public void add<T1>(Action<T1> action, T1 p1, EventFlags flags) { addInternal(closure(action, p1), flags); }
public void add<T1, T2>(Action<T1, T2> action, T1 p1, T2 p2, EventFlags flags) { addInternal(closure(action, p1, p2), flags); }
public void add<T1, T2, T3>(Action<T1, T2, T3> action, T1 p1, T2 p2, T3 p3, EventFlags flags) { addInternal(closure(action, p1, p2, p3), flags); }
public void add<T1, T2, T3, T4>(Action<T1, T2, T3, T4> action, T1 p1, T2 p2, T3 p3, T4 p4, EventFlags flags) { addInternal(closure(action, p1, p2, p3, p4), flags); }

private static Action closure<T1>(Action<T1> action, T1 p1) { return () => action(p1); }
private static Action closure<T1, T2>(Action<T1, T2> action, T1 p1, T2 p2) { return () => action(p1, p2); }
private static Action closure<T1, T2, T3>(Action<T1, T2, T3> action, T1 p1, T2 p2, T3 p3) { return () => action(p1, p2, p3); }
private static Action closure<T1, T2, T3, T4>(Action<T1, T2, T3, T4> action, T1 p1, T2 p2, T3 p3, T4 p4) { return () => action(p1, p2, p3, p4); }

Answer 2

I haven't tried this with Generics, but what about a ParamArray ?

Public Shared Sub WrapFunc(Of T)(ByVal f As Action(Of T()), ByVal ParamArray args() As T)
    ' Test some stuff, start transaction
    f(args)
    ' Test some stuff, end transaction
End Sub

Answer 3

You can't use the ParamArray?

  Public Shared Sub WrapFunc(Of T)(ByVal f As Action(Of T), ByVal ParamArray args() As T)
        ' Test some stuff, start transaction
        For Each arg As T In args
            f(arg)
        Next

        ' Test some stuff, end transaction
    End Sub