When building any component, the first thing you have to do is define your interface. In VB6, the way to do this is to create an abstract class — that is, one without any implementation. Therefore, create an ActiveX DLL project called MegaCalculator. You do this by creating a new project and then changing its name to MegaCalculator by means of the Project

Option Explicit

Public Sub AddInput(InputValue As Double)
End Sub

Public Sub DoCalculation()
End Sub

Public Function GetOutput() As Double
End Function

Public Sub Reset()
End Sub

From the main menu, select File

For the purposes of this demonstration, the actual calculation that you are going to perform is fairly mundane. In fact, the component will calculate the mean of a series of numbers. Create another ActiveX DLL project called MeanCalculator. Add a reference to the type library for the interface that you are going to implement by selecting the MegaCalculator DLL via the References dialog box that appears when you select Project

Having done that, go ahead and write the code for the mean calculation. You do that in a class called MeanCalc:

Option Explicit

Implements IMegaCalc

Dim mintValue As Integer
Dim mdblValues() As Double
Dim mdblMean As Double

Private Sub Class_Initialize()
  IMegaCalc_Reset
End Sub

Private Sub IMegaCalc_AddInput(InputValue As Double)
  mintValue = mintValue + 1
  ReDim Preserve mdblValues(mintValue)
  mdblValues(mintValue) = InputValue
End Sub

Private Sub IMegaCalc_DoCalculation()
  Dim iValue As Integer
  mdblMean = 0#
  If (mintValue = 0) Then Exit Sub

  For iValue = 1 To mintValue
    mdblMean = mdblMean + mdblValues(iValue)
  Next iValue

  mdblMean = mdblMean / mintValue
End Sub

Private Function IMegaCalc_GetOutput() As Double
  IMegaCalc_GetOutput = mdblMean

End Function

Private Sub IMegaCalc_Reset()
  mintValue = 0
End Sub

As before, you select File

If you have made it this far, then you should now have your legacy component. When developing your new .NET application on the same machine, you do not need to do anything more because your component is already registered by the build process. However, if you are working on an entirely new machine, then you must register it there. To do that, open a command window and register it with the following command using regsvr32.exe found at C:Windowssystem32:

regsvr32 MeanCalculator.dll

You should then see the result shown in Figure 25-1.

Figure 25.1. Figure 25-1

Because MeanCalculator implements an interface from MegaCalculator, you have to repeat the trick with that DLL:

regsvr32 MegaCalculator.dll

That action should yield the results shown in Figure 25-2. You are now ready to use your classic component from a .NET application.

Figure 25.2. Figure 25-2

Before you dive into writing the code behind the buttons on the form, you first need to make your new application aware of the MeanCalculator component. Add a reference to the component via the Project

Figure 25.4. Figure 25-4

Press OK after you highlight both of the required components. Note that in the list of references in the Solution Explorer, you can now see the MeanCalculator and MegaCalculator components. If you don't see these items, be sure to press the Show All Files button in the Solution Explorer's toolbar. This view is presented in Figure 25-5.

Figure 25.5. Figure 25-5

Now that you have successfully referenced the components in the .NET application, you can finish coding the application, using the functionality provided via the COM components. To start making use of the new capabilities provided from the COM component, add to the code a global variable (mobjMean) that will hold a reference to an instance of the mean calculation component, as shown here:

Public Class Form1

  Dim mobjMean As MegaCalculator.IMegaCalc

Next, create a Form1_Load event to which you will add the following instruction, which creates the component you are going to use:

Private Sub Form1_Load(ByVal sender As System.Object, _
   ByVal e As System.EventArgs) Handles MyBase.Load

   mobjMean = New MeanCalculator.MeanCalc()

End Sub

Finally, add the code behind the form's buttons. First, working with the Add button, add the following code that calls the COM component:

Private Sub btnAdd_Click(ByVal sender As System.Object, _
                         ByVal e As System.EventArgs) _

Handles btnAdd.Click

   mobjMean.AddInput(CDbl(txtInput.Text))

End Sub

This adds whatever is in the input text box into the list of numbers for the calculation. Next, here's the code-behind for the Calculate button:

