MUKARAKAT

Cara Menghilangkan Gridlines Pada Excel

2017-09-18T13:31:00.000-07:00

Secara Default Jika kita membuka sebuah File Excel maka terdapat Gridlines atau
Garis-garis pada Excel. (Lihat gambar dibawah)

Namun bagi anda yang ingin menghilangkan Gridlines atau Garis agar anda bisa melihatnya dengan bagus, ikuti langkah dibawah ini :

Klik View
Kemudian Uncheck menu Gridlines
maka hasilnya akan tampak seperti gambar dibawah ini :

dan Garis atau Gridlines pun sudah hilang.
Cukup mudah bukan???

Printing Text

2017-03-14T12:40:00.005-07:00

Visual Studio 6.0

Printing text in BASIC is done with the Print statement. Similarly, in Visual Basic, you use the Print method. This method works on the object you wish to print. This object can be an entire form, the Debug object, the Printer object, or a Picture control. We’ve already talked about how the Debug.Print method directs output to the Immediate window (in Chapter 3). The other methods display their output on their respective objects:

Form1.Print sends output to Form1’s background.
Picture1.Print sends the output to the Picture1 control.
Printer.Print sends the output to the printer.

WARNING: Recycled paper versus recycled electrons: When testing your printing programs, remember that most of the methods and properties you will use on the Printer object also can be used with the Picture control. So for most of the examples in this chapter, I use the Picture control to show you how the various methods and properties work. Feel free to try any of these programs out using the Printer object by substituting Printer for Picture1, sending your results directly to your printer. Only your recycler knows the difference.

Printing to and beyond the Edges

The Print method works much as you would expect. Each time you call the Print method, the output will begin at the start of the next line, except if the previous Print method ended with a comma or semicolon. In that case, the print would be continued on the same line. Listing 9.4 contains an example of code that allows printing beyond the right edge, and Figure 9.3 shows the results.

Listing 9.4: Command1_Click Event in Print

Private Sub Command1_Click()
Dim i As Integer
Picture1.Cls
For i = 1 To 100
   Picture1.Print “abcdefg”;
Next i
End Sub

Figure 9.3: Any printed output beyond the right edge of the control is lost.

One limitation of this approach is that, eventually, you will reach the end of the object. If you continue to print to the object, the text will fall off the end of the paper or screen and not be visible. Likewise, if you continue to print on the same line, it will also fall off the edge and be lost. Neither of these conditions will generate an error or a warning. Listing 9.5 contains an example of code that allows printing beyond the bottom edge, and Figure 9.4 shows the results.

Listing 9.5: Command2_Click Event in Print

Private Sub Command2_Click()
Dim i As Integer
Picture1.Cls
For i = 1 To 100
   Picture1.Print “abcdefg”
Next i
End Sub

Figure 9.4: Any printed output beyond the bottom edge of the page is lost

NOTE: Clearing the object: The Cls method is used to clear the contents of a form or of a Picture control and to reposition the cursor to the beginning.

Printing in Columns

Just like in the original BASIC, if you separate values by commas, each value will start at the beginning of the next print zone. Print zones are aligned based on absolute measurements, not characters. This makes it easier to create columns, as long as your data is not wider than a print zone. If it’s wider, you need to be careful to ensure that you are starting the data in the proper print zone. The code shown in Listing 9.6 creates columns with commas. Figure 9.5 shows its output.

Listing 9.6: Command3_Click Event in Print

Private Sub Command3_Click()
Picture1.Cls
Picture1.Print “abc”, “def”, “ghi”, “jkl”, “mno”, “pqr”, _
   “stu”, “vwx”
Picture1.Print “abcdef”, “ghijkl”, “mnopqr”, “stuvwx”
Picture1.Print “abcdefghijkl”, “mnopqrstuvwx”
Picture1.Print “abcdefghijklmnopqrstuvwxyz”, _
   “abcdefghijklmnopqrstuvwxyz”
End Sub

Figure 9.5: When you use commas, columns will line up as long as they are close to the same size.

TIP: Things go better with Tab: One of the functions available for the Print method is the Tab function. The Tab function will position the output cursor at a particular column in the output field. The width of a column is determined by the average width of all of the characters in the current font. This is not the most accurate way to align columns of information, but it is better than relying on the effect of commas and semicolons.

Positioning the Cursor

Another way to control printing alignment is by positioning the cursor. Each object (Form, Picture, and Printer) maintains a cursor that describes the current position on the object. Two properties describe the location of the cursor: CurrentX is the horizontal component, and CurrentY is the vertical component. These properties can be read to find the current location or assigned a value to reset the cursor to a new position. As usual with these objects, all measurements are made in twips. (Recall that one twip is exactly one-twentieth of a printer’s point, and there are 1440 twips to the inch or 567 to the centimeter.)
The code in Listing 9.7 shows how to move around a PictureBox control using the CurrentX and CurrentY properties. I save the values of CurrentX and CurrentY into the string t before I execute the Print method so that these values remain unaffected by the printing process. Figure 9.6 shows the output.

Listing 9.7: Command4_Click Event in Print

Private Sub Command4_Click()
Dim t As String
Picture1.Cls
t = FormatNumber(Picture1.CurrentX, 0) & “,” & _
   FormatNumber(Picture1.CurrentY, 0)
Picture1.Print t
Picture1.CurrentX = 0
Picture1.CurrentY = 2880
t = FormatNumber(Picture1.CurrentX, 0) & “,” & _
   FormatNumber(Picture1.CurrentY, 0)
Picture1.Print t
Picture1.CurrentX = 2880
Picture1.CurrentY = 0
t = FormatNumber(Picture1.CurrentX, 0) & “,” & _
   FormatNumber(Picture1.CurrentY, 0)
Picture1.Print t
Picture1.CurrentX = 2880
Picture1.CurrentY = 2880
t = FormatNumber(Picture1.CurrentX, 0) & “,” & _
   FormatNumber(Picture1.CurrentY, 0)
Picture1.Print t
End Sub

Figure 9.6: You can use the CurrentX and CurrentY properties to control the position of a PictureBox control.

Positioning Text

So far, I haven’t talked about where the cursor is oriented with respect to the text you’re going to print. Maybe it’s obvious, but the cursor is always at the upper-left corner of an imaginary box that surrounds the text. The actual size of the box is determined by the size of the tallest character in the text string, the sum of the widths of each individual character in the text string, and the font used to display the text string.
Because this is a rather complicated process, Visual Basic includes two methods that return the size of the string: TextWidth and TextHeight. Also, if you have embedded carriage returns, these methods will compute the total size of the box based on the size of the longest line and the total number of lines.
The code in Listing 9.8 shows how to display the same string of text in four different quadrants surrounding the center point of the cursor. Figure 9.7 shows the results.
NOTE: Why is there a small space below the text string and behind the text string? This is because the TextWidth method allows for space after the last character in the string, and the TextHeight method includes space above and below the string. This way, you don’t need to worry about where to place the next string.

Listing 9.8: Command5_Click Event in Print

Private Sub Command5_Click()
Dim t As String
t = “Hello”
Picture1.Cls
Picture1.CurrentX = 1440
Picture1.CurrentY = 1440
Picture1.Print t
Picture1.CurrentX = 1440 - Picture1.TextWidth(t)
Picture1.CurrentY = 1440
Picture1.Print t
Picture1.CurrentX = 1440
Picture1.CurrentY = 1440 - Picture1.TextHeight(t)
Picture1.Print t
Picture1.CurrentX = 1440 - Picture1.TextWidth(t)
Picture1.CurrentY = 1440 - Picture1.TextHeight(t)
Picture1.Print t
End Sub

Figure 9.7: You can use the TextHeight and TextWidth methods to control the position of text.

In this example, I begin by printing the first string starting at 1 inch from the top and 1 inch from the left margin (remember, 1440 twips equal 1 inch). Next, I print the second string immediately to the right of the first string. I compute its new X coordinate by subtracting the width of the string.
The third string is printed above the second. Its X coordinate is computed by subtracting the width of the string from the 1440-twips X coordinate. Its Y coordinate is computed by subtracting the height of the string from the 1440-twips Y coordinate. Finally, the last string is printed above the first by subtracting the height of the string from the 1-inch Y coordinate.

Changing Font Characteristics

One of the nice features of Visual Basic is that it has the ability to use multiple fonts in a single object. This means that you can make a block of text bold, italic, or underlined. You can also change the size or even the name of the font you wish to use. This allows you to present information more dramatically by emphasizing certain items.
Doing this in Visual Basic is fairly easy. All you need to do is change the Font object associated with the object you are using. In Listing 9.9, you can see that I copied the same code from the code shown in the previous section and inserted some changes to Picture1’s Font property.

Listing 9.9: Command6_Click Event in Print

Private Sub Command6_Click()
Dim t As String
t = “Hello”
Picture1.Cls
Picture1.CurrentX = 1440
Picture1.CurrentY = 1440
Picture1.Print t
Picture1.Font.Bold = True
Picture1.CurrentX = 1440 - Picture1.TextWidth(t)
Picture1.CurrentY = 1440
Picture1.Print t
Picture1.Font.Italic = True
Picture1.CurrentX = 1440
Picture1.CurrentY = 1440 - Picture1.TextHeight(t)
Picture1.Print t
Picture1.Font.Size = 18
Picture1.CurrentX = 1440 - Picture1.TextWidth(t)
Picture1.CurrentY = 1440 - Picture1.TextHeight(t)
Picture1.Print t
Picture1.Font.Size = 8
Picture1.Font.Bold = False
Picture1.Font.Italic = False
End Sub

As you can see in Figure 9.8, most of these changes did not materially change how the information is aligned. However, in the upper-left corner, where I changed the font size to 18, you can see that the text is pulled slightly away from the other three text blocks. This is because the padding areas above, below, and to the right of the text are greater in an 18-point font than in the standard 8-point font.

Figure 9.8: You can change font characteristics to emphasize text.

Creating a 404 Error Tracker with Visual Basic 6.0

2017-03-14T12:34:00.001-07:00

Visual Studio 6.0

Contents
Introduction

Additional Information

Introduction

In this article, I will walk you through the steps of building a Visual Basic® 6.0 ActiveX® dynamic-link library (DLL) that will make it easy and efficient for you to track and prevent 404 (Not Found) errors on your site. Sure, some stats packages will do parts of this work for you, but most are not flexible in their "out-of-the-box" feature set. Now you will have a chance to expand the techniques in this article to have your 404 tracking and trapping do just about anything you want it to do. Or, you could use the same techniques to build your own ActiveX DLL that has nothing to do with 404 errors.
You might have already asked yourself why I chose a DLL instead of simple Active Server Pages (ASP) code, or even an Include file. A compelling argument against using a DLL is the debugging process. Because Internet Information Server (IIS) holds DLLs in memory, and unless your application is set to run in a separate memory space from the other applications in your Web server, IIS must be restarted when you make changes to any DLL attached to the server. This slows the debugging process somewhat, particularly in the fine-tuning stages.
With those problems aside, I chose a DLL mainly for performance reasons. Compiled code is known to be more efficient than interpreted code, particularly with advanced tasks such as the one this DLL proposes. Also, aside from the obvious performance gains, by storing your business logic in a compiled format:

Your code cannot be easily "borrowed."
Your application cannot be easily compromised by someone who decides to modify your code.
Microsoft SQL Server passwords and other sensitive data are better shielded from prying eyes.

While these benefits are always important, they become even more so when your code is going to be distributed, placed on a shared server, or placed on a server completely outside of your control. In my case, I place the integrity of the code at a much higher priority than whether or not it will be stolen.

Prerequisites

Before we start, let's make sure you've got the goods. You will need the following items installed and running:

Microsoft® Windows NT® 4.0 (Workstation or Server), Service Pack 4 or later.
Windows NT 4.0 Option Pack (IIS/PWS 4.0).
The latest Microsoft Data Access Components (MDAC) release (2.1 Service Pack 2 at the time of writing).
Visual Basic 6.0, Service Pack 2 or later.
SQL Server 6.5 or later (you could use Microsoft Access, but in this article, SQL Server 7.0 and a stored procedure are used).

Note If you are running Windows 2000, there are no service packs, you cannot update core MDAC files, and you will have to add IIS (if it isn't already installed).

To add IIS:

In Control Panel, click the Add/Remove Programs icon.
Select Windows Components, then click the Add/Remove button. This will open the Windows Components Wizard dialog box. (Do not attempt to install the Option Pack or MDAC updates on Windows 2000.)
Select the Internet Information Services check box.
Adjust Details as necessary.

Additionally, you will need to run this on a computer where you have appropriate permissions to do the following things:

Create a custom 404 page for your Web site(s).
Register a custom DLL on your server.
Restart the Web server (during development). I recommend using a workstation or noncritical Web server for development.

Quick Overview

Here are the steps involved in creating this system:

Install prerequisites and verify task permissions.
Enable the custom 404 error page through Internet Services Manager.
Create and test the database and schema.
Create a new ActiveX DLL project and add appropriate references.
Write the code and compile the DLL.
Register the DLL on the development computer.
Edit the 404 error ASP page to instantiate the object.
Before deploying to the production computer, test, test, test!

Preparing IIS

Create a file called 404.asp and place it in your root folder (or the folder of the application). This will serve as a replacement for the bland "404 Not Found" error page, and will be the calling point of the component we're creating. Feel free to customize it with graphics, a friendly "sorry" message, and of course, links to the rest of your site.

Note If you use graphics or links on this page, remember to use absolute references or virtual reference "FROM THE ROOT." This file will "run" where it's called, so if you use <img src="images/logo.gif"> where logo.gif is in /images/logo.gif, then a 404 hit in the /test/ folder will result in one of those lovely broken images (since 404.asp is "running" in /test/ it is looking for /test/images/logo.gif instead of /images/logo.gif).

Open Internet Services Manager.

If you want the file to apply to your entire site:

Right-click the machine name in IIS.
Click Properties.
Select Master Properties for the WWW Service, then click Edit.

If you want the file to apply to a specific application:

Right-click the name of the application in IIS.
Click Properties.

Click the Custom Errors tab.
Scroll down and select 404.
Click the Edit properties button and change the Message Type to URL.
Enter /404.asp or /<application>/404.asp as the URL.

Figure 1. Custom 404 error dialog

The beauty of this solution is that when you use an ASP page to process 404 errors, the query string includes the page that was being requested (and the headers often provide information for the page that contained the bad link). You can do many things with this information. On the front end, the most important thing would be to conditionally offer appropriate alternatives based on the requested page (the ultimate goal is to build a learning application that adapts this for you). On the back end for each request, you would need to notify the site with the bad link; maintain a database of frequently requested 404 pages (and their preferred alternate pages, if any); and replace those nonexistent pages with a redirect page (optional). In this article, we will simply be logging the 404 entries (future articles will cover these other areas).

Preparing SQL Server

The last thing you have to do before creating the DLL is set up a database to store the data. (I chose to use SQL Server because of its flexibility and scalability, though you can certainly use any ODBC-compliant database—as long as you are aware of possible limitations.) The database in this article is called "track404" and the table is called "stats." Stats will initially consist of six fields:

id (INT IDENTITY), which represents an index field.
ip (VARCHAR 15), which represents the user's IP address.
url (VARCHAR 255), which represents the URL they were trying to access.
ref (VARCHAR 255), which represents the URL they came from (e.g., a bad link).
dt (DATETIME), which represents the exact time they entered the site.
ua (VARCHAR 255), which represents the browser they were using.

Here is a screen shot of the table from within Enterprise Manager:

Figure 2. New table in Enterprise Manager

Next you need to add a user to this database. To do this:

Under Security for this SQL Server Registration, select Logins and add a Login named "stats" (with any password you choose).
Give the user permission on your new database.
Once that user is added, right-click your new table and click Properties.
Click the Permissions button in the top right corner, and give the user "stats" INSERT permissions.

Instead of relying on simple insert techniques, you can compile the typical insertion code into a stored procedure. It is a simple stored procedure that accepts five string parameters as inputs and inserts them into a table. This will be faster than a general insert, and while the difference is negligible now, the added efficiency of stored procedures will be significant as your tracking system gets more elaborate. Here is the code from the stored procedure:

             
                             
CREATE PROCEDURE STrack404
   @ip varchar(15),
   @url varchar(255),
   @ref varchar(255),
   @dt char(20),
   @ua varchar(255)

  AS

   BEGIN
    INSERT INTO stats (ip,url,ref,dt,ua)
      VALUES (@ip,@url,@ref,@dt,@ua)
   END

To give executive permissions to the stats user:

Under Stored Procedures in this database, right-click and select "New Stored Procedure"
Name it STrack404, and insert the above code. Click OK.
Right-click, then select Properties.
Apply exec permissions for the "stats" user.

Finally, we need to create a connection string, which will be used in the component later. If you're not using integrated security, you must add the user ID (UID) and password (PWD) into the connection string, as shown in the following code example:

"driver={SQL Server};server=1.1.1.1;database=track404;uid=stats;pwd=xyz"

Test your connection string in a simple ASP page before proceeding, and make any necessary corrections before moving on. There's no greater frustration than having to recompile a DLL simply to straighten out a botched database connection string. Here is an example of what your test ASP page could look like:

             
                             
<%
  set conn = createobject("adodb.connection")
  on error resume next
  conn.open "driver={SQL Server};server=1.1.1.1;database=track404;uid=stats;pwd=xyz"
  if err then
   response.write("There was an error:<br>" & err.description)
  else
   response.write("No problem.")
  end if
  set conn = nothing   
%>

Starting the DLL

Open Visual Basic and start a new ActiveX DLL project. The first thing you want to do when creating a project is right-click the Project Name and change it, as well as change the initial class name to something you'll remember. Naming a project "Project5" does very little to set it apart from "Project3" or "Project4." In this case, they are named "Bertrand" and "track404," respectively. (Incidentally, unless other project changes are made, this will cause the ProgID of the compiled DLL to be "Bertrand.track404," and that is what is used in the createObject() call from ASP. Also, the compiled DLL will be called "Bertrand.dll." You are more than welcome to use any name for your project and DLL. Just make sure it's unique so that you won't be crosswiring anything in the registry.
Next, select Project, then References, and add the following references:

Microsoft Active Server Pages Object Library.
Microsoft ActiveX Data Objects 2.1 Library.
Microsoft Transaction Server Type Library.

These references allow you to use the intrinsic ASP objects (Application, Request, Response, Server, and Session) and ADO objects (such as ADODB.Connection).

Note In Windows 2000, as you can see in the following screenshot, the Microsoft Transaction Server Type Library reference has been replaced by "COM+ Services Type Library."

Figure 3. Adding references to your project

Into the Code

The first item we're going to need is the Request object. In this initial build, we have no need for Session and Application variables, nor for the Response and Server objects, so there's no point in introducing them into your code. The Request object will allow us to retrieve the user-specific information we'll want to track. We'll also set up our Connection object and Logic variables, as shown below.

             
                             
Option Explicit

  ' Create the connection object:
  Public objConnection As ADODB.Connection

  ' Create the servervariable, SQL and datetime strings:
  Public strReferrer As String
  Public strQueryString As String
  Public strServerName As String
  Public strIPAddress As String
  Public strBrowser As String
  Public strSQL As String
  Public strNow As String

  ' Create the array to strip the server name out of the URL:
  Public vntServerName As Variant

  ' Create the boolean which will indicate whether to log or not:
  Public boolValid As Boolean

  ' Create the objects for getting at the ASP Request object
  Public objContext As ObjectContext
  Public objRequest As ASPTypeLibrary.Request

Below is a very simple function that grabs any Server variable and removes the always troublesome apostrophe, instead of performing this code each time it is required. I called this function getSV, and it is as follows:

             
                             
  Public Function getSV(ByVal str As String) As String
     getSV = Replace(objRequest.ServerVariables(str), "'", "''")
  End Function

The above code retrieves information such as the user's IP address and the URL they were referred from (if that information is available). Now, create a method called Log()—; this is where all the action takes place. Once the Request object is created, we call getSV() to get the user-specific variables. We set boolValid = false so that the default is to NOT log this hit into the database unless the 404 page was accessed legitimately. For example, if someone just types in the URL of your 404 page, the hit shouldn't be logged.
Next you need to test that the length of the query string is at least four and that the first four characters are "404;". If both conditions are true, you then set the boolValid flag to true, and parse the URL for everything after the server name (that's the reason for vntServerName). For example, if the user attempts to get to the URL http://yourserver/page.asp, then the only relevant information is /page.asp—no sense filling up the database with http://yourserver/prefixes (unless, of course, you're using a common 404 page for several distinct domain names in a multiple host header situation, in which case you can simply remove the last if/end if block). As mentioned earlier, there are safeguards in place that do not log the entry if there is no query string. Additionally, we don't log the entry if the file requested was Favicon.ico (which happens when a user adds your site to their favorites in Internet Explorer 4.0 or 5.0). This will be addressed more in future articles.

             
                             
  Public Function log() As Long

    ' get the Request object, and parse out the ServerVariables items:
    Set objContext = GetObjectContext()
    Set objRequest = objContext("Request")
    strQueryString = LCase(getSV("query_string"))
    strServerName = LCase(getSV("server_name"))
    strReferrer = LCase(getSV("http_referer"))
    strIPAddress = getSV("remote_addr")
    strBrowser = getSV("http_user_agent")
    strNow = FormatDateTime(Now(), vbShortDate) & " "
    strNow = strNow & FormatDateTime(Now(), vbShortTime)

    ' initialize boolValid as false until it passes
    boolValid = False

    ' make sure the querystring is at least 4 characters, otherwise
    ' they entered the URL directly and should not be logged
    If Len(strQueryString) > 4 Then

      ' Do not log if the beginning of the querystring is not 404
      If Left(strQueryString, 4) = "404;" then

        ' Do not log if it's a search for favicon.ico, which is what
        '  happens when someone adds your site to their favorites:
        If InStr(strQueryString, "favicon.ico") <= 0 Then
          strQueryString = Right(strQueryString, Len(strQueryString) - 4)
          boolValid = True

          ' Remove the server name from the URL in the QueryString
          If InStr(strQueryString, strServerName) > 0 Then
            vntServerName = Split(strQueryString, strServerName)
            strQueryString = vntServerName(1)
          End If
        End If
      End If
    End If

    ' Clean up ObjectContext
    Set objRequest = Nothing
    Set objContext = Nothing

    ' Log the 404 hit, if valid:
    If boolValid Then
      strSQL = "exec STrack404"
      strSQL = strSQL & "  @ip  ='" & strIPAddress & "'"
      strSQL = strSQL & ", @url ='" & strQueryString & "'"
      strSQL = strSQL & ", @ref ='" & strReferrer & "'"
      strSQL = strSQL & ", @dt  ='" & strNow & "'"
      strSQL = strSQL & ", @ua  ='" & strBrowser & "'"
      Set objConnection = CreateObject("adodb.connection")
      objConnection.open "driver={SQL Server};server=1.1.1.1;database=track404;uid=stats;pwd=xyz"
      objConnection.Execute (strSQL)
      objConnection.Close
      Set objConnection = Nothing
    End If
  End Function

So in summary, here's the entire listing of track404.cls (comments removed):

             
                             
  Option Explicit

  Public objConnection As ADODB.Connection

  Public strReferrer As String
  Public strQueryString As String
  Public strServerName As String
  Public strIPAddress As String
  Public strBrowser As String
  Public strSQL As String
  Public strNow As String

  Public vntServerName As Variant

  Public boolValid As Boolean

  Public objContext As ObjectContext
  Public objRequest As ASPTypeLibrary.Request

  Public Function getSV(ByVal str As String) As String
    getSV = Replace(objRequest.ServerVariables(str), "'", "''")
  End Function

  Public Function log() As Long
    Set objContext = GetObjectContext()
    Set objRequest = objContext("Request")
    strQueryString = LCase(getSV("query_string"))
    strServerName = LCase(getSV("server_name"))
    strReferrer = LCase(getSV("http_referer"))
    strIPAddress = getSV("remote_addr")
    strBrowser = getSV("http_user_agent")
    strNow = FormatDateTime(Now(), vbShortDate) & " "
    strNow = strNow & FormatDateTime(Now(), vbShortTime)
    boolValid = False
    If Len(strQueryString) > 4 Then
      If Left(strQueryString, 4) = "404;" then
        If InStr(strQueryString, "favicon.ico") <= 0 Then
          strQueryString = Right(strQueryString, Len(strQueryString) - 4)
          boolValid = True
          If InStr(strQueryString, strServerName) > 0 Then
            vntServerName = Split(strQueryString, strServerName)
            strQueryString = vntServerName(1)
          End If
        End If
      End If
    End If
    Set objRequest = Nothing
    Set objContext = Nothing
    If boolValid Then
      strSQL = "exec STrack404"
      strSQL = strSQL & "  @ip  ='" & strIPAddress & "'"
      strSQL = strSQL & ", @url ='" & strQueryString & "'"
      strSQL = strSQL & ", @ref ='" & strReferrer & "'"
      strSQL = strSQL & ", @dt  ='" & strNow & "'"
      strSQL = strSQL & ", @ua  ='" & strBrowser & "'"
      Set objConnection = CreateObject("adodb.connection")
      objConnection.open "driver={SQL Server};server=1.1.1.1;database=track404;uid=stats;pwd=xyz"
      objConnection.Execute (strSQL)
      objConnection.Close
      Set objConnection = Nothing
    End If
  End Function

That's it for the code. Select File, then Make Bertrand.dll, and you're almost set! Now, in case this doesn't compile for you right away, code for a batch file is also included that will allow you to quickly restart IIS and other dependant services. (As previously noted, once a DLL is attached to IIS, it's very difficult to "detach" it.) A shortcut to this batch file is sitting on my taskbar, which should tell you how often I use it. It is called Restart.bat and contains the following code:

             
                             
  net stop iisadmin /y
  net start w3svc
  net start msftpsvc
  net start smtpsvc

The last two commands are only necessary if you run a File Transfer Protocol (FTP) service and Simple Mail Transfer Protocol (SMTP) service (our workstations here, for the most part, only require the first two lines). Once the Web server has been stopped, you can recompile your DLL without getting a Permission Denied error.
The final two steps are registering your new DLL and writing the ASP code to call it. Click the Start button, point to Run, and type in the following (replace <path> with the absolute path where you saved your DLL):

  regsvr32 <path>\bertrand.dll

Here's the ASP code to insert into your custom 404 page:

             
                             
  <%
    set track = server.createobject("bertrand.track404")
    track.log()
    set track = nothing
  %>

