C# Com

Download source - 244.0 KB

Introduction

This example will help you to understand how to implement and use a C# DLL in VB 6.0 code. As C# is an object-oriented language, we can use the object-oriented features to create proper classes in C# DLL. We can use COM Interop or follow the COM Plus Approach to refer to such DLLs in our old VB 6.0 applications. It's like delegating our business logic to this DLL. In this article, I tried to show two different approaches to refer to a C# DLL in VB 6.0. The code is attached herewith; you can directly refer it to understand the following instructions or try to create your own code from the instructions.

To create COM Interop

By using COM Interop, we create a DLL that can be private or shared. This DLL can be referred to in a VB 6.0 application. A VB 6.0 application refers to a Type Library of this DLL, i.e. a file with the .tlb extension that is created using the VS tool utility. For a client of a COM object to have access to the object, the client needs a description of it, how to locate it and how to call its methods and properties. For a "real" unmanaged COM class, this description is available in the form of a Type Library. A Type Library is a binary description of the GUIDs, classes, and interfaces (methods, properties, and parameters) that the COM class supports.

.NET assemblies don't include information in Type Library compatible format. So, it is necessary for the programmer to run one of two .NET-supplied utilities to extract the assembly description of a class into a Type Library file. One utility is tlbexp.exe, the .NET Type Library Exporter. This command-line utility takes as input the name of an assembly DLL file to be converted to a Type Library. The programmer can also specify the name of a Type Library file to be created.

tlbexp ComInteropExample.DLL /out:ComInteropExample.tlb

Once a Type Library has been created, it can be referenced by a COM client to obtain the information necessary for the COM client to bind to the interfaces of the COM class and activate the COM class at runtime. Another command-line utility for creating a Type Library from an assembly is regasm.exe, the .NET Assembly Registration utility. In addition to creating a Type Library, this utility also creates the Windows Registry entries necessary for making the assembly visible as a COM object to clients, as shown below.

regasm ComInteropExample.DLL /tlb: ComInteropExample.tlb

Note that there is also a property in the Project Properties for a .NET class library DLL called "Register for COM Interop." Setting this property to True instructs the IDE to automatically register the assembly for COM Interop each time you build it, so you don't have to perform this step manually.

Instructions for creating a COM Interop DLL in a Visual Studio 2005 project

Create a new Class Library project in VS 2005, project name: ComInteropExample
Open AssemblyInfo.cs in VS 2005; this is in the Properties folder of the project. Set Com Visible to "True:"
```
[assembly: ComVisible(true)] 
```
Go to Poject Properties -> Build. Check the option Register for Com Interop to "Selected."
Go to class file, e.g. ComInteropClass.cs and add:
```
namespace using System.Runtime.InteropServices
```
Note that there is no need to add a reference to the InteropServices DLL in Application references.

For interface iInterface,

define GUID as [Guid("EC87B398-B775-4e6f-BE2C-997D4594CFAA")] 
[InterfaceType(ComInterfaceType.InterfaceIsDispatch)]

Note that to create GUID, go to tools -> create GUID -> set GUID format to registry format, copy GUID and add it into your code using the syntax. Write Interface Methods as,

[DispId(1)] int PerformAddition(int a, int b); 
[DispId(2)] int PerformDeletion(int a, int b); 

[Guid("EC87B398-B775-4e6f-BE2C-997D4594CFAA")] 
[InterfaceType(ComInterfaceType.InterfaceIsDispatch)]
 
public interface iInterface 
{ 
    [DispId(1)] int PerformAddition(int a, int b); 
    [DispId(2)] int PerformDeletion(int a, int b); 
}

For class ComInteropClass, add statements:

above class [Guid("5674D47E-6B2A-456e-85C4-CB7AA6AIF24A")] 

[ClassInterface(ClassInterfaceType.None)] 
[ProgId("ComInteropClass")] 

public class ComInteropClass:iInterface

[Guid("0C216A19-E1B7-4b05-86D3-4C516BDDC041")] 
[ClassInterface(ClassInterfaceType.None)] 
[ProgId("ComInteropClass")] 

