At my job, I have had a project where I needed to deliver a solution for creating, distributing and running
ActiveX controls written in .NET. This article summarizes all of it. Everything that is in this article can be found on the Web, but believe me this is not so easy;).
Using the Code
- ActiveXSourceCode.zip - Contains .NET source code for the ActiveX
- Setup.zip - Contains example of the *.ini file needed to create CAB
- Web.zip - Example of the HTML file that embeds
So Let Us Start...
1) Creating .NET ActiveX
The first step you have to do is to create the
You can find a good introduction to this subject here.
This article describes how to create and expose Windows Forms on the Web site. Since there is no such support in the .NET Framework, WinForms are wrapped into
ActiveX which is exactly what we need. In summary, what we need is to create a class that will be marked with those attributes:
ProgId is the unique name of the class that will be exposed as
ClassInterface is the type of the
COM interface that will wrap our .NET class
Guid is the unique
GUID that will expose our class to be used as
COM object. To create a new
GUID, you can use the tool in Visual Studio Tools -> Create
ComVisible tells that our class can be used as
COM object means that you need to make some entries in the registry. You can do this manually or you can write methods in your
ActiveX that will do that for you when you register it with tools like regasm:
public static void RegisterClass ( string key )
public static void UnregisterClass ( string key)
Having those methods implemented, you can now use command:
regasm /codebase MyAssemblie.dll which will run the
RegisterClass method and
regasm /u MyAssemblie.dll which will run the
To expose .NET methods and properties in your class to be available as
COM methods and properties, you have to add markup
[ComVisible(true)] to them, i.e.:
public void Open()
public string MyParam
myParam = value;
You have to remember that your assembly must be signed using strong name key, this way you will have the ability to use more complicated controls, assemblies and features (like passing events back to the browser). To create new SNK, you can use tool: sn.exe (you can find it in the .NET SDK):
sn –k Kosmala.Michal.ActiveXReport.snk
Once you create a strong name key, copy it into your project path and put path to it in the AssemblyInfo.cs file in:
Once you have your class registered as
COM, you can now use it in your Web page.
2) Using ActiveX on the HTML Page
To start using your
ActiveX in the HTML file, you just have to put one tag:
<OBJECT id="OurActiveX" name="OurActiveX" classid="clsid:MyGuid"
name are values that will be used to access our
classid is the
GUID of our
ActiveX that we have put in
[Guid("MyGUID")] section of our C# code
Codebase is the path to the file which should be launched when
ActiveX with our
GUID is not found. This is the place where the installation program (wrapped in CAB) should be placed.
Let us now forget for a moment about the
codebase section since we are doing everything on our computer and we can register
ActiveX with using
Now that our Web page knows what kind of
ActiveX we want to use, we can actually start using it.
document.OurActiveX.MyParam = "Hi I am here."
This script will assign value to
MyParam and invoke the
Open() method from our C# code which will return open
MessageBox with “
I am here” text.
Open is just a name of the method, it can be named anything that you can think of.
Assigning variables works both ways. You can also read from
Remember to set proper security values in your Internet Explorer that will allow running
3) Creating .cab Component
Now it is time to create the CAB file that will be launched when the browser won't find our
ActiveX registered on the system. First of all, you have to create a setup program that will either be MSI or it will wrap MSI into setup.exe file. I have done this by using InstallShield application because this is what my company standard was, but you can use Visual Studio to do that (although I have never tested it). The important thing is that your setup has to register your
ActiveX on a target computer. This might require having administration privileges.
Once you have your setup, you have to create CAB. To do that you can use
cabsdk which you can find here.
Now, the important thing about our CAB is to attach not only our setup file but also *.ini file that will describe what CAB contains and what file should be launched. Our OurActiveX.ini can look something like this:
signature="$<place w:st="""""on""""" /><city w:st="""""on""""" />CHICAGO</city /></place />$"
[Add Code] section describes what sections of the file are mapped to what file. In our case, there is only one setup.exe file that is mapped by section with the same name.
[setup.exe] section is the one that is defined in the previous section. It is saying that file that it is mapped to should be launched when accessed with proper
clsid. In this case, this is the
MyGuid that is defined in our C# code and also in
Now that we have all files that we need, we can create CAB file using
cabsdk by using the command:
cabarc.exe n OurActiveX.cab OurActiveX.inf setup.exe
Voila. Our basic
ActiveX with distribution property is ready.
Now for something more sophisticated:).
It might be necessary to send an event from
To do that, you have to update your C# code. You have to add a new
interface and a new
public delegate void ControlEventHandler(string redirectUrl);
public interface ControlEvents
void OnClose(string redirectUrl);
This code creates an
interface wrapper that will be visible outside as
COM object. Every new event that will be available for
COM must be marked
(Creating .NET to COM objects http://www.csharphelp.com/archives/archive281.html)
Now we have to inherit our new interface in
Since we are implementing
ControlEvents interface, now we have to create
OnClose event in our class which we can raise in our
public event ControlEventHandler OnClose;
After compilation of this code, we have to register our
ActiveX control (
regasm) with additional parameter “
/tlb” which will extract
tlb COM library from our DLL and it will register it on our system:
regasm /codebase /tlb MyAssemblie.dll
window.location = hostUrl + "/" + redirectionUrl;
OpenActiveX. Now we have two ways of doing it:
We can attach our function to i.e. button and our
ActiveX will run when we will click on it:
If we want that it will be started automatically after the page will be loaded, we have to attach our function to body event “
You have to remember that your
ActiveX assembly has to be signed and registered with additional parameter “
This is a very simple
ActiveX but it can call any WinForms control or application that your user has rights to.
Points of Interest
As you can see, it is very easy to create and distribute
ActiveX in .NET, but it is very difficult to find right answers on the Web probably because not so many people are using
I hope that this article will cut your search time as much as possible.
- 4th March, 2008: Initial post