Let me just say that using this kind of generic pattern will move you away
from compile time string type checking as well as introduce a drastic
performance issue.  There might be a way with reflection, but i would
strongly suggest you stay away from that.

you could use the "params" keyword in C# (now sure what the VB equivilent
is).  this allows you to have one parm that is an object[] and you can pass
in 0 to many parameters of any type.  No you will have boxing and unboxing
performance issues here, it'll probably be better than anything you could
come up with via reflection.

here is an example of the params from MSDN:

  public static void UseParams(params int[] list)
  {
     for ( int i = 0 ; i < list.Length ; i++ )
        Console.WriteLine(list[i]);
     Console.WriteLine();
  }

  public static void UseParams2(params object[] list)
  {
     for ( int i = 0 ; i < list.Length ; i++ )
        Console.WriteLine(list[i]);
     Console.WriteLine();
  }

  public static void Main()
  {
     UseParams(1, 2, 3);
     UseParams2(1, 'a', "test");

     int[] myarray = new int[3] {10,11,12};
     UseParams(myarray);
  }

Hi,

This is easily done using System.Diagnostics.StackTrace,
System.Diagnostics.StackFrame and reflection. The only real trick is
to be careful of out parameters.

using System;
using System.Diagnostics;
using System.Reflection;
using System.Text;

namespace ConsoleApplication1
{
 class TestClass
 {
   // entry point...
   [STAThread]
   private static void Main()
   {
     LogMethod();

     SimpleTest("Test", -1);

     int lValue;
     MethodWithOut("Test", out lValue, true);
   }

   private static void SimpleTest(string text, int id)
   {
     LogMethod(text, id);
   }
   private static void MethodWithOut(string arg1, out int arg2, bool
arg3)
   {
     LogMethod(arg1, arg3);

     arg2 = 0;
   }

   private static void LogMethod(params object[] args)
   {
     // Get calling method...
     StackTrace lCallStack = new StackTrace(1, true);
     StackFrame lCallingMethodFrame = lCallStack.GetFrame(0);
     MethodBase lCallingMethod = lCallingMethodFrame.GetMethod();

     // If there aren't any argmuments, we're done.
     if (args == null || args.Length == 0)
     {
       Debug.WriteLine(lCallingMethod.Name + "( )");
       return;
     }

     ParameterInfo[] lParameters = lCallingMethod.GetParameters();

     // Count number of "in" parameters.
     int lInParamCount = lParameters.Length;
     foreach (ParameterInfo lParameter in lParameters)
       if (lParameter.IsOut)
         lInParamCount--;

     Debug.Assert(lInParamCount == args.Length,
String.Format("Incorrect number of arguments. Expected {0} but was
{1}.", lParameters.Length, args.Length));

     StringBuilder lSignature = new StringBuilder();
     lSignature.Append(lCallingMethod.Name);

     lSignature.Append("( ");
       
     int lParamCount = lParameters.Length;
     int lArgIndex = 0;
     for (int i = 0; i < lParamCount; i++)
     {
       lSignature.Append(lParameters[i].Name);
       lSignature.Append(" = ");
       if (lParameters[i].IsOut)
         lSignature.Append("<Unknown>");
       else
       {
         if (args[lArgIndex] == null)
           lSignature.Append("<null>");
         else
           lSignature.Append(args[lArgIndex].ToString());

         lArgIndex++;
       }

       if (i < lParamCount - 1)
         lSignature.Append(", ");
     }

     lSignature.Append(" )");

     Debug.WriteLine(lSignature.ToString());
   }
 }
}
--------
Best Regards,
Dustin Campbell
Developer Express, Inc