Dynamically adding ActiveX controls in managed code

• Download demo project - 7.46 Kb
• Download source - 0.8 Kb

Introduction

Visual Studio .NET provides a way for developers to easily add (unmanaged) ActiveX controls to C# or VB.NET forms. However, there are times when you need to add these controls dynamically using code. I was recently presented with exactly this problem and despite searching the usual internet resources for a simple solution, all I could find was questions - no real answers.

I needed to port a suite of ActiveX controls that plug-in into a GUI framework using only their ProgID as a reference into a new .NET GUI framework. The plug-in approach used for the GUI framework was used so new controls could be easily added without the need for the GUI framework code having to change. A manager asks the framework to provide a container window and tells it what the ProgID of the contained control is. This de-coupled approach using just a control reference (in this case the ProgID) is a well used technique in plug-in architectures.

Although Visual Studio allows this to happen at design time by adding a reference or a control to the toolbox, these can't really be used dynamically using code.

Hosting an ActiveX control on a Windows form

Back in the good (bad) old days of VB6, dynamically creating controls on a form was easy. Whether a simple control or some ActiveX control, you just create an instance using CreateObject and add the control to the form's control collection. In a managed environment things are a bit more tricky. You can't just host the ActiveX control on the form because you're trying to run an unmanaged component on a managed form.

Fortunately, Microsoft has helpfully provided a runtime callable wrapper (RCW) class to simplify things - System.Windows.Forms.AxHost. Regardless of whether you are using C# or VB.NET, in a managed environment, Windows Forms can only host Windows Forms controls. All Windows Forms controls are classes that are derived from the System.Windows.Forms.Control class. To host an ActiveX control on a form, it must look like a Windows Forms control from the form's viewpoint and an ActiveX container from the ActiveX viewpoint. This is exactly what the System.Windows.Forms.AxHost class wrapper does. It also exposes the ActiveX methods, properties and events.

This is all well and good and Visual Studio does this under the hood when you add a reference to the control or use the aximp.exe command line tool. However, it's no direct use to us when we want to write code to dynamically instantiate and use ActiveX controls on a form. Clearly we need to do what AxHost does but without having to rewrite it. As it turns out, the solution is pretty straightforward. Although AxHost is an abstract class (Must Inherit if you're currently speaking VB.NET) we can use it to do all the work for us.

If you haven't used aximp.exe before MSDN can explain all.

Use the Source, Luke!

The C# AxForm class below shows how you might implement dynamic ActiveX hosting using the AxHost runtime callable wrapper class. As I said earlier, this is an abstract class, so the AxControl class has been introduced. It simply takes a ProgID as a string in the constructor and passes this onto the AxHost constructor. This is used in the InitializeComponent method to create the wrapped control using the AxControl class.

using System;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Windows.Forms;
using System.Resources;

namespace AxForms
{
    /// <summary>
    /// Summary description for AxControl.
    /// </summary>
    public class AxControl : AxHost 
    {
        public AxControl(string strCLSID) : base(strCLSID) 
        {
        }
    }

    /// <summary>
    /// Summary description for AxForm.
    /// </summary>
    public class AxForm : Form
    {
        private AxControl m_axCtrl;
        private Container components = null;

        public AxForm(string strProgId)
        {
            InitializeComponent(strProgId);

            // TODO: Add any initialization after the InitForm call
        }


        protected override void Dispose(bool disposing)
        {
            if (disposing)
                if (components != null)
                    components.Dispose();
            base.Dispose(disposing);
        }

        private void InitializeComponent(string strProgId)
        {
            ResourceManager resources = new ResourceManager(typeof(AxForm));    

            Type type = Type.GetTypeFromProgID(strProgId, true);
            m_axCtrl = new AxControl(type.GUID.ToString());

            ((ISupportInitialize)(m_axCtrl)).BeginInit();
            SuspendLayout();

            m_axCtrl.Enabled = true;
            m_axCtrl.Name = "axCtrl";
            m_axCtrl.TabIndex = 0;

            Controls.Add(m_axCtrl);
            Name = "AxForm";
            ((ISupportInitialize)(m_axCtrl)).EndInit();
            Resize += new EventHandler(AxForm_Resize);
            ResumeLayout(false);
            OnResize();
            Show();
        }

        private void OnResize()
        {
            m_axCtrl.Width = Width;
            m_axCtrl.Height = Height;
        }

        private void AxForm_Resize(object sender, EventArgs e)
        {
            OnResize();
        }
    }
}

In this particular implementation, the hosted ActiveX control is resized to fit the form whenever it's resized - hence the need for the AxForm_Resize handler. Obviously, other implementations might want to arrange the controls differently on the form. The code would need to change, but the same idea can be used - using AxControl as an intermediate class to AxHost. Incidentally, this shows a C# implementation, but the technique is equally applicable to VB.NET.

To use the class, you only need to know the ProgID of the ActiveX control you want to host. For example:

m_axForm = new AxForms.AxForm("OWC.Spreadsheet.9");

The nugatory sample code supplied demonstrates how you might use the class in your application. It has a couple of hard coded ProgIDs for the OWC spreadsheet and the Outlook control. Obviously, these will only work if these are registered on your system. Alternatively, a third option allows you to enter the ProgID of the control you want to instantiate. Note, I have omitted any error checking in the sample code for clarity.