Nicholas and Peter, thank you both very much.  Nicholas, thank you in
particular for taking the time to code a better version and for teaching me
about Stopwatch.  Using your code and Stopwatch, the elapsed time of the
Delegates method was still about 3.5 times SLOWER than that of the MethodInfo
method.  This seems counter to all that I have heard about Reflection and
Delegates.  I'd appreciate any other ideas you might have, as I'm putting a
change into an Xml web service that will likely get a high traffic needing a
dynamically called comparison operator.

Hello
I've changed some of the values used in your benchmark test(i.e: the delegate type and some of the constants) to match a more realistic situation(upon my opinion...) for the type of function we are trying to execute using invocation and i've obtained different results regarding the difference between the direct invocation and the other 2 types.

Dynamic invoke: 12976
Direct invoke: 12505
Reflection: 13332

Could someone confirm my results and suggest some reason for that?

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

class Benchmark
{
   const string OpGreaterThanOrEqual = "op_GreaterThanOrEqual";

   const int Iterations = 100000;//changed
   const int V1 = 100000;
   const int V2 = 100000;
   const decimal FirstValue = 100000.00m;
   const decimal SecondValue = 101000.00m;

   private delegate bool OperatorTest(decimal first, decimal second);
   private delegate void Blah(int first, int second);//added

   static void Main()
   {
       RunDelegateDynamic();
       RunDelegateDirect();
       RunReflection();
       Console.ReadLine();
   }

   //Some more time consuming function
   public static void BlahTst(int first, int second)
   {
       int res = 0;
       for (int i = 0; i < 100000; i++)
       {
           if (first < second)
           {
               res = -1;
           }
           else
           {
               res = 1;
           }
       }
   }
   static void RunDelegateDirect()
   {              
       Blah d = (Blah)Delegate.CreateDelegate(typeof(Blah), (Type)typeof(Benchmark), "BlahTst");

       Stopwatch sw = Stopwatch.StartNew();
       for (int i = 0; i < Iterations; i++)
       {
           d(V1, V2);
       }
       sw.Stop();
       Console.WriteLine("Direct invoke: " + sw.ElapsedMilliseconds);
       
       /*
       OperatorTest d = (OperatorTest)Delegate.CreateDelegate
       (typeof(OperatorTest), typeof(decimal), OpGreaterThanOrEqual);

       Stopwatch sw = Stopwatch.StartNew();
       for (int i = 0; i < Iterations; i++)
       {
           d(FirstValue, SecondValue);
       }
       sw.Stop();
       Console.WriteLine("Direct invoke: " + sw.ElapsedMilliseconds);
        */
   }

   static void RunDelegateDynamic()
   {
       Delegate d = Delegate.CreateDelegate(typeof(Blah), (Type)typeof(Benchmark), "BlahTst");
       Stopwatch sw = Stopwatch.StartNew();
       for (int i = 0; i < Iterations; i++)
       {
           d.DynamicInvoke(new object[] { V1, V2 });
       }
       sw.Stop();
       Console.WriteLine("Dynamic invoke: " + sw.ElapsedMilliseconds);

       /*
       Delegate d = Delegate.CreateDelegate(typeof(OperatorTest), typeof(decimal), OpGreaterThanOrEqual);
       Stopwatch sw = Stopwatch.StartNew();
       for (int i = 0; i < Iterations; i++)
       {
           d.DynamicInvoke(new object[] { FirstValue, SecondValue });
       }
       sw.Stop();
       Console.WriteLine("Dynamic invoke: " + sw.ElapsedMilliseconds);
        */
   }

   static void RunReflection()
   {
       MethodInfo mi = typeof(Benchmark).GetMethod("BlahTst",
       new Type[] { typeof(int), typeof(int) });
       Stopwatch sw = Stopwatch.StartNew();
       for (int i = 0; i < Iterations; i++)
       {
           mi.Invoke(null, new object[] { V1, V2 });
       }
       sw.Stop();
       Console.WriteLine("Reflection: " + sw.ElapsedMilliseconds);

       /*
       MethodInfo mi = typeof(decimal).GetMethod(OpGreaterThanOrEqual,
       new Type[] { typeof(decimal), typeof(decimal) });
       Stopwatch sw = Stopwatch.StartNew();
       for (int i = 0; i < Iterations; i++)
       {
           mi.Invoke(null, new object[] { FirstValue, SecondValue });
       }
       sw.Stop();
       Console.WriteLine("Reflection: " + sw.ElapsedMilliseconds);
        */
   }
}