Private Sub btnCalculate_Click(ByVal sender As System.Object, _
                               ByVal e As System.EventArgs) _
                               Handles btnCalculate.Click

   mobjMean.DoCalculation()
   txtOutput.Text = mobjMean.GetOutput()

End Sub

This performs the calculation, retrieves the answer, and puts it into the output text box — all of this from the COM component. Finally, the code behind the Reset button simply resets the calculation:

Private Sub btnReset_Click(ByVal sender As System.Object, _
            ByVal e As System.EventArgs) Handles btnReset.Click

   mobjMean.Reset()

End Sub

For the sample being built in this chapter, let's extend the calculator to a more generic framework that can feed inputs into a number of different calculation modules, rather than just the fixed one it currently implements. For this example, you'll keep a table in memory of calculation ProgIDs and present the user with a combo box to select the correct one.

The first problem you encounter with late binding is that you can only late bind to the default interface, which in this case is MeanCalculator.MeanCalc, not MeanCalculator.IMegaCalc. Therefore, you need to redevelop your COM object as a standalone library, with no references to other interfaces.

As before, you'll build a DLL under the VB6 IDE, copy it over to your .NET environment, and reregister it there. Call this new VB6 DLL MeanCalculator2.dll; the code in the class (called MeanCalc) should look as follows:

Option Explicit

Dim mintValue As Integer
Dim mdblValues() As Double
Dim mdblMean As Double

Private Sub Class_Initialize()
  Reset
End Sub

Public Sub AddInput(InputValue As Double)
  mintValue = mintValue + 1
  ReDim Preserve mdblValues(mintValue)
  mdblValues(mintValue) = InputValue
End Sub

Public Sub DoCalculation()
  Dim iValue As Integer
  mdblMean = 0#

  If (mintValue = 0) Then Exit Sub

  For iValue = 1 To mintVal
    mdblMean = mdblMean + mdblValues(iValue)
  Next iValue

  mdblMean = mdblMean / mintValue
End Sub

Public Function GetOutput() As Double
  GetOutput = mdblMean
End Function

Public Sub Reset()
  mintValue = 0
End Sub

As before, move this across to your .NET server and register it using RegSvr32.

For your generic calculation framework, you'll create a new application in Visual Basic 2008 called CalcFrame. You will basically use the same dialog box as before, but with an extra combo box at the top of the form. This new layout is illustrated in Figure 25-8.

Figure 25.8. Figure 25-8

The new combo box is called cmbCalculation. For this to work, you also need to disable the controls txtInput, btnAdd, btnCalculate, and btnReset until you know whether the selected calculation is valid. Begin your application by importing the Reflection namespace, which you need for handling the application's late binding:

Imports System.Reflection

Once the form is in place, add a few member variables to the code of your application:

Public Class Form1
    Inherits System.Windows.Forms.Form
    Private mstrObjects() As String
    Private mnObject As Integer
    Private mtypCalc As Type
    Private mobjcalc As Object

From there, add a few new lines to Form1_Load:

Private Sub Form1_Load(ByVal sender As System.Object, _
   ByVal e As System.EventArgs) Handles MyBase.Load

    mnObject = 0
    AddObject("Mean", "MeanCalculator2.MeanCalc")
    AddObject("StdDev", "StddevCalculator.StddevCalc")

    If (mnObject > 0) Then
        cmbCalculation.SelectedIndex = 0
    End If
End Sub

What you are doing here is building a list of calculations. When you're finished, you select the first one in the list. Let's take a look at that subroutine AddObject:

Private Sub AddObject(ByVal strName As String, ByVal strObject As String)
    cmbCalculation.Items.Add(strName)
    mnObject = mnObject + 1
    ReDim Preserve mstrObjects(mnObject)
    mstrObjects(mnObject - 1) = strObject
End Sub

The preceding code segment adds the calculation name to the combo box, and its ProgID to an array of strings. Neither of these is sorted, so you get a one-to-one mapping between them. Check out what happens when you select a calculation via the combo box:

Private Sub cmbCalculation_SelectedIndexChanged(ByVal sender As System.Object, _
                                           ByVal e As System.EventArgs) _
                           Handles cmbCalculation.SelectedIndexChanged
    Dim intIndex As Integer
    Dim bEnabled As Boolean

    intIndex = cmbCalculation.SelectedIndex
    mtypCalc = Type.GetTypeFromProgID(mstrObjects(intIndex))

    If (mtypCalc Is Nothing) Then
        mobjcalc = Nothing

bEnabled = False
    Else
        mobjcalc = Activator.CreateInstance(mtypCalc)
        bEnabled = True
    End If

    txtInput.Enabled = bEnabled
    btnAdd.Enabled = bEnabled
    btnCalculate.Enabled = bEnabled
    btnReset.Enabled = bEnabled
End Sub

There are two key calls in this example. The first is to Type.GetTypeFromProgID. This takes the incoming ProgID string and converts it to a Type object. This process either succeeds or fails; if it fails, then you disable all the controls and let the user try again. If it succeeds, however, then you create an instance of the object described by the type. You do this in the call to the static method Activator.CreateInstance().

For this example, assume that the user has selected a calculation that you can successfully instantiate. What next? The user enters a number and clicks the Add button on the form:

Private Sub btnAdd_Click(ByVal sender As System.Object, _
       ByVal e As System.EventArgs) Handles btnAdd.Click

        Dim objArgs() As [Object] = {CDbl(txtInput.Text)}
        mtypCalc.InvokeMember("AddInput", BindingFlags.InvokeMethod, _
           Nothing, mobjcalc, objArgs)

    End Sub

The important call here is to the InvokeMember() method. Let's take a closer look at what is going on. Five parameters are passed into the InvokeMember() method:

Something very similar to this is going on underneath VB6 late binding, except that here it is exposed in all its horror. In some ways, that's not a bad thing, because it should highlight the point that late binding is something to avoid if possible. Anyway, let's carry on and complete the program. Here are the remaining event handlers for the other buttons:

Private Sub btnCalculate_Click(ByVal sender As System.Object, _
               ByVal e As System.EventArgs) Handles btnCalculate.Click

Dim objResult As Object
       mtypCalc.InvokeMember("DoCalculation", BindingFlags.InvokeMethod, _
                            Nothing, mobjcalc, Nothing)
       objResult = mtypCalc.InvokeMember("GetOutput", _
                    BindingFlags.InvokeMethod, Nothing, mobjcalc, Nothing)
       txtOutput.Text = objResult

  End Sub

  Private Sub btnReset_Click(ByVal sender As System.Object, _
                ByVal e As System.EventArgs) Handles btnReset.Click

      mtypCalc.InvokeMember("Reset", BindingFlags.InvokeMethod, _
         Nothing, mobjcalc, Nothing)

  End Sub

Let's quickly complete the job by running the application. Figure 25-9 shows what happens when you select the nonexistent calculation StdDev.

Figure 25.9. Figure 25-9

As shown in the screen shot, the input fields have been disabled, as desired. Figure 25-10 shows what happens when you repeat the earlier calculation using Mean. This time, the input fields are enabled, and the calculation can be carried out as before.

Figure 25.10. Figure 25-10

One final word about late binding. You took care to ensure that you checked whether the object was successfully instantiated. In a real-life application, you also need to ensure that the method invocations are successful and that all exceptions are caught — you do not have the luxury of having the compiler find all your bugs for you.

This time, within the VB6 IDE, you need to create an ActiveX Control project. For this example, call the project Magic, and the control class MagicButton, to reflect its remarkable powers. From the Toolbox, select a Shape control and place it on the UserControl form that VB6 provides for you. Rename the shape provided on the form to shpButton, and change its properties as follows:

Add a label on top of the Shape control and rename it to lblText. Change this control's properties to the following:

Switch to the code view of the MagicButton component. Within the code presented, add two properties called Caption and State, and an event called Click(), as well as code to handle the initialization of the properties and persisting them, to ensure that the shape resizes correctly and that the label is centered.

You also need to handle mouse clicks within the code. The final code of the MagicButton class should look as follows:

