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 On
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
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
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