DynamicMethod is lighter weight than the original Reflection.Emit because you don’t need to define an assembly, module, or type.  Basically, you create a static delegate definition dynamically, then bind the dynamically-created delegate to whatever class you want.  One interesting aspect of DynamicMethod is that the memory used to define an instance of the DynamicMethod class is eleigible for garbage collection. 

The design goals we had in mind for ProxyFunction (listed here in no particular order) were:

• Calling a callback function could not be significantly slower than calling Delegate.Invoke.
• Our users needed to be able to create callback functions of any signature they chose.
  • This includes static, virtual and generic methods.
• Callback functions can be either just a function or the implementation of a delegate.
• If the callback function contains either out or ref parameters, the framework needs to propagate the potentially-changed parameter values back to the client code.

Essentially, the way a DynamicMethod works is that you create a delegate type definition that sets the signature for a function you implement by generating IL code.  To accommodate the requirements we list above, the DynamicMethod signature we settled on was:

public delegate object ProxyFunction(object targetClass, object[] args);

The return type is object, so our users can supply whatever return type they want, including void.  targetClass is an instance of the class that houses our user-supplied callback function.  If the callback function is static, we don’t use targetClass in building the DynamicMethod. ‘args’ is an object array, where each element in the array represents one parameter the target function needs. The args array maps its elements to target function parameters top-to-bottom, left-to-right.

We also considered using the following delegate type definition:

public delegate object ProxyFunction(object[] args);

with the intent to use args[0] as an instance of the class housing the user-defined callback.  However, we thought it would make the intent of specifying a defining type versus the parameters to a callback function more explicit by having the delegate definition include both concepts individually.

Now that we know what our ProxyFunction signature will be, let’s take a look at the class that implements the capability to dynamically build a call stack and call framework callback functions.  Our class contains only one function, defined like this:

public static ProxyFunction Create(MethodInfo methodInfo)

Given a reference to the MethodInfo class associated with the callback function we want to invoke, this function creates and returns a ProxyFunction.  We’ll demonstrate a couple different ways to obtain the callback function’s MethodInfo data when we illustrate using this class.

The first thing to do is to create the parameter signatures our DynamicMethod will use.  It is important to point out the distinction between parameters passed to the DynamicMethod definition and those passed to the callback we want to invoke.  Here are the parameter definitions:

Type[] proxyFunctionArgTypes = { typeof(object), typeof(object[]) };

What this statement does is tell the DynamicMethod we will create shortly that it will accept parameters of the same signature we defined in the ProxyFunction delegate definition statement.  This is important, because the matching signatures give us a known type we can instantiate from framework code.

We next create the DynamicMethod:

bool skipVisibilityChecks = true;
DynamicMethod dynamicMethod =
    new DynamicMethod("",                     // we don't give the DynamicMethod a name
        typeof(object),                       // DynamicMethod's return type
        proxyFunctionArgTypes,                // DynamicMethod's arguments
        typeof(ProxyFunctionFactory),         // The class which we will bind DynamicMethod to
        skipVisibilityChecks);

We can associate a DynamicMethod, which we recall is an instance of a static function, to pretty much any class we want.  But, since we can’t know in advance what classes our users may create, we’ll bind the DynamicMethod to the class which defines our factory function: ProxyFunctionFactory.  Doing so brings up the need to allow us to invoke callback functions that will exist in classes other than ProxyFunctionFactory.  If we want to invoke those callbacks which would otherwise be unavailable to our factory function due to the callbacks’ visibility (protected, private, internal, etc.), we need to set a flag that tells the DynamicMethod we want to call those callbacks even though we wouldn’t normally be able to.  We communicate this by setting the value of the skipVisibilityChecks parameter to true.

OK, now that we have a DynamicMethod, we need to associate a function body with it.  We do so by getting the Intermediate Language (IL) code generator associated with the DynamicMethod.  Think of IL as a simplified assembly language that you can feed to the .Net runtime to create a new function on the fly.  The .Net runtime will take that assembly and turn it into machine code when it (the runtime) first tries to do anything with the IL.  IL is surprisingly easy to use, all the more so because all we’re going to do is build a call stack and call a function.  To get an instance of the IL generator, you do something like this:

ILGenerator il = dynamicMethod.GetILGenerator();

