.NET COM Interoperability - Part 1: Using COM Components from .NET Framework

The DotNet framework exposes COM objects through a proxy called the runtime callable wrapper (RCW). The primary function of RCW is to marshal call between a managed client (.Net) and unmanaged COM object. The runtime maintains a single RCW for each COM object.

The primary goal of this article is to create a demo project to show how to call a COM component from DotNet client and to implement events raised by the COM component.

The example uses a COM component and DotNet client extending the functionality of the COM component using delegation.

Step 1

Lets start by creating a COM component (DotNetInterOp.dll) in VB. The Component consists of a single class CEmp, that have some properties (FirstName, LastName, DOB) and raises an event (Senior).

After Creating DotNetInterOp.dll register it using regsvr32 from the command line

regsvr32 C:\testbeds\DptNetInterOP\DotNetInterOp.dll

CEmp Class of DotNetInterOp component

Option Explicit
Public Event Senior()
Private mstrFirstName As String
Private mstrLastName As String
Private mdtDOB As Date
Public Property Get FirstName() As String
FirstName = mstrFirstName
End Property
Public Property Let FirstName(xstrFirstName As String)
mstrFirstName = xstrFirstName
End Property
Public Property Get LastName() As String
LastName = mstrLastName
End Property
Public Property Let LastName(xstrLastName As String)
mstrLastName = xstrLastName
End Property
Public Property Get DOB() As Date
DOB = mdtDOB
End Property
Public Property Let DOB(xdtDOB As Date)
mdtDOB = xdtDOB
If DateDiff("YYYY", mdtDOB, Now) > 60 Then
RaiseEvent Senior
End If
End Property

Step 2

To use this COM component in DotNet, the TypeLib of the component should be imported into an Assembly containing the metadata so that managed clients can create instances of the COM type and call its methods, just as if it were a .NET instance.

There are four ways to create an interop assembly

To add a reference to a type library using Visual Studio.Net

Open a DotNet project in Visual Studio.Net and add a reference to the COM component using the add reference dialog box. This would automatically create an interop assembly containing the metadata.

Type Library Importer

Use Type Library Importer (TlbImp.exe). TlbImp.exe is a command-line tool that converts COM type library to assembly containing metadata.

TypeLibConverter Class

The TypeLibConverter Class of the System.Runtime.InteropServices namespace provides methods to convert a type library to an assembly. This API can convert in-memory Type library and produces output as TlbImp.exe

Custom Wrappers

You can create a duplicate definition of the class or interface in managed source code. You then compile the source code with a compiler that targets the runtime to produce metadata in an assembly. To define COM types manually, you must know the precise descriptions of the coclasses and interfaces being defined and knowledge of the type library-to-assembly conversion rules. Writing a custom wrapper is an advanced technique that you seldom perform.

In our example we will use the TlbImp.exe to create metadata from the coclasses and interfaces definitions in our DotNetInterOp.dll Type library.

From the command line

tlbimp

C:\testbeds\DptNetInterOP\DotNetInterOp.dll /out:C:\DOTNet\TestBeds\VB\RCW\RCW\DotNetInterOp.dll

Step 3

Use the COM component, as it was a DotNet component, add reference to the assembly created in the previous step and code against the assembly by creating CEmp object and delegation the calls to this object.

The DotNet Client has two classes CEmp and CEmps, CEmp is a wrapper over our COM components CEmp and exposes FirstName, LastName and IsSenior properties. The FirstName, LastName properties just delegates to the Properties of COMs CEmp but IsSenior uses the event raised by the COM component to set its value. The CEmps class is a collection of CEmps and exposes methods to test our code.

VB.Net Client of the COM Component

Imports Microsoft.VisualBasic
Imports DotNetInterOp
Public Class CEmp
Private mobjEmp As DotNetInterOP.CEmp
Private mblnIsSenior As Boolean
Sub New(ByVal xstrFName As String, ByVal xstrLName As String, ByVal xdtDOB As Date)
mobjEmp = New DotNetInterOp.CEmp
AddHandler mobjEmp.Senior, New DotNetInterOp.__CEmp_SeniorEventHandler(AddressOf Senior)
With mobjEmp
.FirstName = xstrFName
.LastName = xstrLName
.DOB = xdtDOB
End With
End Sub
Public ReadOnly Property FirstName()
Get
Return mobjEmp.FirstName
End Get
End Property
Public ReadOnly Property LastName()
Get
Return mobjEmp.LastName
End Get
End Property
Public ReadOnly Property IsSenior()
Get
IsSenior = mblnIsSenior
End Get
End Property
Private Sub Senior()
mblnIsSenior = True
End Sub
End Class