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
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
The example uses a COM
component and DotNet client extending the functionality of the COM component
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
After Creating DotNetInterOp.dll register it using regsvr32 from the command
CEmp Class of DotNetInterOp component
Option Explicit On
Public Event Senior()
Private mstrFirstName As String
Private mstrLastName As String
Private mdtDOB As Date
Public Property Get FirstName() As String
FirstName = mstrFirstName
Public Property Let FirstName(xstrFirstName As String)
mstrFirstName = xstrFirstName
Public Property Get LastName() As String
Public Property Let LastName(xstrLastName As String)
mstrLastName = xstrLastName
Public Property Get DOB() As Date
Public Property Let DOB(xdtDOB As Date)
mdtDOB = xdtDOB
mdtDOB, Now) > 60 Then
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
are four ways to create an interop assembly.
To add a reference to a type library using
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.
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.
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.
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.
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.
DotNet Client has two classes CEmp and CEmps, CEmp is a wrapper over our COM
component's CEmp and exposes FirstName, LastName and IsSenior properties. The
FirstName, LastName properties just delegates to the Properties of COM's 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
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)
.FirstName = xstrFName
.LastName = xstrLName
.DOB = xdtDOB
Public ReadOnly Property FirstName()
Public ReadOnly Property LastName()
Public ReadOnly Property IsSenior()
Private Sub Senior()
mblnIsSenior = True