Now we have the context with which we can construct our DynamicMethod body.  The first thing we’ll do is to check that the number of parameters passed to our DynamicMethod matches the number of parameters our target callback function expects.  Remember that what we’re doing is using the DynamicMethod to call a user-defined function, so the parameters passed to the DynamicMethod in the object[] array get passed through to the target callback.  We implement this check by creating a label (which basically marks an IL instruction as a branch target), put in some code that checks the numbers of arguments we have and throws an exception if the numbers of arguments don’t match, then concludes by creating a branch instruction where the branch target is one instruction beyond our throw statement.  So, if the number of parameters supplied to our DynamicMethod matches the number of parameters the callback function expects, we branch past the throw statement.  We define the branch label like this (bearing in mind that this just defines the branch label; it doesn’t associate the branch label with a target IL instruction):

Label numArgsTheSameLabel = il.DefineLabel();

IL is a stack-based language.  To do things you push arguments onto the stack using some form of “load” instruction then push an instruction onto the stack.  When control enters the IL you generate, the instruction will pop the arguments off the stack and potentially push a result onto the stack when the instruction completes.  You use some form of “store” instruction to pull a value off the stack and put the value into a location in the function body.

With this in mind, we begin the section that checks the number of parameters by pushing a reference to our target parameter array onto the stack.  Recall that the second argument to the interception proxy is an array of object[] having as many elements as our target callback function has parameters, as we defined earlier using the statement “Type[] ProxyFunctionArgTypes = { typeof(object), typeof(object[]) }”.  The way we push our argument array onto the stack looks like this:

il.Emit(OpCodes.Ldarg_1)

The Ldarg opcode has a number of specialized shortcuts defining commonly-performed operations to take the place of a more verbose sequence of instructions.  Ldarg_1 tells .Net to put the 2nd parameter to the ProxyFunctionFactory.Create function on the stack.  Parameters are numbered starting at zero.

We then push an instruction that will pop our array reference off the stack then push the array length onto the stack.  The instruction looks like this:

il.Emit(OpCodes.Ldlen);

So, what we’ve done is to look at the arguments array provided in the interception proxy parameter type definition and place onto the stack the number of elements in that array.  Next, we’ll figure out how many arguments our callback function expects.  That’s where the ‘methodInfo’ parameter to the ProxyFunctionFactory.Create method comes in.  Recall that we use the Create method from our framework to dynamically generate the interception proxy function.  The MethodInfo instance refers to the user-supplied callback function the interception proxy will call.  We calculate the number of parameters our callback function using code like this:

ParameterInfo[] targetFunctionParms = methodInfo.GetParameters();
int numTargetParms = targetFunctionParms.Length;

So, what we have on the IL stack now is the length of our interception proxy parameter array.  We’ll push the number of parameters our callback function takes by pushing onto the stack the value of “numTargetParms” as integer constant, like this:

il.Emit(OpCodes.Ldc_I4, numTargetParms);

With these 2 values on the stack, we’ll create a branch instruction to compare the 2 stack values and, if they’re equal, branch to a point in the interception proxy definition identified with the “numArgsTheSameLabel” label we defined above:

il.Emit(OpCodes.Beq, numArgsTheSameLabel);

If the opcode condition, in this case being “branch if equal”, evaluates to false, .Net will just keep processing instructions in the order listed in the IL code.  So, directly following the branch instruction are two IL instructions that construct an instance of an exception and then throw that exception:

il.Emit(OpCodes.Newobj, typeof(TargetParameterCountException).GetConstructor(Type.EmptyTypes));
il.Emit(OpCodes.Throw);

Now we’ll place our branch target label one instruction beyond the throw:

il.MarkLabel(numArgsTheSameLabel);

So, what we did was to push the interception proxy array reference on the stack, push the opcode to evaluate the array length, push the number of parameters the callback function expects, then push a branch instruction that will branch around the exception creation and throw if the parameter array length and number of callback function arguments match.

We’re now ready to construct a call stack and call our target function.  If the target function is not static, we need to push a reference to an instance of the class that conatins the target function.  Recall that the first argument to our ProxyFunctionFactory.Create function is a reference to the class instance containing our target function, so pushing the target object on the stack looks like this:

if (!methodInfo.IsStatic)
{
    // The dynamic method's argument 0 is the instance of a class
    // containing our target function.
    il.Emit(OpCodes.Ldarg_0);
}

