The My component gives VB developers of all levels unprecedented programming power and allows us to perform tasks that would require substantial code if implemented with earlier versions of the language, not to mention the research it would take to locate the appropriate methods in the Framework. You can explore the My component on your own and use it as needed. My is not a substitute for learning the language and the Framework. It can help you initially, but you can't go far without learning the methods of the Framework. It will help you accomplish a whole lot with a few simple statements, and it will also give you a head start with the Framework, as the My component is a miniature Framework.

Let's say you want to locate all the files of a specific type in a folder, including its subfolders. Scanning a folder and its subfolders to any depth is quite a task (you'll find the code in the tutorial "Accessing Folders and Files" at www.sybex.com/go/masteringvb2010). You can do the same with a single statement by using the My component as follows:

Dim files As System.Collections.ObjectModel.ReadOnlyCollection(Of String)
files = My.Computer.FileSystem.GetFiles("D:Data", True, "*.txt")

The GetFiles method populates the files collection with the pathnames of the text files in the folder D:Data and its subfolders. The second argument determines whether the method will scan the specified folder recursively, and although you can pass a True/False value for this argument, you can also set it to one of the members of the FileIO.SearchOption enumeration: SearchAllSubDirectories and SearchTopLevelOnly. However, it won't help you if you want to process each file in place. Moreover, this GetFiles method is synchronous: If the folder contains many subfolders with many files, it will block the interface until it retrieves all the files. Once you have retrieved the filenames you're interested in, you can process them by iterating through the files collection with a For Each loop. As for the method's return type, you need not remember it. You will see it in the IntelliSense box—not to mention that you can turn on inference and let the editor figure out the type of the files variable.

Want to save data to a file and read it back at a later session? It's trivial with the FileSystem component. To send text to a file, call the WriteAllText method passing the text to be saved as an argument:

My.Computer.FileSystem.WriteAllText("file_name", your_text, False)

The first argument is the path of the file, the second argument is the text to be saved, and the last argument is a True/False value that determines whether the text will overwrite the file's original contents or append the text to the existing contents.

To read back the data from the file and use it in your application, use the ReadAllText method:

Dim txt As String = My.Computer.FileSystem.ReadAllText("file_name")

Of course, not all information we save to files is in text format. The WriteAllBytes and ReadAllBytes methods move an array of bytes to and from a file. Converting data to an array of bytes is no piece of cake. You can use the WriteAllText and ReadAllText methods to quickly save and read text to a file, but if you need to create files with structured data, you must look into the methods of the IO namespace, which is discussed in detail in one of the tutorials you can download from www.sybex.com/go/masteringvb2010. You can also take advantage of the serialization techniques discussed in Chapter 12, "Storing Data in Collections."

If you're already familiar with VB, you may think that the My component is an aid for the absolute beginner or the nonprogrammer. This isn't true. VB is about productivity, and the My component can help you be more productive with your daily tasks regardless of your knowledge of the language or programming skills. If you can use My to save a few (or a few dozen) statements, do it. There's no penalty for using the My component because the compiler replaces the methods of the My component with the equivalent method calls to the Framework. If you're not familiar with the My component, or if you're new to the Framework, please explore this component on your own. It will simplify your coding effort, as long as you can locate the method you need for the task at hand.

In the next sections we'll explore the most commonly used classes of the Framework. The classes discussed here are a very small part of the Framework, but they're the classes you'll be using the most. I have chosen the topics I believe you will find most useful and focused on them. Once you start working with the Framework and you learn to navigate through its classes, you'll find it much easier to explore other parts of the Framework on your own.

The System.IO.Directory class exposes all the members you need to manipulate folders. It's a shared class, which means that you can call its methods without having to create an instance of the Directory class. The methods of the Directory class are listed in Table 11.2.

The IO.File class exposes methods for manipulating files. The names of the methods are self-descriptive, and most of them accept as an argument the path of the file on which they act. Use these methods to implement from within your application the common operations that users normally perform through the Windows interface. To get an idea about the functionality of the File class, I'm listing its most important methods in Table 11.3.

The DriveInfo class provides basic information about a drive. Its constructor accepts as an argument a drive name, and you can use the object returned by the method to retrieve information about the specific drive, as shown here:

Dim Drive As New DriveInfo("C")

The argument is the name of a drive (you can include the colon if you want). Notice that you can't specify a Universal Naming Convention (UNC) path with the constructor of the DriveInfo object. You can only access local drives or network drives that have been mapped to a drive name on the target system.

To retrieve information about the specified drive, use the properties of the DriveInfo class listed in Table 11.4.

To create a new instance of the DirectoryInfo class that references a specific folder, supply the folder's path in the class's constructor:

Dim DI As New DirectoryInfo(path)

The members of the DirectoryInfo class are equivalent to the members of the Directory class, and you will recognize them as soon as you see them in the IntelliSense drop-down list. A few methods that are unique to the DirectoryInfo class are the CreateSubdirectory and GetFileSystemInfos methods. The CreateSubdirectory method creates a subfolder under the folder specified by the current instance of the class, and its syntax is as follows:

DI.CreateSubdirectory(path)

The CreateSubdirectory method returns a DirectoryInfo object that represents the new subfolder. The GetFileSystemInfos method returns an array of FileSystemInfo objects, one for each item in the folder referenced by the current instance of the class. The items can be either folders or files. To retrieve information about all the entries in a folder, create an instance of the DirectoryInfo class and then call its GetFileSystemInfos method:

Dim DI As New DirectoryInfo(path)
Dim itemsInfo() As FileSystemInfo
itemsInfo = DI.GetFileSystemInfos()

You can also specify an optional search pattern as an argument when you call this method:

itemsInfo = DI.GetFileSystemInfos(pattern)

Notice the differences between the GetFileSystemInfos method of the DirectoryInfo class and the GetFileSystemEntries of the Directory object. GetFileSystemInfos returns an array of objects that contains information about the current item (file or folder). GetFileSystemEntries returns an array of strings (the names of the folders and files).

The Path class's methods perform simple tasks such as retrieving a file's name and extension, returning the full path description of a relative path, and so on. The Path class's members are shared, and you must specify the path on which they will act as an argument. The most useful methods exposed by the Path class are utilities for manipulating filenames and pathnames, described in the following sections. Notice that the methods of the Path class are shared: You must specify the path on which they will act as an argument. The most important methods of the Path class are listed in Table 11.5.

