Common .NET Libraries for Developers


Craig Utley
CIO Briefings

February 2002

Summary: Identifies and defines many of the common namespaces that you will use when developing .NET applications, and provides examples of the most common classes and methods in those namespaces. (24 printed pages)


  • Identify .NET namespaces that will be used by most developers
  • Learn how to use the .NET functionality found in common namespaces in your code
  • Examine examples of the most common classes and methods in those namespaces


The .NET Framework
Examining Some Common Namespaces
About the Author
About Informant Communications Group

The .NET Framework

As you have no doubt heard, the .NET Framework is the underlying library for all .NET languages. This is a huge library of functions that is programming language-independent, meaning that any programming language targeted at the .NET platform can make use of this functionality.

The importance of this underlying set of types and members cannot be overstated; developers in any language will have access to the same types, and they will behave exactly the same way in any .NET language. If you need to create a multithreaded application, for example, you use the threading classes present in the .NET Framework, instead of having to rely on your language of choice having built-in support for multithreading. While the actual syntax to call the objects varies from language to language, the object is the same across all languages, because they are created from the .NET Framework base class.

Given this common, underlying set of libraries, .NET developers will spend a large percentage of their time working with Framework objects. This should make programming easier in the long run, regardless of what .NET language you are using.

Which Namespaces Will Be Common?

In looking at the libraries in the .NET Framework, the question becomes, "Which ones will developers use more often than others?" Since the purpose of this article is to discuss the more commonly used libraries, there will obviously be libraries that do not get covered. It is inevitable that there are developers whose most commonly used library will not be discussed in this paper. It is also inevitable that some developers will never use one or more of the libraries covered in this paper. This is not unexpected, and it will only serve to show the incredible breadth and depth of applications that can be built with the .NET Platform.

The criteria used to include a library as common in this paper is that it will be used by a majority of developers building applications that use such elements as Windows Forms, Web Forms, Web services, Class Libraries, databases, and XML. By using these rather broad areas as the basis for choosing the libraries, the list of libraries included is large, but not overwhelming. Once you understand some of these libraries, working with other libraries is much easier.

Namespaces Covered in This Paper

The namespaces chosen for inclusion in this paper are:

  • System
  • System.Collections
  • System.Data
  • System.Drawing
  • System.IO
  • System.Text
  • System.Threading
  • System.Timers
  • System.Web
  • System.Web.Services
  • System.Windows.Forms
  • System.Xml

Examining Some Common Namespaces

There are a number of namespaces to examine in this paper. Therefore, most of the sections will include a brief description of the library, along with a mention of some of the more important objects. Finally, most sections will include a short code example showing at least a small portion of what you can do with that particular library.

The System Namespace

At the top of the namespace hierarchy is the System namespace itself. While all the rest of the libraries in this paper will be under the System namespace, it is important to understand that the System namespace does contain the types that represent the base data types, such as Object, Int32, String, and so forth.

In addition to these base data types, there are dozens of classes in the System namespace. These classes cover such areas as garbage collection (the GC class) and certain exceptions (covered with the SystemException, StackOverflowException, and OverflowException classes, among others). These classes represent core functionality within the .NET Framework.

Finally, the System namespace contains many second-level namespaces that provide the rest of the .NET Framework functionality. These secondary namespaces are generally grouped into areas of functionality. For example, data access is handled by System.Data, System.Xml, and System.Xml.Serialization. Graphical User Interfaces are handled with the System.Drawing and System.Windows.Forms namespaces.

The important point to remember with the System namespace is that it contains the base data types and some of the core functionality of .NET. It is also the top of the namespace hierarchy in the .NET Framework. In Visual Basic® .NET the System namespace is automatically imported, so you do not need to prefix any of the data types or any of the other namespaces with "System." You may simply use these namespaces. You will see examples of this usage throughout the document.

System namespace example

The System namespace is the home of the base data types. In .NET, the base data types are defined in the Framework itself, and any .NET language can use those base data types. Most languages provide their own data types, but these typically map directly to base data types in the Framework. For example, the Integer data type in Visual Basic .NET maps to the System.Int32 base type. The long data type in Visual Basic .NET maps to System.Int64.

Base data types are actually structures in the System namespace. Structures are similar to classes in that they can contain data and functions. This means that the base data types can be treated as standard values, or you can treat them as objects with methods. For example, if you need to convert a Visual Basic .NET Integer to a string, you can simply use the ToString method of the Integer type to convert the integer to a string, as shown in the example below.

Dim MeaningOfLife As Integer = 42

Performing these conversions is fairly straightforward, but what if you need to convert the integer to something other than a string? For example, you might want to convert an Integer to a Byte. This type of conversion is normally allowed by Visual Basic .NET, but not C#. In Visual Basic .NET, if you turn on Option Strict, then this type of conversion is disallowed as well, because you are converting a larger number to a smaller one, which could cause problems if the value in the Integer is too large for the Byte.