Option Explicit

Public Event Click()

Dim mintState As Integer

Public Property Get Caption() As String
  Caption = lblText.Caption
End Property

Public Property Let Caption(ByVal vNewValue As String)
  lblText.Caption = vNewValue
  PropertyChanged ("Caption")
End Property

Public Property Get State() As Integer
  State = mintState
End Property

Public Property Let State(ByVal vNewValue As Integer)
  mintState = vNewValue
  PropertyChanged ("State")

  If (State = 0) Then
    shpButton.FillColor = &HFFFFFF&
  Else
    shpButton.FillColor = &H808080&
  End If
End Property

Private Sub UserControl_InitProperties()
  Caption = Extender.Name
  State = 1
End Sub

Private Sub UserControl_ReadProperties(PropBag As PropertyBag)
  Caption = PropBag.ReadProperty("Caption", Extender.Name)
  State = PropBag.ReadProperty("State", 1)
End Sub

Private Sub UserControl_WriteProperties(PropBag As PropertyBag)
  PropBag.WriteProperty "Caption", lblText.Caption
  PropBag.WriteProperty "State", mintState
End Sub

Private Sub UserControl_Resize()
  shpButton.Move 0, 0, ScaleWidth, ScaleHeight
  lblText.Move 0, (ScaleHeight - lblText.Height) / 2, ScaleWidth
End Sub

Private Sub lblText_Click()

RaiseEvent Click
End Sub

Private Sub UserControl_MouseUp(Button As Integer, Shift As Integer, _
                                X As Single, Y As Single)
  RaiseEvent Click
End Sub

If you build this, you'll get an ActiveX control called Magic.ocx.

You now have your legacy control. As before, if you are developing your new .NET application on the same machine, then you don't need to do anything more, because your control will already be registered by the build process. However, if you are working on an entirely new machine, then you need to register it there. As before, open a command window and register it as follows:

regsvr32 Magic.ocx

Having done that, you are ready to build your .NET application.

Turning the tables again, build a VB6 application to see whether this is really going to work. Copy the type libraries over to your pre-.NET machine (if that is where VB6 is running) and create a Standard EXE project in VB6. Call this project "CalcApp2." Within this project, you need to create references to the two new type libraries, so go to the References dialog box, browse to find them, and select them, as shown in Figure 25-21.

Figure 25.21. Figure 25-21

At this point, you have everything you need to create the application. Create it as you did for the Visual Basic CalcApp (see Figure 25-22). As before, the text boxes are txtInput and txtOutput, respectively, and the command buttons are btnAdd, btnCalculate, and btnReset.

Figure 25.22. Figure 25-22

Here's the code behind it:

Option Explicit

Dim mobjCalc As MeanCalculator3.MeanCalc
Dim mobjMega As MegaCalculator2.IMegaCalc

Private Sub btnAdd_Click()
  mobjMega.AddInput (txtInput.Text)
End Sub

Private Sub btnCalculate_Click()
  mobjMega.DoCalculation
  txtOutput.Text = mobjMega.GetResult
End Sub

Private Sub btnReset_Click()
  mobjMega.Reset

End Sub

Private Sub Form_Load()
  Set mobjCalc = New MeanCalculator3.MeanCalc
  Set mobjMega = mobjCalc
End Sub

Notice that this time you have to explicitly get a reference to the interface IMegaCalc. The default interface of the component, MeanCalc, is entirely empty.

Make the executable via the File

Figure 25.23. Figure 25-23

Well, that's not what you expected. What's happened here? In COM, the location of the DLL containing the component is available via the registry. In .NET, the assembly always has to be in either the current directory or the global assembly. All the registry is doing for you here is converting a COM reference to a .NET one; it is not finding the .NET one for you.

Fortunately, this is easy to sort out. To resolve the problem, move the two assemblies, MegaCalculator3 and MeanCalculator2, to your current directory and try again (see Figure 25-24).

Figure 25.24. Figure 25-24

That's better. You've established that in the unlikely event of having to run .NET from a COM-oriented application, Microsoft has provided you with the tools necessary to do the job.