To access files for reading and writing data with the Framework, you must first understand the concept of streams. A stream is a channel between your application and the source of the data. The source of the data need not be a file, although in most cases we use streams to work with files. If you've been around for a while, you're probably expecting to read about commands that open a file, write to it (or read from it), and then close the file. The reason for introducing the concept of streams in the Framework is that streams can be connected to one another and perform multiple operations sequentially. A typical example is the cryptographic stream, which accepts data, encrypts it, and spits out a series of bytes. This stream can be connected to a file stream and send encrypted data to the file.

Let's start by looking at the process of writing data to a file. First, you must import the IO namespace with the Imports System.IO statement. Then create a StreamWriter object, which is associated with a file:

Dim streamOut As New StreamWriter(file_name)

In this statement, file_name is the name of the file you want to write to.

To write something to the file, you call the streamOut variable's Write method. Everything you write to the stream is saved automatically to the file. To save the contents of a TextBox control to a file, use the following statement:

streamOut.Write(TextBox1.Text)

When you're done, you must close the Stream object by calling its Close method. The following statements prompt the user to select a file name with the Save dialog box and then save the contents of the TextBox control to the selected file:

SaveFileDialog1.Filter = "Text Files|*.txt|All Files|*.*"
SaveFileDialog1.FilterIndex = 0

SaveFileDialog1.DefaultExt = ".txt"
SaveFileDialog1.FileName = ""
If SaveFileDialog1.ShowDialog = Windows.Forms.DialogResult.OK Then
    Dim strmOut As New StreamWriter(SaveFileDialog1.FileName)
    strmOut.Write(TextBox1.Text)
    strmOut.Close()
End If

To read back the data in a later session, you must display the OpenFile dialog box to allow users to select the file and then create the StreamReader object and call its ReadToEnd method. Here's the code that reads back the contents of the TextBox1 control:

OpenFileDialog1.Filter = "Text Files|*.txt|All Files|*.*"
OpenFileDialog1.FilterIndex = 0
OpenFileDialog1.DefaultExt = ".txt"
OpenFileDialog1.FileName = ""
If OpenFileDialog1.ShowDialog = Windows.Forms.DialogResult.OK Then
    Dim strmIn As New StreamReader(OpenFileDialog1.FileName)
    TextBox1.Text = strmIn.ReadToEnd
    strmIn.Close()
End If

This concludes the brief introduction to the System.IO namespace. You will find much more information on the topic in the tutorial "Accessing Folders and Files" at www.sybex.com/go/masteringvb2010, but you should also explore the My.Computer.FileSystem component, which provides may shortcuts to the Framework for simple tasks.

Now that I've covered the auxiliary drawing objects, we can look at the drawing methods of the Graphics class. Before getting into the details of the drawing methods, however, let's write a simple application that draws a couple of simple shapes on a form. First, create a Graphics object with the following statements:

Dim G As Graphics
G = Me.CreateGraphics

Everything drawn on the surface represented by the G object will appear on the form. Then, create a Pen object to draw with. The following statement creates a Pen object that's 1 pixel wide and draws in blue:

Dim P As New Pen(Color.Blue)

You just created the two basic objects for drawing: the drawing surface and the drawing instrument. Now you can draw shapes by calling the Graphics object's drawing methods. The following statement will print a rectangle with its top-left corner near the top-left corner of the form (at a point that's 10 pixels to the right and 10 pixels down from the form's corner) and is 200 pixels wide and 150 pixels tall:

G.DrawRectangle(P, 10, 10, 200, 150)

Let's add the two diagonals of the rectangle with the following statements:

G.DrawLine(P, 10, 10, 210, 160)
G.DrawLine(P, 210, 10, 10, 160)

That's all the statements to create a shape on the form, but where do you insert them? The proper handler to create graphics is the form's Paint event handler, as the Paint event is fired every time the form is shown or resized, and this is when the graphics must be regenerated.

The Paint event handler passes the e argument, which (among other properties) exposes the form's Graphics object. You can create a Graphics object in the Paint event handler and then draw on this object. Take a look at the code in Listing 11.1.

Private Sub Form1_Paint(...) Handles Me.Paint
   Dim G As Graphics
   G = e.Graphics
   Dim P As New Pen(Color.Blue)
   G.DrawRectangle(P, 10, 10, 200, 150)
   G.DrawLine(P, 10, 10, 210, 160)
   G.DrawLine(P, 210, 10, 10, 160)
End Sub

If you run the application now, it works like a charm. The shapes appear to be permanent, even though they're redrawn every time you switch to the form. A caveat of drawing from within the Paint event is that the event isn't fired when the form is resized. To force a refresh when the form is resized, you must insert the following statement in the form's Load event handler:

Me.SetStyle(ControlStyles.ResizeRedraw, True)

It is possible to make the graphics permanent by drawing not on the Graphics object, but directly on the control's (or the form's) bitmap. This technique is discussed in the tutorial "Creating Graphics with VB 2010" that is available for download from www.sybex.com/go/masteringvb2010.

The drawing methods can be categorized in two major groups: the methods that draw stroked shapes (outlines) and the methods that draw filled shapes. The methods in the first group start with the Draw prefix (DrawRectangle, DrawEllipse, and so on). The methods of the second group start with the Fill prefix (FillRectangle, FillEllipse, and so on). Of course, some DrawXXX methods don't have equivalent FillXXX methods. For example, you can't fill a line or an open curve, so there are no FillLine or FillCurve methods.

Another difference between the drawing and filling methods is that the filling methods use a Brush object to fill the shape—you can't fill a shape with a pen. So, the first argument of the methods that draw filled shapes is a Brush object, not a Pen object. The remaining arguments are the same because you must still specify the shape to be filled. To view the drawing methods, enter the expression:

Me.CreateGraphics.

and you will see the names of the shape drawing methods (they start with the Draw prefix) and the shape filling methods (they start with the Fill prefix). The DrawLine method draws a straight-line segment between two points with a pen supplied as an argument. The simplest forms of the DrawLine method are the following, where point1 and point2 are either Point or PointF objects, depending on the coordinate system in use:

Graphics.DrawLine(pen, X1, Y1, X2, Y2)
Graphics.DrawLine(pen, point1, point2)

The two most commonly used drawing methods are the DrawString and MeasureString methods. The DrawString method renders a string in a single line or multiple lines. The simplest form of the DrawString method is as follows:

Graphics.DrawString(string, font, brush, X, Y)

