Net Com Interoperability

.NET COM Interoperability Using COM Components from .NET Framework 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 primary goal of this article is to create a demo project to show how to call a COM component from .NET client and to implement events raised by the COM component. The example uses a COM component and .NET client extending the functionality of the COM component using delegation. Step 1 Let’s 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 .NET, 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 .NET 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 .NET 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 .NET 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

Using a .NET Component from COM When a COM client calls a .NET object, the .NET framework will create a COM callable wrapper (CCW). COM clients use the CCW as a proxy for the managed object. Their primary purpose of CCW is to marshal calls between managed and unmanaged code and also to manage the object identity and object lifetime of the managed objects they wrap. The primary goal of this article is to create a demo project to show how to call a .NET component from COM client and to implement events raised by the .NET component. The example uses a .NET component and COM client extending the functionality of the .NET component using delegation. This is a follow on article and we will be using the same demo project the only difference would be the client now is COM using .NET component. Step 1 Let’s start by creating a Strong Name for the .NET component we would be creating in next steps. Strong name is a unique name created by hashing a 128-bit encryption key against the name of the Assembly (ComInterOp in our case). The strong name is created using SN.exe, that would create ComInterOp.snk file, which we would use while creating the .NET Assembly. The command line instruction to create a strong name sn –k ComInterOp.snk Step 2 Now lets create a .NET Assembly. Our assembly has only one class CEmp that exposes properties (FirstName, LastName, DOB) and raises an event (Senior). Raising an event from .NET Component and consuming it in COM component is done by defining event sink interface in managed code and then apply the ComSourceInterfacesAttribute to connect the event sink interface to the managed class. The command line instruction to create an assembly using the strong name (for vbc switch info see MSDN) vbc /out:ComInterOp.dll /t:library /keyfile:ComInterOp.snk CEmp.vb VB.Net CEmp class code Imports System Imports Microsoft.VisualBasic Imports System.Runtime.InteropServices _ Public Interface evtSenior Sub Senior() End Interface _ Public Class CEmp Private mstrFirstName As String Private mstrLastName As String Private mdtDOB As Date Public Event Senior() Public Property FirstName() As String Get FirstName = mstrFirstName End Get Set(ByVal Value As String) mstrFirstName = Value End Set End Property Public Property LastName() As String Get LastName = mstrLastName

End Get Set(ByVal Value As String) mstrLastName = Value End Set End Property Public Property DOB() As Date Get DOB = mdtDOB End Get Set(ByVal Value As Date) mdtDOB = Value If DateDiff(DateInterval.Year, Value, Now) > 60 Then RaiseEvent Senior() End If End Set End Property End Class

Step 3 Once the assembly is created we have to create a Type library so the COM client can use the Assembly seamlessly. We can package an assembly for COM by following methods. Type Library Exporter Using the Type Library Exporter (Tlbexp.exe) the classes and interfaces contained in an assembly are converted into to a COM type library. Once the TypeLib is created COM clients can create an instance of the .NET class and call the methods of that object, just as if it were a COM object. TypeLibConverter Class The TypeLibConverter Class of the System.Runtime.InteropServices namespace provides methods to convert an assembly to a TypeLib. This API produces same output as Tlbexp.exe Assembly Registration Tool The Assembly Registration Tool (Regasm.exe), reads the metadata within an assembly and adds the necessary entries to the registry, which allows COM clients to create .NET Framework classes transparently. The Assembly Registration tool can generate and register a type library when you apply the /tlb: option. COM clients require that type libraries be installed in the Windows registry. Without this option, Regasm.exe only registers the types in an assembly, not the type library. Registering the types in an assembly and registering the type library are distinct activities. The .NET Services Installation Tool (Regsvcs.exe) (see MSDN for more info). In our example we will use the RegAsm.exe to create TypeLib from the classes and interfaces definitions in our ComInterOp.dll assembly. The command line instruction to create and register ComINterOp.tlb is regasm ComInterOp.dll /tlb:ComInterOp.tlb Step 4 Now the .NET component (ComInterOp.dll) should be installs in the GAC(global assembly cache) to work with the COM code. The command line instruction to install ComINterOp.dll in GAC is Gacutil -i ComInterOp.dll Step 5 To use the .NET component, as it was a COM component, add reference to the TypeLib from the COM component project created in the previous steps and code against it by creating CEmp object and delegation the calls to this object. The COM Client has two classes CEmp and CEmps, CEmp is a wrapper over our .NET component’s CEmp and exposes FirstName, LastName and IsSenior properties. The FirstName, LastName properties just delegates to the properties of .NET CEmp but IsSenior uses the event raised by

the .NET component to set its value. The CEmps class is a collection of CEmps and exposes methods to test our code. COM Component 'Class Emps Option Explicit Private Emps As Scripting.Dictionary Private Sub Class_Initialize() Set Emps = New Scripting.Dictionary Dim objEmp As CEmp Set objEmp = New CEmp objEmp.InitMe "John", "Doe", "01/01/1970" Emps.Add 0, objEmp Set objEmp = New CEmp objEmp.InitMe "Mike", "Edwards", "01/01/1941" Emps.Add 1, objEmp Set objEmp = New CEmp objEmp.InitMe "Debra", "Bunn", "01/01/1930" Emps.Add 2, objEmp End Sub Public Function PrintEmps() As String PrintEmps = PrintBool(True) & PrintBool(False) End Function Public Function PrintBool(ByVal xblnSeniors As Boolean) As String Dim intCount As Integer Dim objEmp As CEmp Dim strPrint As String For intCount = 0 To Emps.Count - 1 Set objEmp = Emps(intCount) If xblnSeniors = objEmp.IsSenior Then strPrint = strPrint & PrintEmp(objEmp) & Chr(13) End If Next intCount PrintBool = strPrint End Function Private Function PrintEmp(ByVal xobjEmp As CEmp) As String Dim strPrint As String strPrint = xobjEmp.FirstName & Chr(9) & xobjEmp.LastName PrintEmp = strPrint End Function 'End Class Emps 'Class Emp Option Explicit Private mblnIsSenior As Boolean Private WithEvents mobjEmp As ComInterOp.CEmp Public Sub InitMe(ByVal xstrFName As String, ByVal xstrLName As String, ByVal xdtDOB As Date) Set mobjEmp = New ComInterOp.CEmp With mobjEmp .FirstName = xstrFName .LastName = xstrLName .DOB = xdtDOB End With End Sub Public Property Get FirstName() As String FirstName = mobjEmp.FirstName End Property Public Property Get LastName() As String LastName = mobjEmp.LastName End Property Public Property Get IsSenior() As Boolean IsSenior = mblnIsSenior End Property Private Sub mobjEmp_Senior()

mblnIsSenior = True End Sub 'End Class Emp