-Richard

For those of you unfamiliar with how the setup.exe is created when an add-in is published, it may come as a surprise to learn that ComponentCheck.exe ends up being embedded directly into setup.exe. When setup.exe is run on the target machine, ComponentCheck.exe is unpacked to a temporary directory and run from there.

If you're running into unexpected behaviour (e.g. the PIA installer running when you believe it shouldn't or, conversely, the PIA installer not running at all when you believe it should), you might want to try testing ComponentCheck.exe by copying it from the %ProgramFiles%\Microsoft SDKs\Windows\v6.0A\Bootstrapper\Packages\Office2007PIARedist directory on your Visual Studio 2008 SP1 dev box to an arbitrary location on a test machine and running it from a batch file as follows:

@echo off
ComponentCheck.exe
echo %ERRORLEVEL%

This just serves to run the program and echo its output/return value to the console. This script should echo 1 if the PIAs are already installed or 0 otherwise. The PIAInstallAction property is set to this return value and used to block or enable installation of the PIAs respectively (see the <BypassIf Property="PIAInstallAction" Compare="ValueNotEqualTo" Value="0" /> element in product.xml). You might want to consider trying this a machine with Office 2007 PIAs installed and another machine without the Office 2007 PIAs installed.

If you're seeing genuine issues with this component after running this short test, please don't hesitate to let us know.

• My article on the subject
• A MSDN article on this subject
• Another MSDN article on related subject matter

Visual Studio Tools for Office versioning and compatibility

Abbreviations used in this document

Overview

VSTO consists of two distinct components with different, but intertwined, shipping patterns, versioning and compatibility concerns. Specifically, we are influenced by all three of the following:

·         Office: we aim to provide support for new versions of Office as quickly as possible preferably in advance of, or simultaneously with, each Office release. We distribute our runtime components as a redistributable package through the Microsoft public download site (in addition to chaining into VS for developer use).

·         VS: all our design-time components including designers, code generators, build integration and deployment/publishing are hosted inside VS.

·         .NET Framework/Common Language Runtime: we aim to allow developers to use new .NET technologies wherever possible, primarily by avoiding any artificial blocks to consumption of new APIs, frameworks or subsets. We also aim to allow developers to target “old” or down-level .NET versions if they so desire through multi-targeting.

To a lesser extent we are also influenced by Windows and release updates from time to time to deal with operating system changes and bugs.

The following three tables describe the range of Office applications covered by the VSTO design time and the compatibility and versioning details of each major release of the VSTO Runtime. Note that design-time support and runtime support provided by VSTO are not in one-to-one correspondence with one another.

That that certain items are internal names of solution types and “bizarre cryptonyms”, for example, and are strictly informal terminology and are in no way to be considered official.

Notes about some terminology

A few terms used in the three tables are explained in detail here:

Design-time support matrix

Solution types

Runtime support matrix

What else? Well, in parallel with this, my MSDN blog, I've also started working on my personal blog. This I decided to keep separate since the main subject of my posts on this site, while still primarily of a technical nature, mainly revolve around the interesting challenges associated with writing the actual blog code from scratch. So there.

Anyway, I do plan to post here more often soon.

This was, for me, an interesting digression into the area of IL generation using System.Reflection.Emit which is something I haven't done since my old Speech Server days.

Here's a summary of what I ended up doing:

• The multimethod factory generates a dynamic assembly on the fly. This assembly contains an automatically generated holder class encapsulating the delegate corresponding to each runtime overload of the multimethod plus a private invoker method for each overload. A central invoker method uses System.Type.InvokeMember to perform runtime method resolution while the private invokers perform marshalling and unmarshalling of arguments in and out of the runtime overload.
• This implementation supports by-reference arguments such as ref and out parameters along with in parameters as well as return values, so it offers something much closer to a complete solution than my initial implementation.
• The DebugInfo configuration class can be used to force the code generation phase to generate on-disc assemblies, symbols and pseudo-code which is provided to aid debugging of the generated IL: the code generation is somewhat fragile and it's very easy to leave the code generating "invalid program" errors when it gets JITted.
• The on-disc assemblies can also be referenced in other solutions in order to use the generated multimethod without the overhead of the code/assembly generation phase.

For future investigation:

• It would be nice to eliminate the reflection. As discussed at the recent PDC, there is a new planned dynamic pseudo-type in C# 4.0 which will allow for late-bound method calls. This is designed to improve COM interoperability but could just as well be applied to the problem of multiple dispatch. It would likely simplify a great deal of the IL that my multimethod factory has to generate.
• Currently, the delegate types used to construct the multimethod have to be declared public since the dynamic assembly that implements the multimethod holder needs to be able to access these types at runtime. I would like to be able to remove this limitation in order to improve encapsulation.
• I'm sure I could use abstract syntax trees and DLR-type on-the-fly code generation to do much of what can be done here. However, to remain compatible with .NET Framework 3.5 I'll be sticking with my reflection-based implementation for the time being!

Until next time…

MultipleDispatchRevisited.zip

/// Generates multimethods corresponding to the specified method signature.

/// </summary>

/// <typeparam name="T">Type of delegate specifying method signature</typeparam>

public sealed class MultimethodFactory<T> where T : class

{

    private static class Constants

    {

        internal const string InvokeMethodName = "Invoke";

        internal const string SpecificInvokeMethodName = "__Invoke";

        internal const string CreateDelegateMethodName = "CreateDelegate";

    }

    private sealed class FieldData

    {

        private readonly FieldBuilder _fieldBuilder;

        private readonly object _value;

        internal FieldBuilder FieldBuilder

        {

            get

            {

                return _fieldBuilder;

            }

        }

        internal object Value

        {

            get

            {

                return _value;

            }

        }

        internal FieldData(FieldBuilder fieldBuilder, object value)

        {

            Debug.Assert(null != fieldBuilder);

            Debug.Assert(null != value);

            _fieldBuilder = fieldBuilder;

            _value = value;

        }

    }

    private static readonly InvocationData _invocationData;

    private readonly List<object> _delegates = new List<object>();

    /// <summary>

    /// Type initializer.

    /// </summary>

    static MultimethodFactory()

    {

        if (!typeof(T).IsPublic || !InvocationData.TryCreate(typeof(T), out _invocationData))

            throw new ArgumentException(string.Format(Properties.Resources.ArgumentExceptionMustBeValidPublicDelegateType, typeof(T).FullName), "T");

    }

    /// <summary>

    /// Creates a new multimethod factory instance.

    /// </summary>

    public MultimethodFactory()

    {

    }

    /// <summary>

    /// Implements a runtime overload of the multimethod.

    /// </summary>

    /// <typeparam name="U">Type of delegate specifying method signature</typeparam>

    /// <param name="delegate">Delegate</param>

    public void Implement<U>(U @delegate) where U : class

    {

        InvocationData invocationData;

        if (!typeof(U).IsPublic || !InvocationData.TryCreate(typeof(U), out invocationData))

            throw new ArgumentException(string.Format(Properties.Resources.ArgumentExceptionMustBeValidPublicDelegateType, typeof(U).FullName), "U");

        if (null == @delegate)

            throw new ArgumentNullException(Properties.Resources.ArgumentNullExceptionDelegate, "delegate");

        Debug.Assert(typeof(U).Equals(@delegate.GetType()));

        if (!_invocationData.IsCompatibleWith(invocationData))

            throw new ArgumentException(string.Format(Properties.Resources.ArgumentExceptionDelegateTypeIsIncompatible, typeof(U).FullName, typeof(T).FullName), "U");

        _delegates.Add(@delegate);

    }

    /// <summary>

    /// Creates a multimethod instance.

    /// </summary>

    /// <returns>Multimethod delegate</returns>

    public T CreateMultimethod()

    {

        return CreateMultimethod(null);

    }

    /// <summary>

    /// Creates a multimethod instance.

    /// </summary>

    /// <param name="debugInfo">Debug configuration</param>

    /// <returns>Multimethod delegate</returns>

    public T CreateMultimethod(DebugInfo debugInfo)

    {

        if (_delegates.Count < 1)

            throw new InvalidOperationException(Properties.Resources.InvalidOperationExceptionNoOverloadsDefined);

        AssemblyBuilder assemblyBuilder = CreateAssemblyBuilder(debugInfo);

        ModuleBuilder moduleBuilder = CreateModuleBuilder(debugInfo, assemblyBuilder);

        FieldData[] fields;

        Type holderType = CreateHolderClass(debugInfo, moduleBuilder, _delegates.ToArray(), _invocationData, out fields);

        SaveArtifacts(debugInfo, assemblyBuilder, moduleBuilder);

        object holder = CreateHolderInstance(holderType, fields);

        MethodInfo createDelegateMethod = holderType.GetMethod(Constants.CreateDelegateMethodName, BindingFlags.Public | BindingFlags.Instance, null, Type.EmptyTypes, null);

        if (null == createDelegateMethod)

            throw new InvalidOperationException(Properties.Resources.InvalidOperationExceptionBadCodeGeneration);

        return (T)createDelegateMethod.Invoke(holder, null);

    }