The first argument is the string to be rendered in the font specified by the second argument. The text will be rendered with the Brush object specified by the brush argument. X and Y, finally, are the coordinates of the top-left corner of a rectangle that completely encloses the string.

While working with strings, you need to know the actual dimensions of the string when rendered with the DrawString method in the specified font so you can determine its placement. The MeasureString method allows you to retrieve the metrics of a string before actually drawing it. This method returns a SizeF structure with the width and height, in pixels, of the string when rendered on the same Graphics object with the specified font. We'll use this method extensively in the tutorial "Printing with Visual Basic 2010" (available for download from www.sybex.com/go/masteringvb2010) to position text precisely on the printed page. You can also pass a Rectangle object as an argument to the MeasureString method to find out how many lines it will take to render the string on the rectangle.

The simplest form of the MeasureString method is the following, where string is the string to be rendered and font is the font in which the string will be rendered:

Dim textSize As SizeF
textSize = Me.Graphics.MeasureString(string, font)

To center a string on the form, use the x-coordinate returned by the MeasureString method, as in the following code segment:

Dim textSize As SizeF
Dim X As Integer, Y As Integer = 0
textSize = Me.Graphics.MeasureString(string, font)
X = (Me.Width - textSize.Width) / 2
G.DrawString("Centered string", font, brush, X, Y)

To center a string, you must subtract the rendered string's length from the form's width, split the difference, and render half on each side of the string.

Figure 11.4 shows a string printed at the center of the form and the two lines passing through the same point. Listing 11.2 shows the statements that produced Figure 11.4.

Private Sub Form1_Paint(...) Handles Me.Paint
    Dim G As Graphics
    G = Me.CreateGraphics
    G.FillRectangle(New SolidBrush(Color.Silver), ClientRectangle)
    G.TextRenderingHint = Drawing.Text.TextRenderingHint.AntiAlias
    Dim txtFont As New Font("Verdana", 36, FontStyle.Bold)
    G.DrawLine(New Pen(Color.Green), CInt(Me.Width / 2), CInt(0),
                   CInt(Me.Width / 2), CInt(Me.Height))
    G.DrawLine(New Pen(Color.Green), 0, CInt(Me.Height / 2),
                   CInt(Me.Width), CInt(Me.Height / 2))
    Dim str As String = "Visual Basic 2010"
    Dim txtSize As SizeF
    txtSize = G.MeasureString(str, txtFont)
    Dim txtX, txtY As Integer
    txtX = (Me.Width - txtSize.Width) / 2
    txtY = (Me.Height - txtSize.Height) / 2
    G.DrawString(str, txtFont,
                      New SolidBrush(Color.Red), txtX, txtY)
End Sub

For more information on the DrawString and MeasureString methods, please see the tutorial on generating graphics with VB 2010. You will find more examples of these two methods later in this chapter.

Figure 11.4. Centering a string on a form

The DrawImage method renders an image on the Graphics object and its simplest syntax is as follows:

Graphics.DrawImage(img, point)

Both the image and the location of its top-left corner are passed to the method as arguments (as Image and Point arguments, respectively). Another form of the method draws the specified image within a rectangle. If the rectangle doesn't match the original dimensions of the image, the image will be stretched to fit in the rectangle. The rectangle should have the same aspect ratio as the Image object to avoid distorting the image in the process:

Graphics.DrawImage(img, rectangle)

The rectangle argument determines not only the placement of the image on the Graphics object, but also its dimensions.

Another very useful and interesting aspect of graphics is the generation of gradients. In addition to filling shapes with a solid color, you can fill them with various types of gradients. You can even fill text with a gradient, a topic that's demonstrated in the tutorial "Creating Graphics with VB 2010." The simplest yet most common type of gradient is the linear gradient. To fill a shape with a linear gradient, you must create an instance of the LinearGradientBrush class with statements like the following:

Dim lgBrush As LinearGradientBrush
lgBrush = New LinearGradientBrush(rect, startColor, endColor, gradientMode)

This method creates a gradient that fills a rectangle, specified by the rect variable passed as the first argument. This rectangle isn't filled with any gradient; it simply tells the method how long (or how tall) the gradient should be. The gradient starts with the startColor at the left side of the rectangle and ends with the endColor at the opposite side, while its color changes slowly as it moves from one end to the other. The last argument, gradientMode, specifies the direction of the gradient and its setting is a member of the LinearGradientMode enumeration: BackwardDiagonal, ForwardDiagonal, Horizontal, and Vertical. You will find an example of filling a shape with a linear gradient in the following section. The other types of gradients are discussed in the tutorial on graphics available for download from www.sybex.com/go/masteringvb2010.

The PrintDocument control represents your printer, and you must add a PrintDocument control to any project that generates printouts. In effect, everything you draw on the PrintDocument object is sent to the printer. The PrintDocument control represents the printing device, and it exposes a Graphics object that represents the printing surface, just like the Graphics property of all Windows controls. You can program against the Graphics object by using all the graphics methods discussed earlier in this chapter. To print text, for example, you must call the DrawString method. You can also print frames around the text with the DrawLine or DrawRectangle method. In general, you can use all the methods of the Graphics object to prepare the printout.

The PrintDocument control is invisible at runtime, and its icon will appear in the Components tray at design time. When you're ready to print, call the PrintDocument control's Print method. This method doesn't produce any output, but it does raise the control's BeginPrint and PrintPage events. The BeginPrint event is fired as soon as you call the Print method, and this is where you insert the printout's initialization code. The PrintPage event is fired once for every page of the printout, and this is where you must insert the code that generates output for the printer. Finally, the EndPrint event is fired when the printout ends, and this is where you insert the code to reset any global variables.

The following statement initiates the printing:

PrintDocument1.Print

This statement is usually placed in a button's or a menu item's Click event handler. To experiment with simple printouts, create a new project, place a button on the form, add an instance of the PrintDocument control to the form, and enter the preceding statement in the button's Click event handler.

After the execution of this statement, the PrintDocument1_PrintPage event handler takes over. This event is fired for each page, so you insert the code to print the first page in this event's handler. The PrintPage event provides the usual e argument, which gives you access to the Graphics property of the current Printer object. The printer has its own Graphics object, which represents the page you print on, and you will see shortly how to create graphics to be printed.

If you need to print additional pages, you set the e.HasMorePages property to True just before you exit the PrintPage event handler. This will fire another PrintPage event. The same process will repeat until you've printed everything. After you finish, you set the e.HasMorePages property to False, and no more PrintPage events will be fired. Instead, the EndPrint event will be fired and the printing process will come to an end. Figure 11.5 outlines the printing process.