Now that may not be everything. Once you port this DLL to the production server, you may have problems if the correct Visual Basic run times are not installed. You can get around this either by using the package and deployment wizard, by installing Visual Basic 6.0, or (recommended) by installing the Visual Basic 6.0 run time library on the server (you can http://download.microsoft.com/download/vba6/utility/1/win98/en-us/vbrun60sp3.exe Download the run time library here and read about it in VBRun60sp3.exe Installs Visual Basic 6.0 Run-Time Files).

Conclusion

Well, happy coding. Within no time you should have a stats table full of 404 information, just waiting to be extracted. Here is a sample ASP 404 page, as well as a small sampling of test data retrieved from the SQL Server database instantly:

Figure 4. Sample 404 page

Stay tuned for the next article, where I will enhance this component to provide a viewing and maintenance interface for the stats, and reveal methodology behind making this application smarter. In the meantime, you could expand this technique to other kinds of errors.

Additional Information

For more information on creating ActiveX DLLs with Visual Basic 6.0 and IIS4+, and creating custom 404 error messages, visit the following sites:

About the Author

Aaron Bertrand (aaron@desktop.on.ca) is an ASP/SQL developer for BlueStreak.com, Inc., and runs an ASP Tips site at http://www.aspfaq.com/.

Comparison Between VB 6.0 and VB.NET Objects, Part 2

2017-03-14T12:30:00.002-07:00

For a more detailed look at which Visual Basic 6.0 Form properties still exist or have changed, visit MSDN Control Property, Method, and Event Changes for Visual Basic 6.0 Users.

Visual Basic.NET Properties Descriptions and Settings

Property Name

Property Description

Property Setting

DataBindings

Holds all the bindings of properties of this control to data sources

Refer To the DataBindings Advanced property

DataBindings Advanced

Allows you to bind properties of the control

[VBNETDataBindingsAdv.jpg]Use the above picture to assign binding properties to controls

Uses the DataBindings property to access the ControlBindingsCollection. By adding Binding objects to the collection, you can bind any property of a control to the property of an object.

Dynamic Properties

Maps values in the application configuration file <appSettings> section to this component's properties

[VBNETDynamicPropertiesAdv.jpg]

10 Things You Need to Know About Deploying Microsoft Office 365

Download Now

When a Box similar to the above picture is displayed, you can set Dynamic Properties for your controls

Dynamic Properties Advanced

Advanced Dynamic properties allow you to configure and set key names by which to store any dynamic property values

AcceptButton

The accept button of the form. If this is set, the button is 'clicked' whenever the user presses the 'ENTER' key.

Choose the button you want to select as a Default button from the displayed list

AccessibleDescription

An object's AccessibleDescription property provides a textual description about an object's visual appearance. The description is primarily used to provide greater context for low-vision or blind users, but also can be used for context searching or other applications.

Any Textual and Numeric data can be entered here. Textual is recommended.

AccessibleName

The AccessibleName property is a label that briefly describes and identifies the object within its container, such as the text in a Button, the name of a MenuItem, or a label displayed next to a TextBox control.

Any Textual and Numeric data can be entered here. Textual is recommended.

AccessibleRole

The role of the object describes the function of the object and is used by accessibility applications

[VBNETAccessibleRole.jpg]Choose the applicable Role from the list

AllowDrop

Determines whether the control will receive drag-drop notifications

True
False

AutoScale

You can use this property to allow your form and its controls to automatically adjust based on changes in the font. This can be useful in applications where the font might increase or decrease based on the language specified for use by Windows.

True
False

AutoScroll

If this property is set to True, scroll bars are displayed on the form if any controls are located outside the form's client region. Additionally, when autoscrolling is on, the client area of the form automatically scrolls to make the control with input focus visible.

True
False

AutoScrollMargin

The margin around controls during auto scroll
The auto-scroll margin is the distance between any child controls and the edges of the scrollable parent control. The AutoScrollMargin size is added to the size of any child controls contained in the scrollable control to determine whether or not scroll bars are needed.

Integer data ONLY for Width and Height

AutoScrollMinSize

The AutoScrollMinSize property is used to manage the screen size allocated to the automatic scroll bars.

Integer data ONLY for Width and Height

BackColor

The background color used to display text and graphics in the control

[VBNETBackColorCustom.jpg][VBNETBackColorWeb.jpg]
[VBNETBackColorSystem.jpg]You can select any color from any Tab in the Color Dialogbox

BackgroundImage

The background image used for the control

[VBNETBackgroundPicture.jpg]Browse for a picture on your system using the above Dialog box

CancelButton

This property allows you to designate a default action to occur when the user presses the 'ESC' key in your application. You can use this property to allow the user to quickly navigate a simple form by allowing them to simply press the 'ESC' key to close a window without committing changes instead of manually clicking the Cancel button with their mouse.

Choose the button you wish to select as a Default button from the displayed list

CausesValidation

Gets or sets a value indicating whether the control causes validation to be performed on any controls that require validation when it receives focus.

True
False

ContextMenu

The shortcut menu to display when the user right-clicks the control

Choose any ContextMenu item (on the Form) from the list

ControlBox

If the ControlBox property is set to true, the control box is displayed in the upper-left corner of the caption bar. The control box is where the user can click to access the system menu.

True
False

Cursor

The cursor that appears when the mouse pointer passes over the control

[VBNETCursor.jpg]Based on your needs, select the appropriate Cursor from the list

DockPadding

This determines the size of the border for docked controls

Integer data ONLY for:

All - Number of pixels along all borders to pad docked controls
Left - Number of pixels along the left to pad docked controls
Top - Number of pixels along the top to pad docked controls
Right - Number of pixels along the right to pad docked controls
Bottom - Number of pixels along the right to pad docked controls

Enabled

Gets or sets a value indicating whether the control can respond to user interaction

True
False

Font

The font used to display text in the control

[VB6FontSelectionDialogBox.jpg]Name [VBNETFontName.jpg]

Size - Any Numeric value
Unit - World, Pixel, Point, Inch, Document, Millimetre
Bold - True, False
GdiCharSet - Integer values ONLY
GdiVerticalFont - True, False
Italic - True, False
Strikeout - True, False
Underline - True, False

ForeColor

The foreground color used to display text and graphics in the control

[VBNETBackColorCustom.jpg][VBNETBackColorWeb.jpg]
[VBNETBackColorSystem.jpg]You can select any color from any Tab in the Color dialog box

FormBorderStyle

Controls the appearance of the border for the form. This also will affect how the caption bar is displayed and what buttons are allowed to appear on it.

Fixed3D	A fixed, three-dimensional border.
FixedDialog	A thick, fixed dialog-style border.
FixedSingle	A fixed, single-line border.
FixedToolWindow	A tool window border that is not resizable. A tool window does not appear in the taskbar or in the window that appears when the user presses 'ALT+TAB'.
None	No border.
Sizable	A resizable border.
SizableToolWindow	A resizable tool window border. A tool window does not appear in the taskbar or in the window that appears when the user presses 'ALT+TAB'.

GridSize

Determines the size of the positioning grid

Integer Values ONLY

HelpButton

When this property is set to true, a small button with a question mark appears in the caption bar to the left of the Close button. You can use this button to display help for your application. You can create an event handler for the HelpRequested event of the Control class to display Help information to the user when the Help button of the form is clicked.

True
False

Icon

A form's icon designates the picture that represents the form in the taskbar as well as the icon that is displayed for the control box of the form.

[VBNETIcon.jpg]Unless an icon is selected, the Size sub-properties will be un-editable.

ImeMode

Determines the IME (Input Method Editor) status of the object when selected An input method editor (IME) is a program that allows users to enter complex characters and symbols, such as Japanese Kanji characters, using a standard keyboard. The ImeMode property is typically set to ImeMode.Off for a TextBox control that is intended to only enter numeric values. The ImeMode property value is set to ImeMode.NoControl for the Form class.

Select any of the following:

Inherit
NoControl
On
Off
Disable
Hiragana
Katakana
KatakanaHalf
AlphaFull
Alpha
HangulFull
Hangul

IsMdiContainer

This property changes the display and behavior of the form to an MDI parent form. When this property is set to true, the form displays a sunken client area with a raised border. All MDI child forms assigned to the parent form are displayed within its client area.

True
False

KeyPreview

When this property is set to true, the form will receive all KeyPress, KeyDown, and KeyUp events. After the form's event handlers have completed processing the keystroke, the keystroke is then assigned to the control with focus. You can use this property to process all keystrokes in your application and either handle the keystroke or call the appropriate control to handle the keystroke. For example, when an application uses function keys, you might want to process the keystrokes at the form level rather than writing code for each control that might receive keystroke events.
Note: If a form has no visible or enabled controls, it automatically receives all keyboard events.

True
False

Language

Indicates the current localizable language

List of languages from which to choose

Location

The position of the top-left corner of the control with respect to its container

Integer values for X and Y

Locked

The Locked property determines whether you can move or resize the control

True
False

MaximizeBox

Determines whether a form has a maximize box in the upper-right corner of its caption bar

True
False

MaximumSize

The maximum size the form can be resized to. This property enables you to limit the size of a form to a specified maximum size. You can use this feature when displaying multiple windows at the same time, to ensure that a single window does not cause other windows to be hidden. If this property is set to a Size object that is 0 in height and 0 in width, the form will have no maximum size beyond the limits set by Windows.

Integer values for Width and Height

Menu

You can use this property to switch between complete menu sets at run time. For example, you can define one MainMenu to be displayed when your multiple document interface (MDI) form has no active MDI child forms and another MainMenu to display when a child window is displayed. You can also use a different MainMenu when specific conditions exist in your application that require displaying a different menu set.

Choose from a list of Main Menu controls on the form

MinimizeBox

Determines whether a form has a minimize box in the upper-right corner of its caption bar

True
False

MinimumSize

The minimum size the form can be resized to. This property enables you to limit the size of a form to a specified minimum size. You can use this feature to prevent a user from sizing a window to an undesirable size. If this property is set to a Size object that is 0 in height and 0 in width, the form will have no minimum size beyond the limits set by Windows.

Integer values for: Width and Height

Name

Gets or sets the name of the control.

Textual data

Opacity

This property enables you to specify a level of transparency for the form and its controls. This property differs from transparency provided by the TransparencyKey, which only makes a form and its controls completely transparent if they are the same color as the value specified in the TransparencyKey property. When this property is set to a value less than 100% (1.00), the entire form, including borders, is made more transparent. Setting this property to a value of 0% (0.00) makes the form completely invisible. You can use this property to provide different levels of transparency or to provide effects such as phasing a form in or out of view. For example, you can phase a form into view by setting the Opacity property to a value of 0% (0.00) and gradually increasing the value until it reaches 100% (1.00).

Percentage values Ranging from (0% to 100%)

RightToLeft

The RightToLeft property is used for international applications where the language is written from right to left, such as Hebrew or Arabic. When this property is set to RightToLeft.Yes, control elements that include text are displayed from right to left. If the control is a top-level control, the user's operating system is queried to determine whether the control needs to enable right-to-left support.
The following are a few examples of how control elements are affected by the RightToLeft property value of RightToLeft.Yes:

Vertical scroll bars are displayed on the left side rather than right side of scrollable controls.
Horizontal scroll bars start with the scroll box (thumb) right-aligned.
The check box element alignment, controlled by the CheckAlign property, is reversed for CheckBox and RadioButton controls.
Text displayed in the title bar of a Form is right-aligned. The icon and control box retain their left and right alignment respectively.
Items in list box, combo box, and up-down controls are right aligned.
Menus are displayed right-aligned.
The alignment of toolbar buttons on a ToolBar control or the alignment of text on a ToolBarButton is not affected by the RightToLeft property.

No
Yes
Inherit

ShowInTaskbar

You can use this property to prevent users from selecting your form through the Windows taskbar.

True
False

Size

This property allows you to set both the height and width of the form at the same time instead of setting the Height and Width properties individually.

Integer values for Width and Height

SizeGripStyle

This property enables you to determine when the sizing grip is displayed on the form. You can set this property to display the sizing grip or have it automatically displayed based on the setting of the FormBorderStyle property.

Auto
Show
Hide

SnapToGrid

Determines whether controls should snap to the positioning grid

True
False

StartPosition

This property enables you to set the starting position of the form when it is displayed at run time. The form can be displayed manually or in the default location specified by Windows.

Select any of the following:

Manual
CenterScreen
WindowsDefaultLocation
WindowsDefaultBounds
CenterParent

Tag

A common use for the Tag property is to store data that is closely associated with the control. For example, if you have a control that displays information about a customer you, might store a DataSet that contains the customer's order history in that control's Tag property so the data can be accessed quickly.

Any type derived from the Object class can be assigned to this property. If the Tag property is set through the Windows Forms designer, only text can be assigned.

Text

Gets or sets the text associated with this control.

Textual data and any Numeric data can be entered here.

TopMost

A top-most form is a form that overlaps all the other forms even if it is not the active or foreground form.

True
False

TransparencyKey

When the TransparencyKey property is assigned a Color, the areas of the form that have the same BackColor will be displayed transparently. Any mouse actions, such as the click of the mouse, that are performed on the transparent areas of the form will be transferred to the windows below the transparent area.

[VBNETBackColorCustom.jpg][VBNETBackColorWeb.jpg]
[VBNETBackColorSystem.jpg]You can select any color from any Tab in the Color dialog box.

WindowState

Determines the initial visual state of the form

Select any of the following:

Normal
Minimized
Maximized

I hope this has made your migration to Visual Basic.NET a tiny bit easier, and that I have given you enough insight to the Form object Properties Window changes. Watch for Part II (Changes in the Toolboxes) of Comparison Between VB 6.0 and VB.NET Objects.

Comparison Between VB 6.0 and VB.NET Objects, Part 1

2017-03-14T12:25:00.000-07:00

With this article, I want to provide a detailed explanation of the Form object's Property Window changes (from Visual Basic 6.0 to Visual Basic.NET). This will be very useful when you come from a Visual Basic 6 background. This article is not just aimed at VB6 veterans but to anyone starting with Visual Basic.NET—as you will see.
First off, start with the Visual Basic 6.0 Form property descriptions and settings.

Visual Basic 6 Properties Descriptions and their Settings

Have you ever wondered what all these properties do? I have found myself seeing a Form property in the Properties Window, and realising—I haven't used it before, or I don't know what exactly that particular Property does. So, what I've done was to compile this list of Visual Basic 6.0 Form object Properties along with Descriptions and Settings, which will be a handy reference to anyone using Visual Basic 6.

Property Name	Property Description	Property Setting
Appearance	Returns/Sets whether or not an object is painted at run time with 3-D effects	0 - Flat 1 - 3D
AutoRedraw	Returns the output from a graphics method to a persistent bitmap	True False
BackColor	Background color used to display text and graphics in an object	Choose any color from the appropriate tab in the Color dialog box
BorderStyle	The Border style for an object	Select any of the following: 0 - None 1 - Fixed Single 2 - Sizable 3 - Fixed Dialog 4 - Fixed ToolWindow 5 - Sizable ToolWindow
Caption	Sets the text displayed in a window's title bar	Textual data can be entered here
ClipControls	Determines whether graphics methods in Paint events repaint an entire object	True False
ControlBox	Determines whether the Control's Menu Box is shown on the left side of the title bar	True False
DrawMode	Sets the appearance of output from graphics methods or of a Shape or a Line control	Select any of the following: 1 - Blackness 2 - Not Merge Pen 3 - Mask Not Pen 4 - Not Copy Pen 5 - Mask Pen Not 6 - Invert 7 - Xor Pen 8 - Not Mask Pen 9 - Mask Pen 10 - Not Xor Pen 11 - Nop 12 - Merge Not Pen 13 - Copy Pen 14 - Merge Pen Not 15 - Merge Pen 16 - Whiteness
DrawStyle	Determines the Line Style for output from graphics methods	Select any of the following: 0 - Solid 1 - Dash 2 - Dot 3 - Dash-Dot 4 - Dash-Dot-Dot 5 - Transparent 6 - Inside Solid
DrawWidth	Line width for output from graphics methods	Integer values ONLY
Enabled	Determines whether a control can respond to user-generated events	True False
FillColor	Color used to fill in shapes, circles, and boxes	Choose any color from the appropriate tab in the Color dialog box
FillStyle	Fill style of a shape	Select any of the following: 0 - Solid 1 - Transparent 2 - Horizontal Line 3 - Vertical Line 4 - Upward Diagonal 5 - Downward Diagonal 6 - Cross 7 - Diagonal Cross
Font	Returns a Font object	Choose desired Font from the displayed Dialogbox
ForeColor	Forecolor used to display text and graphics in an object	Choose any color from the appropriate tab in the Color dialog box
HasDC	Determines whether a unique display context is allocated for the control	True False
Height	Height of an object	Integer Values ONLY
HelpContextID	Specifies the default help file context ID of an object	Integer values ONLY; for example: 0
Icon	Icon displayed when a form is minimized at run time	Browse for desired Icon
KeyPreview	Determines whether keyboard events for an object are invoked before keyboard events for controls on that object	True False
Left	Distance between the internal left edge of an object and the left edge of its container	Integer values ONLY
LinkMode	Type of link used for a DDE conversation and activates the connection	0 - None 1 - Manual
LinkTopic	Source application and topic for a destination control	Textual data
MaxButton	Determines whether a form has a Maximize button	True False
MDIChild	Determines whether a form is displayed inside a MDI Parent form	True False
MinButton	Determines whether a form has a Minimize button	True False
MouseIcon	Sets a custom mouse icon	Browse for desired Icon
MousePointer	Type of mouse pointer displayed when over part of an object	Select any of the following: 0 - Default 1 - Arrow 2 - Cross 3 - I - Beam 4 - Icon 5 - Size 6 - Size NE SW 7 - Size N S 8 - Size NW SE 9 - Size W E 10 - Up Arrow 11 - Hourglass 12 - No Drop 13 - Arrow and Hourglass 14 - Arrow and Question 15 - Size All 99 - Custom
Moveable	Determines whether a form can be moved	True False
Name	Name of the form	Textual data
NegotiateMenus	Determines whether a form incorporates the menus from an object on the form's menu bar	True False
OLEDropMode	Determines whether this object can act as an OLE object	0 - None 1 - Manual
Palette	Image that contains the palette to use on an object when PaletteMode is set to Custom	Browse for desired Palette
PaletteMode	Value that determines which palette to use for controls on an object	Select any of the following: 0 - Halftone 1 - UseZOrder 2 - Custom
Picture	Graphic to be displayed on the control	Browse for Picture to use on Form's Background
RightToLeft	Text display direction and control visual appearance on a bidirectional system	True False
ScaleHeight	The number of units for the vertical measurement of a object's interior	Any Numeric value
ScaleLeft	Horizontal coordinates for the left edges of an object	Any Numeric value
ScaleMode	Value indicating measurement units for object coordinates when using graphics methods or positioning controls	Select any of the following: 0 - User 1 - Twip 2 - Point 3 - Pixel 4 - Character 5 - Inch 6 - Millimetre 7 - Centimetre
ScaleTop	Vertical coordinates for the top edges of an object	Any Numeric value
ScaleWidth	Number of units for the Horizontal measurement of an object's interior	Any Numeric value
ShowInTaskbar	Determines whether a form or MDIForm appears in the Windows taskbar.	True False
StartUpPosition	Value specifying the position of a form when it first appears	Select any of the following: 0 - Manual 1 - CenterOwner 2 - CenterScreen 3 - Windows Default
Tag	Stores any extra data needed for your program	Any Textual and Numeric data
Top	Distance between the internal top edge of an object and the top edge of its container	Integer Values ONLY
Visible	Determines whether the object is visible or hidden	True False
WhatsThisButton	Determines whether the What's This Button appears in the title bar of a form or MDI form	True False
WhatsThisHelp	Context-sensitive help uses the What's This popup provided by Windows Help	True False
Width	Width of an object	Integer Values ONLY
WindowState	Visual state of a form at run time	Select any of the following: 0 - Normal 1 - Minimized 2 - Maximized

Microsoft Visual Basic 6.0 Migration Resource Center

2017-03-14T12:20:00.001-07:00

Microsoft’s Commitment to VB 6.0 Customers- Microsoft is committed to helping Visual Basic 6.0 customers upgrade to .NET and preserve existing assets. Visual Studio shipped a Visual Basic 6.0 project migration wizard through 2008 in all Visual Studio SKUs. While Microsoft no longer ships the migration wizard, our partners are offering free migration tools and solutions. Here are more resources to help answer questions on how to migrate from Visual Basic 6.0 to Visual Basic .NET and Visual Studio 2010.

Migration Resources

Prepare >

Migrate >

Test >

Modernize >

Prepare

The first step in a phased migration to .NET is to assess which upgrade strategy is right for you in order to come up with a migration plan.

Click the tab on the left for information on the next step: Migrate

More Resources

Guidance

VB6 Upgrade Guidance from Patterns and Practices
Provides proven practices to reach functional equivalence while upgrading Visual Basic 6 to Visual Basic .NET.
Upgrading Microsoft Visual Basic 6 to Microsoft Visual Basic.NET
This free book is the complete technical guide to upgrading Visual Basic 6 applications to Visual Basic .NET.

Training

VB6 Essential Training Videos
Complete series of training videos that give Visual Basic 6 developers the skills to start developing on the .NET platform.
VB6 Upgrade Assesment Webcast
This webcast gives the framework to develop the right strategy to take advantage of the .NET Framework.

Tools for Code Preparation

Partner Tools & Solutions
Leverage these free tools and solutions from our partners to assist you with a more complete migration from Visual Basic 6 to .NET.
Code Advisor for Visual Basic 6.0
Add-in used to ensure that code meets predetermined coding standards and best practices developed by Microsoft.
Visual Basic 6.0 to Visual Basic .NET Upgrade Assessment Tool
Analyze your Visual Basic 6.0 projects to determine what issues you will need to address to be able to upgrade.

Tools for Full and Phased Migration

Partner Tools & Solutions
Leverage these free tools and solutions from our partner to assist you with a more complete migration from Visual Basic 6 to .NET.
Interop Forms Toolkit
Used to enable phased migration, this free add-in for Visual Studio simplifies the process of displaying .NET forms and controls in a Visual Basic 6 application.
Visual Basic Power Packs
Contains a set of controls to use in .NET forms that are familiar to Visual Basic 6 developers. It includes a DataRepeater control, Line and Shape controls, a PrintForm component, and a Printer Compatibility.

Visual Basic 6.0 Downloads

2017-03-14T12:16:00.001-07:00

Essential Downloads

	Code Advisor for Visual Basic 6.0 This application plugs-in to Visual Basic 6.0 to analyze your code and suggest possible improvements.
	Visual Basic 6.0 to Visual Basic .NET Upgrade Assessment Tool Analyze your Visual Basic 6.0 projects to determine what issues you will need to address to be able to upgrade.
	Interop Forms Toolkit 2.1 Used to enable phased migration, this free add-in for Visual Studio simplifies the process of displaying .NET forms and controls in a Visual Basic 6 application.
	Visual Basic Power Packs Contains a set of controls to use in .NET forms that are familiar to Visual Basic 6 developers. It includes a DataRepeater control, Line and Shape controls, a PrintForm component, and a Printer Compatibility.

Additional Downloads

Microsoft Visual Basic 6.0 Service Pack 6 Cumulative Update
A security issue has been identified that could allow an attacker to compromise your Windows-based system running Microsoft Visual Basic 6.0 Service Pack 6 and gain complete control over it. You can help protect your computer by installing this update from Microsoft.
Service Pack 6 for Visual Basic 6.0
Service Pack 6 for Visual Basic 6.0 provides the latest updates to Visual Basic 6.0. It is recommended for all users of Visual Basic 6.0.
Service Pack 6 for Visual Basic 6.0: Run-Time Redistribution Pack
vbrun60sp6.exe is a self-extracting executable file that installs versions of the Microsoft Visual Basic run-time files required by all applications created with Visual Basic 6.0.
Microsoft Visual Basic 6.0 Common Controls
Update for the Microsoft Visual Basic 6.0 Common Controls: mscomctl.ocx and comctl32.ocx.
Visual Basic 6.0 Upgrade Samples
Download these Microsoft Visual Basic samples to learn more about upgrading your application from Visual Basic 6.0 to Visual Basic .NET. Each sample contains three projects - one in Visual Basic 6 and two in Visual Basic .NET. The two Visual Basic .NET samples show the range of options available in upgrading your applications.
Additional Visual Basic 5.0 and 6.0 Samples
Download additional controls, components and samples for Visual Basic 5.0 and 6.0.
Visual SourceSafe 6.0 Service Pack 6
Microsoft Visual SourceSafe® 6.0 Service Pack 6 (SP6) provides the latest performance and reliability updates to the Visual SourceSafe version control system. Service Pack 6 contains the upgrade to Visual SourceSafe 6.0c and is highly recommended for all Visual SourceSafe 6.0 users, including those also running Visual Studio .NET Professional or Visual Basic .NET Standard.
PRB: Visual SourceSafe 6.0 SP3 Netsetup Installation Problem
The Visual C++ 6.0 Processor Pack provides intrinsic support for enhanced instruction sets supported by Intel and Advanced Micro Devices (AMD) processors. The instructions sets supported are Intel's Pentium III new instruction sets (Streaming SIMD Extensions [SSE]) and Intel's Pentium 4 new instruction sets (Streaming SIMD Extensions 2 [SSE2]) as well as AMD's 3DNow! Instruction sets. The Processor Pack is available as a download.
Microsoft Visual Studio: Installer 1.1
Microsoft Visual Studio Installer 1.1 is the latest update to the graphical tool that simplifies the creation of application setup programs for distribution to single-user or enterprise-wide desktops. New with Visual Studio Installer 1.1 is side-by-side installation of versioned DLLs.
Microsoft Visual Studio: T-SQL Debugger Buffer Overrun Fix
Visual Studio 6.0 Enterprise contains a Microsoft Visual Basic feature for debugging T-SQL. This feature contains a problem that could cause a buffer overrun. Since the default installation of the Debugger object allows anyone to start the debugger and run as the logged on interactive user, this bug potentially could be exploited with malicious intentions.

Additional Visual Basic 5.0 & 6.0 Samples

2017-03-14T12:13:00.003-07:00

These are additional Visual Basic 5.0 and 6.0 samples, controls, utilities and components. Samples marked with "VB6" are intended to be run only in Visual Basic 6.0 and those marked with "VB5" are intended for Visual Basic 5.0 only. All samples on this page that offer a single file download are Intel-x86 versions. Samples that offer two file downloads provide a choice of Intel-x86 (listed first) or Alpha (listed second) versions.

ActiveX Control Upgrade Utility (VB6)
This utility will upgrade your Visual Basic 5.0 and pre-release 6.0 projects to use the latest Visual Basic 6.0 ActiveX controls. Specifically this utility will update any project that contains any of the following ActiveX controls: COMCTL32.OCX, COMCT232.OCX, MSChart.OCX. Note: Before using this utility you should backup your Visual Basic 5.0 projects. Do not convert projects using binary compatibility.

Binary Compatibility Add-in
This download includes the document "Revised Binary Compatibility" as well as the Add-in SyncCompt.dll. Binary Compatibility as implemented in Visual Basic 5.0 and Visual Basic 6.0 ensures that new versions of shipping products are fully compatible with older versions. The document explains issues around Binary Compatibility and GUID revision and introduces the DLL. The DLL add-in builds a new compatibility file to stabilize your product (except Standard EXE's which do not have binary compatibility). This tool only works in an Microsoft Windows NT® environment.

Visual Basic Soft Button Sample
The soft button control mimics the behavior of the buttons in the Microsoft Office 97 toolbar. The soft button control will paint a specified bitmap, using the user provided mask color. When the button is disabled, it will apply the "embossed" or "disabled" effect to the picture. The soft button only has a 3D edge when the mouse pointer is over it or when it has received focus through keystrokes.

Visual Basic Web Button Sample
Web Buttons are ActiveX controls that allow web developers to create interesting, unique user interfaces. They bridge the gap between the immediate response of an HTML form button, and the smooth, graphical look of a client-side image map.
Web Buttons have a gradient texture that mimics the appearance of the textured molded plastic buttons used on car stereos and remote controls. This effect is achieved by creating a custom, gradient bitmap that is stretched at run time to fit the button.
One kind of Web Button is the "push button," which is a rounded button with a charcoal gray, matte finish. It has separate captions for each state (True/False) that can be displayed in any color that the system supports. An ellipse around the edge of the button smooths the jagged edges of the gradient bitmap. Like the caption, this ellipse can be any available color.
The "rocker button," an elliptical object with a charcoal gray, matte finish, is another Web Button. Inside the elliptical object there are three regions. The upper region is a thumbnail-shaped button that contains a sunken, triangle-shaped LED. The middle region contains the button's caption, which can be any available color. This region is not clickable. The lower region is a thumbnail-shaped button that contains a sunken, triangle-shaped LED. An ellipse around the edge of the button smooths the jagged edges of the gradient bitmap. Like the caption, this circle can be any available color. When you click on either button, the LED in that region lights up.

Visual Basic Dial Sample
The Dial control is a circular slider control, similar to a volume knob found on a stereo system. The Dial control has two modes: limited and non-limited.
In limited mode, the "min" and "max" values determine the limits possible within one revolution. The dial can be turned only one revolution. In the non-limited mode, the "min" and "max" values set the range of the dial in one revolution.
The dial can be turned unlimited revolutions. The limited mode could be used to adjust a value between two extremes say 1 and 100. The non-limited mode could be used to determine how much adjustment is possible in the margins of a page. Each revolution could equal one inch.

Visual Basic Dir Walk Sample
The Directory Walking Control (Dir Walk) is an OCX which can be used as either a control placed on a form, or as a standalone ActiveX server using the CreateObject method. It is used to collect information from a directory tree. Whenever a file matching the specified criteria is found, it fires an "ItemFound" event. It will continue to walk the tree until either the entire drive is searched, or the fCancel parameter on the ItemFound event is set to True.

Visual Basic LED Sample
The LED control emulates an LED (light-emitting diode), such as those found in digital clocks and displays. The seven-segment display can be used to indicate numeric or user-defined values.
Developers can either set the display by assigning the numeric number to the value, or set a mask value, and the display will only show the segments that the mask specifies. This allows the user to create unique display items, such as an underline or dash, that are not defined by a numeric value.

Visual Basic IContextMenu Shell Extension Sample
IContextMenu Shell Extension is a sample that demonstrates how to build a Visual Basic 5.0 DLL that creates, implements, and registers three system interfaces (IShellExtInit, IContextMenu, and IDataObject) that interact with Windows Explorer.
This sample shell extension enhances the shell by adding custom commands to the context menu for all .ini files. Sample code for an INI file viewer has been provided that is run by the shell extension when the user right clicks over any file with the .ini extension and selects the option to view INI file. This sample uses the new Visual Basic 5 Implements feature to create system callable interfaces.
Note: This sample requires the release version of Visual Basic 5.0 Professional or Enterprise Edition.

Visual Basic SysTray Sample
The SysTray ActiveX control (.ocx) demonstrates how to add icons to the taskbar status area of Windows and how to process callback messages for taskbar icons. The application's callback messages are received and processed in a basic module that is registered as a callback function in a Win32 API call by using the new Visual Basic 5.0 AddressOf feature.

Visual Basic Data Access Explorer
The Data Access Explorer (DAE) provides Visual Basic developers with the ability to evaluate the different data access options provided by Visual Basic 5.0.
Using queries and sample data provided by the National Software Testing Laboratories, developers can select a combination of queries, data sources, query methods, and database engine options to explore Visual Basic's data access capabilities. As tests are completed, DAE displays the time required for each data access option. Those results can be viewed from within the DAE test window or as a text file.
An "Export To Excel" option is provided for those using Excel.

Visual Component Manager
Visual Component Manager is a tool for publishing, organizing, searching, and sorting reusable Visual Basic components such as controls, designers, samples, templates, and wizards.
You can use the Component Manager to publish components you author to a wider audience. You can also organize all your components in one place and easily search attributes such as keywords, property values, descriptive text, etc.
The Component Manager is implemented on the Microsoft Repository. V1.0.

Intel: VCompMgI.exe
Alpha: VCompMgA.exe

Microsoft Visual Modeler
Visual Modeler is a graphical object modeling tool that is tightly integrated with Microsoft Visual Basic 5.0. Visual Modeler allows you to fulfill the promise of object-oriented programming by quickly and easily creating applications that are maintainable, have a long lifetime, and are comprised of components that can be reused in other applications.
These are the main features of Visual Modeler:

Class diagrams where you describe the design of the system you are about to develop in terms of a model, using a high level of abstraction.
Code generation lets you automatically generate Visual Basic code from the design model you have created with Visual Modeler.
Reverse engineering lets you automatically create or update the model with changes made to the Visual Basic code.
Round-trip engineering which is the combination of modeling, code generation, coding, and reverse engineering.

Introduction to Microsoft Visual Modeler.doc
Visual Modeler is available from either the Microsoft Visual Studio or Microsoft Visual Basic Owner's Areas. This paper describes how Microsoft Visual Modeler works in either the Microsoft Visual Studio or Microsoft Visual Basic Enterprise Editions. Microsoft Visual Modeler is a tool to help visualize application component designs. It is capable of reverse- engineering existing Visual Basic applications to create a model. Or, starting from an existing model, it can build the Visual Basic prototype code used to implement a model.

Microsoft Active Messaging
Microsoft Active Messaging (formerly called OLE Messaging) is an object ../Library for building messaging and collaboration applications. It is a technology designed to simplify the creation of applications with messaging functionality, or to add messaging functionality to existing applications.
For example, Active Messaging enables you add script to a Visual Basic application or web site to provide support for creating, sending, and receiving e-mail as well as participating in discussions and other public folder applications.
Active Messaging does not represent a new messaging model, but rather is an additional scripting interface to the Messaging Application Programming Interface (MAPI) model.

Visual Basic MSChart Sample
The MSChart control allows you to plot data in charts according to your specifications. Create a chart by setting data in the control's properties page, or by retrieving data from another an external source, such as a Microsoft Excel spreadsheet. Use the GetObject method to reference the path to the Excel workbook that contains the worksheet.
The MSChart control has many visible parts, all of which can be programmed. Use the MSChart control's three-dimensional chart features to lend a certain sparkle to a report. In order to see these features, you must either set the ChartType property to a valid 3D type, or set the Chart3D property to True.

Visual Basic About/Splash Sample
The Visual Basic About/Splash sample is a form combining the functionality of an About Box and a Splash Screen into one form. Since the majority of information contained in these two forms is usually identical, it makes sense to combine the forms to reduce coding and provide uniformity. The form also has optional parameters of User Name and User Info. This allows the programmer to pass program-specific registration information, which might be different from the user information stored in the system registry.

Visual Basic ActiveX Document Debugger Sample
The Visual Basic ActiveX Document Debugger Sample is a utility that works directly with the VB5 IDE. It's purpose is to ease the development process for ActiveX Document developers. It does this by acting as a dockable ToolWindow that provides automatic loading and unloading of ActiveX Documents into selected hosts.
The ActiveX Document Debugger provides two drop down combo boxes and two buttons. The comboboxes load a selected ActiveX document into one of three hosts. The buttons start and stop the process.

Visual Basic Paint Effects Tool Sample
The Paint Effects Tool contains a PaintEffects class that provides methods for painting transparent and disabled (embossed) images. The sample includes a demonstration of all methods.

Visual Basic Debug Wiper Sample
This feature clears the Immediate Window with the click of a button. Installing this Add-In adds a button to the Standard Toolbar and a menu item to the Add-Ins menu. The sample code must be compiled and registered in order to create this feature.

Changes to the Visual Basic API Viewer data
Changes have been made to the API Viewer data. Download Win32api.exe which contains these changes. After you've downloaded the file to your machine double click on it. It will be decompressed and copied to the correct folder.

Visual Basics Docs folder from VB 5.0 CD (VB5)
Microsoft Visual Studio owners have access to these docs in Books Online. They do not have the documents which were included on the Microsoft Visual Basics CD in the Docs folder.
If you want the doc files which are easier to print, download this file.

Visual Basic Event-Spy Add-in Sample
The Visual Basic Event-Spy sample is an Add-In for the VB5.0 development environment. It can be used to more clearly identify where and when IDE Events are triggered.
The sample code must be compiled and registered in order to create this feature.

Visual Basic Template Manager Add-In
This is an update to the Add-In that was shipped on the CD under /Tools/Unsupported. The Template Manager is a Visual Basic Add-In which provides three new template types to Visual Basic. With the Template Manager, you can use Code Templates, Menu Templates, and Control Set Templates. These templates are copied to the \Template folder beneath the Visual Basic root folder. They are accessed in the same manner as you would create any other template.

Intel: TmplMgr.exe
Alpha: TmplMgrA.exe

Visual Basic Data Tree Control Sample
This control allows you to display the database schema for an Access MDB file in a treeview. Simply by setting the DatabaseName property you will fill the treeview with a list of the tables, queries, properties, fields, and indexes in the database. You can then browse the schema, rename objects, and modify property values. You can also right click to get a context menu that allows you to open a different database, refresh the treeview or, browse the data in a table.

Visual Basic System Color Control Sample
This sample is a scrollable ListView-type collection of the current Windows System Colors. It could be easily modified to display icons, bitmaps, or whatever you have in mind. It currently displays a 3D box filled with a system color next to each system color name. It is mostly hard-coded, using only a scroll bar, so it is very flexible and lightweight.

Visual Basic Picture and Color Picker Sample
The PropPick.dll contains the PropertyPicker class, which wraps the OleCreatePropertyFrame API with the property pages CStockColorPage and CStockPicturePage that come in Msstkprp.dll. You can use these property pages in a UserControl, by simply adding them to the UserControl's PropertyPages property. To invoke the pages in code, the OleCreatePropertyFrame API must be called to provide a modal property page frame.

Visual Basic Dbgwproc.dll
The DbgWProc.Dll (Debug Object for AddressOf Subclassing) enables you to debug normally while a subclass is active without adding any unnecessary overhead to your finished product or distributing an extra component.
Subclassing is a technique that enables you to intercept Windows messages being sent to a form or control. By intercepting these messages, you can then write your own code to change or extend the behavior of the object. VB5 provides the AddressOf keyword, which can be used to reroute Windows messages to your own message processing procedure. Subclassing using the AddressOf is very efficient, but makes debugging a project difficult. If the window you are subclassing receives a message when you are in break mode, VB will crash.

CodeFlow - Visual Basic Object Library Sample
CodeFlow is a sample code library. Its mission is to aid in situations where the flow of code is somewhat problematic or unusual. Some of the code is complex, using Win32 APIs. Other code is very simple. The uniting factor is that these code snippets, wrapped into well-behaved interfaces, can greatly simplify the task of writing code with a demanding flow of execution.

RegObj.dll - ActiveX Manipulation of the Registry
RegObj.dll is an ActiveX server that allows Visual Basic developers to programmatically control the Registry without having to resort to the Windows API. Included is a document which discusses the object model of RegObj.dll, and includes some Visual Basic code to illustrate using the objects in the server to perform common types of registry manipulation. Although the code in the article is constructed in Visual Basic, any other language capable of constructing ActiveX client applications, such as Java or C/C++ can use this ActiveX DLL.

Intel: RegObjI.exe
Alpha: RegObjA.exe

Visual Basic Resource Editor (VB5)
Notepad is no longer the only editor for your resource files! You can use the Resource Editor, a Visual Basic 5.0 add-in.

Intel: ResEditI.exe (VB5)
Aplha: ResEditA.exe (VB5)

Anything that you need to do to a resource file (short of editing bitmaps & cursors) can be done in the Resource Editor, operating entirely within the Visual Basic integrated development environment.

Visual Basic CoolBar Control
The Visual Basic Coolbar Control is a container control that allows you to create user-configurable toolbars similar to those found in Microsoft Internet Explorer 3.0. It consists of a collection of one or more resizable regions or bands. Each band can host a single child control.

Intel: Comct33I.exe
Alpha: Comct33A.exe

Visual Basic Name View Sample
This sample demonstrates an active-x control that displays its own name at design time and is invisible at run time.
Example of use: Why would a developer want to use this code? Suppose you've created a control which is invisible at run-time, such as a Timer or an ImageList. Such controls often simply display an icon at design time. If you have a large number of such controls on your form, it can be quite a bit of work to determine which one is which, to make sure that you've set properties on the correct control, etc. With this code, each control will clearly identify itself by name, preventing any such confusion.

Visual Basic Hot Tracking Sample
One of the new UI elements in Windows is hot tracking. This means that objects may activate as soon as the mouse moves over them, then deactivate when the mouse moves off. Or, they may activate after the mouse has hovered over them for a little while. Or, they may activate at one level as soon as the mouse moves over them, then activate at a higher level after a pause, once again deactivating after the mouse moves off.
Take for example, the new-style toolbar buttons: As soon as you move over them, they activate, drawing a border around them. Then, after a pause, they activate at a higher level by showing a ToolTip. When the mouse moves off, they deactivate, erasing the border and the ToolTip. This sample code helps developers to implement this behavior.

Visual Basic CoolBar Control Sample
The COOLBAR.VBP sample application contain tips and tricks on how to use the Coolbar control in COMCT332.OCX. COOLBAR.VBP is a sample VB5 project that demonstrates how to create an application with a user interface similar to Internet Explorer 3.x. The code is loaded with comments describing various tips, tricks, and techniques for using the coolbar with other controls.

Visual Basic IObjectSafety Interface Sample
ObjSafety.Dll and ucObjSafety.OCX both implement the IObjectSafety interface, which exposes functionality to Internet Explorer 3.x's Safe For Scripting and Safe For Initialization Security features. This sample contains code which will allow you to compile both items.
IObjectSafety should be implemented by objects that have interfaces which support "untrusted" clients (for example, scripts). It allows the owner of the object to specify which interfaces need to be protected from untrusted use. Examples of interfaces that might be protected in this way are:

IID_IDispatch - "Safe for automating with untrusted automation client or script"
IID_IPersist* - "Safe for initializing with untrusted data"
IID_IActiveScript - "Safe for running untrusted scripts"

* anything starting with IPersist
Two HTML samples have been included to demonstrate the use and testing of the ObjSafety.dll and ucObjSafety.OCX sample Visual Basic projects.

Visual Basic Application Wizard Update (VB5)
The Application Wizard lets you generate an application using one of the predefined visual interfaces - Multiple Document Interface (MDI), Single Document Interface (SDI), or Explorer Style.

Intel: AppWzrdI.exe (VB5)
Alpha: AppWzrdA.exe (VB5)

The application you generate contains a toolbar and a status bar. The default toolbar for SDI and MDI forms is similar to a Microsoft Office toolbar. It includes the New, Open, Save, Print, Cut, Copy, Paste, Bold, Italic, Underline, Align Left, Align Right, and Center buttons.
Explorer-style applications have a default toolbar with the Navigation Buttons, Cut, Copy, Paste, Delete, Properties, View Large Icon, View Small Icon, View List, and View Details buttons. You can customize the toolbar. The status bar includes information about the status of the application and the date and time.
This Upgrade Contains:

Completely customizable menus with persistence between sessions
A Toolbar Builder which builds a Toolbar when you drop one on a form
Integration with the Data Form Wizard to allow more user-specific database scenarios

Visual Basic Data Form Wizard Update (VB5)
The Data Form Wizard is designed to automatically generate Visual Basic forms that contain individual bound controls and procedures used to manage information derived from database tables and queries.

Intel: DataFrmI.exe (VB5)
Alpha: DataFrmA.exe (VB5)

You can use the Data Form Wizard to create either single query forms to manage the data from a single table or simple query, or Master/Detail type forms used to manage more complex one-to-many data relationships. If you are using a control, you can also create a grid or datasheet type form.
The Data Form Wizard is used in conjunction with either the Data or the RemoteData controls, or DAO or RDO code.
This Upgrade Contains:

Ability to build code-only forms where controls are not bound to a data control
Use of DAO or RDO code depending on database type
Integration with the App Wizard

Visual Basic Class Builder Utility Update (VB5)
The Class Builder utility helps you build your class and collection hierarchy for your Visual Basic project. The Class Builder utility keeps track of the hierarchy of your classes and collections and generates the framework code necessary to implement the classes and collections, including the properties, methods, events, and enums.

Intel: ClsBldI.exe (VB5)
Alpha: ClsBldA.exe (VB5)

This Upgrade Contains:

Addition of Enums
Addition of ParamArray, Optional, ByVal, and Default values in argument list
Bug fixes
Enums appear only on the All tab.

Visual Basic Setup Wizard Update (VB5)
The Setup Wizard is a tool used with the Visual Basic Setup Toolkit that helps you create application setup and distribution media. You can also use the Setup Wizard to create dependency (.dep) files.

Intel: SetupWzI.exe (VB5)
Alpha: SetupWzA.exe (VB5)

The Setup Wizard supports:

Multiple floppy disks, and it can split files that are too large to fit onto a single floppy.
Copying your files to a hard disk directory for distribution over a network or on CD-ROM.
Distribution of your application across the Internet using automatic code download from Microsoft Internet Explorer, Version 3.0.

Note: The Setup Wizard is designed for Visual Basic developers and isn't a general Windows Setup Tool.
This Upgrade Contains:

Bug fixes to the Setup Wizard that was released with VB 5.0

Visual Basic 6.0 Resource Center

2017-03-14T12:07:00.000-07:00

Find the best content for Visual Basic 6 development, .NET interoperability, and migration here.

Partner Tools & Solutions
Leverage these free tools and solutions from our partners to assist you with a more complete migration from Visual Basic 6 to .NET.

Getting Started

1. Migration & Support Strategy
Key Visual Basic 6.0 runtime files, used in the majority of application scenarios, are shipping in and supported for the lifetime of Windows 7. Find out what support options are available to you.
2. Visual Basic 6.0 Resources
You will find plenty of resources here for developing in Visual Basic 6.0 including links to the MSDN Library, technical articles, and code samples.
3. Extend Your Visual Basic 6.0 Applications
Extend your Visual Basic 6.0 applications using the functionality of Visual Basic .NET without upgrading. These resources show you how.
4. Upgrading from Visual Basic 6.0
Do you need help in upgrading your Visual Basic 6.0 applications to Visual Basic .NET? This section provides the necessary resources.

Visual Basic Concepts Visual Basic Documentation Map

2017-03-14T11:57:00.003-07:00

Visual Basic includes many documentation tools, each designed to help you learn and use a particular aspect of the product. The documentation provided with Visual Basic is listed below.
Programmer's Guide

A guide to creating applications with Visual Basic. Explains programming techniques, using frequent examples to show how the techniques work in typical applications.

Using ActiveX Controls

An introduction to the ActiveX controls — formerly called OLE controls — included with the Visual Basic Professional and Enterprise editions. Start here for general information, scenarios of real-life uses, and code. Included in the Component Tools Guide.

Creating ActiveX Components

A guide to creating ActiveX controls, ActiveX documents, and ActiveX code components (formerly OLE servers). Includes introductory step-by-step chapters as well as in-depth design guides. Included in the Component Tools Guide.

Extending the Visual Basic Environment with Add-Ins

A guide to using the Visual Basic extensibility object model to tailor the development environment to your unique needs. Use objects in the model to build add-ins that automate repetitive tasks, monitor the development environment for certain events, or perform complex tasks. Included in the Component Tools Guide.

Accessing DLLs and the Windows API

A guide to enhancing functionality provided by Visual Basic by calling functions in dynamic-link libraries (DLLs). Through DLLs, you can access the thousands of procedures that form the backbone of the Microsoft Windows operating system, as well as routines written in other languages. Included in the Component Tools Guide.

Introduction to Internet Applications

An introduction to creating applications that can run on the Internet or an intranet, presenting HTML pages inside forms-based applications, and deploying these applications and other ActiveX components on the Web. Included in the Component Tools Guide.

Data Access Guide

A guide to creating and manipulating databases using Microsoft ActiveX Data Objects (ADO) and other data access technologies.

Provides a complete reference for features available in all editions of Visual Basic. Includes sections on the programming language, controls, the development environment, and more.

Describes the sample applications provided with Visual Basic.

Provides an overview and complete reference for Data Access Objects, a programming model that allows you to programmatically access and manipulate data in local or remote databases, and to manage databases, their objects and their structure.

A guide to using Microsoft Repository, an extensible object modeling system that allows full programmatic access via Automation objects. Microsoft Repository comes with the Repository Add-in, a Visual Basic add-in module that automatically stores and maintains the structure of your Visual Basic projects in an object-oriented data repository.

Great Migrations Studio (gmStudio)

2017-03-14T11:40:00.001-07:00

gmStudio is a unique system re-engineering environment for developing scalable, custom VB6/ASP/COM to .NET upgrade solutions. As a comprehensive software re-engineering platform, gmStudio helps you plan, customize, improve, verify, and track your upgrade process and meet the unique requirements of your source code and your .NET standards. If you are looking towards preserving and enhancing the value of your VB6/ASP/COM assets, gmStudio is the most advanced and cost-effective solution available.

The Tool-Assisted Rewrite

gmStudio offers compiler-as-a-service capabilities to enable an agile Tool-Assisted Rewrite Methodology. This methodology accelerates your upgrade efforts without sacrificing quality or control. Project teams using our tools and methods can deliver a lot more upgrade, better, and faster.

Agile

Scalable

Improvable

Incremental

Repeatable

Measurable

Important Offer for You!

Microsoft and Great Migrations have partnered to offer a free gmStudio license to you. The link below can be used to obtain a free copy of gmStudio that will allow you to upgrade an application of up to 10,000 lines of VB6 code to VB.NET or C#. This promotional offer can also be applied as a discount when purchasing a larger license, or a license for our ASP upgrade tool.

Learn more and Download a free version of gmStudio

Click to request gmStudio Promotional Edition for systems with up to 10,000 lines of VB6 code!

See more gmStudio Screen shots.

Benefits

Cash-in your legacy software assets: use gmStudio to help you "cash in" your legacy assets by upgrading them to .NET.
Get more upgrade for your money: generate code that takes advantage of .NET.
Rewrite to your standards: use .NET APIs and design patterns for lower total cost of ownership and agility after the upgrade.
Integrate manual development: automatically integrate hand-written code fragments, methods or entire files.
Upgrade enterprise applications: upgrade large, complex systems made up of many inter-related VB6/ASP/COM components.
Continue maintenance in parallel with the upgrade: our methodology does not require a code freeze.
Get valuable results quickly: gmStudio facilitates an agile approach to migration that delivers .NET code iteratively.
Build quality in and up: the gmStudio approach is test-driven and improves code quality systematically and incrementally.
Document and reuse your solutions: each gmStudio solution is documented and reusable.
Plan and estimate more effectively: gmStudio's customizable code analysis reports help you plan your upgrade strategies.
Measure and track progress: gmStudio's translation, build, and code review reports help you measure quality and track progress.

Features

VB6/COM Compiler-as-a-service: configure gmStudio using our extensible rules-scripting language.
Choice of Target Language: automatically rewrite VB6/COM in either C# or VB.NET.
Choice of Target IDE: choose VS2010 or VS2012 as your Visual Studio IDE.
Choice of Forms Replacement: target WinForms or WPF (beta).
Custom COM/ActiveX Replacement: replace COM APIs and controls with .NET classes that meet your standards.
Custom API Replacement: replace Win32 API calls with .NET code that meets your standards.
Custom Language Replacement: replace VB6 intrinsics with .NET code that meets your standards.
Stub Generation: generate stubbed-out .NET classes for your COM dependencies and application code.
Content Templates: use custom, dynamic templates for project files, AssemblyInfo files, and many other code structures.
Custom Deployment/Build Processes: add your tasks to the deployment/build processes for the translated code.
High-performance: experiment with many variations of your upgrade rules, even if your system is very large.

Additional Resources

Learn more: visit Great Migrations Documentation Home for white papers, case studies, videos and webcasts.
Try it yourself: submit the gmStudio Demo request form to get a free trial version of gmStudio.

ArtinSoft’s Visual Basic Upgrade Companion (VBUC)

2017-03-14T11:37:00.004-07:00

ArtinSoft’s Visual Basic Upgrade Companion (VBUC) is the industry-leading tool for the migration of Visual Basic 6 to both Visual Basic .NET and C#. With a proven track record of millions of lines of code upgraded to Microsoft’s .NET Framework, the VBUC helps you move your business critical applications out of obsolescence, free of ties to third-party dependencies.
If you are looking towards taking advantage of new Microsoft technologies, reducing development, deployment and maintenance costs, and addressing compliance issues or meeting market demands, the VBUC is the most advanced and cost-effective solution out there.

Learn more and download a free version of VBUC

Exciting Offer for You!

Microsoft and ArtinSoft have partnered to offer a free VBUC license to you. The discount code below can be used to purchase a license that will allow you to migrate an application of up to 10,000 lines of VB6 code to VB.NET or C# for free. It can also be applied when purchasing a larger license.
Download your copy today. Use the code MSDN for a free license for up to 10,000 lines of code!

Benefits

Cost-effectively convert your application to either C# or VB.NET: About 80% savings versus a manual rewrite and 60% versus other tools.
Accelerate your VB6 to .NET migration: Lower your project timeframe up to 4 times less than other solutions.
Reduce project risks: The VBUC is a non-disruptive, highly automated tool that preserves all the business rules embedded in the code and the value of the original application.
Take advantage of the new platform features: Generate 100% native VB.NET or C# code, easy to maintain and evolve. No ties to proprietary third-party runtimes that deprive you of all the benefits of the .NET Framework.
Extend and customize the migration tool based on your needs: Add support for more legacy components and enhance existing features to comply with enterprise coding standards.

Features

The Visual Basic Upgrade Companion includes a large set of powerful features and customization/extensibility options that provide a wide range of choices for the code conversion process, dramatically reducing the subsequent amount of required manual work and producing native .NET code while making the translated application to compile and run with a behavior that is equivalent to the original VB6 system.
These are some of the unique characteristics of the Visual Basic Upgrade Companion:

Language transformations: The VBUC performs the most advanced language transformations to generate pure, clean and readable .NET source code employing the most of its inherent features.
Advanced Code Refactoring: The VBUC applies additional transformation rules to generate code that looks as if it was originally written in .NET.
Reference Resolution Between Projects: Save time, human effort and money by easily upgrading multi-project, complex applications in a single run.
Error Handling Transformation: Eliminate the “On error” and “Go to” statements from your resulting .NET code with just a single click.
Resolve Late Bound Variable Types: All the data-type issues are automatically fixed during the migration. Late binding variables will no longer have generic data types.
Extensibility: Appropriate code conversion rules and component mappings can be set through switchable options that are displayed in a Profile Manager window. All the particular code techniques and patterns found in your code can be described into the VBUC’s core, including the ability to add or fine-tune existing support for ActiveX controls and libraries. More complex customizations can be implemented by ArtinSoft on user request.

Third Party Library Support: The Visual Basic Upgrade Companion is able to upgrade many ActiveX controls found in the original application to inherent .NET components or to newer versions of those third-party controls.
Legacy Data Access to ADO.NET: Upgrade your data access (ADO, DAO, RDO) to ADO.NET automatically with several source-target combination possibilities.
ASP/VB6 Migration Support: The VBUC allows the migration of mixed ASP and VB6 projects to ASP.NET and VB.NET or C#.
User Environment: Advanced GUI and Command Line interface oriented to improve its usability and user experience. The UI and all messages, including EWIs, can be displayed in different languages, besides the standard English.

For an updated, more detailed features list please visit the VBUC’s technical site: http://www.vbtonet.com/?msdn

Learn More and Try it for Yourself

Learn more about the VBUC, read customer evidence, access white papers, videos and webcasts, or download a free trial at: https://www.artinsoft.com/msdn.

Additional Resources

VB/ASP Assessment Tool: a free product that works as a measuring instrument for the upgrade effort, analyzing the application components and the relationships between them from a migration perspective, which considers elements, constructs, and features that consume significant resources during an upgrade project.
VB migration services: ArtinSoft can also provide consulting services that range from technical support on an hourly basis to a complete turn-key solution, accelerating and simplifying the migration process of your Visual Basic 6 applications, either to the .NET Platform or straight to the Web, significantly reducing costs, time, and risks.
VBUC technical site: a comprehensive website around the Visual basic Upgrade Companion, full of documentation and other resources to help you achieve success on your VB6 to .NET migration projects.
ArtinSoft’s customers: a partial list of companies who have benefitted from using our unique migration technology.
ArtinSoft’s case studies and testimonials: detailed customer evidence ranging from quotes to comprehensive success stories.
ArtinSoft’s white papers: loads of useful information to plan your migration project accordingly and succeed.
ArtinSoft’s multimedia resources: training /demo videos, webcasts, podcasts and more.

Access the File System with .NET Framework Classes from Visual Basic 6

2017-03-14T11:34:00.002-07:00

Visual Studio 2005

Scott Swigart
Swigart Consulting LLC.
Applies to:
   Microsoft Visual Basic 6
   Microsoft Visual Basic 2005
   Microsoft Visual Basic .NET 2003
Summary: Accessing the file system is a common application requirement, and in the spirit of Microsoft Visual Basic Fusion, this article shows how to access some of the best Microsoft .NET Framework file system functionality from existing Visual Basic 6 applications. Learn how to get the extension for a file, the directory portion or a path, or the file name portion of a path. Learn how to fire events every time the contents of a directory change. (16 printed pages)
Download the Visual Basic Fusion—IO_IO.msi code sample for this article.

Introduction
Primer: Calling .NET from Visual Basic 6
Using the Path Class from Visual Basic 6
Using the FolderBrowserDialog from Visual Basic 6
Using the FileSystemWatcher from Visual Basic 6
Examining the Construction of IOLib
Conclusion
Additional Resources

Introduction

Accessing the file system is a common application requirement, and in the sprit of Visual Basic Fusion, this article will show you how you can access some of the best .NET Framework file system functionality from existing Visual Basic 6 applications.
First, there's the Path class. This class makes it a snap to work with, and extract pieces of file system path strings. With one line of code, you can get the extension for a file, or get the directory portion of a path, or get the file name portion of a path. You can even switch a file extension, or determine if a path is relative or absolute.
Next, there's the FolderBrowserDialog class, which makes it easy to display a dialog box that lets the user pick a folder path.

Figure 1. Folder Browser dialog box

Displaying this system dialog box from Visual Basic 6 requires a good amount of Win32 API calls. However, by using the IOLib included with this article (written in Visual Basic 2005), you can easily display this dialog box from a Visual Basic 6 application.
Finally, this article will examine the FileSystemWatcher class. This class can fire events every time the contents of a directory change. So if you have an application that needs to process new files as they appear or change, this is a great class to use. And again, it can be used easily from Visual Basic 6.

Primer: Calling .NET from Visual Basic 6

In general, you cannot call classes from Visual Basic 6 directly into the .NET Framework because the .NET Framework classes do not expose themselves as COM objects. However, you can use Visual Basic 2005 to create COM wrappers for the portions of the .NET Framework that you want to use. Your Visual Basic 6 code calls into your COM wrapper, and the COM wrapper calls into the .NET framework.

Figure 2. Calling into the .NET Framework with wrapper classes

This is the approach used in this article. The sample code for this article includes a Visual Basic 2005 project called IOLib that is a wrapper for the .NET Framework Path class, FolderBrowserDialog class, and FileSystemWatcher class. This article will initially show how you can use IOLib from your Visual Basic 6 applications. If you're interested in how IOLib was constructed, the article will finish off with a walkthrough on building your own wrapper classes.

Using the Path Class from Visual Basic 6

Sometimes, an application needs to manipulate a file path string. For example, you might have a full path to a file, but you want to just get the directory portion of the path. Other times, you may want just the file name, without the directory information. Other times, you may want to examine the file extension so that you can take different action for different file types. You may even want to change the extension for a file if you are loading it from one format and saving it with a different one.
The Path class exists to make these kinds of operations very simple. The IOLib included with this article wraps the .NET Path class so that you can call it from Visual Basic 6 or other COM based environments. Through this COM wrapper, you can access the following functionality:

Table 1. COM wrapper functionality

Property or Method	Description
ChangeExtension	Changes the extension of a path string.
Combine	Combines two path strings.
GetDirectoryName	Returns the directory information for the specified path string.
GetExtension	Returns the extension of the specified path string.
GetFileName	Returns the file name and extension of the specified path string.
GetFullPath	Returns the absolute path for the specified path string.
GetPathRoot	Gets the root directory information of the specified path.
GetTempFileName	Returns a uniquely named zero-byte temporary file on disk and returns the full path to that file.
GetTempPath	Returns the path of the current system's temporary folder.
HasExtension	Determines whether a path includes a file name extension.
IsPathRooted	Gets a value indicating whether the specified path string contains absolute or relative path information.
InvalidPathChars	Provides a platform-specific array of characters that cannot be specified in path string arguments passed to members of the Path class.

The following walkthrough will illustrate using Path class from Visual Basic 6.
Prior to completing this walkthrough, you must install Visual Studio 2005, Visual Basic Express. Visual Basic Express is a free and relatively small download, and can install along side of Visual Studio 6.0, Visual Studio .NET, Visual Studio 2003, or Visual Studio 2005, without any problems.
Walkthrough: Using the Path class from Visual Basic 6

If you have not already run the install for the sample code, in the sample code folder for this article, navigate into the Code sub-folder, and double-click install.bat. This registers the .NET framework DLLs, and the IOLib wrapper so that it can be used from Visual Basic 6.0
Start Visual Basic 6.0.
In the New Project dialog box, select Standard EXE, and click Open.
Right-click on the Toolbox, and select Components...
In the Components dialog box, check Microsoft Common Dialog Control 6.0.
Click OK.
Select the Project | References menu command.
Check IOLib.
Click OK. You have now referenced the .NET DLLs needed to display the folder browser dialog box from Visual Basic 6. It's now time to build the user interface.
In the Toolbox, double-click the CommonDialog control to add it to the form.
Add a TextBox to the form, and resize it so that it fills most of the form.
In the Properties window, for the Text1 control, set the following properties:
1. Multiline = True
2. Text = (an empty string) This text box will display information about a selected file using the Path class.
Right-click on the Form, and select View Code.

Enter the following code:

Private Sub Form_Load()
Dim path As New IOLib.PathWrapper
With CommonDialog1
    .ShowOpen
    If .FileName <> "" Then
        Text1 = "Directory: " & path.GetDirectoryName(.FileName) & _
            vbCrLf
        Text1 = Text1 & "Has extension: " & _
            path.HasExtension(.FileName) & vbCrLf
        Text1 = Text1 & "Extension: " & _
            path.GetExtension(.FileName) & vbCrLf
        Text1 = Text1 & "FileName: " & _
            path.GetFileName(.FileName) & vbCrLf
        Text1 = Text1 & "Root: " & _
            path.GetPathRoot(.FileName) & vbCrLf
        Text1 = Text1 & "Absolute or Relative: " & _
            IIf(path.IsPathRooted(.FileName), "Absolute", "Relative")
    End If
End With
End Sub

Press F5 to run the application

As you can see, when you select a file, this application shows you a number of things about that file path.

Figure 3. Using the Path class from Visual Basic 6

With just a line of code, the application can separate the file name from the directory path. The application can also determine if the file has an extension, and what the extension is. Finally, the application can tell you the root folder for the path, and whether the path is relative or absolute. With Visual Basic 6, you are often required to do your own string splitting logic to get these pieces of information, and it's easy to introduce bugs if the user provides UNC paths, or other path formats that your application may not expect. Not only is the Path class easier than writing your own logic, but it's also been tested against a wide range of paths.

Using the FolderBrowserDialog from Visual Basic 6

The folder browser dialog box is very useful when you need the user to select a folder (rather than a specific file). The operating system includes a built-in folder browser dialog box, but Visual Basic 6 does not provide access to this dialog box. If you want to display the folder browser with Visual Basic 6, you need to call the SHBrowseForFolder and other Win32 API functions.
However, the .NET Framework does contain a FolderBrowserDialog class, and the IOLib code included with this article wraps the FolderBrowserDialog class so that it can easily be used from Visual Basic 6. The IOLib FolderBrowserDialogWrapper exposes the following functionality:

Table 2. FolderBrowserDialogWrapper functionality

Property or Method	Description
Description	Gets or sets the descriptive text displayed above the tree view control in the dialog box.
Reset	Resets properties to their default values.
RootFolder	Gets or sets the root folder where the browsing starts from.
SelectedPath	Gets or sets the path selected by the user.
ShowDialog	Displays the folder browser dialog box.
ShowNewFolderButton	Gets or sets a value indicating whether the New Folder button appears in the folder browser dialog box.

The following steps illustrate using the FolderBrowserDialog class from Visual Basic 6:
Walkthrough: Using the .NET FolderBrowserDialog from Visual Basic 6

If you have not already run the install for the sample code, in the sample code folder for this article, navigate into the Code sub-folder, and double-click install.bat. This registers the .NET framework DLLs, and the IOLib wrapper class so that it can be used from Visual Basic 6.0.
Start Visual Basic 6.0.
In the New Project dialog, select Standard EXE, and click Open.
Select the Project | References menu command.
Check IOLib, and System.Windows.Forms.DLL.
Click OK. You have now referenced the .NET DLLs needed to display the folder browser dialog box from Visual Basic 6. It's time to write some code.
Double-click Form1 in the designer to cause Visual Basic to generate the Form_Load subroutine and switch you to the code editor.
Inside of Form_Load, enter the following code:
```
Dim fb As New IOLib.FolderBrowserDialogWrapper
fb.Description = "Select a folder"
fb.ShowNewFolderButton = True
fb.RootFolder = SpecialFolderWrapper_ProgramFiles
If fb.ShowDialog = DialogResult_OK Then
    MsgBox fb.SelectedPath
End If
```
This creates an instance of the box class. This wrapper is then used to configure properties such as the description text and starting folder. The folder browser is also configured to allow the user to create a new folder through the dialog box. Finally, the dialog box is shown, and if the user clicks the OK button, the path selected in the dialog box is processed.
Press F5 to run the application. The following dialog box should appear:

Figure 4. Displaying the folder browser dialog box from Visual Basic 6
When a folder is selected, you should see the path to the folder appear in the message box.

Figure 5. Displaying the folder selected by the user

You can see that displaying the folder browser dialog box from Visual Basic 6 using the .NET Framework is much easier than displaying it using Win32 API calls.

Using the FileSystemWatcher from Visual Basic 6

I've probably saved the best for last. The Microsoft .NET Framework includes a class called the FileSystemWatcher, which will raise an event any time files in a folder are created, deleted, changed, or renamed. Normally, you can't use the FileSystemWatcher directly from Visual Basic 6, but IOLib (supplied with this article) wraps the FileSystemWatcher, making it simple to use from COM environments.
The following walkthrough will show you how to use the FileSystemWatcher to detect changes under a directory.
Walkthrough: Using the FileSystemWatcher from Visual Basic 6

If you have not already run the install for the sample code, in the sample code folder for this article, navigate into the Code sub-folder, and double-click install.bat. This registers the .NET framework DLLs, and the IOLib wrapper class so that it can be used from Visual Basic 6.0
Create a new folder on your hard disk called C:\WatchedFolder. This folder will be monitored by the FileSystemWatcher for changes.
Start Visual Basic 6.0.
In the New Project dialog box, select Standard EXE, and click Open.
Select the Project | References menu command.
Check IOLib.
Click OK. You have now referenced the .NET DLLs needed to use the FileSystemWatcher class from Visual Basic 6.
Add a CommandButton and TextBox to the form.
For the CommandButton, set the text property to Start Watching.
For the TextBox:
1. Set the Text property to blank.
2. Set the MultiLine property to True.
Double-click the Form to have Visual Basic generate the Form_Load event handler, and switch you into Code view.
In the General Declarations section (above Form_Load), enter the following:
```
Private WithEvents fsw As IOLib.FileSystemWatcherWrapper
```
In the Form_Load event, enter the following:
```
Set fsw = New IOLib.FileSystemWatcherWrapper
```
At this point, you have created an instance of the class that will be used to monitor the C:\WatchedFolder for any changes.
From the Object drop-down, select Command1.

Figure 6. Selecting the command button with the Object drop-down
This will generate the click event for the CommandButton control.
In the Command1_Click event, enter the following code:
```
fsw.InitWatcher ("C:\WatchedFolder")
fsw.IncludeSubDirectories = True
fsw.EnableRaisingEvents = True
```
This tells the FileSystemWatcher which folder it should monitor. It also indicates that any sub-directories of that folder should also be watched. Finally, it tells the FileSystemWatcher to begin raising events as soon as anything changes.
The only remaining task is wiring up event handlers to process any changes.
From the Object drop-down, select fsw. This generates the fsw_Changed event handler, which will fire any time a file under the C:\WatchedFolder directory changes.
In the fsw_Changed event handler, enter the following code:
```
Text1 = Text1 & "Changed: " & e.FullPath & vbCrLf
```
In the Procedure drop-down, select Created.

Figure 7. Selecting the Created event with the procedure drop down
This will generate the fsw_Created event handler. This event fires whenever a new file appears under the C:\WatchedFolder directory.
In the fsw_Created event handler, enter the following code:
```
Text1 = Text1 & "Created: " & e.FullPath & vbCrLf
```

Repeat steps 18 and 19 to create event handlers for the Deleted and Renamed events. Your final code should appear as:

Private WithEvents fsw As IOLib.FileSystemWatcherWrapper
Private Sub Command1_Click()
    fsw.InitWatcher ("C:\WatchedFolder")
    fsw.IncludeSubDirectories = True
    fsw.EnableRaisingEvents = True
End Sub
Private Sub Form_Load()
    Set fsw = New IOLib.FileSystemWatcherWrapper
End Sub
Private Sub fsw_Changed(ByVal e As IOLib.FileSystemEventArgsWrapper)
    Text1 = Text1 & "Changed: " & e.FullPath & vbCrLf
End Sub
Private Sub fsw_Created(ByVal e As IOLib.FileSystemEventArgsWrapper)
    Text1 = Text1 & "Created: " & e.FullPath & vbCrLf
End Sub
Private Sub fsw_Deleted(ByVal e As IOLib.FileSystemEventArgsWrapper)
    Text1 = Text1 & "Deleted: " & e.FullPath & vbCrLf
End Sub
Private Sub fsw_Renamed(ByVal e As IOLib.FileSystemEventArgsWrapper)
    Text1 = Text1 & "Renamed: " & e.FullPath & vbCrLf
End Sub

Press F5 to run the application.
Click Start Watching.
Open Windows Explorer and navigate to the C:\WatchedFolder directory.
Select the File | New | Text document menu command. This creates a new file in the folder, and should trigger an event in your application.
Rename the new file to test.txt.
Delete test.txt.
Switch to your application. It should appear as follows:

Figure 8. Output from the Visual Basic 6 application using the FileSystemWatcher

You can see that the application was able to monitor the directory for any changes, and the changes are displayed in the text box. Often this is used for batch processing of files as they are uploaded, exported from a mainframe, or are otherwise placed into a "drop" folder.

Examining the Construction of IOLib

In the code download provided with this article you will find a folder called IOLib. Double-clicking the IOLib.sln file in that folder will open the solution in Visual Studio 2005 or Visual Basic Express.
When the solution opens, you will be able to see the various wrapper classes listed in the Solution Explorer.

Figure 9. Wrapper classes listed in the Solution Explorer

Double-clicking on any of these wrapper classes will open the file in the code editor. If, for example, you double-click the FolderBrowserDialogWrapper.vb file, you will see the following code:

Imports System.Windows.Forms
<ComClass(FolderBrowserDialogWrapper.ClassId, FolderBrowserDialogWrapper.InterfaceId, FolderBrowserDialogWrapper.EventsId)> _
Public Class FolderBrowserDialogWrapper
#Region "COM GUIDs"
    Public Const ClassId As String = "705DDB3F-3A03-4C97-ACE4-9D6F4A50F0AC"
    Public Const InterfaceId As String = "CB311CDB-B62A-444E-B415-A253EB579541"
    Public Const EventsId As String = "E6B1B7BF-F65B-4A56-9534-5C39332332FB"
#End Region
    Private _folderBrowser As FolderBrowserDialog
    Public Sub New()
        MyBase.New()
        _folderBrowser = New FolderBrowserDialog
    End Sub
    Public Property Description() As String
        Get
            Return _folderBrowser.Description
        End Get
        Set(ByVal Value As String)
            _folderBrowser.Description = Value
        End Set
    End Property
    Public Sub Reset()
        _folderBrowser.Reset()
    End Sub
    Public Property RootFolder() As SpecialFolderWrapper
        Get
            Return _folderBrowser.RootFolder
        End Get
        Set(ByVal Value As SpecialFolderWrapper)
            _folderBrowser.RootFolder = Value
        End Set
    End Property
    Public Property SelectedPath() As String
        Get
            Return _folderBrowser.SelectedPath
        End Get
        Set(ByVal Value As String)
            _folderBrowser.SelectedPath = Value
        End Set
    End Property
    Public Function ShowDialog() As DialogResult
        Return _folderBrowser.ShowDialog
    End Function
    Public Property ShowNewFolderButton() As Boolean
        Get
            Return _folderBrowser.ShowNewFolderButton
        End Get
        Set(ByVal Value As Boolean)
            _folderBrowser.ShowNewFolderButton = Value
        End Set
    End Property

End Class

There are a couple of important things to note in this class. First, you can see that the class uses the ComClass attribute, and contains a number of GUIDs. These insure that this class can be properly registered as a COM object, and be usable from Visual Basic 6. Next, the class just provides simple wrappers that pass through to the underlying .NET Framework FolderBrowserDialog class. When the user calls ShowDialog of the wrapper, ShowDialog of the FolderBrowserDialog class is called. When the user sets the Description property of the wrapper, the Description property of the FolderBrowserDialog is set. In most cases, there's nothing overly complicated about the wrapper classes. Their main purpose is to expose a COM interface, and pass-through to the desired .NET framework class.
The following walkthough will take you, step-by-step, through the creation of a minimal wrapper around the FolderBrowserDialog, to further your understanding of wrapper construction.
Walkthrough 4: Constructing a wrapper for the FolderBrowserDialog.
The first task will be to create the wrapper class. Once it is created, you will use it from Visual Basic 6.

(Visual Basic Express Only) Copy the ComClass.zip file from the code download for this article to C:\Documents and Settings\[User Name]\My Documents\Visual Studio 2005\Templates\ItemTemplates\Visual Basic
Start Microsoft Visual Basic 2005 Express Edition, or Microsoft Visual Studio 2005.
Select the File | New Project menu command. The wrapper class will be a class library project. This will compile to a DLL, much like a COM component would.
In the New Project dialog box:
1. (VS 2005 Only) For Project Types, select Visual Basic Projects.
2. For Templates, select Class Library.
3. For Name, enter FBWrapper.
4. Click OK.
In the Solution Explorer, right-click Class1.vb and select Delete.
Click OK. Class1 is not needed because it is a simple .NET class, but not a COM class. For the wrapper, we need to create a COM class so that it can be used as a COM object from Visual Basic 6.
Select the Project | Add New Item menu command.
In the Add New Item dialog box:
1. For Templates, select COM Class.
2. For Name enter FolderBrowserDialogWrapper.
3. Click OK.
This has created the beginning of the wrapper class. Now you need to write the code that will wrap the FolderBrowserDialog class.
Select the Project | Add Reference menu command.
In the Add Reference dialog box:
1. Click System.Windows.Forms.dll.
2. Click Select.
3. Click OK.

Above the Public Sub New constructor, enter the following line of code:

Private fb As New System.Windows.Forms.FolderBrowserDialog
This creates an instance of the FolderBrowserDialog which you are wrapping.

After Public Sub New, but before End Class, enter the following:
```
Public Function ShowDialog() As System.Windows.Forms.DialogResult
    Return fb.ShowDialog()
End Function
```
When the ShowDialog function in your wrapper is called, it will pass the call through to the underlying FolderBrowserDialog class.

Enter the following code to create a property that will allow your Visual Basic 6 application to determine which folder was selected.

Public Property SelectedPath() As String
    Get
        Return fb.SelectedPath
    End Get
    Set(ByVal Value As String)
        fb.SelectedPath = Value
    End Set
End Property

Select the Build | Build FBWrapper menu command. At this point, your wrapper is complete and can be used from Visual Basic 6.
Start Visual Basic 6.
In the New Project dialog box, select Standard Exe, and click Open.
Select the Project | References menu command.
In the References dialog box, check FBWrapper, and click OK. You can see that your wrapper class appears in Visual Basic 6 just like any other COM object. You can just reference and use it.
Double-click the form to have the development environment generate the Form_Load event handler, and switch you to the code editor.
In the Form_Load event, enter the following code:
```
Dim fb As New FBWrapper.FolderBrowserDialogWrapper
fb.ShowDialog
MsgBox fb.SelectedPath
```
This creates an instance of the wrapper class, and displays the folder browser dialog box. When the user selects a folder, the selected folder is displayed in a message box.
Press F5 to run the application and display the folder browser.

Feel free to examine the other wrapper classes in IOLib, and you will see that they are built exactly this way. They simply provide a COM interface, and pass calls through to the underlying .NET framework classes.

Conclusion

In this article, you have seen that the .NET Framework exposes a number of classes that are very useful when working with the file system. The Path class makes it easy to work with file path strings and extract specific pieces of information, such as the directory name, file name, and file extension. The FolderBrowserDialog provides easy access to the system dialog box that allows the user to select a folder. Finally, the file system watcher class makes it easy to monitor folders for new files or changes. This article also includes a component called IOLib that wraps these .NET classes, making them usable from Visual Basic 6 or other COM environments, like Visual Basic for Applications (VBA), ASP, or Visual Basic Scripting Edition (VBScript).

What's Going On? Accessing the Event Log from Visual Basic 6.0 Using the .NET Framework

2017-03-14T11:31:00.001-07:00

Visual Studio .NET 2003

Scott Swigart
Swigart Consulting LLC
April 2006
Applies to:
Visual Basic 6.0
.NET Framework
Summary: This article explains how to use .NET Framework classes to add rich event logging functionality to existing Visual Basic 6.0 applications. (6 printed pages)

Contents

Introduction
The .NET Framework EventLog Class
Instrumentation
Reading the Logs
Conclusion
Click here to download the code sample for this article.

Introduction

Visual Basic 6.0 provides some ability to write to the event log through App.LogEvent, but this API has a number of serious limitations. First, you aren't able to define the source for your events (it always appears as VBRuntime in the event viewer), and you can't specify the event ID or category. You're also limited to writing to the Application event log, and you can't create your own custom sources and logs.
By using the classes provided (for free) by the .NET Framework, you can overcome all of these limitations, and effectively instrument your applications so that you, administrators, or other support people can look at the logs to diagnose issues.

The .NET Framework EventLog Class

The .NET Framework provides a powerful EventLog class that makes it trivial to work with the event log. While you can't access this class directly from Visual Basic 6.0, in the spirit of the VB Fusion article series, I've made this functionality accessible from Visual Basic 6.0 by creating a COM wrapper around the .NET classes.
I've also created a sample Visual Basic 6.0 application that exercises this event log functionality (see Figure 1).

Figure 1. Visual Basic 6.0 application that uses event log functionality

Most of the work in creating wrapper classes simply involves converting .NET types to types understood by Visual Basic 6.0. The GetEventLogs method normally returns an array of EventLog objects, and these EventLog objects can't be used directly from Visual Basic 6.0. However, the Visual Basic .NET function shown in Listing 1 returns a list of all the event logs on the machine as an array of strings, which Visual Basic 6.0 can easily consume. Typically, you will have System, Security, and Application event logs, but some applications also create their own custom event logs, and this method will show you those as well.

Listing 1. Listing all the event logs on a machine using Visual Basic .NET

             
                             
    Public Function GetEventLogs() As String()
        Dim logs(EventLog.GetEventLogs.Length - 1) As String
        Dim i As Integer = 0
        For Each el As EventLog In EventLog.GetEventLogs()
            logs(i) = el.Log
            i += 1
        Next
        Return logs
    End Function

As you can see from Listing 1, the EventLog class lets you access all the event logs through the GetEventLogs function. Once this is called, the function just iterates through the results, and it returns all the event log names as an array of strings. This Visual Basic .NET code can then be exposed as a COM object, allowing it to be called from Visual Basic 6.0.
Calling this from Visual Basic 6.0 and, for example, populating a ListBox with the results is as simple as the code in Listing 2.

Listing 2. Displaying log names in a ListBox using Visual Basic 6.0

             
                             
    Dim eventLog As NetFrameworkWrappers.EventLogWrapper
    Set eventLog = New NetFrameworkWrappers.EventLogWrapper

    lstEventLogs.Clear
    
    Dim logs() As String
    logs = eventLog.GetEventLogs
    
    Dim log As Variant
    For Each log In logs
        lstEventLogs.AddItem log
    Next

Instrumentation

You may want your application to write to the event log for a variety of reasons. Certainly, any catastrophic errors should go into the event log, because this information can be used later to diagnose the problem. Quite often, you may want to write detailed information to the event log that would not be appropriate to show to the user.
The first choice is which log to use. You can choose from the System, Security, or Application event logs. The Application event log is almost always the right choice. However, you can also create your own custom event log if you desire. Listing 3 shows the Visual Basic .NET code in the event log wrapper that lets you create your own custom log.

Listing 3. Creating a custom event log using Visual Basic .NET

             
                             
    Public Sub CreateEventSource(ByVal source As String, ByVal logName As String)
        If EventLog.SourceExists(source) Then
            EventLog.DeleteEventSource(source)
        End If
        EventLog.CreateEventSource(source, logName)
    End Sub

As you can see from Listing 3, the .NET Framework makes it easy to create an event log. The .NET CreateEventSource method does all the work for you. This method just exposes that functionality so that it's easy to call it from Visual Basic 6.0 (see Listing 4).

Listing 4. Creating an event log from Visual Basic 6.0 with the wrapper class

             
                             
    Dim eventLog As NetFrameworkWrappers.EventLogWrapper
    Set eventLog = New NetFrameworkWrappers.EventLogWrapper
    eventLog.CreateEventSource "MyApplication", "MyCustomLog"

Writing an entry to the event log is equally simple. The WriteEntry Visual Basic .NET method wraps the event log functionality and exposes it so that it can be called from Visual Basic 6.0 (see Listing 5).

Listing 5. Writing an entry to the event log in Visual Basic .NET

             
                             
    Public Sub WriteEntry(ByVal source As String, _
        ByVal message As String, _
        Optional ByVal type As String = "Information", _
        Optional ByVal eventID As Integer = 0, _
        Optional ByVal category As Short = 0)

        Dim typeEnum As EventLogEntryType = _
            System.Enum.Parse(GetType(EventLogEntryType), type)
        m_eventLog.WriteEntry(source, message, typeEnum, eventID, category)
    End Sub

This wrapper method exposes a number of optional arguments, so when you call it from Visual Basic 6.0, you can pass in just the event log source and message, or also the message type, event ID, and/or category.
You can call this from Visual Basic 6.0 with the code in Listing 6.

Listing 6. Writing an event log entry from Visual Basic 6.0

             
                             
    Dim eventLog As NetFrameworkWrappers.EventLogWrapper
    Set eventLog = New NetFrameworkWrappers.EventLogWrapper
    eventLog.WriteEntry cboLog.Text, txtMessage, cboType.Text, _
        txtID, txtCategory

Reading the Logs

Reading the information out of the event logs is only slightly more complex. The .NET Framework EventLog class has a GetEntries method that will return all the log entries for a give event log (Application, System, and so on). The problem is that each entry comes back as an EventLogEntry object, which can't be passed directly back to Visual Basic 6.0. However, it was simple for me to create my own EventLogEntryInfo class that I could copy each event log entry into. This is a full COM Class that can be returned to Visual Basic 6.0, and it exposes properties for the entry source, message, type, ID, and category. The Visual Basic .NET code then fills an array of these with the event log entry data, and returns it so that it can be used from Visual Basic 6.0 (see Listing 7).

Listing 7. Reading and converting event log entries from Visual Basic .NET

             
                             
    Public Sub GetEntries(ByRef entries() As EventLogEntryInfo)
        ReDim entries(m_eventLog.Entries.Count - 1)

        For i As Integer = 0 To m_eventLog.Entries.Count - 1
            Dim ent As EventLogEntry = m_eventLog.Entries(i)
            entries(i) = New EventLogEntryInfo
            entries(i).Category = ent.CategoryNumber
            entries(i).Message = ent.Message
            entries(i).Source = ent.Source
            entries(i).EventID = ent.InstanceId
            entries(i).EntryType = ent.EntryType
        Next
    End Sub

When this function is completed, Visual Basic 6.0 has full access to the event log entries (see Listing 8).

Listing 8. Getting the Event Log entries from Visual Basic 6.0

             
                             
    Dim eventLog As NetFrameworkWrappers.EventLogWrapper
    Set eventLog = New NetFrameworkWrappers.EventLogWrapper
    eventLog.Init logName

    Dim entries() As NetFrameworkWrappers.EventLogEntryInfo
    eventLog.GetEntries entries

Conclusion

I believe that you don't need to rewrite existing Visual Basic 6.0 applications in order to take advantage of the extensive functionality provided by the .NET framework. As the Visual Basic Fusion articles show, with simple wrapper classes, you can expose the functionality of the .NET Framework as COM objects, which can be used from Visual Basic 6.0, VBA, ASP, or any environment that can access COM objects. In this article, you saw how you could add rich event logging functionality to existing Visual Basic 6.0 applications. Feel free to download the associated sample code to add event logging to your applications today.

Environmental Awareness: Accessing Operating System Information, Special Folders, and More with Visual Basic 6 and the .NET Framework

2017-03-14T11:29:00.000-07:00

Visual Studio .NET 2003

Scott Swigart
Swigart Consulting LLC
April 2006
Applies to:
Visual Basic 6
.NET Framework
Summary: This article explains how you can use Visual Basic 6 with the .NET Framework to access user and operating system information that normally would require Win32 API calls. (8 printed pages)

Introduction
Spin the Wheel of Win32
Welcome to System.Environment
Wrapping It Up
All Boxed Up
Additional Resources
Click here to download the code sample for this article.

Introduction

There's a lot of user and operating system information that's typically been difficult to get to from Visual Basic 6; however, with a few trivial calls into the .NET Framework, this information is easy to retrieve.
Figure 1 illustrates the retrieval of user and operating system information from Visual Basic 6 with the .NET Framework.

Figure 1. Retrieving user and operating system information

You can see that this application retrieves the domain name, user name, and machine name. It also retrieves the string for the operating system version, letting you know what OS your code is running on. The logical drives are enumerated, and the IP addresses assigned to this machine are also listed—in this case, showing the physical and wireless IP addresses.
In addition, the application is able to retrieve the location for any of the special folders, which include:

Desktop
Programs
Personal
Favorites
StartUp
Recent
SendTo
StartMenu
MyMusic
DesktopDirectory
MyComputer
Templates
ApplicationData
LocalApplicationData
InternetCache
Cookies
History
CommonApplicationData
System
ProgramFiles
MyPictures
CommonProgramFiles

Spin the Wheel of Win32

To do this with 100% Visual Basic 6 would have required a lot of calls into the Win32 API, and all the goo that Win32 API calls entail. You would have to correctly create your Declare statements, craft structures that match what the API functions need, create buffers to hold strings, and so on. Not to mention that there are a number of API functions that do similar things, some of which are available on one operating system, but not others.

Welcome to System.Environment

The .NET Framework Class Library (FCL) organizes access to much of this system information under the System.Enviornment class. Tables 1 and 2 present a quick overview of this class, showing that it can provide a lot of information about the machine, user, and application environment.

Table 1. System.Environment properties

System.Environment Property	Description	Visual Basic 6 Equivalent
CommandLine	Gets the command line for this process.	Command function
CurrentDirectory	Gets and sets the fully qualified path of the current directory—that is, the directory from which this process starts.	App.Path
ExitCode	Gets or sets the exit code of the process.	No equivalent
HasShutdownStarted	Indicates whether the common language runtime is shutting down, or whether the current application domain is unloading.	Win32 API
MachineName	Gets the NetBIOS name of this local computer.	Win32 API
NewLine	Gets the newline string defined for this environment.	No equivalent
OSVersion	Gets an OperatingSystem object that contains the current platform identifier and version number.	Win32 API
StackTrace	Gets current stack trace information.	No equivalent
SystemDirectory	Gets the fully qualified path of the system directory.	Win32 API
TickCount	Gets the number of milliseconds that have elapsed since the system started.	Win32 API
UserDomainName	Gets the network domain name associated with the current user.	Win32 API
UserInteractive	Gets a value indicating whether the current process is running in user interactive mode.	Win32 API
UserName	Gets the user name of the person who started the current thread.	Win32 API
Version	Gets a Version object that describes the major, minor, build, and revision numbers of the common language runtime.	Win32 API
WorkingSet	Gets the amount of physical memory mapped to the process context.	Win32 API

Table 2. System.Environment methods

System.Environment Method	Description	Visual Basic 6 Equivalent
Exit	Terminates this process and gives the underlying operating system the specified exit code.	End or Win32 API
ExpandEnvironmentVariables	Replaces the name of each environment variable embedded in the specified string with the string equivalent of the value of the variable, and then returns the resulting string.	Environ function and custom code
GetCommandLineArgs	Returns a string array containing the command-line arguments for the current process.	Command function
GetEnvironmentVariable	Returns the value of the specified environment variable.	Environ function
GetEnvironmentVariables	Returns all environment variables and their values.	Environ function
GetFolderPath	Gets the path to the system special folder identified by the specified enumeration.	Win32 API
GetLogicalDrives	Returns an array of strings containing the names of the logical drives on the current computer.	Win32 API

As you can see from Tables 1 and 2, the System.Environment class provides a lot of information that isn't readily accessible from Visual Basic 6. To use the System.Environment class, you can create a simple COM wrapper class in Visual Basic .NET. Once the COM wrapper is created, you can use the System.Environment class from Visual Basic 6, VBA, ASP, VBScript, or any other environment that can use COM objects.

Wrapping It Up

To create a wrapper for the System.Environment class, you can just create a new Class Library project in Visual Studio .NET 2003, and add a COM Class to your project (see Figure 2).

Figure 2. Adding a COM Class to your project

You then simply create functions that call into the System.Environment methods and properties, and return the results (see Listing 1). In many cases, this involves just one line of code.

Listing 1. Returning System.Environment information from Visual Basic .NET

             
                             
    Public Function GetLogicalDrives() As String()
        Return System.Environment.GetLogicalDrives()
    End Function

    Public Function GetMachineName() As String
        Return System.Environment.MachineName
    End Function

    Public Function GetOSVersion() As String
        Return System.Environment.OSVersion.ToString()
    End Function

    Public Function GetDomainName() As String
        Return System.Environment.UserDomainName()
    End Function

    Public Function GetUserName() As String
        Return System.Environment.UserName
    End Function

These functions can then be called from Visual Basic 6 to get the information (see Listing 2).

Listing 2. Accessing System.Environment from Visual Basic 6

             
                             
    Set env = New NetFrameworkWrappers.EnvironmentWrapper
    txtDomainName = env.GetDomainName
    txtUserName = env.GetUserName
    txtMachineName = env.GetMachineName
    txtOsVersion = env.GetOSVersion

To get the directory for special folders, you need to specify which folder you're interested in. .NET provides an enumeration of all the possible folders, and this list can easily be provided to Visual Basic 6 as an array of strings (see Listing 3).

Listing 3. Returning the list of special folders from Visual Basic .NET

             
                             
    Public Function ValidFolderPaths() As String()
        Return System.Enum.GetNames(GetType(SpecialFolder))
    End Function

This returns an array of strings with the identifiers for all the special folders. You can then pass in the ID of the special folder to get its directory location (see Listing 4).

Listing 4. Visual Basic .NET function that returns the directory location for a special folder

             
                             
    Public Function GetFolderPath(ByVal specialName As String) As String
        Dim sf As SpecialFolder
        sf = System.Enum.Parse(GetType(SpecialFolder), specialName)
        Return System.Environment.GetFolderPath(sf)
    End Function

From Visual Basic 6, you can just call this function, pass in any special folder ID string, and get the location (see Listing 5).

Listing 5. Retrieving a special folder location from Visual Basic 6

             
    Set env = New NetFrameworkWrappers.EnvironmentWrapper
    txtMyPictures = env.GetFolderPath("MyPictures")

Information about the current system IP addresses isn't actually provided through System.Environment, but to me, it's part of the same theme. For this, I actually use classes in the System.Network namespace (see Listing 6).

Listing 6. Returning IP Addresses from Visual Basic .NET

             
                             
    Public Function GetIpAddresses() As String()
        Dim h As System.Net.IPHostEntry = _
            System.Net.Dns.GetHostEntry(System.Net.Dns.GetHostName)
        Dim addresses(h.AddressList.Length - 1) As String
        For i As Integer = 0 To h.AddressList.Length - 1
            addresses(i) = h.AddressList(i).ToString()
        Next
        Return addresses
    End Function

This function first gets the host name for the computer using the Dns class. Then, it retrieves the IP addresses for that host name. The information is returned as an array of strings.

All Boxed Up

As a convenience, I've already created the wrapper class for System.Environment. The code for the wrapper, and the test application illustrated in Figure 1 are ready for you to download and experiment with. To install the COM wrapper, just execute install.bat, which is located in the download zip file. You can then find the Visual Basic 6 application in the VB6 Projects\Environment folder. The full .NET wrapper solution is available in the VB.NET Wrappers folder.
The theme of Visual Basic Fusion is that you can use everything that .NET offers from non-.NET environments such as Visual Basic 6, VBA, ASP, or VBScript. In this article, you've seen how you can access information that normally would have required Win32 API calls, with just a tiny bit of .NET code.

Implementing File Compression and Encryption in Visual Basic 6 Using the Microsoft .NET Framework, Part II: Compression

2017-03-14T11:26:00.003-07:00

Visual Studio .NET 2003

Scott Swigart
Swigart Consulting LLC.
February 2006
Applies to:
   Microsoft Visual Basic 6
   Microsoft Visual Basic .NET 2003
   Microsoft Visual Basic 2005
   Microsoft Visual Studio .NET 2003
   Microsoft Visual Studio 2005
Summary: In this two-part article series, you'll see how you can easily add encryption and data compression (ZIP) capabilities to existing Visual Basic 6 applications using the .NET Framework. While encryption and compression may not seem like related technologies, if you think about it, each one takes a set of data and performs a transformation on it. In the case of encryption, the data is made unreadable, and with compression, the data is made smaller. You'll also see that both utilize many of the same underlying technologies. (8 printed pages)
Click here to download the code sample for this article.

Introduction
Compression
Zipping Files and Folders
Running the Sample
Conclusion

Introduction

So far, in the Visual Basic Fusion article series, you've been exposed to a significant amount of functionality provided by the Microsoft .NET Framework, but you should also know that there is an enormous amount of high quality open-source code that is also easy to use from your Visual Basic 6 applications. By creating very lightweight wrappers, you can expose functionality in open-source and third party libraries—originally developed for use in .NET applications—to extend your Visual Basic 6 applications. Sites like www.sourceforge.net and www.gotdotnet.com contain literally thousands of open-source projects, providing an extremely broad range of additional functionality. Just a few examples include libraries for RS232 (serial port) communication, working with RSS feeds, working with images and media files, network libraries, FTP libraries, file replication, and thousands of other libraries.
This article will look at utilizing one such open-source library for file compression. SharpZipLib is an open-source project that provides compression (ZIP) functionality. Version 2.0 of the .NET Framework also contains some support for file compression, but SharpZipLib affords more compression options, and makes it easier to create zip archives of whole folders. You can freely include this library even in close-source, for-sale software if you desire.
Before digging into the details of using SharpZipLib, it's worth comparing how .NET file I/O differs from Visual Basic 6 file I/O. As a quick review, Visual Basic 6 uses keywords to control file input and output.

Example 1. Reading for a file with Visual Basic 6

             
                             
Dim dataIn As String
Open someFileName For Input As #1
Do Until Eof(1)
    Line Input #1, dataIn
    Debug.Print dataIn
Loop
Close #1

In Visual Basic .NET, you would instead use some specific classes in the .NET Framework to perform File I/O operations.

Example 2. Visual Basic .NET File IO

             
                             
Dim dataIn As String
Dim sw As New StreamWriter("C:\log.txt")
sw.WriteLine("This is a test")
sw.Close()

With Visual Basic 6, you have to manage file handles, and you have to know the associated language keywords needed to work with that file handle. With Visual Basic .NET, the StreamWriter class wraps up all the functionality associated with files. You don't need to manage the file handles, and the file operations are more discoverable, because you have IntelliSense that will show you all the operations (WriteLine and others) available when working with files.
But the real advantage of these objects (also known as streams) is that they let you stack file I/O functionality. In the first article, you saw how encryption was supported by just adding a CryptoStream to the stack of I/O streams.

Example 3. Stacking streams to enable encryption with Visual Basic .NET

             
                             
fs = New FileStream(fileName, FileMode.Create, FileAccess.Write)
cs = New CryptoStream(fs, rc2.CreateEncryptor(), CryptoStreamMode.Write)
sw = New StreamWriter(cs)

So anything written to the StreamWriter is then sent through the CyrptoStream, where it is encrypted, and then sent to the FileStream where it is written to disk.

Compression

Compression works exactly the same way.

Example 4. Stacking streams to enable compression with Visual Basic .NET

             
                             
Dim fs = New FileStream(fileName, FileMode.Create, FileAccess.Write)
zs = New GZipOutputStream(fs)
sw = New StreamWriter(zs)

As you can see, compression composes with File IO exactly the same way as encryption, which makes sense. Both encryption and compression are really just a transformation of the data. With encryption, the data is transformed to a format that's not readable without a key. With compression, the data is transformed so that it requires fewer bytes to represent the same data.
The entire .NET class that enables you to write out information to a compressed file is as follows.

Example 5. Entire Visual Basic .NET class needed to allow you to write to a compressed file

             
                             
Public Class GZipFileWriterWrapper
    Private fs As FileStream
    Private zs As GZipOutputStream
    Private sw As StreamWriter

    Public Sub Open(ByVal fileName As String)
        fs = New FileStream(fileName, FileMode.Create, FileAccess.Write)
        zs = New GZipOutputStream(fs)
        sw = New StreamWriter(zs)
    End Sub

    Public Sub WriteLine(ByVal value As String)
        sw.WriteLine(value)
    End Sub

    Public Sub Write(ByVal value As String)
        sw.Write(value)
    End Sub

    Public Sub WriteBytes(ByRef bytes() As Byte)
        zs.Write(bytes, 0, bytes.Length)
    End Sub

    Public Sub Close()
        On Error Resume Next
        If Not sw Is Nothing Then sw.Close()
        If Not zs Is Nothing Then zs.Close()
        If Not fs Is Nothing Then fs.Close()
    End Sub
End Class

Now it's time to use this from a Visual Basic 6 application, to write information out to a compressed file. With this wrapper in place, the Visual Basic 6 code is trivial.

Example 6. Visual Basic 6 code to write to a compressed file

             
                             
Dim e As wrappers.GZipFileWriterWrapper
Set e = New wrappers.GZipFileWriterWrapper
    
e.Open "c:\file.gzip"
e.WriteLine (txtMessage)
e.Close
    
txtMessage = ""
MsgBox "Compressed and Saved"

You can see that you simply use the wrapper to open the file, write as much as you want to it, and then close it when you're done. If you try to just open the disk file with something like Notepad, you can see that it has been written in a binary compressed format.

Figure 1. Examining the compressed file

However, using a Visual Basic 6 application, you can easily use the wrapper to read the compressed information back in.

Example 7. Reading the compressed file with Visual Basic 6

             
                             
e.Open "c:\file.gzip"
While Not e.EOF
    txtMessage = txtMessage & e.ReadLine & vbCrLf
    ' Could also just use e.ReadToEnd to read
    ' the entire file.
Wend
e.Close

Zipping Files and Folders

The kind of compression shown so far lets you compress information before placing it into a file. However, it's common to want to create a zip archive, where you have a zip file that contains one or more disk files. This functionality is provided with the following wrapper around the SharpZipLib.

Example 8. Visual Basic .NET wrapper to create a Zip archive

             
                             
Public Sub ZipFile(ByVal source As String, ByVal dest As String)

    Dim entry As New ZipEntry(Path.GetFileName(source))
    Dim fi As New FileInfo(source)
    entry.ExternalFileAttributes = fi.Attributes
    entry.Size = fi.Length

    Dim input As FileStream = File.OpenRead(source)
    Dim output As New ZipOutputStream(File.Create(dest))

    output.PutNextEntry(entry)

    Dim buffer(8191) As Byte
    Dim len As Integer
    Do
        len = input.Read(buffer, 0, buffer.Length)
        If len > 0 Then
            output.Write(buffer, 0, len)
        End If
    Loop Until len = 0
    output.Close()
    input.Close()
End Sub

Here, the ZipEntry class is used to write information about the file that will be added to the archive. Once the ZipEntry is written to the ZipOutputStream, the actual file contents are written. The result is a zip archive that can be opened using WinZip, or the zip functionality built into Windows XP. Now that the wrapper is built, zipping a file from Visual Basic 6 is as simple as the following.

Example 9. Zipping a file from Visual Basic 6

             
                             
CommonDialog1.ShowOpen
Dim source As String
source = CommonDialog1.FileName
    
Dim e As wrappers.FileZipWrapper
Set e = New wrappers.FileZipWrapper
e.ZipFile source, source & ".zip"

This prompts the user for a file to zip, and then uses the wrapper to zip the file. The result is a zip archive that is readable by Windows XP or other zip readers.

Figure 2. Zipping a single file

Finally, you may want to zip an entire folder, and a wrapper is provided for that, as well.

Example 10. Visual Basic 6 code to zip and entire folder structure

             
Dim e As wrappers.FileZipWrapper
Set e = New wrappers.FileZipWrapper
    
e.ZipFolder App.Path, App.Path & "\..\file.zip"

Running the Sample

In part I of this article series, we created a sample that would let you exercise the encryption functionality. I've modified that sample to instead use the compression wrappers provided here. To use the sample:

Download and install the .NET Framework 2.0 Software Development Kit (if you have Visual Studio .NET 2005 or Visual Basic Express installed, you can skip this step).
Download the code associated with this article.
Execute the "Install.bat" file included with the code for this article. This registers the encryption component so that you can use it from your Visual Basic 6 application.
In the code for this article, open the Visual Basic 6 project in the "Compression" folder.
Press F5 to run the sample application:

Figure 3. Form 1
When you click Compress, the text in the textbox will be written to a file using the GZip compression algorithm. When you click Decompress, the contents will be decrypted and displayed.
Clicking Zip File will prompt you to choose a file, and will create a zip archive that contains the file. Clicking Unzip will extract the file from the archive.
Finally, Clicking Zip Folder will compress the contents of an entire folder.

To use this functionality from your own application, just run "Install.bat" and then add a reference to "wrappers.dll."

Conclusion

The Microsoft .NET Framework includes extensive functionality for many scenarios, but the open-source community has contributed a staggering amount of additional functionality that can be wrapped and used just as easily from Visual Basic 6. To some degree, this is nothing new. Visual Basic 6 has always enjoyed a large community that has been generous about providing code samples. Sometimes these have been snippets, and sometimes they have been full libraries. However, with Visual Basic 6, you were limited to code developed and shared by other Visual Basic 6 developers. With .NET, both Visual Basic .NET and C# developers can contribute code that your application can use (SharpZipLib was written in C#, but that doesn't make it any more difficult to wrap and use from Visual Basic 6 than if it was written in Visual Basic .NET). In addition, a tremendous number of libraries originally written in C++ and Java have been ported to .NET. This means that you have, at your disposal, thousands of additional libraries, many ported from libraries that have been developed, enhanced, and used in production applications for many years.
As the VB Fusion article series has shown, you can leverage everything that .NET provides while preserving your existing investment in Visual Basic 6 code. As this article specifically has shown, you're by no means limited to just the .NET framework and libraries provided by Microsoft. The thriving .NET community is at your disposal.

About the author Scott Swigart (www.swigartconsulting.net) spends his time consulting, authoring, and speaking about emerging and converging technologies. Scott has worked with a wide range of technologies over his career, beginning with Commodore 64 programming at the age of 12, writing hardware diagnostics for UNIX systems in C++, and building windows desktop, and Web applications. Over the years, Scott has worked with component development, XML technologies, .NET, Web service, and other languages, platforms, and paradigms. With this experience, Scott has seen how technology evolves over time, and is focused on helping organizations get the most out of the technology of today, while preparing for the technology of tomorrow. Scott is also a Microsoft MVP, and co-author of numerous books and articles. Scott can be reached at Scott Swigart.

Implementing File Compression and Encryption in Visual Basic 6 Using the Microsoft .NET Framework, Part I: Cryptography

2017-03-14T11:24:00.002-07:00

Visual Studio .NET 2003

Scott Swigart
Swigart Consulting LLC.
February 2006
Applies to:
   Microsoft Visual Basic 6
   Microsoft Visual Basic .NET 2003
   Microsoft Visual Basic 2005
   Microsoft Visual Studio .NET 2003
   Microsoft Visual Studio 2005
Summary: In this two-part article series, you'll see how you can easily add encryption and data compression (ZIP) capabilities to existing Visual Basic 6 applications using the .NET Framework. While encryption and compression may not seem like related technologies, if you think about it, each one takes a set of data and performs a transformation on it. In the case of encryption, the data is made unreadable, and with compression, the data is made smaller. You'll also see that both utilize many of the same underlying technologies. (6 printed pages)
Click here to download the code sample for this article.

Prerequisites
Introduction
Visual Basic .NET File IO Primer
Visual Basic 6 Cryptography
Conclusion

Prerequisites

To use the code in this article, you will need to install Visual Studio 2005, or the free Visual Basic Express. These products can be installed along side of Visual Studio 6.0, Visual Studio .NET, and/or Visual Studio 2003, without impacting those products.

Introduction

I have a secret, and I don't want you to know it. Actually, I have an application, and I want it to be able to store information in an encrypted format so that it can't be read by unauthorized users. Visual Basic 6 does not have any built-in functionality to perform encryption or decryption of data, but the Microsoft .NET Framework does have strong encryption built it. In this article, I provide a Visual Basic .NET component that provides encryption and decryption functionality, and you can very easily use this component from Visual Basic 6, ASP, or any other COM environment.
First, it's worth reviewing how Visual Basic 6 lets you work with files. Visual Basic 6 provides a number of language keywords for file I/O.
Example 1. Reading for a file with Visual Basic 6

             
                             
Dim dataIn As String
Open someFileName For Input As #1
Do Until Eof(1)
    Line Input #1, dataIn
    Debug.Print dataIn
Loop
Close #1

With Visual Basic 6, you do all your operations on a file handle (#1 in this case), and it's up to you to manage this file handle. There isn't a single object that encapsulates the file operations; instead, there are a number of keywords (Open, Close, Input, and so on). If you do want to do encryption and decryption with Visual Basic 6, you would have to read all the data into memory, encrypt all of it using some third party component (generating what's known as "cipher text"), and then send all the cipher text to the output file. It would be nice if you could stream the information through your program, but this would not be easy to do.
To facilitate really easy encryption from Visual Basic 6, I've created an excryption/decryption component. Next you'll see how this component was implemented, but it's worth mentioning that you don't need to understand any of the implementation details to actually use the component. If you just want to use the component without digging into how it works, just skip ahead to Visual Basic 6 Cryptography.

Visual Basic .NET File IO Primer

Before jumping into encryption, it's important to understand how Visual Basic .NET deals with file IO. The Microsoft .NET Framework uses something known as "streams" when working with files, as shown here.
Example 2. Visual Basic .NET File IO

             
                             
Dim sw As New StreamWriter("C:\log.txt")
sw.WriteLine("This is a test")
sw.Close()

You can see that Visual Basic .NET provides classes specifically for reading and writing from files (and other IO devices). In this case, the code uses the StreamWriter class to write lines of text to a file. The StreamWriter object is a nice convenience, as you don't have to keep track of a file handle, and all the operations for working with a file show up in Intellisense. In addition to the StreamWriter class, there are also these classes:

Table 1. Classes available in Visual Basic .NET

Class name	Function
FileStream	Reading and writing from a binary file.
NetworkStream	Reading and writing from a network.
MemoryStream	Reading and writing from memory as though it were a file.

In actuality, the StreamWriter in our code sample is internally using a FileStream object to write information to the disk. The FileStream lets you create, open, and append to disk files, and open them for reading and writing. However, the FileStream wants to read and write blocks of data—arrays of bytes—to and from files. When working with text, you typically want to work with lines, not 1024 byte blocks, so the StreamWriter stacks on top of the FileStream to provide the WriteLine functionality. You could also stack the StreamWriter or StreamReader on top of a NetworkStream or MemoryStream so that you could WriteLine or ReadLine from those devices as well.
This is really the strength of streams. You can stack one stream on top of another to plug in additional functionality. In fact, this is how encryption works in Visual Basic .NET. The CryptoStream is added to the stack, and all the data that passes through it is encrypted or decrypted:
Example 3. Stacking streams to enable encryption with Visual Basic.NET

             
                             
fs = New FileStream(fileName, FileMode.Create, FileAccess.Write)
cs = New CryptoStream(fs, rc2.CreateEncryptor(), CryptoStreamMode.Write)
sw = New StreamWriter(cs)

Here, a FileStream class is created to enable writing to a specific disk file. A CryptoStream is stacked on top of the FileStream so that information is encrypted before it's sent to the FileStream. The StreamWriter is then stacked on top of the CryptoStream so that you have convenient WriteLine functionality, rather than having to work with fixed length blocks of data.
The CryptoStream is what does the magic of encryption. It supports many encryption algorithms, and so it needs to be configured with some initial information before it's used. For this component, the RC2 encryption algorithm was used, as it provides strong, fast encryption. However, if you want to use DES, Triple-DES, or Rijndael encryption, this code can be modified to use those instead.
Example 4. Configuring RC2 Encryption with Visual Basic.NET

             
Dim rc2 As New RC2CryptoServiceProvider
rc2.IV = IV

Dim pdb As New PasswordDeriveBytes(password, Nothing)
rc2.Key = pdb.CryptDeriveKey("RC2", "SHA1", 128, IV)

Symmetric cryptography is based on using a secret key to encrypt the information. In this case, the key will be supplied to this algorithm in the form of a password. From the password, a cryptographic key is derived using the PasswordDeriveBytes class. For additional security, an initialization vector can be used (IV). An IV is used to insure that, if a document contains identical sections of plain text, the document doesn't encrypt to identical cipher text. This also makes the key more secure if multiple files are encrypted using the same key. When you use this component, specifying an IV is optional.

Visual Basic 6 Cryptography

Again, while the basics of cryptography are being covered here, you don't need to know anything about .NET or cryptography to use this component. From Visual Basic 6, using this component is as simple as this.
Example 5. Using the cryptography component from Visual Basic 6

             
                             
Dim e As wrappers.EncryptedFileWriterWrapper
Set e = New wrappers.EncryptedFileWriterWrapper
    
e.Open "c:\file.bin", txtPassword, False, ""
e.WriteLine (txtMessage)
e.Close

You can see that once the EncryptedFileWriterWrapper has been created, it's trivial to use. You just create an instance of it, give it a file name and password, and start writing data. The data will be encrypted and written to the file.

Figure 1. Attempting to view encrypted data with Notepad

Reading and decrypting the data is equally simple.
Example 6. Reading and decrypting data using Visual Basic 6

             
                             
Dim e As wrappers.EncryptedFileReaderWrapper
Set e = New EncryptedFileReaderWrapper

e.Open "c:\file.bin", txtPassword, ""
While Not e.EOF
    txtMessage = txtMessage & e.ReadLine & vbCrLf
Wend
e.Close

Again, you just specify a file name and password, and start reading. The data is decrypted by the component and returned as simple text.
For your convenience, I've put together a Visual Basic 6 application that uses the component to perform encryption and decryption. To use this component, you may need to do a couple of things.

Download and install the Microsoft .NET Framework SDK 2.0 (if you have Visual Studio .NET 2005 or Visual Basic Express installed, you can skip this step).
Download the code associated with this article.
Execute the "Install.bat" file included with the code for this article. This registers the encryption component so that you can use it from your Visual Basic 6 application.
In the code for this article, open the Visual Basic 6 project in the "Encryption" folder.
Press F5 to run the sample application:

Figure 2. Sample application for encryption and decryption

Enter any string for the password and click Save. The text is saved to "c:\file.bin." If you open this file in Notepad, you will see that it's encrypted. The textbox is also cleared.
If you click on Load, the information will be retrieved, decrypted, and displayed in the text box. If you change the password so that it doesn't match the password that the text was saved with, you will see that the file is not decrypted.

Conclusion

Visual Basic 6 doesn't provide built in encryption and decryption functionality, but the Microsoft .NET Framework does. As with everything in the .NET Framework, it is relatively simple to expose that functionality so that it can be used from a Visual Basic 6 application. This article provides you with a pre-packaged solution to add encryption and decryption functionality to your Visual Basic 6 application with just a few lines of code. Enjoy.

About the author Scott Swigart (www.swigartconsulting.net) spends his time consulting, authoring, and speaking about emerging and converging technologies. Scott has worked with a wide range of technologies over his career, beginning with Commodore 64 programming at the age of 12, writing hardware diagnostics for UNIX systems in C++, and building windows desktop, and Web applications. Over the years, Scott has worked with component development, XML technologies, .NET, Web service, and other languages, platforms, and paradigms. With this experience, Scott has seen how technology evolves over time, and is focused on helping organizations get the most out of the technology of today, while preparing for the technology of tomorrow. Scott is also a Microsoft MVP, and co-author of numerous books and articles. Scott can be reached at Scott Swigart.

Using Background Threads with Visual Basic 6

2017-03-14T11:22:00.002-07:00

Visual Studio .NET 2003

Scott Swigart
Swigart Consulting LLC.
March 2006
Applies to:
   Microsoft Visual Basic 6
   Microsoft Visual Basic 2005
   Microsoft Visual Studio 2005
Summary: Learn how to use the .NET Framework 2.0 BackgroundWorker component from Visual Basic 6 applications to perform long running operations on background threads. This article shows you how to inform the user of progress, how to allow the user to cancel the background task, and how to debug multi-threaded applications. (10 printed pages)
Click here to download the code sample for this article.

Overview
Getting Started with the Article Sample Code
Using the BackgroundWorker
Canceling Background Tasks
Implementing Progress Notifications
Debugging Considerations
Conclusion

Overview

Applications can stop responding during long running operations, resulting in dissatisfied users. The traditional Visual Basic 6 technique to keep the application responding during a long running operation is to call DoEvents repeatedly. This allows the application to respond to events, and prevents the impression that the application has locked up. To provide a smooth user experience, DoEvents must be called several times a second. Sometimes, this simply isn't possible. If you execute a long running SQL statement, or are blocked waiting on an external resource, you do not have the ability to call DoEvents throughout the operation, and so the application appears to hang.
An advanced programming technique for handling long running operations is to perform the operation on a background thread. However, Visual Basic 6 does not support developing multi-threaded applications, and does not provide any built-in mechanism for starting background threads. However, Visual Basic .NET does support multi-threaded development, and Visual Studio 2005 includes a BackgroundWorker component that makes it easy to put operations on a background thread. This lets your application remain responsive while the operation progresses.
Normally, the BackgroundWorker component would only be available to .NET applications. However, this article includes a COM wrapper for the BackgroundWorker component so that it can be used seamlessly from COM environments, such as Visual Basic 6.

Getting Started with the Article Sample Code

Included in this article is a sample application that performs work in a background thread. To start using the sample, download and extract the code, and navigate into the "VS 2005 NetFX20Wrapper" folder. Open the solution file (.sln) with Visual Studio 2005. If you do not have Visual Studio 2005, you can download the free Visual Basic Express from http://lab.msdn.microsoft.com/express/vbasic/default.aspx, and use it instead. In fact, Visual Basic Express is a great way to try out many of the features of Visual Studio 2005, with no cost.
Once you have the solution open, select the Build | Build Solution menu command to compile the Visual Basic .NET wrapper that makes the BackgroundWorker component available as a COM object. You can then navigate to the "VB6 Application" folder and open the Visual Basic 6 sample application. When you run the application, it will perform a long running operation in the background, displaying the progress as the operation executes:

Figure 1. Sample application performing a long running operation

The application also gives you the ability to cancel the background operation. Next you will see how you can use the BackgroundWorker component from your own applications.

Using the BackgroundWorker

As the following walk-through will show, you can reference the BackgroundWorker component as though it were any simple COM object. BackgroundWorker exposes functions that let you start and stop the background operation. BackgroundWorker also exposes events to let you know how the work is progressing, and when it has completed.
Walkthrough: Setting up background work

Open Visual Basic 6.0.
In the New Project dialog, select Standard EXE, and click Open.
Select the Project | References menu command.
Check NetFx20Wrapper, and click OK. This adds a reference to the wrapper for the BackgroundWorker component, allowing you to use BackgroundWorker from Visual Basic 6.
Select the Project | Add Module menu command.
In the Add Module dialog, click Open.

In the Code Editor, insert the following code:

             
                             
Private Declare Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As Long)
Public backgroundWorker As NetFX20Wrapper.BackgroundWorkerWrapper

Public Sub BackgroundWork(ByRef argument As Variant, _
    ByRef e As NetFX20Wrapper.RunWorkerCompletedEventArgsWrapper)
On Error GoTo eh
    Sleep argument
    e.SetResult "Background work done"
    Exit Sub
    
eh:
    e.Error.Number = Err.Number
    e.Error.Description = Err.Description
End Sub

The BackgroundWorker component will be used to run this subroutine on a background thread. The subroutine simply sleeps for a specified number of milliseconds and returns, to simulate a long running operation. This subroutine is also passed a RunWorkerCompletedEventArgsWrapper argument. This argument lets the subroutine indicate whether it was successful or not, and returns a result. If the subroutine completes without error, it will use e.Result to pass a return value back to the main thread. If it fails, the error handler will set error information that is passed back to the main thread. It is critical that the background thread does not have any unhandled errors. If any errors go unhandled in the background thread, the application will crash. For this reason, you always must set up an On Error Goto in your background subroutine, and use e.Error to return error information.
Walkthrough: Starting the background work

In the Project Explorer, double-click Form1.
Add a button to the form and set its caption to Start.
Double-click the button to create the event handler.
Replace the code in the code editor with the following:
Dim WithEvents background As NetFX20Wrapper.BackgroundWorkerWrapper

Private Sub Form_Load()
Set background = New NetFX20Wrapper.BackgroundWorkerWrapper
End Sub

Private Sub Command1_Click()
set module1.backgroundWorker = background
background.RunWorkerAsync AddressOf BackgroundWork, 5000
End Sub
This creates an instance of the BackgroundWorker component. When the button is clicked, BackgroundWorker is used to start the BackgroundWork subroutine (created in the previous walkthrough) on a background thread. Also notice that an argument of 5000 will be passed to the subroutine. This is used inside of the subroutine to determine the number of milliseconds to sleep.
In the Object drop-down menu, select background. In the Procedure drop-down menu, select RunWorkerCompleted. This will create an event handler that fires when the background work has finished.

Figure 2. Create the event handler here

Code the RunWorkerCompleted event handler as follows:

             
                             
Private Sub background_RunWorkerCompleted(ByVal sender As Variant, _
    ByVal e As NetFX20Wrapper.RunWorkerCompletedEventArgsWrapper)
    
    If e.Error.Number = 0 Then
        MsgBox e.GetResult
    Else
        MsgBox e.Error.Description
    End If
End Sub

This will check to see if the background work completed without error. If so, the return value from the background work will be displayed. Otherwise, an error message will be displayed.

Select the Tools | Options menu command.
Select the Environment tab.
In the When a program starts group box, select Save Changes.
Click OK. It's very important to save changes every time the application runs. If errors happen in the background subroutine, it can crash the development environment. If you don't save changes, this can result in a loss of work.
Press F5.
Select a folder to save all project files.
The application starts:

Figure 3. Application with Start button to begin the background operation
Click the Start button. This starts the background operation, which will run for 5 seconds.
Drag the form around to prove that the application is not blocked while the background subroutine is running.
After five seconds, a message box is displayed indicating that the background subroutine completed. The message box contains a string returned from the background subroutine.

Figure 4. Background work completed message box
Click OK, and close the application.

Canceling Background Tasks

With the BackgroundWorker, you can also request that the background subroutine abort. I say request, because your background subroutine must periodically poll a property to see if a cancellation has been requested, and abort if so. In the walkthrough shown previously, the background subroutine calls Sleep, and the background subroutine isn't able to do anything else until Sleep returns, five seconds later. For this reason, the background subroutine would not be able to abort if a cancel request was sent, because it would not be able to process that cancel request until it was already finished processing.
For a background thread to be able to respond to a cancel request, it must be doing its work in discrete chunks, with the ability to check for a cancellation request between chunks. If you're making a call to a long running stored procedure, or otherwise waiting on an external resource, then the BackgroundWorker component is still very useful, as it allows you to put that operation in the background and keep the application responsive, but you will not be able to give the user the option to abort the operation once it begins.
For the purposes of demonstration, the background work in the walkthrough can be broken into smaller chunks so that you can see how cancel functionality is implemented.
Walkthrough: Canceling background operations

In the Project Explorer, double-click Module1.

Modify the BackgroundWork subroutine as follows:

             
                             
Public Sub BackgroundWork(ByRef argument As Variant, _
    ByRef e As NetFX20Wrapper.RunWorkerCompletedEventArgsWrapper)
On Error GoTo eh
    For i = 1 To argument / 500
        Sleep 500
        If backgroundWorker.CancellationPending Then
            e.SetResult "Cancelled after " & i * 500 & " ms"
            e.Cancelled = True
            Exit Sub
        End If
    Next
    e.SetResult "Background work done"
    Exit Sub
    
eh:
    e.Error.Number = Err.Number
    e.Error.Description = Err.Description
End Sub

This code has been modified so that the work is broken into 500 millisecond chunks. After each 500 millisecond unit of work the code checks the CancellationPending property of the BackgroundWorker component. If CancellationPending is true, then the routine sets the Cancelled property to true. This will let the main thread determine if the background work ran to completion, or if it was successfully cancelled. The background subroutine also sets the result message, and then exits.

In the Project Explorer, double-click Form1.
Add another button to the form, and set its caption to Cancel.
Double-click the button to create its Click event handler.

Code the Click event handler as follows:

             
                             
Private Sub Command2_Click()
    background.CancelAsync
End Sub

In the Project Explorer, right-click Form1, and select View Code.

Modify background_RunWorkerCompleted as follows:

             
                             
    If e.Cancelled Then
        MsgBox "Cancelled: " & e.GetResult
    ElseIf e.Error.Number = 0 Then
        MsgBox e.GetResult
    Else
        MsgBox e.Error.Description
    End If

This routine can now check the Cancelled property to see if the background subroutine ran to completion, or was cancelled prematurely.

Press F5 to run the application.
Click the Start button, and then click the Cancel button. You should see a message like the following:

Figure 5. Message box indicating cancellation of the background task
Click OK, and close the application.

Implementing Progress Notifications

The BackgroundWorker component also provides facilities so that the background subroutine can send progress events to the main thread. This is useful if you want to display a progress bar while the background subroutine runs.
Walkthrough: Adding progress support

In the Project Explorer, double-click Module1.

Add a call to BackgroundWorker.ReportProgress as shown below:

             
                             
Public Sub BackgroundWork(ByRef argument As Variant, _
    ByRef e As NetFX20Wrapper.RunWorkerCompletedEventArgsWrapper)
On Error GoTo eh
    For i = 1 To argument / 500
        Sleep 500
        If backgroundWorker.CancellationPending Then
            e.SetResult "Cancelled after " & i * 500 & " ms"
            e.Cancelled = True
            Exit Sub
        End If
        backgroundWorker.ReportProgress _
            (CDbl(i) / (argument / 500)) * 100
    Next
    e.SetResult "Background work done"
    Exit Sub
    
eh:
    e.Error.Number = Err.Number
    e.Error.Description = Err.Description
End Sub

This sends a value from 0 to 100 indicating what percentage of the work has been completed.

In the Project Explorer, double-click Form1.
Right-click the Toolbar, and select Components.
Check Microsoft Windows Common Controls 6.0, and click OK.
Add a ProgressBar control to the form.
Press F7 to switch to code view.
In the Object drop-down, select background. In the Procedure drop-down, select ProgressChanged.
Code the ProgressChanged event handler as follows:
Private Sub background_ProgressChanged(ByVal sender As Variant, _
ByVal e As NetFX20Wrapper.ProgressChangedEventArgsWrapper)

ProgressBar1 = e.ProgressPercentage

End Sub
When the background subroutine calls ReportProgress, it causes the ProgressChanged event to fire on the main thread. In this event, you can look at the ProgressPercentage property to determine how much of the work has been done.
Press F5 to run the application.
Click Start. You should see the progress bar move as the background subroutine does work.

Figure 6. Progress bar display
Close the application.

Debugging Considerations

The Visual Basic 6 development environment was not designed to support debugging multi-threaded applications. For this reason, you cannot set a breakpoint in your background subroutine. If you do, the development environment will crash. Also, if your background subroutine has an unhandled exception, the development environment will also crash.
To facilitate debugging, the wrapper for the BackgroundWorker exposes a RunWorkerSync function. This works exactly like RunWorkerAsync, except the background subroutine is run on the main thread, instead of a background thread. This means that while the subroutine is running, your application will appear to lock up. However, this does allow you to safely set breakpoints in your background routine, and perform debugging.
Walkthrough: Debugging the background routine

In the Project Explorer, right-click Form1, and select View Code.
Modify the Button1_Click event as follows:
Private Sub Command1_Click()
Set Module1.backgroundWorker = background
background.RunWorkerSync AddressOf BackgroundWork, 5000
End Sub
Changing the call from RunWorkerAsync to RunWorkerSync will cause the background subroutine to run synchronously (on the main thread), so that it can be debugged.
In the Project Explorer, double-click Module1.
Set a breakpoint on the following line of code inside the BackgroundWork subroutine:
For i = 1 To argument / 500
Press F5 to run the application.
Click on Start. Execution stops on the breakpoint, and you can debug without error.
Clear the breakpoint, and press F5. Execution continues, but the application is not responsive until the BackgroundWork subroutine completes.

Conclusion

In this article, you have seen how the BackgroundWorked component from version 2.0 of the .NET Framework has been wrapped so that it can be used seamlessly from a Visual Basic 6 (or other COM based) application. This lets you perform long running operations on a background thread so that the application remains responsive, and does not appear to lock up or hang. The BackgroundWorker provides capabilities for aborting the background operation, and the background operation can provide events to the main thread, notifying it of the percentage completed.

About the author Scott Swigart www.swigartconsulting.net, spends his time consulting with companies on how to best use today's technology and prepare for tomorrows. Along this theme, Scott is a proud contributor to the Visual Basic Fusion site, as it offers information and tactics of real use for Visual Basic developers who want to build the most functionality with the least effort. Scott is also a Microsoft MVP, and co-author of numerous books and articles. If you have any question or comments about this article, feel free to send e-mail to scott@swigartconsulting.com.

Diagnose This: Launching and Controlling System Processes with Visual Basic 6 and the .NET Framework

2017-03-14T11:19:00.001-07:00

Visual Studio .NET 2003

Scott Swigart
Swigart Consulting LLC
April 2006
Applies to:
Visual Basic 6
.NET Framework
Summary: This article explains how to use the Process class (in the System.Diagnostics section of the .NET Framework Class Library) from a Visual Basic 6 application, to launch and control system processes. (10 printed pages)

Introduction
Tom, I Can Write That App in One Line of Code
Using the Process Class from Visual Basic 6
Your Very Own Task Manager
Running the Sample
Conclusion
Click here to download the code sample for this article.

Introduction

Continuing with the Visual Basic Fusion theme of "There's nothing in .NET that you can't access from Visual Basic 6," I want to take some time to dig into the functionality provided by the .NET Framework System.Diagnostics classes. In particular, I want to take a look at the very useful Process class, which lets you launch and control system processes, and show you how you can use this class from a Visual Basic 6 application.

Tom, I Can Write That App in One Line of Code

Have you ever noticed how .NET demonstrations often degrade to "And all that with just one line of code!" It's almost like the coding version of "Name that Tune." In some ways, it's become a cliché.
Well, I'm a sucker for clichés, so take a look at the application in Figure 1, which shows extensive information about all the processes that are currently running.

Figure 1. Visual Basic .NET application that shows running process information (Click on the image for a larger picture)

And all that with just one line of code! (See Listing 1.)

Listing 1. Visual Basic .NET code to display process information

DataGrid1.DataSource = Process.GetProcesses()

The .NET Framework contains a class called Process. This class exposes functions that let you start processes, stop processes, and get information about running processes. The GetProcesses function returns an array of information about all the currently running processes. Visual Basic .NET supports databinding grids directly to arrays, and so all you have to do is set the DataSource property of the grid to the results returned from GetProcesses, and you get all the process information displayed in a grid.

Using the Process Class from Visual Basic 6

Like most of the classes in the .NET Framework, the Process class is not directly available to a Visual Basic 6 application. Instead, you can expose the functionality of this class by creating a simple wrapper in Visual Basic .NET.
Listing 2 shows the code for the wrapper.

Listing 2. Visual Basic .NET wrapper class

             
                             
Imports System.Diagnostics

Public Class ProcessWrapper

#Region "COM GUIDs"
    ' These  GUIDs provide the COM identity for this class 
    ' and its COM interfaces. If you change them, existing 
    ' clients will no longer be able to access the class.
    Public Const ClassId As String = "C655826A-F52C-4DE8-91DF-61B6C439B839"
    Public Const InterfaceId As String = "2205598A-B161-421A-A6FF-2741418F2817"
    Public Const EventsId As String = "9A7918EE-E3BA-41C8-A514-04B8D18DE605"
#End Region

    ' A creatable COM class must have a Public Sub New() 
    ' with no parameters, otherwise, the class will not be 
    ' registered in the COM registry and cannot be created 
    ' via CreateObject.
    Public Sub New()
        MyBase.New()
    End Sub

    Public Function Start(ByVal command As String) As ProcessInfo
        Dim p As Process = Process.Start(command)
        Return New ProcessInfo(p)
    End Function

End Class

This class was created by using the COM Class template in Visual Studio 2003, as follows:

Start Visual Studio 200, click the File menu, and click New Project.
Under Templates, select Class Library.
In the Name text box, enter NetFrameworkWrappers, and click OK (see Figure 2).

Figure 2. Creating a new project
Click the Project menu, and then click Add New Item.
Under Templates, select COM Class. This allows you to create a class from Visual Basic .NET that will expose itself as a COM object.
In the Name text box, enter ProcessWrapper.vb, and then click OK (see Figure 3).

Figure 3. Adding ProcessWrapper.vb
At the top of the file, add the following line of code:
Imports System.Diagnostics

Add the following method to the class:

             
                             
Public Function Start(ByVal command As String) As ProcessInfo
    Dim p As Process = Process.Start(command)
    Return New ProcessInfo(p)
End Function

Click the Build menu, and then click Build Solution. This will compile the class and register it as a COM object.

At this point, you can just add a reference to NetFrameworkWrappers from a Visual Basic 6 application, and start using the ProcessWrapper class (see Listing 3).

Listing 3. Using the ProcessWrapper class from Visual Basic 6

             
                             
Dim p As NetFrameworkWrappers.ProcessWrapper
Set p = New NetFrameworkWrappers.ProcessWrapper
p.Start ("calc.exe")

The Process class also exposes a GetProcesses method that will return information about every process running on the system. The return value of GetProcesses is an array of Process classes, and therefore it is not directly consumable by Visual Basic 6. I created a wrapper for this as well. The ProcessInfo wrapper class wraps the Process class to surface information in a way that's directly consumable by Visual Basic 6. I can then create an array of ProcessInfo classes, and return to my Visual Basic 6 code as shown in Listing 4.

Listing 4. Wrapping the results of GetProcesses so that it can be used from Visual Basic 6

             
                             
Public Sub GetProcesses(ByRef procInfos() As ProcessInfo)
    Dim processes() As Process = Process.GetProcesses
    ReDim procInfos(processes.Length - 1)
    For i As Integer = 0 To processes.Length - 1
        procInfos(i) = New ProcessInfo(processes(i))
    Next
End Sub

You can see that this calls GetProcesses to retrieve an array of Process classes for each running process. I then loop through each one, and convert it to a ProcessInfo class that was specifically designed to be consumable by Visual Basic 6. For example, the TotalProcessorTime property of the Process class used the .NET TimeSpan data type. This will not show up on the Visual Basic 6 side, and therefore the ProcessInfo class instead returns this information simply as a string.

Your Very Own Task Manager

I've created a Visual Basic 6 sample application (see Figure 4) that uses the Process wrappers to let you control all the processes on your machine. You can launch processes, change a process priority, and even kill a process.

Figure 4. Visual Basic 6 Process Manager

When the form loads, it calls the GetProcesses wrapper and places all the processes in a ListView control (see Listing 5).

Listing 5. Loading the Visual Basic 6 form with process information

             
                             
Public Sub LoadList()
    ListView1.ListItems.Clear
        
    Dim p As NetFrameworkWrappers.ProcessWrapper
    Set p = New NetFrameworkWrappers.ProcessWrapper
    p.GetProcesses procs
    
    Dim i As Integer
    For i = 0 To UBound(procs) - 1
        Dim subItem As ListItem
        Set subItem = ListView1.ListItems.Add(, , procs(i).ProcessName)
        subItem.SubItems(1) = procs(i).Id
        subItem.SubItems(2) = procs(i).BasePriority
        subItem.SubItems(3) = procs(i).PriorityClass
        subItem.SubItems(4) = procs(i).PriorityBoostEnabled
        subItem.SubItems(5) = procs(i).MainWindowTitle
        subItem.SubItems(6) = procs(i).MainWindowHandle
        subItem.SubItems(7) = FormatNumber(procs(i).VirtualMemorySize / 1048576, 2) & " MB"
        subItem.SubItems(8) = FormatNumber(procs(i).PeakVirtualMemorySize / 1048576, 2) & " MB"
        subItem.SubItems(9) = FormatNumber(procs(i).WorkingSet / 1048576, 2) & " MB"
        subItem.SubItems(10) = FormatNumber(procs(i).PeakWorkingSet / 1048576, 2) & " MB"
        subItem.SubItems(11) = procs(i).Responding
        subItem.SubItems(12) = procs(i).TotalProcessorTime
        subItem.SubItems(13) = procs(i).UserProcessorTime
        subItem.SubItems(14) = procs(i).HasExited
    Next

End Sub

The LoadList method is used whenever the ListView needs to be repopulated with process information. It simply calls ProcessWrapper.GetProcesses, passing in an empty array of ProcessInfo classes. When the method returns, the array is populated, and the method simply loops through the results and adds them to the list view. Some values—for example, memory usage statistics—are formatted along the way, so that they are more readable.
The application contains a field where you can enter a process name and launch it (see Listing 6).

Listing 6. Launching a process from the Visual Basic 6 application

             
                             
Private Sub cmdLaunch_Click()
    Dim p As NetFrameworkWrappers.ProcessWrapper
    Set p = New NetFrameworkWrappers.ProcessWrapper
    p.Start (txtProcessLaunch)
    LoadList
End Sub

The application also lets you kill a process (see Listing 7).

Listing 7. Killing a process from the Visual Basic 6 application

             
                             
Private Sub mnuKill_Click()
    CurrentProc.Kill
    LoadList
End Sub

Note I don't think there's ever been an example of killing a process that didn't come with the warning that you really shouldn't go just killing processes willy-nilly. So consider yourself warned.

Finally, you can change the priority of a running process (see Listing 8).

Listing 8. Changing the priority of a process from the Visual Basic 6 application

             
                             
Private Sub mnuSetPriority_Click()
    Set frmModifyProcess.CurrentProc = CurrentProc
    If frmModifyProcess.ShowDialog = vbOK Then
        CurrentProc.PriorityClass = frmModifyProcess.PriorityClass
        LoadList
    End If
End Sub

This simply displays another form that prompts the user to select a process priority. When the user selects a priority and clicks OK (see Figure 5), the form closes, and the information is returned. The process priority can be set simply by setting the PriorityClass property of the ProcessInfo class. This passes the information to the Visual Basic .NET component, which changes the string back into the appropriate enumeration, and changes the process priority.

Figure 5. Selecting a new process priority from the Visual Basic 6 application

Running the Sample

Included with this article is the Visual Basic 6 and Visual Basic .NET code for working with processes. To run the sample, complete the following procedures.
If you do not have Visual Studio 2005 installed, you need to download the (free) Microsoft .NET Framework, and the (free) Visual Basic Express:

Download and install Visual Basic 2005 Express.

At this point, you can download and run the sample:

Download and unzip the code for this article.
Within the zip file, you will find a file called Build and Register.bat. Double-click this to build and register the Visual Basic .NET COM component.
In the ProcController folder, you will find the Visual Basic 6 sample application.

Conclusion

Once again, you have seen that you can use powerful functionality in the Microsoft .NET Framework easily from a Visual Basic 6 application in order to get things done. The class used in this article was the Process class, one of the many classes in the System.Diagnostics section of the Framework Class Library.

About the Author Scott Swigart spends his time consulting, authoring, and speaking about emerging and converging technologies. Scott has worked with a wide range of technologies over his career, beginning with Commodore 64 programming at the age of 12, writing hardware diagnostics for UNIX systems in C++, and building Windows desktop and Web applications. Over the years, Scott has worked with component development, XML technologies, .NET, Web services, and other languages, platforms, and paradigms. With this experience, Scott has seen how technology evolves over time, and he is focused on helping organizations get the most out of the technology of today while preparing for the technology of tomorrow. Scott is also a Microsoft MVP, and co-author of numerous books and articles. Scott can be reached at scott@swigartconsulting.com.

Deploying the Hybrid Visual Basic 6.0 and Visual Basic .NET Application

2017-03-14T11:16:00.000-07:00

Visual Studio 2005

Sales Support: A Hybrid Visual Basic 6.0 & Visual Basic 2005 Application, Part 4
Scott Swigart
February 2008
Summary: This article—the last in a four-part series that walks through enhancing an existing Microsoft Visual Basic 6.0 application by using functionality that is expected of modern applications—focuses solely on deployment considerations. (18 printed pages)

Introduction
Application Dependencies
Building the VBNET_Extensions Installer
Turning VBNET_Extensions into a Prerequisite for SalesSupport83
Building the Bootstrapper Setup.exe
Conclusion

Introduction

This article series, "Sales Support: A Hybrid Visual Basic 6.0 & Visual Basic 2005 Application," walks through enhancing an existing Microsoft Visual Basic 6.0 application by using functionality that is expected of modern applications. The application enhancements were coded in Microsoft Visual Basic .NET, simply because it was more productive and better suited to develop the desired functionality.
The key message of this article series is that the existing Visual Basic 6.0 application did not need to be migrated to Visual Basic .NET. The existing application was just enhanced by using small amounts of Visual Basic .NET code. This technique should be strongly considered if you have a large existing Visual Basic 6.0 code base that you are still maintaining and enhancing.
In Part 1 of this article series, Enhancing an Application with Windows Desktop Search and Office Outlook Integration, I showed that it is not necessary to migrate a Visual Basic 6.0 application to Visual Basic 2005 in order to take advantage of .NET functionality. Instead, you can integrate Microsoft Windows Desktop Search into a Visual Basic 6.0 application by using COM objects that have been created with Visual Basic 2005.
In Part 2, Enhancing a Visual Basic 6.0 Application with MapPoint Web Service, I demonstrated how to enhance the same application to display maps for locations in an existing database by calling into Microsoft MapPoint Web Service.
In Part 3, Enhancing a Visual Basic 6.0 Application with the ReportViewer Control, I showed how to add reporting capabilities to the application.
If you have yet to read the previous articles, I strongly recommend that you read at least the first one, to familiarize yourself with the application. This article will focus solely on deployment considerations.

Application Dependencies

When planning a deployment, it's important to understand your application dependencies. In this case, the Sales Support application is a Visual Basic 6.0 program that is dependent on extensions that are written in Visual Basic .NET. The application dependencies are diagrammed in Figure 1.

Figure 1. Application dependencies
The various components of this application must be packaged as part of the deployment. The Sales Support Application is installed by using a traditional Microsoft Visual Studio 6.0 Package and Deployment wizard setup.exe file. The VBNET_Extensions DLL, which provides the functionality for all of the preceding screen shots, is packaged by using a Visual Studio 2005 setup project. The application is also dependent on Microsoft SQL Server 2005 and the Microsoft .NET Framework 2.0, which are also packaged with the Sales Support installation.
The installation is somewhat complicated because an existing Visual Basic application, the VB.NET components, the .NET Framework, and SQL Server 2005 Express Edition must all be installed. Each of these components has its own stand-alone installer. Somehow, these all must be bound together, so that the user need only run a single setup.exe file to install everything.
The way to accomplish this is to use a bootstrapper setup.exe file. A bootstrapper can install any number of prerequisite packages and then launch the setup for the main application. This allows the .NET Framework 2.0, SQL Server 2005 Express Edition, and VBNET_Extensions to be installed as prerequisites to the Sales Support application.

Figure 2. Steps in constructing the full installer
The first component that must be constructed is the installer for the VBNET_Extensions DLL. This is accomplished simply by using a Visual Studio 2005 setup project, as shown in box (1) of Figure 2.
When building a bootstrapper, the bootstrapper "understands" the concept of prerequisites. Prerequisites are components that must be installed prior to the main application. You can include built-in prerequisites, such as the .NET framework or SQL Server 2005 Express Edition. However, for the Sales Support application, the VBNET_Extensions must be installed as a prerequisite to the main Sales Support application. The Bootstrap Manifest Generator utility is used to configure the VBNET_Extensions installer, so that it can be chosen as a prerequisite, as shown in box (2) of Figure 2.
MSBuild is then used to generate the bootstrapper setup.exe, and copy all of the prerequisite installers to a deployment folder. When MSBuild completes, you have a single folder that contains the setup.exe, all of the prerequisites, and the legacy installer. This entire folder could be copied either to a network share or to a CD.
When the bootstrapper setup.exe is executed, it installs the prerequisite components in the order that is shown in Figure 2, and then it starts the installation of the installer for the Sales Support application.
That’s a lot of steps, and, depending on your familiarity with deployment, it all might have been confusing. But each step in the process is straightforward; the following sections will walk through constructing each section of the installation in more detail.

Building the VBNET_Extensions Installer

Visual Studio 2005 allows you to add a setup project to an existing solution. This type of project provides functionality that is similar to the Visual Basic 6.0 Package and Deployment wizard, and makes it relatively easy to build a deployment for a Visual Basic .NET application or DLL.

Figure 3. Adding a setup project to the VBNET_Extensions solution
When you build a deployment, the first step is to select what you want to deploy. This deployment should deploy the VBNET_Extensions DLL, which contains the forms that were shown in the earlier screen shots. This was accomplished by right-clicking the VBNET_Extensions_Install project in the Solution Explorer, and then selecting Add | Project Output. This displays the Add Project Output Group dialog box, as shown in Figure 4.

Figure 4. Add Project Output Group dialog box
The Add Project Output Group dialog box shows that the primary output of the VBNET_Extensions project should be packaged and deployed. Generally, the primary output is the application executable or, in this case, the VBNET_Extensions DLL.
After the VBNET_Extensions primary output has been added to the VBNET_Extensions_Install setup project, Visual Studio automatically detects any dependencies and targets them for deployment, too. You can see what will be installed, and where, by right-clicking on the VBNET_Extensions_Install project, and selecting View | File System. As shown in Figure 5, the Microsoft.InteropFormsTools assembly and assemblies that are needed by the ReportViewer control will be bundled with the application and deployed to the Application folder (which defaults to a folder under C:\Program Files) on the target computer.

Figure 5. Files that will be deployed to the Application folder
Often, installations must perform certain custom actions beyond just copying files to the correct folder. For example, this application must install a database file and attach that file to SQL Server 2005 Express Edition. These kinds of operations are best performed through a custom action. The easiest way to create a custom action is to add a new Class Library project to the solution. In this Class Library project, you can code any operations that must be performed as part of the installation.
To perform custom actions for the VBNET_Extensions component, a class library that is called InstallerClassLibrary is added to the solution. An InstallerClass item is added to this project. An InstallerClass is just a class that inherits the System.Configuration.Install.Installer base class. This base class allows the Windows installer to call into this class during the install, commit, rollback, and uninstall stages of an installation. You can provide code for any of these installation stages by overriding base-class methods, as shown in Listing 1.

             
    Public Overrides Sub Install( _
        ByVal stateSaver As System.Collections.IDictionary)

        Dim sf As New StatusForm
        sf.Message = "Select a server where the database should be installed."

        sf.ShowDialog()

        stateSaver.Add("DBInstance", sf.DBInstance)

        MyBase.Install(stateSaver)
    End Sub

Listing 1. Providing a custom installation action
The Install function examines the computer to determine which instances of SQL Server are installed. SQL Server 2005 Express Edition will be installed with the application, but you might have another instance of SQL Server already installed. By using a custom form, the installer will "ask" you to which instance of SQL Server you want to attach the Sales Support database.
The SQL Server database file SalesSupport83.mdf also is added to the InstallerClassLibrary project. This will allow the actual database file to be deployed along with the application.
After the custom action has been coded, it also must be deployed by the installer. This is accomplished by right-clicking the VBNET_Extensions_Install setup project and selecting Add | Project Output. This time, the InstallerClassLibrary project is chosen for the project, and Primary Output and Content Files are selected for deployment. Choosing Content Files ensures that other ancillary files are included in the deployment. The SalesSupport83.mdf database file is considered a content file, and selecting this option ensures that this file is packaged with the deployment.
Finally, the InstallerClassLibrary must be connected to the installer, so that it will be triggered during the Install stage of the installation process. This is accomplished by right-clicking the VBNET_Extensions_Install project and selecting View | Custom Actions.
From the Custom Actions window, you can trigger custom code for various stages of the installation. For this deployment, the InstallerClassLibrary must be triggered during the Install stage. This is accomplished by right-clicking Install and selecting Add Custom Action. The installer must know the location where the custom-action executable code can be found. This illustrates why the custom-action DLL must be deployed with your application. It is run on the target computer during the installation, so that it must be packaged with the deployment. In this case, it is found in the Application folder and appears as "Primary output from InstallerClassLibrary," as shown in Figure 6.

Figure 6. Hooking the database-installation custom action to the installer
The installation can now be built by right-clicking the VBNET_Extensions_Install project and selecting Build.

Turning VBNET_Extensions into a Prerequisite for SalesSupport83

At this point, the pieces are in place to install the complete application. However, the installation is not integrated into a single setup.exe. The user would have to install the legacy SalesSupport83 Visual Basic application, as well as the .NET Framework 2.0 and SQL Server 2005 Express Edition. Finally, the user would have to install also the VBNET_Extensions DLL.
To integrate these components so that they are installed from a single setup, a bootstrapper is needed. The bootstrapper installs the .NET Framework 2.0, SQL Server 2005 Express Edition, and VBNET_Extensions as application prerequisites. The bootstrapper then launches the legacy SalesSupport83 setup.exe to install the main application.
Installing the .NET Framework 2.0, and SQL Server 2005 Express Edition as application prerequisites is as easy as checking a couple of check boxes. However, the VBNET_Extensions DLL is custom code, and a little work must be done for it to be installed as a prerequisite. The easiest way to accomplish this is by using Bootstrap Manifest Generator (BMG), which is available as a free product from CodePlex.
BMG allows you to take an existing application installer and turn it into a package that can be used as an application prerequisite. To turn VBNET_Extensions into a prerequisite package, BMG is started, and then Package Manifest is chosen for the new project type, as shown in Figure 7.

Figure 7. Creating a new package manifest
This step prompts you to provide information about the package that you want to build, as shown in Figure 8.

Figure 8. Entering basic information about the package
Next, the BMG must be given the location of the VBNET_Extensions installer. This is done by clicking the Add Install File toolbar icon, which appears directly above the word "Package." The MSI installer for VBNET_Extensions is then chosen, as shown in Figure 9.

Figure 9. Selecting the VBNET_Extensions installer to make a prerequisite package
When the bootstrapper setup.exe installs the prerequisites, it requires a way of knowing whether the prerequisite installed correctly or experienced an error. This information is provided to the bootstrapper by selecting the VBNET_Extensions_Install.msi, under Package, and then selecting the Exit Codes tab, as shown in Figure 10.

Figure 10. Configuring Success and Failure exit codes
Under Custom Exit Codes, an exit code of 0 is added to indicate success. If this is not added, even though the VBNET_Extensions prerequisite will install without error, the bootstrapper will always "think" that the installation failed.
The prerequisite package can now be built. This is accomplished by clicking the Build toolbar icon, which is located on the left, directly above the word "Package."
A build-output window opens, as shown in Figure 11. BMG creates the needed package directory and files under the Visual Studio 2005 installation, so that VBNET_Extensions can be installed as a prerequisite, just as the .NET Framework 2.0 or SQL Server 2005 Express Edition was.

Figure 11. Build output when creating a package

Building the Bootstrapper Setup.exe

At this point, a legacy setup.exe installer exists for the main Sales Support application. The VBNET_Extensions had been packaged, so that it can be installed as an application prerequisite. Out of the box, the .NET Framework 2.0 and SQL Server 2005 Express Edition can be installed as prerequisites. So that everything is installed from a single setup.exe file, one final step is required to glue everything together: to build the setup.exe itself.
This setup.exe is known as a bootstrapper, which means that the only thing that it "knows" how to do is kick off other installers. It will launch the install for the .NET Framework 2.0, the install for SQL Server 2005 Express Edition, the install for the custom VBNET_Extensions DLL, and, finally, the legacy setup.exe for the Visual Basic 6.0 Sales Support application.
The bootstrapper is generated by running a utility that is called MSBuild. Typically, MSBuild is used to compile projects from the command line. MSBuild can compile files, and it can perform other tasks that are commonly needed for an automated build process, such as copying files. MSBuild is driven by an XML file that contains the specific build instructions. The MSBuild project file for building the bootstrapper is shown in Listing 2.

             
                             
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <BootstrapperFile Include="Microsoft.Net.Framework.2.0">
      <ProductName>.NET Framework 2.0</ProductName>
    </BootstrapperFile>
    <BootstrapperFile Include="Microsoft.Sql.Server.Express.1.0">
      <ProductName>SQL Server 2005 Express Edition</ProductName>
    </BootstrapperFile>
    <BootstrapperFile Include="VBNET_Extensions">
      <ProductName>VBNET_Extensions</ProductName>
    </BootstrapperFile>
    <BootstrapperFile Include="Microsoft.Windows.Installer.3.1">
      <ProductName>Windows Installer 3.1</ProductName>
    </BootstrapperFile>

    <SourceFiles
      Include="$(MSBuildProjectDirectory)\..\SalesSupportV8_3\Package\setup.exe;
      $(MSBuildProjectDirectory)\..\SalesSupportV8_3\Package\SalesSupport.cab;
      $(MSBuildProjectDirectory)\..\SalesSupportV8_3\Package\Setup.LST" />

  </ItemGroup>

  <Target Name="Bootstrapper">
    <Copy
      SourceFiles="@(SourceFiles)"
      DestinationFolder="$(MSBuildProjectDirectory)\Deployment\SalesSupport" />

    <GenerateBootstrapper
      BootstrapperItems="@(BootstrapperFile)"
      ApplicationFile="SalesSupport\setup.exe"
      ApplicationName="Sales Support Installer"
      ComponentsLocation="Relative"
      Culture="en"
      FallbackCulture="en-US"
      CopyComponents="True"
      Validate="False"
      OutputPath="$(MSBuildProjectDirectory)\Deployment" />

  </Target>
</Project>

Listing 2. Sales Support Bootstrapper.msbuild file
The ItemGroup section contains a listing of the packages that will be installed as prerequisites. Notice that this list includes the built-in packages for the .NET Framework 2.0 and SQL Server 2005 Express Edition. Notice also that the custom VBNET_Extensions package appears in the list. This package was created in the "Turning VBNET_Extensions into a Prerequisite for SalesSupport83" section, earlier in this document.
As part of the build process, the legacy installer (built by the Visual Basic 6.0 Package and Deployment wizard) must be copied into a Deployment directory. This is accomplished by listing the installer files in the SourceFiles tag, and then referencing that list in the Copy task under the Bootstrapper target.
The GenerateBootstrapper tag contains the information that MSBuild requires to build the actual bootstrapper setup.exe. The BootstrapperItems attribute references the prerequisites that must be included. The ApplicationFile attribute specifies the legacy installer that will be executed after the prerequisites are installed. The OutputPath specifies the folder in which the bootstrapper will be built and to which the prerequisites will be copied.
The bootstrapper is built by using the MSBuild command line. To run MSBuild, open the Visual Studio command prompt, which can be found under the Start menu (under All Programs | Visual Studio 2005 | Visual Studio Tools | Visual Studio 2005 Command Prompt). MSBuild runs and generates the bootstrapper setup.exe by entering the command msbuild "Sales Support Bootstrapper.msbuild". The output is shown in Figure 12.

Figure 12. Output from building the bootstrapper
The full deployment folder is shown in Figure 13. The contents of this folder can be copied to a CD, "zipped" for download, or packaged otherwise for distribution.

Figure 13. Complete deployment folder
The entire application, including the .NET Framework 2.0, SQL Server 2005 Express Edition, and the VBNET_Extensions, are installed by just executing the setup.exe.

Conclusion

Packaging products for distribution is, and always has been, difficult. Applications have prerequisites, and they often require custom code to run during the installation, for example, to attach databases, migrate settings from previous versions, and so forth.
Deploying a hybrid Visual Basic 6.0 and Visual Basic .NET application adds additional complexity. The coding that you do in Visual Basic .NET likely will be compiled into a DLL that must be deployed. The application is now dependent on the .NET Framework, which should be included as a prerequisite.
I hope that this article eases the task by giving you concrete information that you can use when you deploy your own hybrid applications. In my opinion, this is still far easier than porting the entire legacy Visual Basic 6.0 application to Visual Basic .NET.
Building hybrid applications allows you to maintain your existing application investment, learn the .NET Framework and Visual Basic .NET incrementally, and incur very little risk.

About the author

Scott Swigart spends his time consulting, authoring, and speaking about converging and emerging technologies. With development experience going back over 15 years, and by staying in constant contact with future software-development technologies, Scott is able to help organizations get the most out of today's technology while they prepare to leverage the technology of tomorrow. Scott is also the author of several .NET books, a certified Microsoft trainer (MCT) and developer (MCSD), and a Microsoft MVP. Feel free to contact the Scott at scott@swigartconsulting.com, or check out his latest musings at blog.swigartconsulting.com.

Automatically Updating Visual Basic 6 Applications: Part I

2017-03-14T11:13:00.003-07:00

Visual Studio 2005

Scott Swigart
Swigart Consulting LLC
May 2006
Applies to:
   Microsoft Visual Basic 6.0
   Microsoft Visual Basic 2005
   Microsoft Visual Basic Express 2005 Edition
   Microsoft Visual Studio 2005
   .NET Framework 2.0
Summary: This article shows how you can add automatic updating functionality to your existing Visual Basic 6.0 applications, using features now available with the .NET Framework 2.0. (10 printed pages)
Click here to download the code sample for this article.

Introduction
ClickOnce Deployment
ClickOnce Deploying a Visual Basic 6.0 Application
Versioning
Conclusion

Introduction

Deploying applications is hard. It takes time to build and test installers. Applications often require additional COM components to operate, and these components require registration. You also have to consider how you're going to physically distribute the bits. Will you burn a CD? Will you zip them up and place them on a website for downloading? Will you use a product like SMS to push them out?
Versioning applications is also hard. You may have previous versions of the application installed that may require removal. Applications today are expected to somehow know when a new version is available, prompt you to see whether you want to install it, and then take care of the rest.
Visual Basic 6.0 allows you to build installers to address some of these issues. Third-party products offer even more capabilities for deploying and versioning application, but automatic updating can be tricky. Visual Basic 6.0 provides no capabilities for making an application that automatically detects, downloads, and installs a new version of itself. Rolling your own capability for this would be, for lack of a better term, hard.

ClickOnce Deployment

Automatic application updating is a feature that Microsoft has been working to simplify. With Visual Studio 2005 and the .NET Framework 2.0, Microsoft provides a built-in solution for robust application deployment and automatic updating. While this technology, known as ClickOnce deployment, was developed with .NET applications in mind, it can be used to automate the deployment and updating of Visual Basic 6.0 applications. Considering that bazillions of lines of Visual Basic 6.0 code will continue to run in production for some time, this might be a useful thing.

Getting Started

To begin with ClickOnce deployment, it's important to have the latest version of Visual Studio. If you already have Visual Studio 2005 installed, that's great! Otherwise, I strongly recommend that you download and install the free Visual Basic Express. Visual Basic Express provides all the functionality that you need in order to ClickOnce deploy applications. It's a free, trimmed-down version of the full Visual Studio 2005, but unlike typical evaluation software, it doesn't timeout.
This article will walk you, step by step, through the process of ClickOnce deploying a Visual Basic 6 application. The steps in this article are written for Windows XP with Internet Information Server (IIS) installed. This technique should work on other versions of Windows, but the steps for configuring Internet Information Server will vary slightly.
The first steps will walk you through using Visual Basic Express to ClickOnce deploy a Visual Basic .NET application. This .NET application will become the launcher for your Visual Basic 6.0 application. It will check for, download, and install new versions automatically.

Start Visual Basic Express or Visual Studio 2005.
Click the File menu, and then click New Project.
Create a Visual Basic Windows Application. Name the application MyAppLauncher.
Click the File menu, and then click Save All.
In the Save Project dialog box that appears, click Save. You should now see the form designer, which will let you create the launcher application. Initially, this will be a trivial application that will let you get familiar with ClickOnce deployment. Later, this will include your Visual Basic 6.0 application, and you will see how it can automatically update itself.
In the Solution Explorer, double-click My Project.
Click the Publish tab on the left side. The Publish tab shows the options related to ClickOnce deployment (see Figure 1). When you ClickOnce deploy your application, it will be posted on a website, allowing the user to download, install, and execute the application with a single click. The application will also download and install any needed prerequisites, such as the .NET Framework 2.0.

Figure 1. ClickOnce settings
On the Publish tab, click Prerequisites if you want to select additional packages to download and install with your application (see Figure 2). The .NET Framework 2.0 is a requirement, but you might also want to download and install MDAC 2.8, for example.

Figure 2. Selecting prerequisites
On the Publish tab, click Updates to configure when the application checks for new versions (see Figure 3). The default is to check before the application starts, but you can have the application check in the background while it's running.

Figure 3. Configuring when to check for updates
On the Publish tab, click Publish Now to compile and deploy the application to your local Web server. Once the application has been deployed, the Web page in Figure 4 will be displayed, allowing you, or any other user, to download and install the prerequisites and the application.

Figure 4. Web installation page

Little Details

Unfortunately, at this point, it's necessary to pull back the covers on ClickOnce deployment just a bit, and talk about what's going on behind the scenes. When you publish your application to a website, it will create on the Web server a folder like the one shown in Figure 5.

Figure 5. Files published to the Web folder

You'll notice some files with an .application extension. If you drill into the MyApplicationLauncher_1_0_0_0 folder, youll also find files with .deploy and .manifest extensions. By default, Internet Information Server doesn't correctly serve these up, and as a result, if someone tries to install the application through the Web, it won't work. There's a one-time change that you need to make to Internet Information Server's settings so that it correctly supports ClickOnce deployment.

Configuring Internet Information Server

On Windows XP, the following steps will correctly configure IIS. If you're running on a different operating system, the steps will vary slightly.

Click the Start menu, and then click Control Panel. Then, open Administrative Tools > Internet Information Services.
Expand the local computer name, expand Web Sites, right-click Default Web Site, and click Properties (see Figure 6).

Figure 6. Selecting Default Web Site Properties
In the Properties dialog box, click the HTTP Headers tab, and then click File Types.
In the File Types dialog box, add the file types shown in Figure 7.

Figure 7. Configuring file extensions for ClickOnce deployment
Return to the Web installation page shown in Figure 4, and click Install. The application installer will download and run, and the Application Install – Security Warning dialog box will appear (see Figure 8).

Figure 8. Prompt for application install
Click Install. The application will install and run.

ClickOnce Deploying a Visual Basic 6.0 Application

With a basic knowledge of ClickOnce in hand, you can easily include other files in your deployment. In the following steps, you will include a Visual Basic 6.0 application as part of your ClickOnce deployment, and you will configure the launcher application to start the Visual Basic 6.0 application after it ensures that the latest version is installed.

Start Visual Basic 6.0.
In the New Project dialog box, select Standard Exe, and click Open.
Change the caption property of Form1 to VB6 App.
From the toolbox, add a Command button to Form1.

In the Click event of the Command button, enter the following code:

Private Sub Command1_Click()
    MsgBox "Hello World from VB6"
End Sub

Click the File menu, and then click Save Project As.
Save the project in the same folder as the MyAppLauncher.vbproj file.
Click the File menu, and then click Make Project1.exe.
In the Make Project dialog box, click OK. You now have a simple Visual Basic application that can be ClickOnce deployed along with your Visual Basic .NET launcher.
Switch to Visual Basic Express.
Click the Project menu, and then click Add existing item.
In the Add Existing Item dialog box, in the File Types drop-down list, click All Files (*.*).
Select Project1.exe, and click Add. If you don't see Project1.exe, ensure that you saved your Visual Basic 6 project to the correct folder in Step 7.
In the Solution Explorer, select Project1.exe.
Press F4 to view the Properties window.
In the Properties window, set the Copy to Output property to Copy if newer. By adding the Visual Basic 6 executable to your Visual Basic .NET solution, and indicating that you want it copied to the output, you are ensuring that the Visual Basic 6 application will be included in your ClickOnce deployment. The only remaining task is to modify the launcher application so that it will launch the Visual Basic 6 application.
In the Solution Explorer, double-click Form1.vb.
Double-click Form1 in the designer to switch to code view. You should be in the Form1_Load event handler.
Enter the following lines of code in Form1_Load:
```
Process.Start("Project1.exe")
Me.Close()
```
You can now publish the new version of the application. This time, the Visual Basic 6 application will be included with your launcher.
In the Solution Explorer, double-click My Project.
Click the Publish tab.
Click Publish Now.
When the MyAppLauncher Web page appears, click Install. The Visual Basic 6 application, deployed through ClickOnce, should appear as shown in Figure 9.

Figure 9. Visual Basic 6 application deployed through ClickOnce

Versioning

Now that you've completed the initial deployment of your Visual Basic 6 application, deploying a new version becomes simple. Essentially, you make changes to your Visual Basic 6 application, republish it, and that's it. The following steps will walk you through the details:

Switch to Visual Basic 6.0.
In the Project Explorer, double-click Form1.vb.
Set the BackColor for Form1 to something obviously different, like red.
Click the File menu, and then click Make project1.exe.
In the Make Project dialog box, click OK.
When prompted to replace Project1.exe, click Yes.
Switch to Visual Basic Express.
In the Solution Explorer, double-click My Project.
Click the Publish tab.
Click Publish Now. A new version has now been posted to the server. The next time the user runs the application, the new version will automatically download, install, and run.
Don't install MyAppLauncher through the Web page. Instead, just launch the existing version through the Start menu. (Click the Start menu, point to All Programs, and then click MyAppLauncher.) Note that the dialog box shown in Figure 10 briefly appears.

Figure 10. Application automatically checking for a new version
A new version is detected automatically, and you're prompted to install.

Figure 11. Prompt to install the new version
When you click OK, the new version installs and runs.

Figure 12. New version of the Visual Basic 6 application

Conclusion

Hopefully, the technique shown in this article has opened a new door for how you deploy some of your applications. In this first article, you have learned how to deploy a Visual Basic 6 application through ClickOnce deployment. Stay tuned for Part II, where you will learn how to deploy COM object and ActiveX controls along with your Visual Basic 6 application.

About the author Scott Swigart spends his time consulting, authoring, and speaking about converging and emerging technologies. With development experience going back over 15 years, and by staying in constant contact with future software development technologies, Scott is able to help organizations get the most out of today's technology while preparing to leverage the technology of tomorrow. Scott is also the author of several .NET books, a certified Microsoft trainer (MCT) and developer (MCSD), and a Microsoft MVP. Feel free to contact the Scott at scott@swigartconsulting.com, or check out his latest musings at blog.swigartconsulting.com.

Enhancing a Visual Basic 6.0 Application with the ReportViewer Control

2017-03-14T11:11:00.003-07:00

Visual Studio 2005

Sales Support: A Hybrid Visual Basic 6.0 & Visual Basic 2005 Application, Part 3
Scott Swigart
February 2008
Summary: This article, the third in a four-part series, shows how to include modern, simple-to-configure Microsoft Visual Basic 2005 reporting components within an existing Microsoft Visual Basic 6.0 application. (13 printed pages)

Introduction
The Sales Support Application
Reporting
Application Architecture
Visual Basic .NET Implementation
Interoperability with Visual Basic 6.0
Conclusion

Introduction

Do you want to modernize your Microsoft Visual Basic 6.0 applications? Would you like to take advantage of Web services, desktop search, and more, but you don't have the time or resources to upgrade (or rewrite) your production applications in Microsoft Visual Basic 2005?
In Part 1 of this article series, Enhancing an Application with Windows Desktop Search and Office Outlook Integratione, I showed that it is not necessary to migrate a Visual Basic 6.0 application to Visual Basic 2005 in order to take advantage of .NET functionality. Instead, you can integrate Microsoft Windows Desktop Search into a Visual Basic 6.0 application by using COM objects that have been created with Visual Basic 2005.
In Part 2, Enhancing a Visual Basic 6.0 Application with MapPoint Web Service, I demonstrated how to enhance the same application to display maps for locations in an existing database by calling into Microsoft MapPoint Web Service.
This hybrid approach lets you take advantage of all of the functionality of the .NET Framework without having to rewrite your application.
This article focuses on what is often an afterthought to developers, but is top-of-mind to users: reporting capabilities. Instead of struggling with the more limited reporting capabilities of Visual Basic 6.0, you will see how to include modern, simple-to-configure Visual Basic 2005 reporting components within an existing Visual Basic 6.0 application.

The Sales Support Application

"Sales Support" is a very simple sales-force support application that allows the user to look up accounts, contacts, and forecasted sales. The application is not intended to be a complete sales-force automation solution. Instead, it is designed to be a representative placeholder for an existing line-of-business Visual Basic 6.0 application. Also, it serves as the anchor for a number of logical application enhancements that are best implemented by using Visual Basic 2005.

Installation

The Sales Support installer has been tested on Microsoft Windows XP SP2 and on Windows Vista, and likely would work on older operating systems, too. Because this is a hybrid Visual Basic 6.0 and Visual Basic 2005 application, the Sales Support installer will install the.NET Framework 2.0 as a prerequisite. This application also stores data in a back-end database. For this reason, the installer will install Microsoft SQL Server 2005 Express Edition, which replaces Microsoft SQL Server 2000 Desktop Engine (MSDE 2000).
If you do not have these prerequisites installed, the installer will download them for you automatically. If they are already installed, the installer will detect their presence and skip to the application installation.

Operation

After the application is installed, you can launch it from the Start menu. Look for the Sales Support8_3 entry. The application will initially prompt you to log on. To simplify use, the user name and password fields default to working values, as shown in Figure 1. You can just click the Login button to continue.

Figure 1. The Sales Support Login form
After you have logged on, the main application window appears, as shown in Figure 2. The application provides three different views of the sales information. The Accounts tab provides the first view and shows each account and associated sales information. This view can be sorted differently by clicking on a column heading. The Contacts tab provides the second view and shows more detailed information about each individual contact. The Forecast tab provides the third view and displays future sales-forecast information.

Figure 2. The main application window
Again, the Sales Support application is not designed to be a working sales-force solution. Instead, it serves only as a basis for realistic application enhancements.

Reporting

Most line-of-business applications are "forms-over-data" applications that serve as a way to enter, edit, view, and visualize discrete pieces of information that is stored in back-end databases. Of course, users also want to see this data in the aggregate; for this reason, reports are a key component of most line-of-business applications (although they often are developed as an afterthought in version 1.0 of an application). Reporting has been available for Visual Basic through options such as Crystal Reports, the Data Environment, and a rich ecosystem of third-party reporting tools.
With Visual Studio 2005, Microsoft has released the powerful new ReportViewer control, which allows you to create reports and view them in your application. The ReportViewer control supports interactive reports, printing, layout control, and exporting options.
To add new reports to a Visual Basic 6.0 application, you could continue to use the tools that shipped with the product in 1998. However, the users of our fictional Sales Support application demand the "latest and greatest," so that the ReportViewer control was the best choice. This control can be added easily to a .NET form; also, by using the Interop Forms Toolkit 2.0, this form can be launched from the existing Visual Basic 6.0 application. Figure 3 shows the resulting report for accounts.

Figure 3. Accounts report
You can access this report in the sample application via the new Reports menu item that includes Account, Contacts, and Forecast reports.

Application Architecture

The core of the Sales Support application is a Visual Basic 6.0 application that communicates with a SQL Server 2005 Express database. When the user selects a report from the new Reports menu, the Visual Basic 6.0 application creates an instance of the .NET report form as though it were a COM object. The Visual Basic 6.0 application passes the report data to the .NET report form as an ADO Recordset object. The .NET report form converts the Recordset object to a DataSet object. This is necessary because the ReportViewer control cannot bind to an ADO Recordset object, but it can bind to an ADO.NET DataSet object. The report is then displayed as shown in Figure 3. (For more information, please see "Sharing ADO Recordsets Between Visual Basic 6.0 and Visual Basic 2005," in the MSDN Library.)

Figure 4. Application data flow

Visual Basic .NET Implementation

Extending the Visual Basic 6.0 Sales Support application requires a Visual Basic .NET Framework Class Library project that is called VBNET_Extensions. This project accepts a Recordset object from the Visual Basic 6.0 Sales Support application and converts it to a DataSet object that is suitable for reporting. The DataSet object provides a visual designer that allows you to create table definitions to hold the data. By looking at the designer, you can see that this DataSet object is configured with tables that map to the data that the Sales Support application will provide.

Figure 5. DataSet designer
If you are completely new to the .NET Framework, a DataSet object is a big change from the four main ADO objects—namely, Recordset objects. A DataSet object could be described as a collection of hierarchically related Recordset objects (DataTables), disconnected from the database, but accompanied by associated Command objects to handle data manipulation within the database. What is yet more interesting, a DataSet object can be filled with data from sources other than a database. In this example, the DataSet object is filled with data from ADO Recordset objects.
The Contacts, Account, and Forecast tables hold data that is supplied from the Sales Support Visual Basic 6.0 application. The Visual Basic 6.0 application passes in Recordset objects that contain this information, and the VBNET_Extensions Class Library copies that data from the Recordset object into these DataTable objects. The TopAccounts and TopForecast tables are designed specifically for charts that appear in some of the reports. These charts show the top 10 accounts, in terms of recent sales and forecast sales.
After the DataSet is created, you're ready to create the actual reports. Many reporting options have been available for Visual Basic; however, with Visual Studio 2005, Microsoft has introduced the ReportViewer control, which is an all-in-one reporting tool that simplifies the building of powerful and interactive reports. This is a .NET control, of course, so that it has to be placed on a .NET form that is launched from the existing Visual Basic 6.0 application.
Creating a .NET form that is accessible from Visual Basic 6.0 requires the Interop Forms Toolkit 2.0, which is a free and supported Visual Basic 2005 PowerPack that makes .NET forms appear as COM objects in Visual Basic 6.0 applications. After you install it, a Visual Basic 6.0 InteropForm is added to the Visual Basic .NET Framework Class Library, as shown in Figure 6.

Figure 6. Adding a Visual Basic 6.0 InteropForm
The InteropForm is just like any other .NET form, except that it contains a few extra items that make it COM-callable. After the form has been added to the project, place a ReportViewer control from the Data section of the toolkit onto the form. The ReportViewer control has a small smart tag in the top-right corner that is used to dock the ReportViewer control in the form. Docking a control will cause the control to fill the available space, and resize automatically as the form is resized—a challenging task in Visual Basic 6.0. The smart tag is used also to create a new report definition. You can see the smart tag accessed in Figure 7.

Figure 7. Creating a new report from the smart tag
With the report designer open, the toolkit updates to contain a number of items that are specific to reports. For this application, tables and charts are the two main items that are used. Drag a table from the toolkit onto the report-design surface. As soon as the table is in place, drag individual columns from the Data View window onto the table to bind table cells to the DataSet columns, as shown in Figure 8. You can also drag columns onto the chart to specify from where the data values and category names should come.

Figure 8. Building the report
To make the report more readable, set the BackgroundColor property of the table cells to the expression =iif(RowNumber(Nothing) Mod 2, "PaleGreen", "White"), which will alternate the background color of each line of the table. Right-click the chart, and then select Properties to display the custom property pages for the chart, as shown in Figure 9. These property pages allow you to customize the chart—for example, by setting the chart title, or by formatting the x-axis labels as currency.

Figure 9. Chart-property pages
The final step is to connect the ReportViewer control to the SalesSupportDataSet.
To interact with the Sales Support Visual Basic 6.0 application, the application requires a way to pass a Recordset object into the AccountReportForm. This step is accomplished by exposing a property on the report form, as shown in Listing 1.

             
                             
    Private mRecordset As Object
    <InteropFormProperty()> _
    Public Property Recordset() As Object
        Get
            Return mRecordset
        End Get
        Set(ByVal value As Object)
            If (value IsNot mRecordset) Then
                mRecordset = value
                SalesSupportDataSet.Account.Clear()
                Dim da As New OleDbDataAdapter()
                da.Fill(SalesSupportDataSet.Account, mRecordset)
                GenerateTopAccounts()
                AccountReportViewer.RefreshReport()
            End If
        End Set
    End Property

Listing 1. Recordset property on the Visual Basic .NET form
The property uses a .NET Framework OleDbDataAdapter object to copy the contents of the Recordset object into the DataSet's Account DataTable object, which was created earlier in the DataSet designer. The magic of taking data from Visual Basic 6.0 and ADO and transferring it to an ADO.NET DataSet comes in one line of code:
da.Fill(SalesSupportDataSet.Account, mRecordset)

The DataAdapter does all of the work for you.
Some of the reports also include charts, which show "top-10" information. You use a function to generate the data for these reports. For the Accounts report, you accomplish this by using the GenerateTopAccounts function that is shown in Listing 2.

             
                             
    Private Sub GenerateTopAccounts()
        Dim bs As New BindingSource(SalesSupportDataSet, _
            SalesSupportDataSet.Account.TableName)

        bs.Sort = SalesSupportDataSet.Account. _
            sales_last_3_monthsColumn.ColumnName & _
            " asc"

        SalesSupportDataSet.TopAccounts.Clear()
        For i As Integer = bs.Count - 11 To bs.Count - 1
            Dim accountRow As SalesSupportDataSet.AccountRow
            accountRow = bs.Item(i).Row
            SalesSupportDataSet.TopAccounts. _
                AddTopAccountsRow(accountRow.CompanyName, _
                accountRow.sales_last_3_months)
        Next
    End Sub

Listing 2. GenerateTopAccounts function
The GenerateTopAccounts function uses a .NET Framework BindingSource object to sort the accounts by sales. The first 10 rows are then copied from the BindingSource object into the TopAccounts DataTable. Because the chart already was bound to this table, the chart just populates itself and shows the top accounts.

Interoperability with Visual Basic 6.0

As noted earlier, the Interop Forms Toolkit 2.0 allows you to build forms in Visual Basic .NET that can be called from Visual Basic 6.0. The Interop Forms Toolkit 2.0 installs a Visual Basic 6.0 InteropForm item that was used to build the report forms. After the reports are created, select Tools | Generate Interop Wrapper Classes, as shown in Figure 10, to generate COM wrappers that are needed for Visual Basic 6.0 to interact with the .NET form.

Figure 10. Generating COM wrapper classes
After the wrapper classes are generated, compile the solution by using the Build | Build Solution menu command.
With the Sales Support application open in Visual Basic 6.0, add a reference to the VBNET_Extensions COM object. Visual Basic 6.0 code can create an instance of this object and call into it, as though it were any other COM object. Listing 3 shows the Visual Basic 6.0 code that passes the account data into the Visual Basic .NET report form.

             
                             
Private Sub mnuAccounts_Click()
    Dim f As New VBNET_Extensions_AccountReportForm

    If rsAccount Is Nothing Then
        LoadAccountData
    End If

    f.Recordset = rsAccount
    f.Show
End Sub

Listing 3. Passing a Recordset object into a Visual Basic .NET report form
You can see that only a tiny amount of code was required in Visual Basic 6.0 to trigger the new Visual Basic .NET functionality.

Conclusion

Visual Basic .NET is a great choice for many new application scenarios. Microsoft continues to pour its efforts into enhancing the .NET Framework and related technologies. At the same time, many organizations are maintaining significant Visual Basic 6.0 applications. As this article has shown, there is no reason that you cannot create hybrid applications by using the best of both technologies.

About the author

Enhancing a Visual Basic 6.0 Application with MapPoint Web Service

2017-03-14T11:08:00.004-07:00

Visual Studio 2005

Sales Support: A Hybrid Visual Basic 6.0 & Visual Basic 2005 Application, Part 2
Scott Swigart
February 2008
Summary: This article, the second in a four-part series, demonstrates how to use .NET functionality to expand and modernize a Microsoft Visual Basic 6.0 application by adding mapping capabilities via the Microsoft MapPoint Web Service API. (14 printed pages)
Click here to download the application installer.
Click here to download the application source code.

Introduction
The Sales Support Application
Customer-Mapping Enhancement
Application Architecture
Visual Basic 2005 Implementation
Interoperability with Visual Basic 6.0
Conclusion
Additional Resources

Introduction

Do you want to modernize your Microsoft Visual Basic 6.0 applications? Would you like to take advantage of Web services, desktop search, and more, but you don't have the time or resources to upgrade (or rewrite) your production applications in Microsoft Visual Basic 2005?
In Part 1 of this article series, Enhancing an Application with Windows Desktop Search and Office Outlook Integration, I showed that it is not necessary to migrate a Visual Basic 6.0 application to Visual Basic 2005 in order to take advantage of .NET functionality. Instead, you can integrate Microsoft Windows Desktop Search into a Visual Basic 6.0 application by using COM objects that have been created with Visual Basic 2005. This approach lets you take advantage of all of the functionality of the Microsoft .NET Framework without having to rewrite your application.
This article demonstrates another practical example of using .NET functionality to expand and modernize a Visual Basic 6.0 application—in this case, adding mapping capabilities via the Microsoft MapPoint Web Service API.
Of course, the example is intended only to show you how to access MapPoint Web Service from Visual Basic 6.0—not to show off everything that MapPoint Web Service can do for your applications. How to make MapPoint Web Service a part of your applications is up to you, but here are a few ideas:

You can add a feature to a sales-force automation application that allows sales reps to specify which customers they plan to visit on a particular day, and automatically generate driving directions from one customer site to the next.
Perhaps you work for a company that builds new homes, and you manage an application that tracks potential real-estate investments. You could use MapPoint Web Service to add a map of the area—including schools, shops, and so forth—to forms and reports that document those potential investments.
Maybe you have to validate addresses. You could use MapPoint Web Service to return possible matches to an address that you have entered into your application.

The Sales Support Application

Installation

Operation

Figure 1. The Sales Support Login form
After you have logged on, the main application window appears, as shown in Figure 2. The application provides three different views of the sales information. The Accounts tab provides the first view and shows each account and associated sales information. This view can be sorted differently by clicking on a column heading. The Contacts tab provides the second view and shows more detailed information about each individual contact. The Forecast tab provides the third view and displays future sales-forecast information.

Customer-Mapping Enhancement

Mapping and geographic functionalities are becoming standard features of line-of-business applications, whether they validate addresses or provide driving directions for customer visits. In Visual Basic 6.0, there is no built-in way to generate maps. Microsoft does provide extensive mapping capabilities through MapPoint Web Service, but there’s no easy way to call this service from Visual Basic 6.0. Calling MapPoint Web Service from Visual Basic 2005, however, is almost trivial. By using the extension that is described in this article, you can map a customer location, as shown in Figure 3.

Figure 3. Mapping a customer location

Application Architecture

The core of the application is a Visual Basic 6.0 application that communicates with a SQL Server 2005 Express database. When you click the Map button, the client address is passed to a Visual Basic 2005 form. The Visual Basic 2005 form communicates with MapPoint Web Service to retrieve a map image for the address. The map is rendered on the Visual Basic 2005 form, which also allows the user to zoom in and zoom out.

Figure 4. Application data flow

Visual Basic 2005 Implementation

For some time, mapping capabilities have been available through Web sites, many of which make it easy for a user to look up a location. However, pulling maps into an application is more challenging. To use a typical Web site, you would have to write code to download and parse the HTML; if the site changed its layout, your application could easily break.
Web services offer an alternative to screen-scraping Web sites. Web services are not intended to be used by a human being with a browser. Instead, Web services take requests as XML over HTTP, and return results as XML. Web services use the same infrastructure as Web sites, but they’re designed specifically to communicate with applications—not with people.
By using Visual Studio 2005, communicating with Web services is even easier. Visual Studio 2005 generates classes for you that take care of creating and parsing the XML. You just create an instance of a class, call a function, and get a result.
In the case of mapping data, a Web service makes perfect sense, because you would not want to deploy worldwide detailed maps to every desktop, and you would not want to have to keep that mapping data updated. Instead, it would make much more sense just to retrieve the map for a specific area, on demand. Microsoft MapPoint Web Service provides exactly that capability.
To begin using MapPoint Web Service, you have Visual Studio 2005 download a definition file for the service and generate client-side "proxy" classes. You do this through the Project | Add Web Reference menu command in Visual Studio 2005.

Figure 5. Adding a Web reference
The definition for a Web service is contained in a Web Services Description Language (WSDL) document—in this case, http://staging.mappoint.net/standard-30/mappoint.wsdl. Visual Studio 2005 downloads this WSDL document and generates a proxy class under a MapPointService namespace.

Looking up Addresses by Using MapPoint Web Service

After the Web reference has been added, you can begin writing code to make requests and process responses from the Web service.

             
                             
Dim address As New MapPointService.Address()
address.FormattedAddress = Me.Address

Dim findOptions As New MapPointService.FindOptions()
findOptions.ThresholdScore = 0

Dim findAddressSpec As New MapPointService.FindAddressSpecification
With findAddressSpec
    .InputAddress = address
    .DataSourceName = "MapPoint.NA"
    .Options = findOptions
End With

findService.Credentials = credentials
findResults = findService.FindAddress(findAddressSpec)

Listing 1. Looking up an address in MapPoint Web Service
The first step in using MapPoint Web Service is to find the latitude and longitude for an address. You begin by creating an instance of the Address class. This class was automatically generated when the Web service was referenced. You set the FormattedAddress property to the text address that you want to look up.
When you search for an address, multiple possible matches could be returned if the address is not exactly matched. The ThresholdScore property of the FindOptions class lets you control how closely an address must match to be returned. Regardless of the ThresholdScore value, address matches are returned in order from best to worst.
The address and options are then linked to a FindAddressSpecification. In addition, the specification lets you specify which data source you want to search. For example, you can search North America, Europe, or other data sources.
To communicate with MapPoint Web Service, you must specify credentials. In this example, the application is connecting to the MapPoint Web Service staging service, not to the production Web service, so that developer credentials will suffice. (For your convenience, I've hard-coded credentials into the application. If those credentials stop working at some future date, you can apply for your own developer credentials at https://mappoint-css.partners.extranet.microsoft.com/MwsSignup/Eval2.aspx.)
At this point, you have configured the information that is necessary for MapPoint Web Service to look up the address and return latitude and longitude information—key inputs for any mapping service. When the FindAddress method of findService is called, the request is packaged as XML and sent over the Internet to MapPoint Web Service. The results are obtained, and they are returned as XML. The proxy class, which is created by Visual Studio 2005, parses the XML and returns the results in the findResults object.

Requesting a Map from MapPoint Web Service

Now, you're ready to request a map image for the address. You accomplish this by using the code that is shown in Listing 2.

             
                             
' Set the centerpoint on and scale of
' the map location you want to display
Dim mapViews(0) As ViewByScale
mapViews(0) = New ViewByScale
With mapViews(0)
    .CenterPoint = Me.findResults.Results(0).FoundLocation.LatLong
    .MapScale = ZoomScrollBar.Value * ZoomScrollBar.Value
End With

' Add a pushpin to the map
Dim pushPins(0) As Pushpin
pushPins(0) = New Pushpin
With pushPins(0)
    .PinID = "pin0"
    .Label = PushPinName
    .IconName = "0"
    .IconDataSource = "MapPoint.Icons"
    .LatLong = mapViews(0).CenterPoint
End With

' Customize the map display options
Dim options As New MapOptions
With options
    .Format = New ImageFormat
    .Format.Height = PictureBox1.Height
    .Format.Width = PictureBox1.Width
End With

Dim mapSpec As New MapSpecification
With mapSpec
    .Views = mapViews
    .Options = options
    .DataSourceName = "MapPoint.NA"
    .Pushpins = pushPins
    .HideEntityTypes = New String() {"School"}
End With

' Retrieve the map image
renderService.Credentials = credentials
Dim mapImages() As MapImage = renderService.GetMap(mapSpec)

PictureBox1.Image = New System.Drawing.Bitmap(New _
    System.IO.MemoryStream(mapImages(0).MimeData.Bits))

Listing 2. Requesting a map for the address
There are a number of objects that must be sent to request a map image. First, you create a ViewByScale object. The CenterPoint property is set to the latitude and longitude of the address that was previously retrieved. Next, you set the MapScale property. This controls how zoomed in or zoomed out the map is. In this application, this value is controlled by a scroll bar, so that the user can control the zoom level. In addition, it works better to change this value logarithmically instead of linearly, so that the value of the scroll bar is squared when you set the MapScale property (otherwise, zooming out could take a very long time).
To create a label on the map by using the business name, you create pushpins. You use the Label property to specify the text that you want, and the Icon property to specify the icon to appear on the map. Next, you create an instance of a MapOptions class, and set properties to define the height and width of the image that you want returned. This information is all connected to a MapSpecification object, and sent to the MapPoint Web Service RenderService. The RenderService generates an image of the requested area, and returns the image (encoded in XML) back to the application.
Again, the application parses the XML and returns the data. There's just one small bit of conversion to convert the image data to an actual BitMap data type, and then the image can be displayed in a PictureBox. The results are rendered as shown in Figure 3.

Interoperability with Visual Basic 6.0

Now, you have .NET code with mapping capability. However, how do you tie that to your existing Visual Basic 6.0 application? The answer is: You use the Interop Forms Toolkit 2.0 () to create a Visual Basic 2005 form that can easily be called from Visual Basic 6.0. When you install the Interop Forms Toolkit 2.0 into Visual Studio 2005, it provides a new Visual Basic 6.0 InteropForm item type that you can add to your projects. This is a .NET form that is easily callable from Visual Basic 6.0.

Figure 6. Adding a Visual Basic 6.0 InteropForm item type
The InteropForm is a standard .NET form that contains a number of attributes that control which portions of the form are COM-callable. Listing 3 shows a section of this form code.

             
                             
Imports System.Windows.Forms
Imports Microsoft.InteropFormTools
Imports VBNET_Extensions.MapPointService

<InteropForm()> _
Public Class MapPointForm
    Private findResults As FindResults
    Private renderService As New RenderServiceSoap
    Private findService As New FindServiceSoap

    Private isInitialized As Boolean = False

    Private m_address As String
    <InteropFormProperty()> _
    Public Property Address() As String
        Get
            Return m_address
        End Get
        Set(ByVal value As String)
            If value <> m_address Then
                m_address = value
                findResults = Nothing
                RenderTimer.Enabled = True
            End If
        End Set
    End Property
    
    ...

End Class

Listing 3. Visual Basic 6.0 InteropForm item type
The form contains an InteropForm attribute, and any properties or methods that you want to make available to Visual Basic 6.0 are also decorated with an attribute, such as the InteropFormProperty and InteropFormMethod attributes.
There are two steps to compiling your Visual Basic 2005 COM objects. First, you select the Tools | Generate InteropForm Wrapper Classes menu command. This generates COM wrapper code that is based on your attributes. Then, you just build the project by using the Build | Build Solution menu command.

Figure 7. Generating the InteropForm wrapper classes

Calling the .NET Form from Visual Basic 6.0

After you have created an interoperable form, you can call it from Visual Basic 6.0, as with any other COM object. From Visual Basic 6.0, you can just add a reference to your Visual Basic 2005 code.

Figure 8. Referencing a Visual Basic 2005 component from Visual Basic 6.0
As soon as the component is referenced, you can create an instance of your Visual Basic 2005 form, set properties, and perform other operations.

             
                             
Private Sub cmdMap_Click()
    Dim frmMap As VBNET_Extensions_MapPointForm
    Set frmMap = New VBNET_Extensions_MapPointForm
    
    frmMap.Address = rsAccount("Address") & ", " & _
        rsAccount("City") & ", " & _
        rsAccount("Region") & "  " & _
        rsAccount("PostalCode")
    
    frmMap.PushPinName = rsAccount("CompanyName")
    frmMap.Show
End Sub

Listing 4. Calling into a Visual Basic 2005 form from Visual Basic 6.0
Here, customer data from the database is passed to the Address property of the form. The PushPinName property is set to the company name, which will cause the company name to appear on the map image. Finally, the form is shown displaying the map.

Conclusion

If you have applications that are written in Visual Basic 6.0, you can preserve those investments, and just extend them by using Visual Basic 2005. In this article, I showed how to call a Web service via Visual Basic 2005 and add MapPoint Web Service functionality to a Visual Basic 6.0 application.

Additional Resources

For more information on using MapPoint Web Service, check out the following links:

MapPoint Web Service Resources/Virtual Earth Developer Centerhttp://msdn.microsoft.com/mappoint/
MapPoint Web Service Technical Articles
bb507685
MSDN Library
"Getting Started with the MapPoint Web Service SDK"

About the author

Enhancing an Application with Windows Desktop Search and Office Outlook Integration

2017-03-14T11:05:00.003-07:00

Visual Studio 2005

Sales Support: A Hybrid Visual Basic 6.0 & Visual Basic 2005 Application, Part 1
Scott Swigart
February 2008
Summary: This article, the first in a four-part series, shows that it is not necessary to migrate a Microsoft Visual Basic 6.0 application to Microsoft Visual Basic 2005 in order to take advantage of .NET functionality. (15 printed pages)
Click here to download the application installer.
Click here to download the application source code.

Introduction
The Sales Support Application
Windows Desktop Search Enhancement
Application Architecture
Visual Basic 2005 Implementation
Visual Basic 6.0 Implementation
Conclusion
Additional Resources

Introduction

Business and other organizations have written billions of lines of code in Microsoft Visual Basic 6.0 since its introduction in 1998. Considering how expensive and time-consuming it can be to upgrade important—even mission-critical—Visual Basic 6.0 applications to Microsoft Visual Basic 2005, it is extremely common for organizations to continue maintaining and even enhancing existing Visual Basic 6.0 applications.
Many developers and business have the impression that porting an application to the Microsoft .NET Framework is a prerequisite to using the .NET Framework for application enhancements. This is not the case. In fact, you can extend existing Visual Basic 6.0 applications by building new components in Visual Basic 2005. There is no need to port the entire application to Visual Basic 2005.
This series of articles covers different ways to extend an existing Visual Basic 6.0 application—in this case, a sample sales-force automation application—by using Visual Basic 2005 and the .NET Framework.

The Sales Support Application

Installation

The Sales Support installer (http://download.microsoft.com/download/A/5/6/A56DD645-14AF-4CC2-BEC6-EEBE5B284167/installer.03.zip) has been tested on Microsoft Windows XP SP2 and on Windows Vista, and likely would work on older operating systems, too. Because this is a hybrid Visual Basic 6.0 and Visual Basic 2005 application, the Sales Support installer will install the.NET Framework 2.0 as a prerequisite. This application also stores data in a back-end database. For this reason, the installer will install Microsoft SQL Server 2005 Express Edition, which replaces Microsoft SQL Server 2000 Desktop Engine (MSDE 2000).
If you do not have these prerequisites installed, the installer will download them for you automatically. If they are already installed, the installer will detect their presence and skip to the application installation.
The installation of prerequisites is something that Microsoft Visual Studio 2005 greatly simplifies. You can just select application prerequisites, as shown in Figure 1.

Figure 1. Making application prerequisites with Visual Studio 2005
When you create an installer for a hybrid application, the best strategy is to create a new Visual Studio 2005 Setup Project, which will install any prerequisites, such as the .NET Framework, and any Visual Basic 2005 extensions for your application. This installer will launch the existing installer for your Visual Basic 6.0 application, too, after the prerequisites and Visual Basic 2005 extensions are in place.
You continue to build your Visual Basic 6.0 installer as you always have: by using the Visual Studio 6.0 Package and Deployment wizard, or any of the excellent third-party deployment products. The result for users is that they need only launch a single installer to have your application—and everything on which it depends—be installed.

Operation

After the application is installed, you can launch it from the Start menu. Look for the Sales Support8_3 entry. The application will initially prompt you to log on. To simplify use, the user name and password fields default to working values, as shown in Figure 2. You can just click the Login button to continue.

Figure 2. The Sales Support Login form
After you have logged on, the main application window appears, as shown in Figure 3. The application provides three different views of the sales information. The Accounts tab provides the first view and shows each account and associated sales information. This view can be sorted differently by clicking on a column heading. The Contacts tab provides the second view and shows more detailed information about each individual contact. The Forecast tab provides the third view and displays future sales-forecast information.

Figure 3. The main application window
Again, the Sales Support application is not designed to be a working sales-force solution. Instead, it serves only as a basis for realistic application enhancements.

Windows Desktop Search Enhancement

Sales-force applications must track the flow of communications to the client. A logical extension for the Sales Support application would be better integration with e-mail. It would be especially useful to be able to retrieve all of the communication to and from a particular contact, and to do so from within the application itself.
Microsoft provides this base functionality through the free Microsoft Windows Desktop Search (WDS). WDS typically runs as its own separate application; however, for the best user experience, it would be better to surface the WDS functionality directly as part of the Sales Support user interface.
The first extension to Sales Support does exactly that. It includes a new form, implemented in Visual Basic 2005 that retrieves all e-mail messages to and from a client by using WDS. The client database contains a set of fictitious e-mail addresses. To use the WDS functionality, it's recommended that you edit one of the clients to contain an e-mail address with which you have communicated.
To configure a real e-mail address:

Run the Sales Support application.
Click the Contacts tab. You will see contacts listed, as shown in Figure 4.

Figure 4. The Contacts tab

Double-click the name of a contact, to edit that contact.

Figure 5. Editing a contact

Change the e-mail address of the contact to your e-mail address, your boss's e-mail address, or some other e-mail address with which you have communicated, and then click OK.

The search functionality is accessed through a new Communications button on the Contacts tab, as shown in Figure 6.

Figure 6. Windows Desktop Search enhancement
When the Communications button is clicked, the Visual Basic 6.0 application calls out to a form that was built by using Visual Basic 2005. This form calls into WDS to retrieve the e-mail communications with the selected contact, as shown in Figure 7.

Figure 7. New Visual Basic .NET form with search results
Because Visual Basic 2005 was used for this enhancement, this form gets a number of features for free. Firstly, the splitter bar between the grid and text area just works and requires zero code, because Visual Basic 2005 includes a SplitPanel control. Secondly, the form and its controls resize intelligently, because .NET Framework controls support docking: The controls just fill whatever space is available to them.

Application Architecture

The core of the application is a Visual Basic 6.0 application that communicates with a SQL Server 2005 Express database. When you click the Communications button on the Contacts form, the e-mail address of the contact is passed to the Visual Basic 2005 form. As soon as the Visual Basic 2005 form has the e-mail address, it calls into Windows Desktop Search to retrieve the list of communications, and then calls into Microsoft Office Outlook to retrieve the e-mail contents.

Figure 8. Application data flow

Visual Basic 2005 Implementation

You can create forms that are callable from Visual Basic 6.0 by installing Visual Studio 2005 and the Interop Forms Toolkit 2.0. By using the Interop Forms Toolkit 2.0, you can create Visual Basic 2005 forms that appear to Visual Basic 6.0 as regular COM objects.
The first steps are to install the Interop Forms Toolkit 2.0, start Visual Studio 2005, and create a new Visual Basic 6.0 InteropForm Library project, as shown in Figure 9.

Figure 9. Creating an InteropForm Library project
The new project contains an InteropForm item. This item is a regular Visual Basic 2005 form that contains additional information that indicates that a COM wrapper should be generated, making it easy for Visual Basic 6.0 to call into this form. If you want your component to contain multiple forms, you can just add additional InteropForm project items, as shown in Figure 10.

Figure 10. Adding additional InteropForms to the project
In the InteropForm, you can easily mark various properties and methods as being COM-callable. For properties, you just use the InteropFormProperty attribute, as shown in Listing 1.

             
                             
    <InteropFormProperty()> _
    Public Property EmailAddress() As String
        Get
            Return m_emailAddress
        End Get
        Set(ByVal value As String)
            If value <> m_emailAddress Then
                m_emailAddress = value
            End If
        End Set
    End Property

Listing 1. Exposing Visual Basic 2005 form properties to Visual Basic 6.0
This property will allow the Visual Basic 6.0 application to specify the e-mail address for which communications should be found. The actual searching is performed by the Search function that is shown in Listing 2.

             
                             
    <InteropFormMethod()> _
    Public Sub Search()
        LabelSearching.Visible = True
        Application.DoEvents()

        Dim cn As New OleDbConnection( _
            "Provider=Search.CollatorDSO;" & _
            "Extended Properties='Application=Windows';")
        Try
            cn.Open()
        Catch
            MessageBox.Show("Search functionality is dependent " & _
                "on Windows Desktop Search 3.0 or later, " & _
                "which is not installed.")
            Me.Close()
            Return
        End Try

        Dim da As New OleDbDataAdapter("Select System.Title, " & _
            "System.ItemURL, " & _
            "System.Message.SenderName, " & _
            "System.Message.SenderAddress, " & _
            "System.Message.ToAddress, " & _
            "System.Message.DateSent  " & _
            "from systemindex " & _
            "where (System.Message.SenderAddress = '" & _
                m_emailAddress & "' " & _
            "or CONTAINS(System.Message.ToAddress, '" & _
                m_emailAddress & "')) " & _
            "and CONTAINS(System.Message.MessageClass, 'MAPI')" & _
            "order by System.Message.DateSent desc", cn)

        Dim dt As New DataTable
        da.Fill(dt)
        dt.Columns.Add("To", GetType(String))
        For Each dr As DataRow In dt.Rows
            Dim toAddress As New StringBuilder
            For Each address As String In dr("System.Message.ToAddress")
                If toAddress.Length = 0 Then
                    toAddress.Append(address)
                Else
                    toAddress.Append(", ").Append(address)
                End If
            Next
            dr("To") = toAddress.ToString()
        Next

        bs.DataSource = dt

        WdsResultsDataGridView.AutoGenerateColumns = False
        WdsResultsDataGridView.DataSource = bs
        bs.ResetBindings(False)

        LabelSearching.Visible = False

        cn.Close()
    End Sub

Listing 2. Visual Basic 2005 Search function
You can see that this function is marked with the InteropFormMethod attribute, which exposes the Search function to Visual Basic 6.0 applications.
WDS exposes an OLE DB provider, which allows you to query WDS by using SQL statements. Here, you can see that a select statement is retrieving the sender name, "to" address, date sent, and other information. The results are limited to e-mail messages to or from the contact, and are sorted by date. The details of forming a WDS query can be a little complex, as WDS supports many fields and search options. (For links to WDS queries, see the Additional Resources section.)
An e-mail can be sent to multiple reciepients, so that additional code is used to generate a derived column that contains a comma-separated list of "to" addresses. Finally, a DataGridView control is bound to the results.
In Figure 5, you can see that the form shows also a preview of the actual message. This information is not available from WDS, which is just an index into e-mail messages and files. Instead, the form must communicate with Office Outlook to get the e-mail contents.
Every time that the user clicks on a different e-mail message in the grid, an event fires on the underlying BindingSource object. The BindingSource object is responsible for keeping track of the current record (much as the Recordset object in Visual Basic 6.0) and firing events whenever something changes. The PositionChanged event of the binding source is a good place to retrieve the contents for the currently selected e-mail item, as shown in Listing 3.

             
                             
    Private Sub bs_PositionChanged(ByVal sender As Object, ByVal e As System.EventArgs) Handles bs.PositionChanged
        If outlookNs IsNot Nothing Then
            Dim dr As DataRow = bs.Item(bs.Position).row
            Dim s As String = EIDFromEncodedStringWDS30(dr("system.itemurl"))
            Dim mailItem As Object = outlookNs.GetItemFromID(s, Nothing)

            If mailItem IsNot Nothing Then
                RichTextBox1.Text = mailItem.body
            Else
                RichTextBox1.Text = "Unable to show preview."
            End If

        Else
            RichTextBox1.Text = "Outlook is not installed.  " & _
                "Unable to show preview"
        End If
    End Sub

Listing 3. Getting the message contents from Office Outlook
Items are retrieved from Office Outlook by using an item ID. WDS returns the item ID as a portion of the ItemURL field. The application extracts the ID from the ItemURL field, and then uses the Office Outlook object model to request the item. As soon as the item is retrieved, its contents are displayed in a rich-text box.

Visual Basic 6.0 Implementation

As you can see, creating the new form in Visual Basic 2005 is relatively straightforward and simple. Calling the new form from Visual Basic 6.0 also is straightforward and simple. When you compile the Visual Basic 2005 code, Visual Studio automatically registers it as a COM object. From Visual Basic 6.0, it just shows up in the References dialog box, as shown in Figure 11.

Figure 11. Referencing the Visual Basic 2005 extension from Visual Basic 6.0
As soon as the project has been referenced, you can call into the Visual Basic 2005 code as you would any other COM object. The code to display the search form is shown in Listing 4.

             
                             
Private Sub cmdCommunications_Click()
    Dim frmSearch As VBNET_Extensions_WdsForm
    Set frmSearch = New VBNET_Extensions_WdsForm
    frmSearch.Show
    frmSearch.EmailAddress = rsContacts("Email")
    DoEvents
    frmSearch.Search
End Sub

Listing 4. Calling into the Visual Basic 2005 extension from Visual Basic 6.0

Conclusion

In this example, you can see that it is not complicated to create Visual Basic 2005 extensions to existing Visual Basic 6.0 application; in fact, in many cases, it might well be the best course of action for many legacy applications. Extending existing applications by using Visual Basic 2005 allows you to leverage your existing investment and ramp up on Visual Basic 2005 as you go. It's a very low-risk approach (compared with migrating the entire application to Visual Basic 2005) and can allow you to make enhancements to your application very quickly.

Additional Resources

Visual Basic Developer Center
Microsoft Interop Forms Toolkit 2.0
MSDN Library
"Handy Tasks Using Microsoft Office Outlook 2003 and Visual Basic .NET"
"Overview of the Search SQL Syntax"

About the author

Calling Web Services from Visual Basic 6, the Easy Way

2017-03-14T11:03:00.004-07:00

Visual Studio 2005

Scott Swigart
Swigart Consulting LLC
April 2006
Applies to:
   Visual Basic 6
   Visual Basic .NET
   Visual Basic 2005
   Visual Studio 2005
Summary: This article shows you how to build an application that downloads satellite photos of a given street address from Visual Basic 6. (12 printed pages)

Introduction
The Application
Decisions
Where Art Thou?
A View from Beyond
Conclusion
Click here to download the code sample for this article.
Download the sample
CallingWebServicesfromVisualBasic6.msi
MSDNSamples\vb6

Introduction

Websites expose all sorts of useful information. Through Amazon, you can look up book ranks and make purchases; through Google, you can search the World Wide Web; with MapPoint, you can look up addresses and get directions; and through EBay, you can buy or sell, well, just about anything.
The problem with websites is that they don't expose information in a way that's easy for an application to consume. For example, you might want your customer service agents to have an application that lets them locate the nearest store, so that they can provide directions for customers who call in. Building an application that screen-scrapes MapPoint or MapQuest (1) would be hard, and (2) could break at any moment if those websites change in any way.
The answer is Web services. Web services typically let an application make requests over the Web, and rather than getting the data back as an HTML document, the data is returned as XML. This makes it very easy for the application to consume the information. Web services have emerged as the way that applications communicate with each other. In some cases, legacy back-end systems are wrapped with Web services in order to easily expose their data and functionality to the rest of the company. In other cases, Web-based providers (such as those listed above) add a Web service to allow programmatic access to the data and functionality that they currently provide to Web browsers.

The Application

For this article, I wanted to build an application that would download satellite photos of a given street address. I know that the satellite photos are available through the TerraServer Web service. I also know that you can convert a street address to a latitude/longitude through the MapPoint Web service and through Geocoder, so I know that all the building blocks are available.
First, I'll show you the completed application (see Figure 1), and then we'll examine how this was accomplished from Visual Basic 6.

Figure 1. Satellite photo of an address from Visual Basic 6

View the video for this article.

Decisions

There are two ways in which you can call a Web service from Visual Basic 6. You can use the Web Services Toolkit, but when you call a Web service that takes complex data, this leaves you dealing with a lot of raw XML. In addition, the satellite image will be returned from TerraServer as a series of image tiles that must be pieced together. This means that your application would get XML documents with Base64-encoded image tiles. The application would have to decode these and somehow stitch them together to make the complete image. From Visual Basic 6, this would not be fun.
With Visual Basic .NET, however, this is very simple. Visual Basic .NET can get the image tile and convert it to a bitmap, with just one line of code. It can also easily put the tiles together to make the complete image. In fact, you will find that, in most cases, the best way to call a Web service from Visual Basic 6 is to write a little bit of Visual Basic .NET code to make the call, and return the results as standard COM that Visual Basic 6 can consume.

Where Art Thou?

The first step is to convert a street address into the latitude and longitude coordinates needed by TerraServer. There are a couple ways to go about this. The "best" way would be to use something like the MapPoint Web service. This is a highly reliable Web service provided by Microsoft that can quickly convert the address to a latitude and longitude (a process known as "geocoding"). MapPoint is designed to be high-performance, scalable, and reliable enough that you can depend on it for mission-critical applications. However, MapPoint has a couple of downsides that make it less than ideal for casual use. First, you must register and obtain an evaluation user ID and password. This authentication information is used to make calls to the MapPoint service. This free evaluation ID is valid for only 45 days. Also, after you register, it can take a couple of days for you to receive your ID. I wanted to provide you with a sample application that you could just download and run, without any special registration or setup; therefore, in addition to MapPoint, I included another option for geocoding the address.
The Geocoder.us website also provides functionality for turning a street address into lat/long coordinates. If you send the address as part of the query string, the site will return an XML document containing the lat/long information. To begin, I created a very simple class to hold the lat/long results (see Listing 1).

Listing 1. Class to hold lat/long information

<ComClass(LatLongInfo.ClassId, LatLongInfo.InterfaceId, _
LatLongInfo.EventsId)> _
Public Class LatLongInfo

#Region "COM GUIDs"
    Public Const ClassId As String = "4362FF28-FFF7-4BCE-B844-8CF4208536AC"
    Public Const InterfaceId As String = "4A8FC896-6A9D-4F85-8B55-104CE4211829"
    Public Const EventsId As String = "B9108846-8A2C-4698-831B-D3BC197168C5"
#End Region

    Public Sub New()
        MyBase.New()
    End Sub

    Private _lat As Double
    Public Property Lat() As Double
        Get
            Return _lat
        End Get
        Set(ByVal Value As Double)
            _lat = Value
        End Set
    End Property

    Private _long As Double
    Public Property [Long]() As Double
        Get
            Return _long
        End Get
        Set(ByVal Value As Double)
            _long = Value
        End Set
    End Property
End Class

This class just contains properties for the latitude and longitude. In addition, the class contains attributes so that it will be exposed as a COM object that can be used directly from Visual Basic 6.
The Geocoder site can then be used to look up an address and populate a LatLongInfo object with the information (see Listing 2).

Listing 2. Using Geocoder to get the lat/long for an address

    Public Function AddressToLatLongGeocoder(ByVal address As String) _
    As LatLongInfo
        Dim wc As New WebClient
        Dim geocodeStream As Stream = _
            wc.OpenRead("http://geocoder.us/service/rest?address=" _ 
            & address)

        Dim xr As New XmlTextReader(geocodeStream)

        Try
            Dim ll As New LatLongInfo
            While xr.Read()
                If xr.Name = "geo:lat" Then
                    ll.Lat = CDbl(xr.ReadInnerXml)
                End If
                If xr.Name = "geo:long" Then
                    ll.Long = CDbl(xr.ReadInnerXml)
                End If
            End While

            wc.Dispose()
            Return ll
        Catch
            Return Nothing
        End Try

    End Function

The thing I love about .NET is that it makes interacting with the Web so easy. The WebClient class lets you "open" a URL as though it were a file. Since this "file" is an XML document, I can just use the XmlTextReader to look through the results for XML elements with certain names. When I find them, I just grab the values and put them into my LatLongInfo class. If the website is unable to resolve the address, this function will return Nothing; otherwise, it will return a LatLongInfo class with the latitude and longitude of the street address.
I also mentioned that you could use the MapPoint Web service to get the lat/long for an address. The code for this is even simpler that using Geocoder (see Listing 3).

Listing 3. Geocoding an address using the MapPoint Web service

    Public Function AddressToLatLongMapPoint(ByVal address As String, _
        ByVal username As String, ByVal password As String) As LatLongInfo

        Dim fs As New MapPoint.FindServiceSoap
        fs.Credentials = New System.Net.NetworkCredential(username, password)
        fs.PreAuthenticate = True

        Dim addressInfo As New MapPoint.Address
        addressInfo.FormattedAddress = address
        Dim fas As New MapPoint.FindAddressSpecification
        fas.InputAddress = addressInfo
        fas.DataSourceName = "MapPoint.NA"

        Dim results As MapPoint.FindResults = fs.FindAddress(fas)

        Dim ll As New LatLongInfo
        If results.Results.Length = 0 Then
            Return Nothing
        Else
            With results.Results(0).FoundLocation.LatLong
                ll.Lat = .Latitude
                ll.Long = .Longitude
            End With
        End If
        Return ll
    End Function

The first few lines of this function just set up the user ID and password so that they will be sent to the MapPoint Web service. To make any calls to the MapPoint Web service, you must have already created an account. If you don't have an account, and you want to use MapPoint instead of Geocoder, you can register for an account here.
The code then creates a MapPoint Address object and populates it with the address supplied by the user. MapPoint has a number of data sources (North America, Europe, and so on), and so the FindAddressSpecification.DataSourceName is set to MapPoint.NA, indicating that North America will be searched.
Finally, the call is made to FindAddress. This returns a FindResult object that contains the latitude and longitude information. This information is then just copied into my custom LatLongInfo class and returned.

A View from Beyond

Now that you know the latitude and longitude for the street address, TerraServer can return a satellite image of that location. The image comes in the form of image "tiles" that you must splice together to make the complete image. The code to do this is provided on the TerraServer website. I lifted this code and converted it to Visual Basic .NET. The code begins by simply calculating the pixel width and height of the desired image (see Listing 4).

Listing 4. Calculating image dimensions in Visual Basic .NET

    Public Function DownloadSatteliteImage(ByVal latLong As LatLongInfo, _
        ByVal scale As Integer, _
        ByVal widthTwips As Double, _
        ByVal heightTwips As Double) As Object

        Dim center As New LonLatPt
        Dim theme As Integer
        Dim mapWidth As Integer
        Dim mapHeight As Integer

        center.Lon = latLong.Long
        center.Lat = latLong.Lat
        theme = 1
        mapWidth = Compatibility.VB6.TwipsToPixelsX(widthTwips)
        mapHeight = Compatibility.VB6.TwipsToPixelsY(heightTwips)

Visual Basic .NET contains some helper functions that make it easy to convert from Visual Basic 6 twips to standard pixels. This allows the Visual Basic 6 application to pass in the height and width of the Image control as twips, and the Visual Basic .NET code is able to calculate the pixel dimensions so that it can call the TerraServer service and correctly obtain the image.
Next, the code calls TerraServer with the image dimensions, and TerraServer returns a list of tile IDs for the area that you want to view (see Listing 5).

Listing 5. Obtaining tile IDs for the area you want to view

        Dim ts As New TerraService
        Dim abb As AreaBoundingBox = ts.GetAreaFromPt(center, _
            theme, scale, mapWidth, mapHeight)

The AreaBoundingBox contains a list of all the image tiles that will need to be downloaded in order to create the complete image for the requested area. As each tile is downloaded, it will be drawn into a .NET Framework Bitmap object, which will eventually hold the completed image. The Bitmap class makes it astonishingly easy to draw and work with graphics (see Listing 6).

Listing 6. Creating a Bitmap object to hold the satellite photo

        Dim pf As PixelFormat = PixelFormat.Format32bppRgb
        Dim compositeImage As Bitmap = New Bitmap(mapWidth, mapHeight, pf)
        Dim compositeGraphics As Graphics = Graphics.FromImage(compositeImage)

At this point, each tile can be downloaded and drawn to form the composite image (see Listing 7).

Listing 7. Downloading each tile and adding it to the composite image

        Dim xStart As Integer = abb.NorthWest.TileMeta.Id.X
        Dim yStart As Integer = abb.NorthWest.TileMeta.Id.Y
        For x As Integer = xStart To abb.NorthEast.TileMeta.Id.X
            For y As Integer = yStart To abb.SouthWest.TileMeta.Id.Y Step -1
                Dim tid As TileId = abb.NorthWest.TileMeta.Id
                tid.X = x
                tid.Y = y
                Dim tileImage As Image = Image.FromStream( _
                    New MemoryStream(ts.GetTile(tid)))
                compositeGraphics.DrawImage(tileImage, _
                    (x - xStart) * tileImage.Width - _
                    CInt(abb.NorthWest.Offset.XOffset), _
                    (yStart - y) * tileImage.Height - _
                    CInt(abb.NorthWest.Offset.YOffset), _
                    tileImage.Width, tileImage.Height)
                tileImage.Dispose()
            Next
        Next

Here, each tile is downloaded and drawn on the composite image in the correct location. When this loop is finished, the entire satellite photo for the requested area will be downloaded, and the compositeImage object will contain the complete image. The only thing left to do is return this image so that it can be assigned to a Visual Basic 6 Image or PictureBox control.
I have to admit, the only part of this application that had me worried was returning the image to Visual Basic 6. I knew that the .NET Bitmap class, and the Visual Basic 6 Image controls were not directly compatible, and I thought that converting the Bitmap to something that Visual Basic 6 could use would be a pain. I spent some time panning for answers in the stream of Google, looking for Win32 API calls or libraries that had already been written. But then, just to make sure I wasn't overlooking something obvious, I looked through the Microsoft.VisualBasic.Compatibility.VB6 object. This is the same object that provided the twips to pixels conversion. Sure enough, it had an ImageToIPictureDisp method. The Picture property of the Image and PictureBox controls is an IPictureDisp, so this accomplished the conversion with one line of code (see Listing 8).

Listing 8. Returning the completed image from Visual Basic .NET to Visual Basic 6

        Return Compatibility.VB6.ImageToIPictureDisp(compositeImage)

From Visual Basic 6, you can call the DownloadSatelliteImage method, pass in the lat/long and size of the image control, and get a satellite photo that just fits (see Listing 9).

Listing 9. Calling DownloadSatelliteImage from Visual Basic 6

    Dim msw As MapServiceWrapper.SatImageService
    Set msw = New MapServiceWrapper.SatImageService
    Dim satImage As Object
    Set satImage = msw.DownloadSatteliteImage(latLong, hscrScale.Value, _
        imgSatPhoto.Width, imgSatPhoto.Height)
    Set imgSatPhoto.Picture = satImage

You can see that you just call DownloadSatelliteImage, passing in the lat/long, the scale (how zoomed-in you want the image to be), and the height and width. The Visual Basic .NET code does the work of calling TerraServer and composing the full image (see Figure 2). The image is returned, and it can just be assigned to the Picture property of the Visual Basic 6 Image control.

Figure 2. Image downloaded and displayed in a Visual Basic 6 application

Conclusion

Building this application with just Visual Basic 6 would have been really hard. To download a Web page, I would have needed to use a Web browser control, and then extract the document information. This is overkill compared to the simple classes that the .NET Framework provides for this task. The Web Services Toolkit would have been needed in order to call the Web services, leaving me to deal with a lot of raw XML. I don't know how I would have decoded the Base64-encoded image tiles or stitched them together.
However, by extending Visual Basic 6 with Visual Basic .NET, this was really easy to do. Hopefully, this article has illustrated how you could take an existing Visual Basic 6 application, and then extend it with Visual Basic .NET in order to pull real-time information from Web services. The Web services might be hosted inside of your organization to expose back-end systems, or they may exist on the Web—for example, Google, eBay, Amazon, or MapPoint. There are Web services that expose stock prices, weather information, and just about any other data. And, with the combination of Visual Basic 6 and Visual Basic .NET, they are all at your disposal.

About the Author Scott Swigart spends his time consulting, authoring, and speaking about emerging and converging technologies. Scott has worked with a wide range of technologies over his career, beginning with Commodore 64 programming at the age of 12, writing hardware diagnostics for UNIX systems in C++, and building Windows desktop and Web applications. Over the years, Scott has worked with component development, XML technologies, .NET, Web services, and other languages, platforms, and paradigms. With this experience, Scott has seen how technology evolves over time, and he is focused on helping organizations get the most out of the technology of today while preparing for the technology of tomorrow. Scott is also a Microsoft MVP, and co-author of numerous books and articles. Scott can be reached at scott@swigartconsulting.com.

MUKARAKAT

Cara Menghilangkan Gridlines Pada Excel

Printing Text

Printing to and beyond the Edges

Printing in Columns

Positioning the Cursor

Positioning Text

Changing Font Characteristics

Creating a 404 Error Tracker with Visual Basic 6.0

Introduction

Prerequisites

Quick Overview

Preparing IIS

Preparing SQL Server

Starting the DLL

Into the Code

Conclusion

Additional Information

About the Author

Comparison Between VB 6.0 and VB.NET Objects, Part 2

Visual Basic.NET Properties Descriptions and Settings

Comparison Between VB 6.0 and VB.NET Objects, Part 1

Visual Basic 6 Properties Descriptions and their Settings

Microsoft Visual Basic 6.0 Migration Resource Center

Migration Resources

Prepare

More Resources

Guidance

Training

Tools for Code Preparation

Tools for Full and Phased Migration

Visual Basic 6.0 Downloads

Essential Downloads

Additional Downloads

Additional Visual Basic 5.0 & 6.0 Samples

Visual Basic 6.0 Resource Center

Getting Started

Visual Basic Concepts Visual Basic Documentation Map

Other Documentation

Great Migrations Studio (gmStudio)

The Tool-Assisted Rewrite

Important Offer for You!

Benefits

Features

Additional Resources

ArtinSoft’s Visual Basic Upgrade Companion (VBUC)

Exciting Offer for You!

Benefits

Features

Learn More and Try it for Yourself

Additional Resources

Access the File System with .NET Framework Classes from Visual Basic 6

Contents

Introduction

Primer: Calling .NET from Visual Basic 6

Using the Path Class from Visual Basic 6

Using the FolderBrowserDialog from Visual Basic 6

Using the FileSystemWatcher from Visual Basic 6

Examining the Construction of IOLib

Conclusion

What's Going On? Accessing the Event Log from Visual Basic 6.0 Using the .NET Framework

Introduction

The .NET Framework EventLog Class

Instrumentation

Reading the Logs

Conclusion

Environmental Awareness: Accessing Operating System Information, Special Folders, and More with Visual Basic 6 and the .NET Framework

Contents

Introduction

Spin the Wheel of Win32

Welcome to System.Environment

Wrapping It Up

All Boxed Up

Implementing File Compression and Encryption in Visual Basic 6 Using the Microsoft .NET Framework, Part II: Compression

Contents

Introduction

Compression

Zipping Files and Folders

Running the Sample

Conclusion