    private static void SaveArtifacts(DebugInfo debugInfo, AssemblyBuilder assemblyBuilder, ModuleBuilder moduleBuilder)

    {

        Debug.Assert(null != assemblyBuilder);

        Debug.Assert(null != moduleBuilder);

        if (null == debugInfo)

            return;

        // Copy the assembly to the output path.

        string fileName = Path.GetFileName(debugInfo.AssemblyPath);

        assemblyBuilder.Save(fileName);

        File.Move(fileName, debugInfo.AssemblyPath);

        // Copy the module to the output path.

        File.Move(moduleBuilder.FullyQualifiedName, debugInfo.ModulePath);

        // Copy the source to the output path.

        string symbolSourcePath = Path.ChangeExtension(moduleBuilder.FullyQualifiedName, ".pdb");

        string symbolTargetPath = Path.ChangeExtension(debugInfo.ModulePath, ".pdb");

        File.Move(symbolSourcePath, symbolTargetPath);

    }

    private static AssemblyBuilder CreateAssemblyBuilder(DebugInfo debugInfo)

    {

        AssemblyName assemblyName = new AssemblyName(null == debugInfo ? "ANONYMOUS" : Path.GetFileName(debugInfo.AssemblyPath));

        ConstructorInfo attributeConstructor = typeof(SecurityTransparentAttribute).GetConstructor(Type.EmptyTypes);

        if (null == attributeConstructor)

            throw new InvalidOperationException(Properties.Resources.InvalidOperationExceptionBadCodeGeneration);

        AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave, new CustomAttributeBuilder[] { new CustomAttributeBuilder(attributeConstructor, new object[0]) });

        attributeConstructor = typeof(DebuggableAttribute).GetConstructor(new Type[] { typeof(DebuggableAttribute.DebuggingModes) });

        assemblyBuilder.SetCustomAttribute(new CustomAttributeBuilder(attributeConstructor, new object[] { DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.Default }));