In order to perform such conversions, the System namespace includes a Convert class, which converts a base type to another base type. Not all base types are supported, but many are. Not all conversions are supported, such as Char to Double. Such invalid conversions throw an InvalidCastException. If a conversion is attempted from a larger size to a smaller size, such as from Int32 to Byte, and the value in Int32 is too large for a Byte, then an OverflowException is thrown.

Using the Convert class is fairly easy. For example, the following code converts an Integer to a Byte successfully in the first case, and then fails in the second case.

Dim MeaningOfLife As Integer = 42
Dim ShortMeaningOfLife As Byte

'This conversion will work fine
ShortMeaningOfLife = Convert.ToByte(MeaningOfLife)

'This conversion will fail
   MeaningOfLife = 42000
   ShortMeaningOfLife = Convert.ToByte(MeaningOfLife)
Catch except As OverflowException
   MsgBox("Overflow occurred")
End Try

The System.Collections Namespace

The System.Collections Namespace is one of the four basic programming namespaces (along with System.IO, System.Text, and System.Threading). System.Collections contains all the classes and interfaces needed to define collections of objects. Some of the classes include:

  • ArrayList: An ArrayList is a type of collection to which you can add items and have it automatically grow. You can move through the items using a MoveNext on the enumerator of the class. The ArrayList can have a maximum capacity and a fixed size.
  • CollectionBase: This class is the base for a strongly-typed collection, critical for creating collection classes, which are described below.
  • DictionaryBase: This class is the base for a strongly-typed collection utilizing associated keys and values. This is similar to the Dictionary object found in VBScript and used by many ASP developers.
  • SortedList: This class represents a collection of keys and values, and is automatically sorted by the key. You can still access the values with either the key or the index number.
  • Hashtable: This class represents a collection of keys and values, but the keys and values are hashed using a hashing algorithm. Searching based on key is very fast, and is moderately fast when based on value. The order of the items cannot be determined, but if you need searching capabilities, this is the best collection to use.
  • Queue: This class represents a collection that is to be used on a first-in, first-out or FIFO basis. This unsorted list lets you add items to the end and read (and optionally remove) the items from the top.
  • Stack: In contrast to the FIFO nature of the Queue class, the Stack class represents a collection for last-in, first-out or LIFO.

Some of the classes are for specialized purposes, such as a Stack class that represents a last-in-first-out collection implemented as a circular buffer. As you can see, some of the classes are quite specialized.

The main use of the System.Collections namespace, however, will be to create collection classes. Many Visual Basic 6.0 developers were confused by the concept of collection classes. This following example should help clarify this concept. Assume you create a class called Patient. The Patient class has a number of properties, methods, and events. You then want to create several Patient objects within one structure so you can iterate over each object and perform some operation upon each object. You could just create a variable of type Collection, but a standard collection can hold any type of value. In other words, you could add a Patient object to it, but you could also add a Form object, a text string, an integer, and any other type of item.

To get around this limitation, you create your own class that looks like a collection. It has Add and Remove methods, as well as an Item property, but the class is coded so you can only add Patient objects. A class that mimics a collection is called a collection class.

In Visual Basic 6.0, you simply started by creating an empty class, creating an Add method, a Remove method, an Item property, a Count property, and so on. This is easier in .NET, thanks to System.Collections.

System.Collections namespace example

Assume that you have created a Patient object. The structure of the Patient object is immaterial for this example as you only want to create a collection of Patient objects. This collection will be called Patients, following the standard of having object names as singular and collection names as plural.

First, you create a class called Patients. In this class, you inherit the System.Collections.Collection base. Inheriting CollectionBase automatically gives you a Clear method (to empty the collection) and a Count property. There is also a protected member called List, which acts as an internal collection to hold your objects.

Public Class Patients
    Inherits System.Collections.CollectionBase
End Class

Next, you create an Add method to add objects to the list, a Remove method to remove items from the list, and an Item property to retrieve an individual object from the list. Here is the basic code to create these items:

Public Sub Add(ByVal pPatient As Patient)
End Sub

Public Sub Remove(ByVal pIndex As Integer)
    If pIndex > Count - 1 Or pIndex < 0 Then
        'return error message
    End If
End Sub

Public ReadOnly Property Item(ByVal pIndex As Integer) _
  As Patient
        If pIndex > Count - 1 Or pIndex < 0 Then
           'return error message
            Return CType(list.Item(pIndex), Patient)
        End If
    End Get
End Property

In this code, you can see that the Add method simply adds the object of type Patient to the list item that is given to you when you inherit from CollectionBase. In the Remove method, you receive the index and remove that specific item from the list if it exists.