Figure 11.5. All printing takes place in the PrintPage event handler of the PrintDocument object.

The code in Listing 11.3 shows the structure of a typical PrintPage event handler. The PrintPage event handler prints three pages with the same text but a different page number on each page.

Private Sub PrintDocument1_PrintPage(...) Handles PrintDocument1.PrintPage
   Static pageNum As Integer
   Dim prFont As New Font("Verdana", 24, GraphicsUnit.Point)
   e.Graphics.DrawString(
               "PAGE " & pageNum + 1, prFont,
               Brushes.Black, 700, 1050)
   e.Graphics.DrawRectangle(Pens.Blue, 0, 0, 300, 100)
   e.Graphics.DrawString( _
               "Printing with VB 2010", prFont,
               Brushes.Black, 10, 10)

' Following is the logic that determines whether we're done printing
   pageNum = pageNum + 1
   If pageNum <= 3 Then
      e.HasMorePages = True
   Else
      e.HasMorePages = False
      pageNum = 0
   End If
End Sub

The pageNum variable is declared as Static, so it retains its value between invocations of the event handler and isn't reset automatically. The last statement, which is executed after you have printed the last page, resets the pageNum variable in anticipation of another printout. Without this statement, the first page of the second printout (if you clicked the button again) would become page 4, and so on.

The entire printout is generated by the same subroutine, one page at a time. Because pages are not totally independent of one another, you need to keep some information in variables that are not initialized every time the PrintPage event handler is executed. The page number, for example, must be stored in a variable that will maintain its value between successive invocations of the PrintPage event handler, and it must be increased every time a new page is printed. If you're printing a text file, you must keep track of the last printed line so that each page will pick up where the previous one ended, not from the beginning of the document.

To add printing features that adhere to the Windows standards to your applications, you must also use the PrintDialog and PageSetupDialog controls, which are discussed in the following section.

The PrintDialog control displays the standard Print dialog box, which allows users to select a printer and set its properties. If you don't display this dialog box, the output will be sent automatically to the default printer and will use the default settings of the printer.

To display the Print dialog box, call the PrintDialog control's ShowDialog method. However, you must first set the control's PrinterSettings property, as shown in the following code segment; if you do not, a runtime exception will be thrown:

PrintDialog1.PrinterSettings = PrintDocument1.PrinterSettings
If PrintDialog1.ShowDialog() = Windows.Forms.DialogResult.OK Then
    PrintDocument1.PrinterSettings = PrintDialog1.PrinterSettings
End If

When users select a printer in this dialog box, it automatically becomes the active printer. Any printout generated after the printer selection will be sent to that printer; you don't have to insert any code to switch printers.

The PageSetupDialog control displays the Page Setup dialog box, which allows users to set up the page (its orientation and margins). The dialog box returns the current page settings in a PageSettings object, which exposes the user-specified settings as properties. These settings don't take effect on their own; you simply read their values and take them into consideration as you prepare the output for the printer from within your code.

To use this dialog box in your application, drop the PageSetupDialog control on the form and call its ShowDialog method from within the application's code. The single property of this control that you'll be using exclusively in your projects is the PageSettings property, which exposes a number of properties reflecting the current settings of the page (margins and orientation). These settings apply to the entire document. The PrintDocument control has an analogous property: the DefaultPageSettings property. After the user closes the Page Setup dialog box, we assign its PageSettings property to the DefaultPageSettings property of the PrintDocument object to make the user-specified settings available to our code.

Print Preview is another dialog box that displays a preview of the printed document. It exposes a lot of functionality and allows users to examine the output and, optionally, to send it to the printer. After you write the code to generate the printout, you can direct it to the PrintPreviewDialog control. You don't have to write any additional code; just place an instance of the control on the form and set its Document property to the PrintDocument control on the form. Then show the PrintPreviewDialog control instead of calling the Print method of the PrintDocument object:

PrintPreviewDialog1.Document = PrintDocument1
PrintPreviewDialog1.ShowDialog

After the execution of these two lines, the PrintDocument control takes over. It fires the PrintPage event as usual, but it sends its output to the Print Preview dialog box, not to the printer. The dialog box contains a Print button, which the user can click to send the document being previewed to the printer. The exact same code that generated the preview document will print the document on the printer.

The first example of this chapter (refer to Listing 11.3) prints three simple pages to the printer. To redirect the output of the program to the PrintPreview control, add an instance of the PrintPreview control to the form and replace the statement that calls the PrintDocument1.Print method in the button's Click event handler with the following statements:

PrintPreviewDialog1.Document = PrintDocument1
PrintPreviewDialog1.ShowDialog

Run the project, and this time you will be able to preview the document on your monitor. If you're satisfied with its appearance, you can click the Print button to send the document to the printer.

Like the drawing surface on the monitor (the client area), the page on which you're printing has a fixed size and resolution. The most challenging aspect of printing is the calculation of the coordinates and dimensions of each graphic element on the page.

To access the margins of the current page, use the Margins property of the PrintDocument1.DefaultPageSettings object. This property, which is also an object, exposes the Left, Right, Top, and Bottom properties, which are the values of the four margins. Another property exposed by the DefaultSettings object is the PageSize property, which represents the dimensions of the page. The width and height of the page are given by the following expressions:

PrintDocument1.DefaultPageSettings.PaperSize.Width
PrintDocument1.DefaultPageSettings.PaperSize.Height

The top of the page is at coordinates (0, 0), which correspond to the top-left corner of the page. We never actually print at this corner. The coordinates of the top-left corner of the printable area of the page are given by the following expressions:

PrintDocument1.DefaultPageSettings.Margins.Top
PrintDocument1.DefaultPageSettings.Margins.Left

The basic methods you'll use to create printouts are no different than the methods you use to create graphics. The method for printing text is the DrawString method, which has the following syntax:

Graphics.DrawString(string, font, brush, X, Y)

This method will render its string argument in the font specified in the second argument, using a Brush object as specified by the brush argument at the coordinates specified by the last two arguments. To position multiple elements on the page, you need to know how much space each element takes so you can advance accordingly on the page. To find out the size of a string when rendered on the page, use the MeasureString method. The two methods are used in tandem and this is a common theme in printing text.

The simplest form of the MeasureString method is the following, where string is the string to be rendered and font is the font in which the string will be rendered:

Dim textSize As SizeF
textSize = Graphics.MeasureString(string, font)