The next thing to do is extact from the DynamicMethod’s object[] array argument the parameters the target function will need.  One thing to account for is the need to copy back to the DynamicMethod object[] array any ref or out parameters the target function may change.  As an example, let’s say our target function looks like this:

string F7(int a, ref string b)

The target function may change the value of ‘b’, so we will need to arrange to copy back into the args array the updated value of ‘b’. The way we arrange for this is to define, in the body of our DynamicMethod, as many local variables as there are ref or out parameters in the target function. We’ll keep a dictionary that maps the position of the ref or out parameter to the DynamicMethod’s declaration of the corresponding local variable. After we call the target function, we’ll copy the contents of the dictionary back to the DynamicMethod’s arg array. We’ll define our dictionary like this:

Dictionary<int, LocalBuilder> referenceValueMap = new Dictionary<int, LocalBuilder>();

LocalBuilder is a class, defined in the Relection.Emit namespace, used to declare local variables in IL code.

It’s probably better to explain the next section by showing the code first, then going through it in detail. Basically, what we’re doing is extracting from the DynamicMethod’s args array the parameters our target function will need.

            for (int i = 0; i < numTargetParms; i++)
            {
                // The proxy funcion signature has the class containing the target function
                // as its first argument.  The 2nd argument is an array of object holding the
                // target function arguments.
                // Push the argument array onto the stack.
                il.Emit(OpCodes.Ldarg_1);

                // Push the argument index onto the stack.
                il.Emit(OpCodes.Ldc_I4, i);

                // Load the argument array object at index i onto the stack
                il.Emit(OpCodes.Ldelem_Ref);

                Type parameterType = targetFunctionParms[i].ParameterType;
                if (parameterType.IsByRef)
                {
                    parameterType = parameterType.GetElementType();
                    if (parameterType.IsValueType)
                    {
                        // Turn the object into a primitive type
                        il.Emit(OpCodes.Unbox, parameterType);
                    }
                    else
                    {
                        // If the target function has arguments passed by reference, we create a local variable 
                        // that will hold the address of the variable to be passed to the target function.  We 
                        // put the local variable in a map, so we can put the local variable value back in the 
                        // argument array after we call the target delegate function, which may have chaged
                        // the reference parameter value.
                        LocalBuilder localVar = il.DeclareLocal(parameterType);
                        referenceValueMap.Add(i, localVar);

                        // Store the argument value in a local variable
                        il.Emit(OpCodes.Stloc, localVar);

                        // Push the local variable address onto the stack
                        il.Emit(OpCodes.Ldloca, localVar);
                    }
                }
                else
                {
                    if (parameterType.IsValueType)
                    {
                        // Turn the object into aprimitive type
                        il.Emit(OpCodes.Unbox, parameterType);

                        // Replace the object reference with its value
                        il.Emit(OpCodes.Ldobj, parameterType);
                    }
                }
            }

For each parameter in args, we load a reference to args onto the stack, load a constant that indexes into the args array onto the stack, then pull the actual parameter out of the args array using the opcode:

il.Emit(OpCodes.Ldelem_Ref);

OK, so we now have the parameter on the stack as an object reference. We need to be able to set things up to handle ref and out parameters. There are 2 cases to consider: first, where the parameter is a primitive or value type, such as an int; and second, where the parameter is a class type. If the parameter is a primitive type, all you need to do is ‘unbox’ the object reference that is on the stack. ‘Unboxing’ means that we remove all the wrappings .Net puts around a primitive type to make the type take on all the attributes needed for variables of type object to have the fundamental capabilities needed for printing its value, etc. Once pushed onto the stack in its native type, the target function can change the value, and the updated value will be reflected in the DynamicMethod’s args array.

In the case where the ref or out parameter is a class type, we need to create a local variable, add it to the dictionary, store the parameter into the local variable, then push the local variable onto the stack.

If the parameter is neither a ref nor out parameter, all we need to do is examine it to see if it of a primitive type. If it is, we need to unbox it and push the raw parameter value onto the stack.

Now that we have the parameters on the stack, it’s time to call our target function. There are 2 basic ways to call a function in IL (actually, there are 3, but one of them is rarely used). If a fuinction’s definition allows it to be overridden, the opcode to use is:

il.Emit(OpCodes.Callvirt, methodInfo);

otherwise the correct opcode is:

il.Emit(OpCodes.Call, methodInfo);