Finally, in the Item method, you receive an index number and return the current object from the list as type Patient.

As you can see, inheriting from System.Collections.CollectionBase has made creating collection classes easier than it was in Visual Basic 6.0.

In this example, the order in which your patients were stored in the collection was unimportant. However, there might well be times where you do care about the order in which items are stored. The SortedList class allows you to easily sort items, and easily retrieve those items with either the key or the index of the array.

For example, some companies always want to see their products sorted in a certain order, even if that order is not alphabetic. You could add the items to the SortedList in any order, but provide a key that would keep them sorted. In the following code, the key is a simple numeric sort order, but could be any other way you wanted to sort the items.

Dim myItems As New SortedList()
With myItems
   .Add("2", "Apples")
   .Add("1", "Oranges")
   .Add("4", "Lemons")
   .Add("5", "Grapes")
   .Add("3", "Limes")
End With
Dim i As Integer
For i = 0 To myItems.Count - 1

The System.Data Namespace

The System.Data namespace will be used in the vast majority of applications because it is the namespace that holds the classes for ADO.NET. This means that any application using ADO.NET will call System.Data. It is interesting to note that the exact name of the class will depend on the managed provider you are using. The major categories will be:

  • Connection: In the first version of ADO.NET, this will be either SqlConnection or OleDbConnection. This class is responsible for making the actual connection to the database, and it also handles starting a transaction.
  • Command: This will be either SqlCommand or OleDbCommand. This class allows you to issue SQL statements or call stored procedures. It is the object that will actually execute the command, and may return data.
  • DataReader: Either SqlDataReader or OleDbDataReader, this object is used to read data in a forward-only manner. This is the firehose cursor with which most ADO developers are familiar.
  • DataAdapters: Either SqlDataAdapter or OleDbDataAdapter, this object encapsulates a connection and one or more commands. It gets data and fills a DataSet object with data.
  • DataSets: Either SqlDataSet or OleDbDataSet, this is the ADO.NET disconnected data cache. It stores data in memory in a schema, and applications can use it like a database, accessing and updating data.

Making database access part of the underlying .NET Framework means that any language targeting the .NET platform will have access to the same set of data objects. In addition, if the .NET Framework is ported to other platforms, the database access objects will be the same on all platforms.

ADO.NET is different from previous Microsoft database access technologies in several ways. For example, the DataSet is the object used to store data in memory in ADO.NET. The DataSet is disconnected by nature, having no understanding of the underlying data source. In addition, the DataSet holds data in memory in a schema format, which allows you to define tables, relationships, and constraints. Finally, the DataSet speaks fluent XML, having the ability to both read and write XML. This makes it quite easy to transmit an entire DataSet, with the data and schema, from one application to another, even if the applications are on separate machines.

System.Data namespace example

In the following example, you see several of the major ADO.NET objects. First, an ADO.NET Connection (SqlConnection) object is created, which is what is used to connect you to a particular server and database. Next, an ADO.NET Command (SqlCommand) object is created, which will be used to issue a command to the database to which you are connected. Next, a DataAdapter (SqlDataAdapter) object is created, which is what sits between a DataSet and a data source, and retrieves records and handles updates. Finally, a DataSet object is created, which will be used to hold data in memory.

After the objects are created, the connection is opened, and the Fill method of the DataAdapter is called. This issues the command and places the records returned into the DataSet. The GetXml method is called in order to get the entire DataSet in XML format, and it is displayed in a message box. Normally, of course, this XML string would be returned from the method, but it is easy to see here inside a message box.

Dim cn As SqlConnection = New _
   SqlConnection("Data Source=localhost;user id=sa;pwd=;Initial Catalog=Pubs")
Dim authorCommand As SqlCommand = _
   New SqlCommand("SELECT * FROM Authors", cn)
Dim authorDA As SqlDataAdapter = New SqlDataAdapter()
authorDA.SelectCommand = authorCommand

Dim authorDS As DataSet = New DataSet()
authorDA.Fill(authorDS, "Authors")

Dim xmlAuthor As String = authorDS.GetXml


The following example used the System.Data.SqlClient namespace. This namespace is for accessing Microsoft SQL Server 7.0 or 2000. If you are using any other database, you would use the System.Data.OleDb namespace. The object names are slightly different, as you saw in the bulleted list earlier. The methods and properties are the same, as are all the concepts. However, while the SqlClient uses a new, direct connection driver, the OleDb namespace uses OLE DB as the underlying mechanism to connect to databases. This gives you backwards compatibility to databases that have not yet created a .NET managed provider.

The System.Drawing Namespace