To center a string on the form, subtract the string's width and height from the page's width and height and then split the difference equally between the two sides of the strings, vertically and horizontally. If the string's width is 320 pixels and the page's printable width is 780 pixels, you must start printing at the x-coordinate (780-320)/2. This will center the string on the page, leaving 320 pixels on either side. Basically, perform the following calculations using the x- and y-coordinates returned by the MeasureString method, as shown here:

Dim textSize As SizeF
Dim X As Integer, Y As Integer = 0
textSize = Me.Graphics.MeasureString(string, font)
X = (Me.Width – textSize.Width) / 2
Y = (Me.Height – textSize.Height) / 2
G.DrawString("Centered string", font, brush, X, Y)

To position your strings on the page you need to know the size of each string when rendered on the printer in a specific font. You can obtain this information with the MeasureString method, as discussed in the preceding section. As you will read in detail in the tutorial on printing with VB, a printing routine must first determine the printable area on the page.

In this section, we're going to build a simple, but certainly not trivial, printout to demonstrate the use of many of the print-related concepts discussed in the preceding sections. The printout, which contains centered strings and an image as well as a gradient, is shown in Figure 11.6.

Figure 11.6. Previewing a simple printout

Start a new form and drop on it a button and the PageSetupDialog, PrintDocument, and PrintDialog controls. Although we will add preview capabilities to the application, we won't use an instance of the PrintPreviewDialog control. Instead, we'll create an instance of this control from within the application's code.

The code for the application is shown in Listing 11.4. The Click event handler for the button displays the PrintDialog control to allow users to select a printer and set the properties of the printout. The PrintDialog control has a Preferences button, where users can set the page orientation. If you want users to be able to set the page's margins, you must also display the PageSetupDialog. Windows applications provide a Page Setup menu item, which displays the PageSetup dialog box.

After the user has selected a printer and set the orientation of the page, the code creates a new instance of the PrintPreviewDialog control, the prn variable, and assigns the PrintDocument control to the Document property of the prn object and calls the same object's Show method to initiate the printout.

Then the PrintPage event takes over. This event's handler contains quite a bit of code, but it's straightforward. First, it extracts the coordinates of the printable area's upper-left corner, taking into consideration the page's margins. These two values are stored in the variables topX and topY. Then it calculates the width and height of the page's printable area and stores these values in the pageWidth and pageHeight properties.

The following few statements create a LinearGradientBrush object, the LGBrush variable, which is then used to fill a large rectangle with the FillRectangle method. The following statements print the text and the image on the page. To print text, the code uses the MeasureString method to calculate the size of each string and center it horizontally on the page. Then, it advances to the y-coordinate of the next string by incrementing the Y variable.

The image is printed with the DrawImage method, but there's a slight trick here. Because the image has a portrait orientation, I've decided to reduce its size when it's printed in landscape mode because it would take up most of the page. The code examines the property of the e.PageSettings.Landscape property, and if it's True, it fits the image into a rectangle that's half as tall and half as wide as the original image. You can experiment with the SimplePrintout project's code and add more elements to the printout, possibly arrange differently the elements on the page, and break the printout into multiple pages.

Private Sub Button1_Click(...) Handles Button1.Click
    PrintDialog1.PrinterSettings = PrintDocument1.PrinterSettings
    If PrintDialog1.ShowDialog() = Windows.Forms.DialogResult.OK Then
        PrintDocument1.PrinterSettings = PrintDialog1.PrinterSettings
    End If
    Dim prn As New PrintPreviewDialog
    prn.Document = PrintDocument1
    prn.Show()
End Sub

Private Sub PrintDocument1_PrintPage(...) Handles
                  PrintDocument1.PrintPage
    Dim msg1 As String = "Mastering Visual Basic 2010"
    Dim msg2 As String = "Published by SYBEX"
    Dim topX = e.PageSettings.Margins.Left
    Dim topY = e.PageSettings.Margins.Top
    Dim pageWidth =  e.PageSettings.Bounds.Width –
                     e.PageSettings.Margins.Left –
                     e.PageSettings.Margins.Right
    Dim pageHeight = e.PageSettings.Bounds.Height –
                     e.PageSettings.Margins.Top –
                     e.PageSettings.Margins.Bottom
    Dim R As New RectangleF(topX, topY, pageWidth, pageHeight)
    Dim startColor As Color = Color.BlueViolet
    Dim EndColor As Color = Color.LightYellow
    Dim LGBrush As New System.Drawing.Drawing2D.LinearGradientBrush(

R, startColor, EndColor,
                        Drawing2D.LinearGradientMode.ForwardDiagonal)
    e.Graphics.FillRectangle(LGBrush, R)
    e.Graphics.DrawRectangle(Pens.Red,
                       New Rectangle(New Point(topX, topY),
                       New Size(pageWidth, pageHeight)))
    Dim size = e.Graphics.MeasureString(msg1,
                               New Font("Verdana", 28, FontStyle.Bold))
    Dim X = topX + (pageWidth - size.Width) / 2
    Dim Y = 150
    e.Graphics.DrawString(msg1,
              New Font("Verdana", 28, FontStyle.Bold),
              Brushes.White,
              New RectangleF(X, Y, size.Width, size.Height))
    size = e.Graphics.MeasureString(msg2,
                      New Font("Microsoft YaHei", 18, FontStyle.Regular))
    X = topX + (pageWidth - size.Width) / 2
    Y = Y + 70
    e.Graphics.DrawString(msg2,
              New Font("Microsoft YaHei", 18, FontStyle.Regular),
              Brushes.Yellow,
              New RectangleF(X, Y, 2 * size.Width, 2 * size.Height))
    Dim img As Image
    img = My.Resources.MVB2010
    Dim imgSize As Size
    If e.PageSettings.Landscape Then
        imgSize = New Size(img.Width / 2, img.Height / 2)
    Else
        imgSize = New Size(img.Width, img.Height)
    End If
    Y = Y + 80
    X = topX + (pageWidth - imgSize.Width) / 2
    e.Graphics.DrawImage(img,
                    New Rectangle(New Point(X, Y), imgSize))
    e.HasMorePages = False
    Dim bookDescription As String =
                "This expert guide covers ... .NET Framework. " &
                vbCrLf &
                "In a clear, easy-to-follow style, ... " & vbCrLf
    Y = Y + imgSize.Height + 25
    X = topX + 40
    Dim txtRectangle As New Rectangle(X, Y, pageWidth - 80, 280)
    e.Graphics.DrawString(bookDescription, _
                New Font("Microsoft YaHei", 9, FontStyle.Regular),
                Brushes.Black, txtRectangle)
    e.HasMorePages = False
