Reader Level:
ARTICLE

COM Components from .NET Clients using VB.NET

Posted by Ashish Jaiman Articles | Visual Basic .NET November 10, 2012
The .NET 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 example uses a COM component and DotNet client extending the functionality of the COM component using delegation.
  • 0
  • 0
  • 3645
Download Files:
 

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 StringByVal xstrLName As StringByVal 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

COMMENT USING

Trending up