The System.Drawing namespace gives you easy access to the GDI+ graphics system. Certain controls from previous versions of Visual Basic 6.0, such as the Line and Shape ActiveX® controls, are no longer in Visual Basic .NET. In order to get lines and shapes on your Visual Basic .NET Windows Forms, you use the GDI+ functions in System.Drawing.

In addition to drawing simple shapes, System.Drawing allows you to perform a number of interesting tasks, such as having forms that are not just rectangular in nature. If you've always wanted a round form for some reason, you can achieve that with System.Drawing.

In addition, there are several lower-level namespaces for advanced functionality, such as System.Drawing.Drawing2D and System.Drawing.Text.

System.Drawing namespace example

In this example, you have a simple form with one button. When the user clicks the button, the form takes on the shape of a circle. Because the circle is contained in a rectangle that starts at coordinates 0,0 the user will able to click on part of the title bar and move the form around.

Imports System.Drawing.Drawing2D

Public Class Form1
   Inherits System.Windows.Forms.Form
   Private Sub Button1_Click _
    (ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles Button2.Click
      Dim grafPath As GraphicsPath = New GraphicsPath()
      grafPath.AddEllipse(New Rectangle(0, 0, 200, 200))
      Me.Region = New [Region](grafPath)
   End Sub
End Class

As mentioned earlier, the line and shape are both gone. You can use a couple of methods to generate a line. The quick and dirty way is to use a label with a height of one and turn on the border. This looks exactly like a line. Or, you can use the DrawLine method in System.Drawing.Graphics. In fact, System.Drawing.Graphics also includes methods such as DrawEllipse, DrawArc, DrawRectangle, and many other methods for drawing simple shapes.

The System.IO Namespace

As another one of the four basic programming namespaces, System.IO namespace allows you to read and write files and data streams. Reading and writing can be done synchronously or asynchronously. IO is performed against a base Stream class, which is a generic way to access the data without regard to the underlying platform on which the data resides. Streams can support any combination of reading, writing, and seeking (modifying the current position within a stream).

A File class allows you to perform actions such as copying and deleting files. In addition, there are Exists, Open, OpenRead, OpenText, and OpenWrite shared methods for performing file IO. Since the methods of the File class are defined as Shared, you do not need to create an instance of a File class, you can just use the methods.

System.IO provides several classes that inherit from a few base classes, of which StreamReader and StreamWriter are commonly used for reading and writing from text files.

System.IO namespace example

In this example, you use the File object in order to create a file and then write text to it using the WriteLine method of the StreamWriter.

Imports System.IO

Public Class Foo
   Private Sub WriteFile(ByVal psFileName As String)
      If File.Exists(psFileName) Then
         'return error
         Dim myFile As StreamWriter = _
         myFile.WriteLine _
            ("I got this to work at " & TimeString)
      End If
   End Sub
End Class

The System.Text Namespace

The System.Text namespace is one of the four basic programming namespaces, and is all about working with text. String manipulation is a common activity in any application, but it is also one of the most expensive activities in terms of processor cycles.

If you create a variable of type String, you are actually creating a String object; all types in .NET inherit from the base Object class, so all data types are actually objects. The String object cannot be changed, despite the fact that it can appear to be changed by assigning a new string to a String variable. For example, there is a method called Concat that allows you to concatenate strings (or objects). However, because the String object is immutable, a new string is actually created and returned. This consumes a significant amount of overhead, but you do have an alternative—the StringBuilder class. If you are performing a few simple assignments or concatenations, don't worry about the overhead. However, if you are building a string inside a loop, the StringBuilder is going to give you much better performance with lower overhead.

The StringBuilder class is found in System.Text. StringBuilder allows you to change a string without creating a new String object. Therefore, if you want to append, insert, remove, or replace characters in a string, the StringBuilder may be a better choice if you have a significant amount of manipulation to perform.

The System.Text namespace also contains classes for encoding characters into bytes and decoding bytes into characters. For example, there are also encoders for ASCII and Unicode.

System.Text namespace example

In this example, you create a StringBuilder object and set it to a string using the constructor. Next, you create a message box showing the character in position six (caution: start counting with zero, not one). Next, you change that character in position six to a 'g' (which changes 'think' to 'thing'). Next, you replace the string 'thing' with the string '.NET' and show it in a message box. Finally, you append a string to the end of the string, claiming that Descartes said "I .NET, therefore I am."

Imports System.Text
Public Class Form1
   Inherits System.Windows.Forms.Form
   Private Sub Button1_Click _
    (ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles Button4.Click
      Dim sbQuote As New StringBuilder _
         ("I think, therefore I am.")
      sbQuote.Chars(6) = "g"
      sbQuote.Replace("thing", ".NET")
      sbQuote.Insert(sbQuote.Length, " -- Descartes", 1)
   End Sub
End Class

The System.Threading Namespace

System.Threading is another of the four basic programming namespaces. Visual Basic .NET is truly multithreaded because the .NET Framework provides the System.Threading namespace, which provides the classes needed for multithreaded application development.

The Thread class represents a thread on which you can execute code. You can create a thread and specify its priority by instantiating a new Thread object.

Creating multithreaded applications requires planning and forethought. Many Visual Basic 6.0 developers will want to dive in and create multithreaded applications because they can. However, synchronization can be a challenge for multithreaded applications. If multiple threads attempt to access a shared resource at the same time, deadlock issues can result. Therefore, you must synchronize access to shared resources. Fortunately, the .NET Framework provides objects to manage thread synchronization.

Another challenge with multithreading is that you cannot place Functions on a separate thread in Visual Basic .NET. Therefore, you must make the procedure a Sub, which cannot return a value. In addition, the constructor for a new thread will only take a procedure that does not accept any arguments. Given these two limitations, you may have to come up with alternative ways of coding your application.

One way around the inability to pass a parameter to a Sub running on a separate thread is to place the Sub in a separate class, set a property in that class, and then call the Sub. To handle a return value, the called Sub should raise an event, which is handled by the calling class. This call-back functionality is not new, but it was not commonly implemented by Visual Basic 6.0 developers.

System.Threading namespace example

This example is more involved than most, but is fairly simple code. Create a new Visual Basic .NET Windows Application project. On the form, add a button. Create a second form and add a label.

In the code for the first form, instantiate an object to point to the second form, set a property, and then call a method. The property you set, MaxCount, can be altered depending on the speed of your processor and how long you want to wait.

Public Class Form1
    Inherits System.Windows.Forms.Form

#Region " Windows Form Designer generated code "
#End Region

   Private Sub Button1_Click _
    (ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles Button1.Click
      Dim myForm As New Form2()
      myForm.MaxCount = 50000
   End Sub
End Class

On the second form, add a label, and then add the code you see below. Realize that you won't actually see the label update because there is not a DoEvents, but the label is being updated or the code would run too fast for you to see what is happening. There is a Beep to let you know when it is done.

Public Class Form2
    Inherits System.Windows.Forms.Form

#Region " Windows Form Designer generated code "
#End Region

   Public MaxCount As Long

   Public Sub DoStuff()
      Dim Counter As Long
      For Counter = 1 To MaxCount
         Label1.Text = Counter
         'without a DoEvents, you won't
         'actually see the label update.
         'However, it helps make this 
         'take more time
   End Sub
End Class

When you run this code, you'll click the button on Form1. Form2 will open, but it will be on the same thread as Form1. Form2 will consume all processor cycles for the thread, so if you try to click back on Form1, you will find it will not get the focus until the loop is done.

The next step is to have the DoStuff method in Form2 launch on a separate thread. In order to do this, you need only make changes in Form1. There are no changes required to DoStuff or anything else in Form2.

You create a new Thread object and pass it the address of the DoStuff procedure in Form2. Then, you simply start the thread. Your new code will look like this:

Private Sub Button1_Click _
 (ByVal sender As System.Object, _
 ByVal e As System.EventArgs) Handles Button1.Click
   Dim myForm As New Form2()
   myForm.MaxCount = 50000
   Dim busyThread As New _
     System.Threading.Thread(AddressOf myForm.DoStuff)
End Sub

If you run the code now, you'll see that when Form2 opens, you can click on Form1 immediately. As a side benefit, you now see the label on Form2 being updated, since the application's threads each get time at the processor, and this frees up time for the label to be updated.

The System.Timers Namespace

Visual Basic 6.0 could use a Timer ActiveX control on a form to fire an event at a regular interval. The challenge with this is what if you needed to fire an event on a regular basis in a COM Component? You could call the Windows API, but many Visual Basic 6.0 developers just went ahead and created regular applications and used a hidden form to host the Timer control.

In Visual Studio .NET, the Timer control exists, and is part of the System.Windows.Forms namespace. However, you also have the System.Timers namespace, which contains a Timer class. This Timer class allows you to create one or more timers and have them fire events at a regular interval.

The Timer in .NET is more accurate than previous Windows timers. The Timer is designed to work in a multithreaded environment, which allows it to move among threads in order to handle the raising of its Elapsed event. Because of the multithreaded nature of the Timer, it is possible, although unlikely, that you issue the Stop command while an Elapsed event is being handled on another thread. This could result in an Elapsed event occurring after you stop the Timer. To check for this, the Timer has a SignalTime property that lets you determine exactly when the Elapsed event gets raised.

System.Timers namespace example

There are two pieces to this example—a component that implements the timer, and a form that handles the event returned from the component.

Create a new component called timerComponent. In timerComponent create an Event called TimerFired, which is what you will send back to the client. You then create a public method called StartTimer, which is what you will call from the client in order to start the timer. Notice that there isn't a StopTimer method, but you could easily add one. Finally, you add an event handler to handle the event of the timer firing. The timer fires and you must handle that in the component. Then, you raise an event that can be handled back in the client program. In this case, you handle the timer's event with a sub called TimerHandler, and you raise an event to be handled on the client. You also pass back the DateTime of the Elapsed event, which is called SignalTime.

Your code for the component looks like this:

Imports System.Timers
Public Class timerComponent
   Inherits System.ComponentModel.Component

#Region " Component Designer generated code "
#End Region

   Event TimerFired(ByVal TimeFired As DateTime)
   Dim tTimer As New Timer()

   Public Sub StartTimer()
      AddHandler tTimer.Elapsed, AddressOf TimerHandler
      tTimer.Interval = 5000
      tTimer.Enabled = True
   End Sub

   Public Sub TimerHandler _
    (ByVal sender As Object, _
    ByVal e As System.timers.ElapsedEventArgs)
      RaiseEvent TimerFired(e.SignalTime)
   End Sub
End Class

Now, you need to create the client. This is a simple form that instantiates timerComponent, but it instantiates it using the WithEvents keyword so it can handle any events raised by the component. Then, in a button, you turn on the timer. Finally, you have an event handler that handles the event and creates a message box showing the time the event was fired. You have five seconds to close the message box before the next event is received.

Imports System.Timers

Public Class Form2
   Inherits System.Windows.Forms.Form

#Region " Windows Form Designer generated code "
#End Region

   Dim WithEvents tTimer As New timerComponent()

   Private Sub Button1_Click _
    (ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles Button1.Click
   End Sub

   Private Sub tTimer_TimerFired _
    (ByVal TimeFired As Date) Handles tTimer.TimerFired
   End Sub

End Class

The System.Web Namespace

One of the most exciting changes in .NET is the fact that ASP.NET is part of the Framework. This means that Visual InterDev® as a product is gone, and Web applications can be built in any .NET language. Further, ASP.NET uses truly compiled code instead of scripting languages, as were used in traditional ASP applications.

By making ASP.NET part of the Framework, Web applications take full advantage of the Framework's services, such as memory management and security. This allows you to build powerful Web applications using the classes of the Framework, such as the System.IO, System.Data, and System.XML namespaces covered in this paper.

System.Web includes Windows Forms that allow you to build pages by simply dragging and dropping from within Visual Studio® .NET. System.Web also includes a host of Windows Form controls that work like objects from a coding standpoint, but generate standard HTML when it comes time to interact with a browser. These controls can be as simple as text boxes and labels, or more complex, such as the validator controls and the calendar control.

System.Web namespace example

As simple as this example may be, it shows several things. First, there are three controls added to this form. These are ASP.NET server controls, which allow you to code against the objects using familiar property and method calls. In addition, there is no programming code in this file, but if you save it as a file with an ASPX extension in a directory in Inetpub\wwwroot, it will run without adding any code. If you click the button with no value in the textbox, you will get the message that the first name is required. Fill in a value and click the button, and no message appears.

      <form id="Form1" method="post" runat="server">
         <asp:TextBox id="FirstName" 
            id="RequiredFieldValidator1" runat="server"
            ErrorMessage="First name is required"
         <asp:Button id="Button1" runat="server"

The System.Web.Services Namespace

XML Web services are one of the newest and most exciting additions to the world of development. XML Web services have been available for some time on the Microsoft platform, thanks to the SOAP Toolkit.

Basically, a Web service is a way to take a component and make it accessible through the Web. Distributed components have been available for years in the form of ActiveX components accessed through DCOM, but Web services make components available over HTTP using SOAP. DCOM is a binary standard that is often not transmitted through firewalls or proxy servers. In addition, DCOM is only supported on platforms running COM, which has basically limited COM/DCOM to Microsoft Windows® platforms.

With Web services, however, the landscape has changed. The call and response are in XML format, and are passed over HTTP. This means that the component can be called using simple text and can be called by any client on any platform. The result comes back in XML format, meaning that any client that speaks XML can consume the results. Finally, you can code your components using your favorite Microsoft tools and have those components used by people running on Unix or an AS/400, or any other platform that can make HTTP calls and consume XML. This opens up a new world of interoperability, and means you can distribute your application on servers around the world and tie them together with HTTP.

Creating Web services is fairly straightforward, as you will see in a moment. However, how Web services are discovered and accessed is a topic worthy of an article unto itself. Therefore, this paper will just show how to create a Web service, and a simple way to access it. Realize that the access could come from a Windows application, a Web application, or any other client you can imagine, including the growing wireless devices such as PDAs and Web-enabled phones.

System.Web.Services namespace example

The easiest way to create a new Web service is to create a new project in Visual Studio of type ASP.NET Web Service and name it TestWebService. The shell of the first service is already done for you, including commented lines of code showing the way to build public methods. Make your Web services code look like this:

Imports System.Web.Services

Public Class Service1
    Inherits System.Web.Services.WebService

#Region " Web Services Designer Generated Code "
#End Region

   <WebMethod()> Public Function GetLatestSteelPrice() _
    As String
      'look up steel price using whatever method
      GetLatestSteelPrice = 35
   End Function

End Class

The one public function here, GetLatestSteelPrice, is simplified to show you how it works. Normally, you'd actually look up the latest steel price by looking in a database or accessing some form of streaming quote system. Regardless, you would return that value to the client. This simple example uses a hard-coded value in order to see how this works.

You can compile the project and test the Web service immediately. Open Internet Explorer and type in the following URL, replacing the server name and project name if necessary:


The result that will appear in your browser is the XML response from the Web service. It will look like this:

<?xml version="1.0" encoding="utf-8" ?> 
<string xmlns="">35</string>

If you're not very excited, think about it this way—you called a method in a component over standard HTTP and retrieved the result.

Normally, you'd call this Web service from a client application. In Visual Studio .NET, you can simply add a Web Reference, which is just like adding a reference to a COM component in previous versions of Visual Studio. After adding the Web Reference, you refer to the Web service as you would any other component.

For example, if you create the XML Web service and then start a new Windows application, you can right-click on the References node in the Solution Explorer window and choose Add Web Reference. This opens the Add Web Reference dialog box, and in the Address box, you type in the name of the service (in this case, //localhost/TestWebService/Service1.asmx.) Now, you will see that the Add Reference button is enabled, as shown in Figure 1.

Figure 1. Add Reference button is enabled

After clicking the Add Reference button, a Web References node is added to the Solution Explorer, showing the reference to the XML Web service.

Figure 2. Web Reference node in the Solution Explorer

Now, in your code, you reference the XML Web service as any other component. In your client Windows Form, you can call the XML Web service using the following code:

Dim SteelPrice As New localhost.Service1()

The System.Windows.Forms Namespace

With Visual Studio .NET, Microsoft introduces a new forms engine, replacing the forms that had been in Visual Basic since the beginning. By making System.Windows.Forms (or Windows Forms) part of the Framework, any .NET language can take advantage of a forms engine designed to take full advantage of the graphical richness of the Windows operating system. It has never been easier to create powerful GUI applications on the Windows platform, and the Windows Forms engine adds functionality that developers have been craving for some time.

Forms have been objects in Visual Basic since the start, but you didn't always specifically treat them as objects. Windows Forms have a Form class that represents a form, and thanks to .NET's built-in inheritance, you can finally create a base form and inherit from that base form as you build other forms.

In addition, most of the common controls are part of the System.Windows.Forms namespace. For example, there are classes such as Button, Label, and TextBox.

Since the basic form controls are part of the .NET Framework, you can create a form entirely with a text file. Unlike previous versions of Visual Basic, there is no .FRX file that contains the binary data of a form. Binary data, such as background images, does get stored in an RESX file, however. The RESX file is an XML file that mixes XML with the binary data. You can still open the file with Notepad and view and manipulate the XML. You can now create the forms in Notepad if you desire by creating instances of the classes for the controls you want.

While Windows Forms have these new .NET-based controls, they can still use most ActiveX controls. Using ActiveX controls on Windows Forms is the subject of another article in this series, but basically .NET creates an AxHost class that wraps around the ActiveX control and extends it with the new properties available with .NET Windows Forms controls.

System.Windows.Forms namespace example

There is no code to write in this example. Instead, you'll see the resulting code from some of your actions within the IDE. On an empty form, drag and drop some controls, such as a Button and Label. Right-click on the Toolbox and choose Customize Toolbox. Now, choose an ActiveX control and add it to the toolbox. Now, drag that ActiveX control onto the form.

Switch to code view and expand the region Windows Form Designer generated code and look at the resulting code.

Buttons are declared as Friend outside of any procedures, such as this:

Friend WithEvents Button1 As System.Windows.Forms.Button

The ActiveX control gets the letters Ax as a prefix, as shown here:

Friend WithEvents AxCUtley1 As _

Inside the InitializeComponent section, you can see the controls actually being instantiated, such as:

Me.Button1 = New System.Windows.Forms.Button()
Me.AxCUtley1 = New AxCUtleyCtrl.AxGenAmortSched()
CType(Me.AxCUtley1, _

Finally, you'll see the code that positions the controls and sets properties:

Me.Button1.Location = New System.Drawing.Point(104, 16)
Me.Button1.Name = "Button1"
Me.Button1.TabIndex = 0
Me.Button1.Text = "Button1"
Me.AxCUtley1.Enabled = True
Me. AxCUtley1.Location = _
  New System.Drawing.Point(232, 120)
Me. AxCUtley1.Name = " AxCUtley1"
Me. AxCUtley1.OcxState = _
  CType(resources.GetObject("AxCUtley1.OcxState"), _
Me. AxCUtley1.Size = New System.Drawing.Size(120, 23)
Me. AxCUtley1.TabIndex = 4

The System.Xml Namespace

The System.Xml Namespace is used for processing XML. This namespace supports a host of XML standards, such as:

  • XML 1.0
  • Namespaces
  • Schemas
  • XSL/T
  • SOAP 1.1

The System.Xml namespace contains classes that represent the XML elements. For example, there is an XmlDocument class, an XmlEntity class, and an XmlNode class. The XmlValidatingReader can be used to read XML and validate it against a DTD, XDR, or XSD schema.

The System.Xml namespace also includes a reader and writer that provide fast, forward-only reading and writing of XML streams. Back in the System.Data discussion you learned about the DataReader class, used for fast forward-only data access. The XmlTextReader provides the same basic functionality against an XML stream.

When a Reader is used to read XML, the Reader can determine each node type and act accordingly. The Writer has methods such as WriteCData, WriteDocType, and WriteNode in order to create an XML document.

System.Xml namespace example

This example combines several of the namespaces that were covered in this paper. First, you use System.Data to read data from SQL Server. Next, you use System.IO to output that data into an XML file. Finally, you reopen that XML file and use System.Xml to read the contents of that file and dump the data to the console.

There are more possible values when reading in an XML document than shown in the case statement below. However, for brevity, the number of types examined is small.

Imports System.Data.SqlClient
Imports System.IO
Imports System.Xml
Module Module1

   Sub Main()
      Dim cn As SqlConnection = New SqlConnection _
         ("Data Source=localhost;user id=sa;" & _
         "pwd=;Initial Catalog=Pubs")
      Dim authorCommand As SqlCommand = _
         New SqlCommand("SELECT * FROM Authors", cn)
      Dim authorDA As SqlDataAdapter = New _
      authorDA.SelectCommand = authorCommand

      Dim authorDS As DataSet = New DataSet()
      authorDA.Fill(authorDS, "Authors")
      Dim sFileName As String = "c:\test.xml"

      Dim xmlAuthor As String = authorDS.GetXml
      Dim srFile As StreamWriter = _

      Dim reader = New XmlTextReader(sFileName)
      reader.WhitespaceHandling = WhitespaceHandling.None

      'Parse the file and display each of the nodes.
      While reader.Read()
         Select Case reader.NodeType
            Case XmlNodeType.Element
               Console.Write("<{0}>", reader.Name)
            Case XmlNodeType.Text
            Case XmlNodeType.XmlDeclaration
               Console.Write("<?xml version='1.0'?>")
            Case XmlNodeType.Document
            Case XmlNodeType.DocumentType
               Console.Write("<!DOCTYPE {0} [{1}]", _
                  reader.Name, reader.Value)
            Case XmlNodeType.EndElement
               Console.Write("</{0}>", reader.Name)
         End Select
      End While
   End Sub

End Module


This paper covered some of the more common namespaces you will use when developing your .NET applications. There are many other namespaces, and you may find yourself often using a namespace that is not covered in this paper.Regardless of which namespaces you use, gaining a familiarity with the functionality of the .NET Framework and how to use it in your applications is important.

The .NET Framework will open up a new era in application development. Because the .NET Framework can be ported to any platform, your applications can run, unchanged, on any platform. Unlike the Virtual Machine that Java uses, .NET applications are compiled to native code on each platform.

You've no doubt read about new features in Visual Basic .NET, such as inheritance and multithreading. These new features are available to Visual Basic .NET, but they are provided by the .NET Framework, not the Visual Basic .NET language itself. By using the .NET Framework classes, .NET languages gain access to a modern, object-oriented platform designed for building distributed applications.

About the Author

Craig Utley is President of CIOBriefings LLC, a consulting and training company focused on Microsoft development. He has been working with and writing about .NET since it was first announced. Recently, Craig has been writing about .NET for Sams Publishing and Volant Training.

About Informant Communications Group

Informant Communications Group, Inc. ( is a diversified media company focused on the information technology sector. Specializing in software development publications, conferences, catalog publishing and Web sites, ICG was founded in 1990. With offices in the United States and the United Kingdom, ICG has served as a respected media and marketing content integrator, satisfying the burgeoning appetite of IT professionals for quality technical information.

Copyright © 2002 Informant Communications Group and Microsoft Corporation

Technical editing: PDSA, Inc.