End Sub

The Char data type stores characters as individual, double-byte (16-bit), Unicode values, and it exposes methods for classifying the character stored in a Char variable. You can use methods such as IsDigit and IsPunctuation on a Char variable to determine its type and other similar methods that can simplify your string validation code.

To use a character variable in your application, you must declare it with a statement such as the following one:

Dim ch As Char
ch = Convert.ToChar("A")

The expression "A" represents a string, even if it contains a single character. Everything you enclose in double quotes is a string. To convert it to a character, you must cast it to the Char type. If the Strict option is off (the default value), you need not perform the conversion explicitly. If the Strict option is on, you must use one of the CChar() or the CType() functions (or the Convert class) to convert the single-character string in the double quotes to a character value. There's also a shorthand notation for converting one-character strings to characters—just append the c character to a single-character string:

Dim ch As Char = "A"c

If you let the compiler decipher the type of the variable from its value, a single-character string will be interpreted as a string, not as a Char data type. If you later assign a string value to a Char variable by using a statement such as the following, only the first character of the string will be stored in the ch variable:

ch = "ABC"    ' the value "A" is assigned to ch!

Methods

The Char data type exposes several useful methods for handling characters. All the methods described in Table 11.6 have the same syntax: They accept either a single argument, which is the character they act upon, or a string and the index of a character in the string on which they act.

Table 11.6. Char data type methods

Method	Description
GetNumericValue	This method returns a positive numeric value if called with an argument that is a digit and the value −1 otherwise. If you call GetNumericValue with the argument 5, it will return the numeric value 5. If you call it with the symbol @, it will return the value −1.
GetUnicodeCategory	This method returns a numeric value that is a member of the UnicodeCategory enumeration and identifies the Unicode group to which the character belongs. The Unicode groups characters into categories such as math symbols, currency symbols, and quotation marks. Look up the UnicodeCategory enumeration in the documentation for more information.
IsLetter, IsDigit, IsLetterOrDigit	These methods return a True/False value indicating whether their argument, which is a character, is a letter, decimal digit, or letter/digit, respectively. You can write an event handler by using the IsDigit method to accept numeric keystrokes and to reject letters and punctuation symbols.
IsLower, IsUpper	These methods return a True/False value indicating whether the specified character is lowercase or uppercase, respectively.
IsNumber	This method returns a True/False value indicating whether the specified character is a number. The IsNumber method takes into consideration hexadecimal digits (the characters 0123456789ABCDEF) in the same way as the IsDigit method does for decimal numbers.
IsPunctuation, IsSymbol, IsControl	These methods return a True/False value indicating whether the specified character is a punctuation mark, symbol, or control character, respectively. The Backspace and Esc keys, for example, are ISO (International Organization for Standardization) control characters.
IsSeparator	This method returns a True/False value indicating whether the character is categorized as a separator (space, new-line character, and so on).
IsWhiteSpace	This method returns a True/False value indicating whether the specified character is white space. Any sequence of spaces, tabs, line feeds, and form feeds is considered white space. Use this method along with the IsPunctuation method to remove all characters in a string that are not words.
ToLower, ToUpper	These methods convert their argument to a lowercase or uppercase character, respectively, and return it as another character.
ToString	This method converts a character to a string. It returns a single-character string, which you can use with other string-manipulation methods or functions.

Real World Scenario: IsLetter, IsDigit, IsLetterOrDigit

The IsLetter, IsDigit, and IsLetterOrDigit methods deserve a bit more discussion. I commonly use these methods to intercept keystrokes from within a control's KeyPress (or KeyUp and KeyDown) events. The e.KeyChar property of the e argument returns the character that was pressed by the user and that fired the KeyPress event. To reject non-numeric keys as the user enters text in a TextBox control, use the event handler shown here:

Private Sub TextBox1_KeyPres(
             ByVal sender As Object,
             ByVal e As System.Windows.Forms.KeyPressEventArgs)
             Handles TextBox1.KeyPress
   Dim c As Char
   c = e.KeyChar
   If Not (Char.IsDigit(c) or Char.IsControl(c)) Then
     e.Handled = True
   End If
End Sub

This code ignores any keystrokes that don't represent numeric digits and are not control characters. Control characters are not rejected because we want users to be able to edit the text on the control. The Backspace key, for example, is captured by the KeyPress event, and you shouldn't "kill" it. For more information on handling keystrokes from within your code, see the section "Capturing Keystrokes" in Chapter 5, "Basic Windows Controls." If the TextBox control is allowed to accept fractional values, you should allow the period character as well, by using the following If clause:

Dim c As Char
c = e.KeyChar
If Not (Char.IsDigit(c) or c = "." or
        Char.IsControl(c)) Then
    e.Handled = True
End If

The String class implements the String data type, which is one of the richest data types in terms of the members it exposes. We have used strings extensively in earlier chapters, and you're more than familiar with the String class by now, but I will review the basic members of the String class here for reasons of completeness.

To create a new instance of the String class, you simply declare a variable of the String type. You can also initialize it by assigning to the corresponding variable a text value:

Dim title As String = "Mastering VB2010"

Everything enclosed in double quotes is a string, even if it's the representation of a number. String objects are immutable: Once created, they can't be modified. The names of some of the methods of the String class may lead you to think that they change the value of the string, but they don't; instead, they return a new string. The Replace method, for example, doesn't replace any characters in the original string, but it creates a new string, replaces some characters, and then returns the new string. The Replace method, like all other methods of the String class, doesn't operate directly on the string to which it's applied. Instead, it creates a new string and returns it as a new string.

If you plan to create and manipulate long strings in your code often, use the StringBuilder class instead, which is extremely fast compared to the String class and VB's string-manipulation functions. This doesn't mean that the String data type is obsolete, of course. The String class exposes many more methods for handling strings (such as locating a smaller string in a larger one, comparing strings, changing individual characters, and so on). The StringBuilder class, on the other hand, is much more efficient when you build long strings bit by bit, when you need to remove part of a string, and so on. To achieve its speed, however, it consumes considerably more memory than the equivalent String variable.

The StringBuilder class stores dynamic strings and exposes methods to manipulate them much faster than the String class. As you will see, the StringBuilder class is extremely fast, but it uses considerably more memory than the string it holds. To use the StringBuilder class in an application, you must import the System.Text namespace (unless you want to fully qualify each instance of the StringBuilder class in your code). Assuming that you have imported the System.Text namespace in your code module, you can create a new instance of the StringBuilder class via the following statement:

Dim txt As New StringBuilder

Because the StringBuilder class handles dynamic strings in place, it's good to declare in advance the size of the string you intend to store in the current instance of the class. The default capacity is 16 characters, and it's doubled automatically every time you exceed it. To set the initial capacity of the StringBuilder class, use the Capacity property.

To create a new instance of the StringBuilder class, you can call its constructor without any arguments or pass the initial string as an argument:

Dim txt As New StringBuilder("some string")

If you can estimate the length of the string you'll store in the variable, you can specify this value by using the following form of the constructor so that the variable need not be resized continuously as you add characters to it:

Dim txt As New StringBuilder(initialCapacity)

The size you specify is not a hard limit; the variable might grow longer at runtime, and the StringBuilder will adjust its capacity.

If you want to specify a maximum capacity for your StringBuilder variable, use the following constructor:

Dim txt As New StringBuilder (
                 Intialcapacity, maxCapacity)

Finally, you can initialize a new instance of the StringBuilder class by using both an initial and a maximum capacity, as well as its initial value, by using the following form of the constructor:

Dim txt As New StringBuilder(
                 string, intialcapacity, maxCapacity)

Dim newString As String = ""
Dim words() = TextBox1.Text.Split(" ")
Dim SW As New Stopwatch
SW.Start()
For Each wrd In words
    newString = wrd & " " & newString
Next
SW.Stop()
MsgBox("Reversed word order with the String class in " &
         (SW.ElapsedMilliseconds / 1000).ToString)

Dim newSB As New System.Text.StringBuilder
SW = New Stopwatch
SW.Start()
For wrd = words.Count - 1 To 0 Step −1
    newSB.Append(words(wrd) & " ")
Next
SW.Stop()
MsgBox("Reversed word order with the StringBuilder class in " &
         (SW.ElapsedMilliseconds / 1000).ToString)

The DateTime class is used for storing date and time values, and it's one of the Framework's base data types. Date and time values are stored internally as Double numbers. The integer part of the value corresponds to the date, and the fractional part corresponds to the time. To convert a DateTime variable to a Double value, use the method ToOADateTime, which returns a value that is an OLE (Object Linking and Embedding) Automation-compatible date. The value 0 corresponds to midnight of December 30, 1899. The earliest date you can represent as an OLE Automation-compatible date is the first day of the year 100; it corresponds to the Double value −657,434.

To initialize a DateTime variable, a date value is enclosed in a pair of pound symbols. If the value contains time information, separate it from the date part by using a space:

Dim date1 As Date = #4/15/2011#
Dim date2 As Date = #4/15/2011 2:01:59#

If you have a string that represents a date and you want to assign it to a DateTime variable for further processing, use the DateTime class Parse and ParseExact methods. The Parse method parses a string and returns a date value if the string can be interpreted as a date value. Let's say your code prompts the user for a date and then it uses it in date calculations. The user-supplied date is read as a string, and you must convert it to a date value:

Dim sDate As String
Dim dDate As DateTime
sDate = InputBox("Please enter a date")
Try
    dDate = DateTime.Parse(sDate)
        ' use dDate1 in your calculations
    Catch exc As Exception
        MsgBox("You've entered an invalid date")
End Try

The Parse method will convert a string that represents a date to a DateTime value regardless of the format of the date. You can enter dates such as 1/17/2011, Jan. 17, 2011, or January 17, 2011 (with or without the comma). The ParseExact method allows you to specify more options, such as the possible formats of the date value.

Real World Scenario: Different Cultures, Different Dates

Different cultures use different date formats, and Windows supports them all. However, you must make sure that the proper format is selected in Regional And Language Options. By default, dates are interpreted as specified by the current date format in the target computer's regional settings. The Parse method allows you to specify the culture to be used in the conversion. The following statements prompt the user for a date value and then interpret it in a specific culture (the en-GB culture, which is used in the United Kingdom):

Dim sDate1 As String
Dim dDate1 As DateTime
sDate1 = InputBox("Please enter a date")
Try
    Dim culture As CultureInfo = _
               New CultureInfo("en-GB", True)
    dDate1 = DateTime.Parse(sDate1, culture)
    MsgBox(dDate1.ToLongDateString)
Catch exc As Exception
    MsgBox("You've entered an invalid date")
End Try

To use the CultureInfo class in your code, you must import the System.Gobalization namespace in your project. These statements will convert any English date regardless of the regional settings. If you enter the string 16/3/2011 in the input box, the preceding statements will produce the following output:

Wednesday, March 16, 2011

Let's see how the same date will be parsed in two different cultures. Insert the following code segment in a button's Click event handler:

Dim sDate1 As String
Dim dDate1 As DateTime
sDate1 = InputBox("Please enter a date")
Try
    Dim culture As CultureInfo = _
                   New CultureInfo("en-GB", True)
    dDate1 = DateTime.Parse(sDate1, culture)
    Debug.WriteLine(dDate1.ToLongDateString)
    culture = New CultureInfo("en-US", True)
    dDate1 = DateTime.Parse(sDate1, culture)
    Debug.WriteLine(dDate1.ToLongDateString)
Catch exc As Exception
    MsgBox("You've entered an invalid date")
End Try

The method ToLongDateString returns the verbose description of the date so that we can read the name of the month instead of guessing it. Run the code and enter a date that can be interpreted differently in the two cultures, such as 4/9/2011. The following output will be produced:

Saturday, September 04, 2011
Friday, April 09, 2011

If the month part of the date exceeds 12, the exception handler will be activated. Dates are always a tricky issue in programming, and you should include the appropriate culture in the Parse method so that user-supplied dates will be converted correctly, even if the user's culture hasn't been set correctly in the regional settings or if you're processing a file that originated in a computer with different culture settings. You should also not prompt users for dates with a TextBox control; use the DateTimePicker control instead so that users can enter only valid dates.

aDate.ToString(formatSpec)

