COM in .NET

In nonblittable data types, conversion is required during the data pass because these data types have a higher overhead. The following table lists some nonblittable to related blittable types.

You can use the previously created COM component comServerTest.dll from within the .NET application. We will implement the COM components methods within a Windows Form project. Here, first, we add the reference of the COM component and then instantiate the MathLib class to invoke the methods.

1. Create a C# Window Forms project named comServerTestClient.
2. Design the form with the appropriate controls as in the following.
   
3. Add the COM component reference as in the following.
   
4. Place the following code for both button click events as in the following.

   using System;
   using System.Windows.Forms;
   using comServerTestLib;
   
   namespace comServerTestClient
   {
       public partial class Form1 : Form
       {
           mathLib obj = new mathLib();
   
           public Form1()
           {
               InitializeComponent();
           }
   
           private void btnAdd_Click(object sender, EventArgs e)
           {
               int x = Int32.Parse(txtX.Text);
               int y = Int32.Parse(txtY.Text);
   
               txtResult.Text = obj.Addition(x, y).ToString();
           }
   
           private void btnSquare_Click(object sender, EventArgs e)
           {
               int x = Int32.Parse(txtX.Text);
               txtResult.Text = obj.Square(x).ToString();
           }
       }
   }
   

5. Finally, compile and run the application.

Runtime Callable Wrapper

In the preceding example, we have done many activities. Every time you create a default interop assembly by importing a COM DLL into Visual Studio. So, it might be better to do a wrapping once and then let the application import the resulting .NET assembly instead of a COM component. The RCW would spare the hassle of repeatedly dealing with COM characteristics because it hides the unknown and IDispatch interfaces and deals with the reference count of the COM object.

RCW can be created by using the command line utility tlbimp.exe. Here, we are creating a new.dll from the COM component that contains a .NET assembly with the wrapper class as in the following.

COM Callable Wrapper

So far, we have seen how to access a COM component from a .NET application with RCW. Equally interesting is to find a solution for accessing a .NET component from the COM client using a COM Callable Wrapper (CCW).

In the following example, we create a simple C# class library project. Then add an interface to define methods that are invoked from a COM client.

using System;
using System.Runtime.InteropServices;
namespace NETcomponent
{
    [ComVisible(true)]
    public interface ITest
    {
        string Hello(string msg);
    }
    public class Test : ITest
    {
        public string Hello(string msg)
        {
            return "Hello " + msg;
        }
    }
}

Now compile this class library project. Before the .NET components can be used as a COM object, it is necessary to configure it in the registry. You can use the regasm.exe utility to configure the components inside the registry as in the following.

Now open the Visual Studio command prompt to create a COM wrapper class using the tlbexp.exe utility as in the following.

As you notice in the directory of the solution, the NewLib.tlb file is created after executing the tlbexp.exe command. You can view the type library with the OLE/COM object Viewer utility that resides in Visual Studio Tools as in the following.

In the generated code, you can see that the interface ITest is defined as a COM interface, and all the methods defined in the C# code are listed here in the type library.

Active-X

ActiveX controls are COM objects with a user interface. They are used by many containers, such as Word, Excel, IE, and Windows Forms. Similarly, to RCW, we can also create a wrapper for ActiveX controls using the aximp.exe command-line utility.

Conclusion

In this article, you have learned how the .NET application interoperates with COM and vice-versa using RCW and CCW. You also come across a couple of underlying utilities such as tlbimp to import a type library, tlbexp to export a type library from .NET assemblies, and regasm and regsvr32 to register a .NET component in the registry. You also incorporate the ActiveX control into a .NET user interface.