Start Visual Studio 2012 and create a new CLR Console Application project named ComWrapper.

On the Project menu, click ComWrapper Properties to open the Project Properties dialog box. Select Common Properties, and then, in the pane on the left, click Frameworks And References, and then click the Add New Reference button.

In the Add Reference dialog box that opens, in the pane on the left, choose the COM entry.

It might take a few seconds to populate the list box with details of the COM components registered on your system.

Browse the list to find the entry for the TempConverterLib component. Click to the left of this entry to add a check mark and then click OK.

You will see that a new entry for TempConverterLib has been added to the project’s list of references.

Open Windows Explorer and look in the project’s Interop directory. You will see that it contains a file called Interop.TempConverterLib.1.0.dll, which contains the RCW assembly. These files are always named Interop.XXX.YYY.dll, where XXX and YYY are the name and version of the COM component to which the RCW refers.

Open the IL disassembler tool (ISDASM) and use it to examine Interop.TempConverter.1.0.dll.

The shield-like symbol with the red top represents a namespace, so the namespace you need to import is TempConverterLib. You can see that the assembly contains three types. Converter and IConverter represent the original COM co-class and interface definitions, respectively; their symbol is marked with an I (a capital “i”) to show that they are interfaces. ConverterClass is a real type, so its symbol doesn’t contain the I. The RCW is produced by the tlbimp tool.

To deduce the name of the wrapper class without using ILDASM, you take the name of the COM co-class and append Class.

Add a using directive to your code to make it easier to reference the RCW.

using namespace TempConverterLib;

Add code to create a wrapper object, and use it to call methods on the COM object, as shown in the following:

int main(array<String^>^ args)
{
    Console::WriteLine("COM Interop Sample");

    // Create a COM object
    ConverterClass ^conv = gcnew ConverterClass();

    // Call a conversion method and print the result
    double d = conv->ConvertC2F(27.0);
    Console::WriteLine("27C is {0}F", d);

    return 0;
}

Observe how the wrapper is created just like any other managed object, and methods are called on it in exactly the same way as normal. There’s no way to determine from this code that you’re using a COM object, and the wrapper performs all the lifetime management for you.

Build and run the application, checking that the output is what you expect.

Create a new CLR Console Application project named LateBind.

Add code to main to get a Type object that represents the COM component. (Consult Chapter 23, for more details on the Type class and its uses.)

// Get a type representing the COM object
Guid g = Guid("75F3EDC5-AA71-437A-ACB6-F885C29E50F7");
Type ^t = Type::GetTypeFromCLSID(g);
if (t == nullptr)
{
    Console::WriteLine("Error getting type for TConverter");
    return -1;
}
Console::WriteLine("Got type for TConverter");

The GetTypeFromCLSID static method takes a COM class ID (CLSID) as a Guid object and creates a Type object to represent the co-class. If there is a problem creating the Type object because the CLSID can’t be found or because of some other registry-related problem, a null is returned. Overloads of this function let you specify that an exception be thrown instead of returning a null, if that suits your code better.

You can find the CLSID of a component by examining the .idl file that was used when creating it.

Use the System::Activator class to create the COM object for you, as demonstrated here:

// Use System::Activator to create an instance
Object ^obj = Activator::CreateInstance(t);

The Activator class creates instances of local or remote objects for you. The reference returned is a general object reference; you don’t need to cast it to any specific type because this will be taken care of for you later.

Build the parameter list before you call a conversion method on the object. This takes the form of an array of Objects, as shown here:

// Make up the argument list

array<Object^> ^argarray = { 27.0 };

Here, the array contains only one value: the temperature to be converted.

Call the conversion method dynamically, using the InvokeMember method of the Type class.

// Invoke the method
try
{
    Object ^result = t->InvokeMember("ConvertC2F",
           Reflection::BindingFlags::InvokeMethod, nullptr, obj, argarray);

    double d = Convert::ToDouble(result);
    Console::WriteLine("27C is {0}F", d);
}
catch(Exception ^ex)
{
    Console::WriteLine("Exception from Invoke: ", ex->Message);
}

InvokeMember, as its name implies, dynamically invokes a member of an object. The arguments supplied to the function are the name of the member to be invoked, the type of operation (in this case, you’re invoking a method rather than accessing a property or field), a handle to a Binder object (which you’re not using), a handle to the object on which the operation is to be invoked, and a handle to the argument array.

If the call works, you’ll be passed back an Object reference representing the result, which is then converted to the appropriate type by using one of the static methods of the Convert class.

Build and run the application, and check that you get the right answer (which is 80.6F).