After we call the target function, we need to copy any changed ref or out parameters that are of class type back to the calling context, where the calling context is defined as the DynamicMethod args array. Doing so looks like this:

            // Copy any changed reference values back into the argument array.
            foreach (KeyValuePair<int, LocalBuilder> kvp in referenceValueMap)
            {
                // Push the argument array onto the stack
                il.Emit(OpCodes.Ldarg_1);

                // Push the argument array index onto the stack
                il.Emit(OpCodes.Ldc_I4, kvp.Key);

                // Push the possibly-changed local variable value onto the stack
                il.Emit(OpCodes.Ldloc, kvp.Value);

                // Store the local value in the argument array, so that the changed
                // value is available to the calling context.
                il.Emit(OpCodes.Stelem_Ref);
            }

We’ve called our target function, so now we need to put its return value on the stack. Recall that our DynamicMethod signature has the return type declared as type object. If the target function return type is void, we load a null as the DynamicMethod return value, by doing this:

il.Emit(OpCodes.Ldnull);

If the return value is a primitive type, we need to box it. Boxing a primitive type wraps all the information necessary for the .Net runtime to work with the value type as it would with any other type that derives from System.Object. This boxing allows for things like serializing the primitive type’s value in a uniform way.

il.Emit(OpCodes.Box, methodInfo.ReturnType);

We finish the DynamicMethod body by generating the ‘return’ opcode, like this:

il.Emit(OpCodes.Ret);

What remains to be done is to create the DynamicMethod delegate object we can call directly. Doing so seals the DynamicMethod, making it ineligible for further modification. We create the delegate like this:

return (ProxyFunction)dynamicMethod.CreateDelegate(typeof(ProxyFunction));

That’s it for creaing the proxy function. In this next section we’ll demonstrate using the proxy. When a customer uses our framework to set up their functions to be used as callbacks, we use .Net reflection to build the MethodInfo class needed to construct a ProxyFunction. Doing so is relatively straight forward, but we do need to take into account the fact that a user may declare generic functions or use functions in generic types.