        return assemblyBuilder;

    }

    private static ModuleBuilder CreateModuleBuilder(DebugInfo debugInfo, AssemblyBuilder assemblyBuilder)

    {

        Debug.Assert(null != assemblyBuilder);

        if (null == debugInfo)

            return assemblyBuilder.DefineDynamicModule("ANONYMOUS");

        return assemblyBuilder.DefineDynamicModule(debugInfo.ModulePath, Path.GetFileName(debugInfo.ModulePath), true);

    }

    private static Type CreateHolderClass(DebugInfo debugInfo, ModuleBuilder moduleBuilder, object[] delegates, InvocationData invocationData, out FieldData[] fields)

    {

        Debug.Assert(null != moduleBuilder);

        Debug.Assert(null != delegates && delegates.Length > 0);

        Debug.Assert(null != invocationData);

        bool isDebuggable = null != debugInfo;

        string sourceFileName = isDebuggable ? debugInfo.SourcePath : null;

        using (SourceWriter sourceWriter = new SourceWriter(isDebuggable, sourceFileName, moduleBuilder))

        {

            TypeBuilder typeBuilder = moduleBuilder.DefineType(ILHelpers.GenerateUniqueName("MultimethodHolderClass"), TypeAttributes.Public | TypeAttributes.Class);

            fields = new FieldData[delegates.Length];

            for (int i = 0; i < fields.Length; ++i)

            {

                // Create runtime overload of "__Invoke" and save the field name for later use.

                object @delegate = delegates[i];

                FieldBuilder fieldBuilder = GenerateSpecificInvokeMethod(sourceWriter, typeBuilder, @delegate.GetType());

                fields[i] = new FieldData(fieldBuilder, @delegate);

            }

            GenerateConstructor(sourceWriter, typeBuilder, fields);

            // Generate public "Invoke" method.

            MethodBuilder publicInvokeMethod = GenerateInvokeMethod(sourceWriter, typeBuilder, invocationData);

            // Create delegate creator method.

            GenerateCreateDelegateMethod(sourceWriter, typeBuilder, typeof(T), publicInvokeMethod);

            // Instantiate generated multimethod holder class.

            return typeBuilder.CreateType();

        }

    }

    private static object CreateHolderInstance(Type holderType, FieldData[] fields)

    {

        Debug.Assert(null != holderType);

        Debug.Assert(null != fields && fields.Length > 0);

        object[] args = new object[fields.Length];

        for (int i = 0; i < args.Length; ++i)

            args[i] = fields[i].Value;

        return Activator.CreateInstance(holderType, args);

    }

    private static void GenerateConstructor(SourceWriter sourceWriter, TypeBuilder typeBuilder, FieldData[] fields)

    {

        Debug.Assert(null != sourceWriter);

        Debug.Assert(null != typeBuilder);

        Debug.Assert(null != fields && fields.Length > 0);

        // Create array of delegate types for constructor.

        Type[] parameterTypes = new Type[fields.Length];

        for (int i = 0; i < parameterTypes.Length; ++i)

            parameterTypes[i] = fields[i].Value.GetType();

        // Default constructor for System.Object.

        ConstructorInfo objectConstructor = typeof(object).GetConstructor(Type.EmptyTypes);

        if (null == objectConstructor)

            throw new InvalidOperationException(Properties.Resources.InvalidOperationExceptionBadCodeGeneration);

        ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, parameterTypes);

        ILGenerator generator = constructorBuilder.GetILGenerator();

        sourceWriter.EmitFunctionHeader(".ctor");

        sourceWriter.EmitSourceLine(generator, "PUSH this");

        generator.Emit(OpCodes.Ldarg_0); // Push "this" onto stack.

        sourceWriter.EmitSourceLine(generator, "CALL System.Object..ctor");

        generator.Emit(OpCodes.Call, objectConstructor); // Invoke System.Object..ctor.

        for (int i = 1; i <= fields.Length; ++i)

        {

            sourceWriter.EmitSourceLine(generator, "PUSH this");

            generator.Emit(OpCodes.Ldarg_0); // Push "this" onto stack.

            sourceWriter.EmitSourceLine(generator, "PUSH ARG {0}", i);

            ILHelpers.EmitLdarg(generator, i);

            sourceWriter.EmitSourceLine(generator, "STORE FIELD {0}", fields[i - 1].FieldBuilder.Name);

            generator.Emit(OpCodes.Stfld, fields[i - 1].FieldBuilder); // Store in field.

        }

        sourceWriter.EmitSourceLine(generator, "RETURN");

        generator.Emit(OpCodes.Ret);

    }

    private static void GenerateCreateDelegateMethod(SourceWriter sourceWriter, TypeBuilder typeBuilder, Type delegateType, MethodBuilder publicInvokeMethod)

    {

        Debug.Assert(null != sourceWriter);

        Debug.Assert(null != typeBuilder);

        Debug.Assert(null != delegateType && typeof(Delegate).IsAssignableFrom(delegateType));

        Debug.Assert(null != publicInvokeMethod);

        // Get delegate's constructor.

        ConstructorInfo delegateConstructor = delegateType.GetConstructor(new Type[] { typeof(object), typeof(IntPtr) });

        if (null == delegateConstructor)

            throw new InvalidOperationException(Properties.Resources.InvalidOperationExceptionBadCodeGeneration);

        // Generate delegate factory method.

        MethodBuilder methodBuilder = typeBuilder.DefineMethod(Constants.CreateDelegateMethodName, MethodAttributes.Public, delegateType, Type.EmptyTypes);

        ILGenerator generator = methodBuilder.GetILGenerator();

        sourceWriter.EmitFunctionHeader(Constants.CreateDelegateMethodName);

        sourceWriter.EmitSourceLine(generator, "DECLARE LOCAL");

        generator.DeclareLocal(delegateType);

        sourceWriter.EmitSourceLine(generator, "PUSH this");

        generator.Emit(OpCodes.Ldarg_0); // Push "this" onto stack.

        sourceWriter.EmitSourceLine(generator, "PUSH {0}", publicInvokeMethod.Name);

        generator.Emit(OpCodes.Ldftn, publicInvokeMethod); // Push reference to "__Invoke" method onto stack.

        sourceWriter.EmitSourceLine(generator, "CREATE {0}", delegateType.FullName);

        generator.Emit(OpCodes.Newobj, delegateConstructor); // Create instance of delegate.

        sourceWriter.EmitSourceLine(generator, "STORE LOCAL");

        generator.Emit(OpCodes.Stloc_0); // Store to local variable.

        sourceWriter.EmitSourceLine(generator, "PUSH LOCAL");

        generator.Emit(OpCodes.Ldloc_0); // Push local variable onto stack to return it.

        sourceWriter.EmitSourceLine(generator, "RETURN");

        generator.Emit(OpCodes.Ret); // Return;

    }

    private static FieldBuilder GenerateSpecificInvokeMethod(SourceWriter sourceWriter, TypeBuilder typeBuilder, Type delegateType)

    {

        Debug.Assert(null != typeBuilder);

        Debug.Assert(null != sourceWriter);

        Debug.Assert(null != delegateType && typeof(Delegate).IsAssignableFrom(delegateType));

        InvocationData invocationData;

        if (!InvocationData.TryCreate(delegateType, out invocationData))

            throw new InvalidOperationException(Properties.Resources.InvalidOperationExceptionBadCodeGeneration);

        // Generate a random name for the field.

        string fieldName = ILHelpers.GenerateUniqueName("InvokerDelegate");

        // Create the private delegate field.

        FieldBuilder fieldBuilder = typeBuilder.DefineField(fieldName, delegateType, FieldAttributes.Private | FieldAttributes.InitOnly);

        // Generate the "__Invoke" method.

        MethodBuilder methodBuilder = typeBuilder.DefineMethod(

            Constants.SpecificInvokeMethodName,

            MethodAttributes.Public,

            invocationData.InvokeMethod.ReturnType,

            invocationData.GetParameterTypes());

        ILGenerator generator = methodBuilder.GetILGenerator();

        sourceWriter.EmitFunctionHeader(string.Format(CultureInfo.InvariantCulture, "{0}[{1}]", Constants.SpecificInvokeMethodName, delegateType.FullName));

        sourceWriter.EmitSourceLine(generator, "PUSH DELEGATE ONTO STACK");

        generator.Emit(OpCodes.Ldarg_0); // Push "this".

        generator.Emit(OpCodes.Ldfld, fieldBuilder); // Pop this and push field.

        sourceWriter.EmitSourceLine(generator, "LOAD ARGS");

        for (int i = 0; i < invocationData.ParameterCount; ++i)

            ILHelpers.EmitLdarg(generator, i + 1);

        sourceWriter.EmitSourceLine(generator, "INVOKE DELEGATE");

        generator.EmitCall(OpCodes.Callvirt, invocationData.InvokeMethod, null); // Call the "Invoke" method.

        sourceWriter.EmitSourceLine(generator, "RETURN");

        generator.Emit(OpCodes.Ret); // Return.

        Debug.Assert(0 == string.Compare(fieldName, fieldBuilder.Name, StringComparison.Ordinal));

        return fieldBuilder;

    }

    private static MethodBuilder GenerateInvokeMethod(SourceWriter sourceWriter, TypeBuilder typeBuilder, InvocationData invocationData)

    {

        Debug.Assert(null != sourceWriter);

        Debug.Assert(null != typeBuilder);

        Debug.Assert(null != invocationData);

        // Create method.

        MethodBuilder methodBuilder = typeBuilder.DefineMethod(

            Constants.InvokeMethodName,

            MethodAttributes.Private,

            invocationData.InvokeMethod.ReturnType,

            invocationData.GetParameterTypes());

        ILGenerator generator = methodBuilder.GetILGenerator();

        sourceWriter.EmitFunctionHeader(Constants.InvokeMethodName);

        // Declare local object array.

        sourceWriter.EmitSourceLine(generator, "DECLARE LOCAL");

        generator.DeclareLocal(typeof(object[]));

        // Create an array of three objects and assign it to the local variable.

        sourceWriter.EmitSourceLine(generator, "CREATE LOCAL");

        ILHelpers.EmitLdc_I4(generator, invocationData.ParameterCount);

        generator.Emit(OpCodes.Newarr, typeof(object)); // Create array of objects of size given by value on top of stack (i.e. 3) and push result onto stack.

        generator.Emit(OpCodes.Stloc_0); // Store the result (i.e. the newly created array) in the local variable.

        // Marshal in- and ref-parameters.

        for (int i = 0; i < invocationData.ParameterCount; ++i)

        {

            ParameterData parameter = invocationData.GetParameter(i);

            switch (parameter.Kind)

            {

                case ParameterKind.In:

                    sourceWriter.EmitSourceLine(generator, "MARSHAL ARG {0} [{1}]", i, parameter.Kind);

                    generator.Emit(OpCodes.Ldloc_0); // Push local array variable onto stack.

                    ILHelpers.EmitLdc_I4(generator, i); // Push array index onto stack.

                    ILHelpers.EmitLdarg(generator, i + 1); // Push corresponding argument's value onto stack.

                    generator.Emit(OpCodes.Stelem_Ref);

                    break;

                case ParameterKind.Out:

                    break;

                case ParameterKind.Ref:

                    sourceWriter.EmitSourceLine(generator, "MARSHAL ARG {0} [{1}]", i, parameter.Kind);

                    generator.Emit(OpCodes.Ldloc_0); // Push local array variable onto stack.

                    ILHelpers.EmitLdc_I4(generator, i); // Push array index onto stack.

                    ILHelpers.EmitLdarg(generator, i + 1); // Push corresponding argument's value or address onto stack.

                    generator.Emit(OpCodes.Ldind_Ref); // Fetch the value of by-reference values.

                    generator.Emit(OpCodes.Stelem_Ref);

                    break;

                default:

                    Debug.Fail("Unexpected");

                    throw new InvalidOperationException(Properties.Resources.InvalidOperationExceptionBadCodeGeneration);

            }

        }

        // Invoke this.GetType(). This leaves the Type instance on the stack.

        sourceWriter.EmitSourceLine(generator, "CALL GetType");

        generator.Emit(OpCodes.Ldarg_0); // Push "this" onto stack.

        MethodInfo getTypeMethod = typeof(object).GetMethod("GetType");

        if (null == getTypeMethod)

            throw new InvalidOperationException(Properties.Resources.InvalidOperationExceptionBadCodeGeneration);

        generator.EmitCall(OpCodes.Call, getTypeMethod, null);

        // Invoke this.GetType().InvokeMember(Constants.PrivateInvokeMethodName, BindingFlags, null, target, args). This leaves the return value on the stack.

        sourceWriter.EmitSourceLine(generator, "CALL InvokeMember");

        generator.Emit(OpCodes.Ldstr, Constants.SpecificInvokeMethodName);

        generator.Emit(OpCodes.Ldc_I4, (int)(BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod));

        generator.Emit(OpCodes.Ldnull);

        generator.Emit(OpCodes.Ldarg_0); // Push "this" onto stack.

        generator.Emit(OpCodes.Ldloc_0); // Push local array variable onto stack.

        MethodInfo invokeMemberMethod = typeof(Type).GetMethod("InvokeMember", BindingFlags.Instance | BindingFlags.Public, null, new Type[] { typeof(string), typeof(BindingFlags), typeof(Binder), typeof(object), typeof(object[]) }, null);

        if (null == invokeMemberMethod)

            throw new InvalidOperationException(Properties.Resources.InvalidOperationExceptionBadCodeGeneration);

        generator.EmitCall(OpCodes.Callvirt, invokeMemberMethod, null);

        // Unmarshal ref- and out-parameters.

        for (int i = 0; i < invocationData.ParameterCount; ++i)

        {

            ParameterData parameter = invocationData.GetParameter(i);

            switch (parameter.Kind)

            {

                case ParameterKind.In:

                    break;

                case ParameterKind.Out:

                case ParameterKind.Ref:

                    sourceWriter.EmitSourceLine(generator, "UNMARSHAL ARG {0} [{1}]", i, parameter.Kind);

                    ILHelpers.EmitLdarg(generator, i + 1); // Push argument 2's address onto stack.

                    generator.Emit(OpCodes.Ldloc_0); // Push local array variable onto stack.

                    ILHelpers.EmitLdc_I4(generator, i); // Push array index 1 onto stack.

                    generator.Emit(OpCodes.Ldelem_Ref); // Load element from array and pop arguments off stack.

                    generator.Emit(OpCodes.Stind_Ref); // Store elemtn to argument 2.

                    break;

                default:

                    Debug.Fail("Unexpected");

                    throw new InvalidOperationException(Properties.Resources.InvalidOperationExceptionBadCodeGeneration);

            }

        }

        // Pop return value off stack.

        if (typeof(void) == invocationData.InvokeMethod.ReturnType)

            generator.Emit(OpCodes.Pop);

        // Return.

        sourceWriter.EmitSourceLine(generator, "RETURN");

        generator.Emit(OpCodes.Ret);

        return methodBuilder;

    }

}

MultimethodFactory.cs