//this name is used in VB code for late binding Dim the
//Object As Object Set theObject = CreateObject("ComInteropClass")
 
public class ComInteropClass:iInterface 
{ 
    #region iInterface Members public int PerformAddition(int a, int b) 
    { 
        // throw new Exception(
            "The method or operation is not implemented."); 
        try 
    { 
        return a + b; 
    } 

        catch 
        { 
            return 0; 
        } 
    }
    public int PerformDeletion(int a, int b) 
    { 
        //throw new Exception(
            "The method or operation is not implemented."); 
        try 
        { 
            return a - b; 
        } 
        catch 
        { 
            return 0; 
        } 
     } 
     #endregion 
}

Register the assembly using the SDK command prompt of VS 2005. Go to the release folder of your project:
```
regasm ComInteropExample.DLL /tlb: ComInteropExample.tlb
```

Refer to this TLB in VB. The VB code is provided with the ZIP file, so please refer to it. It can be used for late binding. If the strong key is not assigned, the assembly will be private, so copy the assembly into the folder where you want to use it. To make the assembly public, assign the strong key to the assembly using the SN tool of VS 2005.

To create COM+

Create a new C# .NET class library project in Visual Studio 2005.
Open the AssemblyInfo.cs file in VS2005. Set following option:
```
[assembly: ComVisible(true)] 
```
Go to the References folder -> right click -> Add references (in .NET tab). Add:
```
reference : System.EnterpriseServices
```
Open a class file (ComPlusClass.cs) and refer Enterprise Service as:
```
using System.EnterpriseServices 
```
Add the following statements below namespaces:

[assembly: ApplicationName("ComPlusExample")] 
[assembly:Description("ComPlus Assmebly")] 
[assembly:ApplicationActivation(ActivationOption.Server)] 
[assembly:ApplicationAccessControl(false)]

Create an interface, e.g. iInterface:

public interface iInterface 
{ 
    int PerformAddition(int a,int b); 
    int PerformSubtraction(int a,int b); 
}

Create the class implementing interfaces ServicedComponent and iInterface.

To track events in COM+ for this class, add the following statements:

[EventTrackingEnabled(true)] 
[Description("Serviced Component")] 
[EventTrackingEnabled(true)] 
[Description("Interface Serviced Component")]

    Collapse [EventTrackingEnabled(true)] 
             [Description("Serviced Component")] 
             [EventTrackingEnabled(true)] 
             [Description("Interface Serviced Component")] 

public class ComPlusClass:ServicedComponent,iInterface 
{
    #region iInterface Members

    public int PerformAddition(int a, int b) 
    { 
         // throw new Exception(
             "The method or operation is not implemented."); 
         try 
         { 
             return a + b; 
         } 
             catch 
         { 
             return 0; 
         } 
    }

    public int PerformSubtraction(int a, int b) 
    { 
        //throw new Exception(
            "The method or operation is not implemented."); 
        try 
        { 
            return a - b; 
        } 
            catch 
        { 
            return 0; 
        }
        #endregion 
    }
}

Build the Application. Assign the strong key to the Application using the VS 2005 command prompt. Go to Start-> Program files-> Visual Studio 2005-> Visual Studio tools -> SDK command prompt.
```
sn -k ComPlusClass.snk 
```
Add this strong key to Application properties -> Signing -> Strong key
To register the assembly:

Use VS tool to register the assembly as:
```
regasm ComPlusExample.DLL 
```
Create a Type Library using the tool:
```
tlbexp ComPlusExample.DLL 
```
Register it in COM+ as:
```
regsvcs ComPlusExample.DLL 
```

To view this registered COM+ go to Control Panel -> Administrative Tools -> Compoent Services. In Component Services -> Computers -> My Computer -> Com + Applications. Here, right click on it. You can create MSI for it.

Summary

Refer to the TLB of the assembly from the Release folder to use in VB6 applications. Please let me know if you have any problems; my email is gunijan_rakesh@yahoo.co.in. I have tried to make this article a readable one and I will try to improve it with your invaluable suggestions. Thank you.