In the simple case, where we just have a non-generic function, we can manufacture the required MethodInfo class instance by doing something like this:

        double F6(int a, ref double b)
        {
            Console.WriteLine("F6");

            double result = a + b;

            b = a;

            return result;
        }

            mi = typeof(Program).GetMethod("F6", BindingFlags.Instance |
                BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
            proxy = ProxyFunctionFactory.Create(mi);
            double dblArg = 4.0;
            object[] targetArgs = new object[] { 3, dblArg };
            double dblReturn = (double)proxy(p, targetArgs);

Where the ‘F6′ function is declared in a simple test harness class named (quite imaginatively) Program. Once created, we can call the proxy as we would any other function.

Our Program class defines one generic method. Constructing the MethodInfo instance we need is a 2 step process: first we need the definition for the generic method itself; then we need a MethodInfo representing the data-type-specific concrete instance of the generic function’s definition. Stated another way, we get the MethodInfo for the generic type before specifying the generic’s type, then we need to qualify the generic with the data type that makes the generic take on a particular data type. Here’s how we do that:

        int F11<T>(int a, out T b, string c, ref double d) where T : new()
        {
            Console.WriteLine("F11");

            T e = new T();
            b = e;
            d = 1.23;
            return a;
        }

            MethodInfo genericMi = typeof(Program).GetMethod("F11", BindingFlags.Instance |
                BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
            mi = genericMi.MakeGenericMethod(new Type[] { typeof(double) } );
            proxy = ProxyFunctionFactory.Create(mi);
            intArg = 3;
            dblArg = 3.45;
            stringArg = "Ick";
            double dblArg2 = 6.78;
            targetArgs = new object[] { intArg, dblArg, stringArg, dblArg2 };
            intReturn = (int)proxy(p, targetArgs);

The call to ‘MakeGenericMethod’ tells the generic method that its one generic parameter will become concrete as data type double.

So, there you have it. The remainder of this post is the code for the ProxyFunction class and its associated factory and a small class used to test the ProxyFunction class.

//////////////////////////////////////////////////////////////////////
// This file implements a class that lets us dynamically construct
// a static function whose signature is general enough that we can
// use the dynamic function as a proxy that can call any other
// function we want.  We use this capability so that we can marshal
// functions' signatures to a client that wants to be able to call
// functions in a server without rquiring the server to create
// a delegate signature or service contract for each callback
// function.
//////////////////////////////////////////////////////////////////////

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Collections.Generic;
using System.Text;

namespace ProxyGen
{
    /// <summary>
    /// Define a type whose signature allows us to call an exisitng function we want to be able to call
    /// dynamically.
    /// </summary>
    /// <param name="target">The data type that contains the callback function we want to call.</param>
    /// <param name="args">An array of data type object that are the values we will call the
    /// user-defined callback with.</param>
    /// <returns>Data type object whose contained value is of the same type as the original instrument
    /// action method, which may be null.</returns>
    public delegate object ProxyFunction(object targetClass, object[] args);

    /// <summary>
    /// A class that generates a ProxyFunction given an instance of  a MethodInfo
    /// class.  We examine the MethodInfo instance and construct from it a ProxyFunction
    /// we can call dynamically.
    /// </summary>
    class ProxyFunctionFactory
    {
        /// <summary>
        /// Generates a ProxyFunction given an instance of a MethodInfo
        /// class.
        /// </summary>
        /// <param name="method">An instance of the MethodInfo class representing the
        /// instrument action we want to call.</param>
        /// <returns>An instance of the ProxyFunction we can call dynamically.</returns>
        public static ProxyFunction Create(MethodInfo methodInfo)
        {
            // The arguments we send to the dynamic method are the target object instance
            // containing the target callback function we want to call and an array
            // of type object, where each element in the object in the array is one
            // argument to the target function.
            Type[] proxyFunctionArgTypes = { typeof(object), typeof(object[]) };

            // Create dynamic method and obtain its IL generator to
            // inject code.  
            // We set skipVisibilityChecks true because the target callback
            // function may be in a class we would not usually have access to.
            bool skipVisibilityChecks = true;
            DynamicMethod dynamicMethod =
                new DynamicMethod("",                   // we don't give the DynamicMethod a name
                typeof(object),                         // DynamicMethod's return type
                proxyFunctionArgTypes,                  // DynamicMethod's arguments
                typeof(ProxyFunctionFactory),           // The class which we will bind DynamicMethod to
                skipVisibilityChecks);
            ILGenerator il = dynamicMethod.GetILGenerator();

            #region Generate IL for proxy function

            #region Check proxy arg count against target arg count

            // Define a label for succesful argument count checking.
            Label numArgsTheSameLabel = il.DefineLabel();

            // Check the number of arguments sent to the proxy function.
            // Push the proxy function argument array onto the stack.
            il.Emit(OpCodes.Ldarg_1);

            // Get the proxy function argument array length
            il.Emit(OpCodes.Ldlen);

            // Get the number of arguments defined in the target function.
            ParameterInfo[] targetFunctionParms = methodInfo.GetParameters();
            int numTargetParms = targetFunctionParms.Length;

            // Push numTargetParms onto the stack as an int constant
            il.Emit(OpCodes.Ldc_I4, numTargetParms);

            // If the number of arguments in the object array matches the number
            // of arguments the target function expects, we're golden, branch around
            // the next section of code to where we set the argsOK label.
            il.Emit(OpCodes.Beq, numArgsTheSameLabel);

            // Argument count was wrong, throw TargetParameterCountException.
            il.Emit(OpCodes.Newobj,
                typeof(TargetParameterCountException).GetConstructor(Type.EmptyTypes));
            il.Emit(OpCodes.Throw);

            // Set the branch target, identifying the statement where we will pick
            // up if the number of arguments in the target function match the number
            // of arguments sent to the dynamic method.
            il.MarkLabel(numArgsTheSameLabel);

            #endregion

            #region Push target function containing object

            // If method isn't static push target instance on top
            // of stack.
            if (!methodInfo.IsStatic)
            {
                // The dynamic method's argument 0 is the instance of a class
                // containing our target function.
                il.Emit(OpCodes.Ldarg_0);
            }

            #endregion

            #region Push proxy function parameters onto stack 

            // If the target function has arguments passed by reference, we create a local variable 
            // that will hold the address of the variable to be passed to the target function.  We 
            // put the local variable in a map, so we can put the local variable value back in the 
            // argument array after we call the target delegate function, which may have chaged
            // the reference parameter value.
            Dictionary<int, LocalBuilder> referenceValueMap = new Dictionary<int, LocalBuilder>();

            for (int i = 0; i < numTargetParms; i++)
            {
                // The proxy funcion signature has the class containing the target function
                // as its first argument.  The 2nd argument is an array of object holding the
                // target function arguments.
                // Push the argument array onto the stack.
                il.Emit(OpCodes.Ldarg_1);

                // Push the argument index onto the stack.
                il.Emit(OpCodes.Ldc_I4, i);

                // Load the argument array object at index i onto the stack
                il.Emit(OpCodes.Ldelem_Ref);

                Type parameterType = targetFunctionParms[i].ParameterType;
                if (parameterType.IsByRef)
                {
                    parameterType = parameterType.GetElementType();
                    if (parameterType.IsValueType)
                    {
                        // Turn the object into a primitive type
                        il.Emit(OpCodes.Unbox, parameterType);
                    }
                    else
                    {
                        // If the target function has arguments passed by reference, we create a local variable 
                        // that will hold the address of the variable to be passed to the target function.  We 
                        // put the local variable in a map, so we can put the local variable value back in the 
                        // argument array after we call the target delegate function, which may have chaged
                        // the reference parameter value.
                        LocalBuilder localVar = il.DeclareLocal(parameterType);
                        referenceValueMap.Add(i, localVar);

                        // Store the argument value in a local variable
                        il.Emit(OpCodes.Stloc, localVar);

                        // Push the local variable address onto the stack
                        il.Emit(OpCodes.Ldloca, localVar);
                    }
                }
                else
                {
                    if (parameterType.IsValueType)
                    {
                        // Turn the object into a primitive type
                        il.Emit(OpCodes.Unbox, parameterType);

                        // Replace the object reference with its value
                        il.Emit(OpCodes.Ldobj, parameterType);
                    }
                }
            }

            #endregion

            #region Call the target function

            // If the target function is final (cannot be overridden)
            // use the Call opcode, otherwise use Callvirt
            if (methodInfo.IsFinal)
            {
                il.Emit(OpCodes.Call, methodInfo);
            }
            else
            {
                il.Emit(OpCodes.Callvirt, methodInfo);
            }

            // Copy any changed reference values back into the argument array.
            foreach (KeyValuePair<int, LocalBuilder> kvp in referenceValueMap)
            {
                // Push the argument array onto the stack
                il.Emit(OpCodes.Ldarg_1);

                // Push the argument array index onto the stack
                il.Emit(OpCodes.Ldc_I4, kvp.Key);

                // Push the possibly-changed local variable value onto the stack
                il.Emit(OpCodes.Ldloc, kvp.Value);

                // Store the local value in the argument array, so that the changed
                // value is available to the calling context.
                il.Emit(OpCodes.Stelem_Ref);
            }

            if (methodInfo.ReturnType == typeof(void))
            {
                il.Emit(OpCodes.Ldnull);
            }
            else
            {
                // If the result is a value type, it needs to be boxed, as opposed to pushing
                // an object reference to it onto the stack.
                if (methodInfo.ReturnType.IsValueType)
                {
                    il.Emit(OpCodes.Box, methodInfo.ReturnType);
                }
            }

            // Return from the proxy function
            il.Emit(OpCodes.Ret);

            #endregion

            #endregion

            return (ProxyFunction)dynamicMethod.CreateDelegate(typeof(ProxyFunction));
        }
    }
}


using System;
using System.Reflection;

namespace ProxyGen
{
    class Program
    {
        #region Test Functions

        static void F1()
        {
            Console.WriteLine("F1");
        }

        void F2()
        {
            Console.WriteLine("F2");
        }

        static int F3()
        {
            Console.WriteLine("F3");
            return 1;
        }

        int F4()
        {
            Console.WriteLine("F4");
            return 2;
        }

        int F5(int a)
        {
            Console.WriteLine("F5");
            return ++a;
        }

        double F6(int a, ref double b)
        {
            Console.WriteLine("F6");

            double result = a + b;

            b = a;

            return result;
        }

        string F7(int a, ref string b)
        {
            Console.WriteLine("F7");

            string result = b + a.ToString();

            b = a.ToString();

            return result;
        }

        double[] F8(int numArrayElements, double initialValue)
        {
            Console.WriteLine("F8");

            double[] result = new double[numArrayElements];

            for (int i = 0; i < numArrayElements; ++i)
            {
                result[i] = initialValue;
            }

            return result;
        }

        string[] F9(int numArrayElements, double initialValue)
        {
            Console.WriteLine("F9");

            double[] dblArray = F8(numArrayElements, initialValue);

            string[] result = new string[dblArray.Length];

            for (int i = 0; i < dblArray.Length; ++i)
            {
                result[i] = (dblArray[i] * i).ToString();
            }

            return result;
        }

        void F10(out string[] a)
        {
            Console.WriteLine("F10");
            string[] b = new string[] { "Moe", "Larry", "Curly" };
            a = b;
        }

        delegate int GenericDelegate<T>(int a, out T b, string c, ref double d) where T : new();

        int F11<T>(int a, out T b, string c, ref double d) where T : new()
        {
            Console.WriteLine("F11");

            T e = new T();
            b = e;
            d = 1.23;
            return a;
        }

        #endregion

        static void Main(string[] args)
        {
            Program p = new Program();

            MethodInfo mi = typeof(Program).GetMethod("F1", BindingFlags.Instance |
                BindingFlags.NonPublic | BindingFlags.Public| BindingFlags.Static);
            ProxyFunction proxy = ProxyFunctionFactory.Create(mi);
            proxy(p, new object[] {});

            mi = typeof(Program).GetMethod("F2", BindingFlags.Instance |
                BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
            proxy = ProxyFunctionFactory.Create(mi);
            proxy(p, new object[] { });

            mi = typeof(Program).GetMethod("F3", BindingFlags.Instance |
                BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
            proxy = ProxyFunctionFactory.Create(mi);
            int intReturn = (int)proxy(p, new object[] { });

            mi = typeof(Program).GetMethod("F4", BindingFlags.Instance |
                BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
            proxy = ProxyFunctionFactory.Create(mi);
            intReturn = (int)proxy(p, new object[] { });

            mi = typeof(Program).GetMethod("F5", BindingFlags.Instance |
                BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
            proxy = ProxyFunctionFactory.Create(mi);
            intReturn = (int)proxy(p, new object[] { 3 } );

            mi = typeof(Program).GetMethod("F6", BindingFlags.Instance |
                BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
            proxy = ProxyFunctionFactory.Create(mi);
            double dblArg = 4.0;
            object[] targetArgs = new object[] { 3, dblArg };
            double dblReturn = (double)proxy(p, targetArgs);

            mi = typeof(Program).GetMethod("F7", BindingFlags.Instance |
                BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
            proxy = ProxyFunctionFactory.Create(mi);
            int intArg = 4;
            string stringArg = "Yo!";
            targetArgs = new object[] { intArg, stringArg };
            string stringResult = (string)proxy(p, targetArgs);

            mi = typeof(Program).GetMethod("F8", BindingFlags.Instance |
                BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
            proxy = ProxyFunctionFactory.Create(mi);
            intArg = 4;
            double initVal = 3.14;
            targetArgs = new object[] { intArg, initVal };
            double[] dblArrayResult = (double[])proxy(p, targetArgs);

            mi = typeof(Program).GetMethod("F9", BindingFlags.Instance |
                BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
            proxy = ProxyFunctionFactory.Create(mi);
            intArg = 4;
            initVal = 3.14;
            targetArgs = new object[] { intArg, initVal };
            string[] stringArrayResult = (string[])proxy(p, targetArgs);

            mi = typeof(Program).GetMethod("F10", BindingFlags.Instance |
                BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
            proxy = ProxyFunctionFactory.Create(mi);
            string[] stringArrayArg = new string[] { };
            targetArgs = new object[] { stringArrayArg };
            proxy(p, targetArgs);

            MethodInfo genericMi = typeof(Program).GetMethod("F11", BindingFlags.Instance |
                BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
            mi = genericMi.MakeGenericMethod(new Type[] { typeof(double) } );
            proxy = ProxyFunctionFactory.Create(mi);
            intArg = 3;
            dblArg = 3.45;
            stringArg = "Ick";
            double dblArg2 = 6.78;
            targetArgs = new object[] { intArg, dblArg, stringArg, dblArg2 };
            intReturn = (int)proxy(p, targetArgs);

            // This is intentionally intended to fail to test out the argument-
            // checking part of the proxy function generation
            try
            {
                intReturn = (int)proxy(p, new object[] { });
            }
            catch (TargetParameterCountException e)
            {
                Console.WriteLine("Correctly caught exception:{0}{1}",
                    Environment.NewLine, e.Message);
            }
        }
    }
}