Debug.Writeline(#9/17/2010#.ToString("D"))
Friday, September 17, 2010

Debug.WriteLine(now().ToString("d"))
    2/2/2010
Debug.WriteLine(Now().ToString("D"))
    Tuesday, February 02, 2010
Debug.WriteLine(Now().ToString("f"))
    Tuesday, February 02, 2010 10:51 PM
Debug.WriteLine(Now().ToString("F"))
    Tuesday, February 02, 2010 10:51:16 PM
Debug.WriteLine(Now().ToString("g"))
    2/2/2010 10:51 PM
Debug.WriteLine(Now().ToString("G"))
    2/2/2010 10:51:16 PM

Debug.WriteLine(Now().ToString("m"))
    February 02
Debug.WriteLine(Now().ToString("r"))
    Tue, 02 Feb 2010 22:51:16 GMT
Debug.WriteLine(Now().ToString("s"))
    2010-02-02T22:51:16
Debug.WriteLine(Now().ToString("t"))
    10:51 PM
Debug.WriteLine(Now().ToString("T"))
    10:51:16 PM
Debug.WriteLine(Now().ToString("u"))
    2010-02-02 22:51:16Z
Debug.WriteLine(Now().ToString("U"))
    Tuesday, February 02, 2010 8:51:16 PM
Debug.WriteLine(Now().ToString("y"))
    February, 2010

Debug.WriteLine(now().ToString("MMMM d"))
July 27

Dim Date1 As Date = Now()
Dim dbl As Double

dbl = Date1.ToOADate
Debug.WriteLine(dbl)

dbl = (Now().AddDays(1)).ToOADate
Debug.WriteLine(dbl)

dbl = Now().AddMinutes(48 * 60).ToOADate
Debug.WriteLine(dbl)

Debug.WriteLine(Now().AddYears(10).ToLongDateString)

Debug.WriteLine(Now().AddDays(3650).ToLongDateString)
Debug.WriteLine(Now().AddDays(3650).ToOADate)

The last class discussed in this chapter is the TimeSpan class, which represents a time interval and can be expressed in many different units—from ticks or milliseconds to days. The TimeSpan is usually the difference between two date/time values, but you can also create a TimeSpan for a specific interval and use it in your calculations.

To use the TimeSpan variable in your code, just declare it with a statement such as the following:

Dim TS As New TimeSpan

To initialize the TimeSpan object, you can provide the number of days, hours, minutes, seconds, and milliseconds that make up the time interval. The following statement initializes a TimeSpan object with a duration of 9 days, 12 hours, 1 minute, and 59 seconds:

Dim TS As TimeSpan = New TimeSpan(9, 12, 1, 59)

As you have seen, the difference between two dates calculated by the Date.Subtract method returns a TimeSpan value. You can initialize an instance of the TimeSpan object by creating two date/time values and getting their difference, as in the following statements:

Dim TS As New TimeSpan
Dim date1 As Date = #4/11/1994#
Dim date2 As Date = Now()
TS = date2.Subtract(date1)
Debug.WriteLine(TS)

Depending on the day on which you execute these statements, they will print something like the following in the Output window:

5585.17:05:12.7623000

The days are separated from the rest of the string with a period, whereas the time parts are separated with colons. Notice that a TimeSpan object might represent an interval of many years, but it doesn't provide members to report months or years. The difference represented by TS variable in the preceding example is 5,585 days, 17 hours, 5 minutes, 12 seconds, and 762,300 nanoseconds (or 762.3 milliseconds).

Dim T1, T2 As DateTime
T1 = Now
MsgBox("Click OK to continue")
T2 = Now
Dim TS As TimeSpan
TS = T2.Subtract(T1)
Debug.WriteLine("Total duration = " & TS.Duration.ToString)
Debug.WriteLine("Minutes = " & TS.Minutes.ToString)
Debug.WriteLine("Seconds = " & TS.Seconds.ToString)
Debug.WriteLine("Ticks = " & TS.Ticks.ToString)
Debug.WriteLine("Milliseconds = " & TS.TotalMilliseconds.ToString)
Debug.WriteLine("Total seconds = " & TS.TotalSeconds.ToString)

Total duration = 00:01:34.2154752
Minutes = 1
Seconds = 34
Ticks = 942154752
Milliseconds = 94215,4752
Total seconds = 94,2154752

Dim TS1 As New TimeSpan(1, 0, 1)
Dim TS2 As New TimeSpan(2, 1, 9)
Dim TS As New TimeSpan
TS = TS1.Add(TS2)

To simplify the task of timing operations, a new class was introduced with the .NET Framework version 4, the StopWatch class. This class implements a stopwatch, which you can start just before the code segment you want to time and stop it after the last statement in this code segment. In addition, you can pause the stopwatch (you may wish to exclude some debugging statements from the code to be timed).

To use the StopWatch class, declare a new variable of this type:

Dim SW As New StopWatch

Use the Start method to start the stopwatch and the Stop method to stop it or pause it. While the stopwatch is stopped or paused, you can request the elapsed time with the Elapsed property, which returns the elapsed time as a TimeSpan object. You can also retrieve the elapsed time in milliseconds with the ElapsedMilliseconds method, and in ticks of the internal clock with the ElapsedTicks method (as a reminder, a tick is 1/10 of a millisecond).

You can also use the Reset method to stop the stopwatch and zero the elapsed time or the StartNew method to zero the elapsed time and start the stopwatch.

Listing 11.6 demonstrates the basic members of the StopWatch class. Initially, the sample code declares and starts a new instance of the StopWatch class and then displays a message box prompting you to close the dialog box and stop the stopwatch. Leave the message box open for a few seconds before clicking the OK button to simulate some delay. Then the code displays another dialog box, prompting you to close it. Then it starts the stopwatch again and displays yet another message box. The time between stopping and restarting the stopwatch won't be included in the total elapsed time. When you close the last dialog box, you can see the results of the operation in the Output window.

Private Sub timeButton_Click(...) Handles timeButton.Click
    Dim sw As New Stopwatch
    sw.Start()
    ' This is where the statements to be timed should appear
    ' Use the MsgBox() function to simulate a delay
    MsgBox("Stopwatch is running. Press any key to pause it")
    ' End of timing operations
    sw.Stop()
    Debug.WriteLine("Elapsed time")
    Debug.WriteLine(sw.Elapsed.ToString)
    Debug.WriteLine(sw.ElapsedMilliseconds.ToString)
    MsgBox("Stopwatch is not running. " &
           "Wait a few seconds and press any key to restart it")
    ' Continue timing the operations
    sw.Start()
    MsgBox("And now press a key to stop the stopwatch")
    Debug.WriteLine("Total elapsed time")
    Debug.WriteLine(sw.Elapsed.ToString)
    Debug.WriteLine(sw.ElapsedMilliseconds.ToString)
End Sub