- The Concept of Managed Code Execution
- The Common Language Runtime
- COM+ Component Services
- Using VB.NET to Develop Managed Components
- Serviced Components
- Building VB.NET Serviced Components
- Summary
This chapter is from the book
This chapter is from the book
This chapter is from the book
5.4 Using VB.NET to Develop Managed Components
In this section I'll present the concepts you need to understand to build managed components using VB.NET.
5.4.1 Defining Namespaces
Namespaces are a way to hierarchically organize class names. Namespaces become especially useful when the number of classes available to you is quite large. You've been exposed to namespaces quite a bit already in this book. Whenever you write VB.NET code, you use .NET classes in the System namespace. For example, when you use the Console.WriteLine() command, you are using an assembly called Console that exists in the System namespace. In the code, Console is not fully qualified because it is assumed to be a part of the System namespace based on the uniqueness of the name Console. You could fully qualify the statement this way:
System.Console.WriteLine(...)
When you create a new .NET assembly (program), a default root namespace is assigned to the assembly. This name is typically the name of your project. However, you are free to assign your own namespace names.
5.4.2 Using the Class Library
Managed components start with a VS.NET project called a class library. The class library puts the infrastructure in place for creating an assembly for packing a component. Figure 5-2 shows the selections used to create a new class library project.
)
Figure 5-2 Creating a new class library project in VB.NET
You can specify several project properties and options for class library projects. Of particular interest are the root namespace and the assembly name. VB.NET creates default names for both of these options. You can view and modify them by selecting the Project'Properties menu. This opens the Property Pages dialog shown in Figure 5-3.
)
Figure 5-3 The Property Pages dialog
By default, VB.NET assigns the name you specified for the project as the names for the assembly and the root namespace. You can override these default names with better, more descriptive ones. Given these new designations, references to classes inside the assembly would be made in the following manner. (This example shows the usage of Dim to declare an object for a particular class inside the assembly.)
Dim objMyObject As objMyExample.SomeClassInTheAssembly
.NET applications that you write need to include a reference to each assembly you wish to use inside the main application. You can add a reference to an assembly by right-clicking on the References folder (see Figure 5-4) and selecting Add Reference.... VS.NET displays a dialog with a list of available assemblies (see Figure 5-5). Those assemblies that are a part of the .NET Framework distribution are displayed in the list. To add a reference to another assembly, click the Browse... button. Then you'll be able to select the assembly file you need.
)
Figure 5-3 The Property Pages dialog
)
Figure 5-5 The Add Reference dialog
5.4.3 Using Component "Plumbing" Code
When class library projects are started in VB.NET, some stub code is generated for you. A new, "empty" component's "plumbing" code looks something like this:
Public Class Class1 End Class
The VS.NET IDE adds this code for you for an empty class called Class1. A .vb file is also generated that contains the class's code (which VS.NET should be displaying in the front-most window). Give the class another name (in the example below, we'll name it CTaxComponent) by changing it in the editor and then renaming the class file in the Solution Explorer to CTaxComponent. The code should now say:
Public Class CTaxComponent End Class
5.4.4 Adding Initialization Code
Whenever your component is instantiated, the New() subroutine is called. Any initialization code you require goes here. As an illustration, suppose your class contains a private member variable that you wish to have an initial default value when the component is instantiated. Such initialization code could look like the following.
Private m_dblTaxRate As Double Public Sub New() MyBase.New ' Specify default percent tax rate m_dblTaxRate = 5 End Sub
5.4.5 Creating Methods
In Chapter 2 we discussed classes and several class concepts, such as methods. When creating class libraries and components, you'll notice that the same principles apply to components. Methods are simply member functions and subroutines. In order for other .NET applications to access methods you define, you need to expose them by marking them for public access. Here's a public method definition and implementation to illustrate.
Public Function CalculatePriceAfterTax( _ ByVal Amount As Double) As Double CalculatePriceAfterTax = Amount * (1 + (m_dblTaxRate / 100)) End Function
5.4.6 Creating Properties
Component properties are created in the same way as properties for regular classes. Like methods, they should be marked for public access. The property in the sample code below sets or gets the value of the private class member variable used in the previous example.
Public Property TaxRate() As Double
Get
TaxRate = m_dblTaxRate
End Get
Set(ByVal Value As Double)
m_dblTaxRate = Value
End Set
End Property
5.4.7 Using the Class Library in an Application
The preceding sections described all the steps required to create a class library that can function as an independent component in another application. Now the class library needs to be tested. You can create another .NET application that references the assembly and write code to call the CTaxComponent class. The code below is a simple console application that uses the class library.
Imports System
Imports SCDemoClasses
Imports Microsoft.VisualBasic
Module Module1
Sub Main()
Dim objTaxComponent As New CTaxComponent()
Dim dblItemPrice As Double = 9.99
Dim dblTotalPrice As Double
With objTaxComponent
.TaxRate = 7
dblTotalPrice = _
.CalculatePriceAfterTax(dblItemPrice)
End With
Console.WriteLine("{0} after tax is {1}", _
FormatCurrency(dblItemPrice), _
FormatCurrency(dblTotalPrice))
End Sub
End Module
This code produces the following output (assuming U.S. currency):
$9.99 after tax is $10.69
WARNING
Before this program can compile and run, a reference to the assembly DLL, SCDemo (used in the example), must be added as a reference to the hosting application (the sample console application) using the Add Reference... command from the menu.