.NET (Core and Framework)

Class DoItMagic
    Interface iAct(Of T)
        Sub Act(ByVal param As T)
    End Interface

    Public Shared Sub exec(Of T)(ByVal target As iAct(Of T), ByVal param As T)
        target.Act(param)
    End Sub

    Public Shared Sub hitEverything(Of T, U As DoItMagic.iAct(Of T))(ByVal theEnum As IEnumerable(Of U), ByVal theParam As T)
        For Each thing As U In theEnum
            exec(Of T)(thing, theParam)
        Next
    End Sub
End Class

Class DoItTarget
    Implements DoItMagic.iAct(Of param1), DoItMagic.iAct(Of param2)

    Class param1
    End Class

    Class param2
    End Class

    Public Sub Act_param1(ByVal param As param1) Implements DoItMagic.iAct(Of param1).Act

    End Sub

    Public Sub Act_param2(ByVal param As param2) Implements DoItMagic.iAct(Of param2).Act

    End Sub
End Class

Class DoItTest
    Dim firstParam As DoItTarget.param1
    Dim secondParam As DoItTarget.param2

    Dim L As List(Of DoItTarget)

    Sub go()
        DoItMagic.hitEverything(Of DoItTarget.param1, DoItTarget)(L, firstParam)
        DoItMagic.hitEverything(Of DoItTarget.param2, DoItTarget)(L, secondParam)
    End Sub
End Class

1. Are there any performance implementations with creating empty classes that are used as method selectors rather than as distinct ways of holding data (e.g. there might be a number of different classes that hold a single integer, but select different methods).
   
2. Does invoking methods via generics pose any performance problems in cases where everything can be type-checked at compile time?
   
3. What would be the performance implications in cases where things couldn't be checked until run-time (e.g. if a list holds a number of elements, not all of which will support any particular iAct(of type).
   
4. Is this overall approach a brilliant idea, crazy idea, or somewhere in between?