    
    
    
    
|
The Developer's Resource & Community Site |
| COM | XML | ASP | Java & Misc. | NEW: VS.NET |
| International | This Week | Forums | Author Central | Find a Job |
(Reproduced with kind permision of Wrox Press: https://www.wrox.com)
C# Programming with the Public Beta - Chapter 7 - Namespaces and the Base Classes
Author: Simon Robinson, Karli Watson, Burton Harvey and Julian Templeman
Date: February 2001
In this chapter we're going to look at the base classes - the vast number of .NET classes that Microsoft has written for you, and also namespaces - the system by which classes are grouped together.
A significant part of the power of the .NET framework comes from the base classes supplied by Microsoft as part of the .NET framework. These classes are all callable from C# and provide the kind of basic functionality that is needed by many applications to perform, amongst other things, basic system, Windows, and file handling tasks. To a large extent the .NET base classes can be seen as replacing the previous Win32 API and a large number of MS-supplied COM components. The base classes are simpler to use, and you can easily derive from them to provide your own specialist classes. You can also use the base classes from any .NET-aware language (calling Win32 API functions from VB was possible but not easy). The types of purposes you can use the base classes to do include:
- String handling
- Arrays, lists, maps etc.
- Accessing files and the file system
- Accessing the registry
- Security
- Windowing
- Windows messages
- Connecting to other computers and to the Internet
- Drawing
- Directory Access
- Database Access
You can see from the above list that besides giving access to basic Windows operations, the base classes define many useful data types, including strings and collections of data.
The base classes are not, of course, only available to C# programs - they can equally well be accessed from VB, C++ or any other .NET-compliant or (by use of some wrapper objects) COM-aware language, but we will concentrate on C# here.
The aim of this chapter is to give you an overview of the kinds of things you can do using the base classes and how to perform certain common operations. Clearly the scope of the base classes is so vast that we cannot give any kind of comprehensive guide in one chapter - instead we are going to pick on a few common programming tasks and present sample code to demonstrate how you can easily execute those tasks. However we will also show you how you can use the WinCV tool which is supplied with the .NET SDK to explore the base classes for yourself.
The tasks we're going to cover in this chapter include:
- Manipulating dates and times
- Navigating the file system
- Reading and writing to files
- Copying, Moving and Deleting files
- Connecting to the Internet
- Accessing the registry
- Mathematical functions
Note that we are not covering windowing or data access in this chapter. These areas are important enough to warrant chapters in their own right and are respectively covered in Chapters 8 and 9.
Before we do that though, we need to switch topics for a while and understand how namespaces work in C#, since you need to be able to use and reference namespaces in order to be able to access the base classes.
Namespaces
A namespace can be seen as a container for some classes in much the same way that a folder on your file system contains files. Namespaces are needed because there are a lot of .NET classes. Microsoft has written many thousands of base classes, and any reasonably large application will define many more. By putting the classes into namespaces we can group related classes together, and also avoid the risk of name collisions: If your company happens to define a class that has the same name as the class written by another organization, and there were no namespaces, there would be no way for a compiler to figure out which class a program is actually referring to. With namespaces, there isn't a problem because the two classes will be placed in different namespaces, which compares with, say, the Windows files system where files with the same name can be contained in different folders.
It is also possible for namespaces to contain other namespaces, just as folders on your file system can contain other folders as well as files.
When Visual Studio generates your projects, it automatically puts your classes in a namespace. Say for example you use the developer environment to create a C# Windows Application project called MyProject. If you do this and look at the code generated for you, you'll see something like this.
namespace MyProject
{
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.WinForms;
using System.Data;
There's two C# keywords here that we need to understand: namespace and using. We'll look at namespace first then examine what using does.
The initial namespace command indicates that everything following the opening curly brace is part of a namespace called MyProject. Later on in the file, a class called Form1 is declared.
public class Form1 : System.WinForms.Form
Because this class has been declared inside the namespace, its 'real' name is not Form1 but MyProject.Form1, and any other code outside this namespace must refer to it as such. This name is correctly known as its fully-qualified name. Notice that in the above line, Form1 is derived from a class called Form. This class is defined inside the namespace WinForms, which in turn is defined inside the namespace System (recall we mentioned earlier that it is possible for namespaces to contain other namespaces). This code sample refers to the Form class using its fully qualified name.
Now we'll have a look at the purpose of the using command in the above code. It's basically a way of avoiding having to write fully-qualified names everywhere, since the fully-qualified names can get quite long and make your code hard to read. For example if we consider the line
using System.WinForms;
This line declares that I may later in the code use classes from the System.WinForms namespace, without indicating the fully-qualified name - and the same applied for every other namespace mentioned in a using command. For example consider the line of code, also generated by the developer environment
public class Form1 : System.WinForms.Form
Because of the earlier using command, we could equally well write this as
public class Form1 : Form
In this latter case the compiler will locate the class by searching all the namespaces that have been mentioned in a using command. If it finds a class named Form in more than one of these namespaces, it will generate a compilation error - in that case you would need to use the fully-qualified name in your source code.
Note that the only purpose of the using command in this context is to save you typing and make your code simpler. It doesn't, for example, cause any other code or libraries to be added to your project. If your code uses base classes or any other classes that are defined in libraries (recall in .NET these are stored in assemblies), you need to ensure separately that the compiler knows which assemblies to look in for the classes. If you are compiling from the Visual Studio developer environment, this is done through the project references, which are listed in the Solution Explorer window, as shown in this screenshot:
Some references are inserted automatically when your project is created - which ones depends on the type of project, and you can add others using the Project | Add Reference menu. The screenshot shows the situation for a newly created C# Windows Application. (Note that although it is assemblies rather than namespaces that are referenced, the solution explorer shows the namespaces that are found in these assemblies. A given assembly can contain more than one namespace and vice versa.)
If you are compiling from the command line then the assembly mscorlib.dll, which contains some of the most important base classes, is referenced implicitly. You will need to indicate any other assemblies to be referenced with the command line parameter /r, supplying the full file system path to the assembly. For example for the above project, the appropriate command is:
csc ReadFile.cs /r:c:\WinNT\Microsoft.NET\Framework\v1.0.2204\System.Drawing.dll
/r:c:\WinNT\Microsoft.NET\Framework\v1.0.2204\System.WinForms.dll
/r:c:\WinNT\Microsoft.NET\Framework\v1.0.2204\System.Data.dll
/r:c:\WinNT\Microsoft.NET\Framework\v1.0.2204\System.Diagnostics.dll
/r:c:\WinNT\Microsoft.NET\Framework\v1.0.2204\System.dll
/r:c:\WinNT\Microsoft.NET\Framework\v1.0.2204\Microsoft.Win32.Interop.dll
Now we've understood the concept of a namespace we can go on to look at the namespaces that contain the various base classes.
Using Aliases
If you have a very long namespace and you want to use it several times in your code, then you can substitute a short word for the long namespace name which you can refer to in the code as often as you want. The advantages of doing this are that the code becomes easier to read and maintain and it saves you typing out very long strings.
The syntax for declaring an alias is:
using Alias = Wrox.SampleCode.CSharpPreview.Examples;
and this sample code illustrates how you can use an alias:
namespace Wrox.SampleCode.CSharpPreview
{
using System;
using MathEx = Wrox.SampleCode.CSharpPreview.Examples;
namespace ChBaseClasses
{
public class clsExample1
{
public static void Main()
{
MathEx.clsMath MyMathClass = new MathEx.clsMath();
Console.WriteLine(MyMathClass.Add(3,4));
}
}
}
// The alias MathEx refers to this namespace
namespace Examples
{
public class clsMath
{
public int Add(int x, int y)
{
int z = x + y;
return (z);
}
}
}
}
The Base Classes
As we've remarked there are a huge number of base classes, and there are also a large number of namespaces that contain these classes. We cannot hope to give comprehensive coverage in this chapter, but we'll give a quick summary of some of the more useful namespaces here.
Namespace | Namespace Classes Contained |
| System.Web | Classes that assist in the generation of web pages using ASP+ |
| System.Net | Classes to make requests over the network and Internet |
| System.Data | ADO+ classes that make it easy to access data from relational databases and other data sources. |
| System.WinForms | Classes to display controls for standalone (as opposed to web) windows applications. |
| Microsoft.Win32 | Functions that were previously accessible mainly through the Win32 API functions, such as registry access. |
There are many more namespaces, and the best way to learn about them and the classes they contain is to explore them yourself - and Microsoft have provided a tool for just this purpose. That's what we'll look at next.
The WinCV Tool
WinCV is a class viewer tool, which can be used to examine the classes available in shared assemblies- including all the base classes. (A shared assembly is an assembly that has been marked for use by other applications - we'll cover shared assemblies in Chapter 10). For each class, it lists the methods, properties, events and fields using a C#-like syntax.
At the present time you start it by typing in wincv at the command prompt or clicking on the file in Windows Explorer. This gives you a basic window with two panes, as shown.
You then type in a search string that is contained in the class you are looking for in the Searching For box. For example if you want to find a class that handles dates, you might try typing in Date in this box. As you type, WinCV will display a list of classes that contain the string in question in their names:
As this screenshot shows, there are a lot of classes whose name contains the string date - then it's just a question of scanning through the names to find the one that looks most suitable. The definition of the selected class is then displayed in the right hand pane. The left hand pane also indicates the namespace the class is contained in - you'll need this in order to be able to use that class in your C# code. In the case of DateTime, WinCV tells us that it is part of the System namespace, which means that the line
using System;
that is placed by the AppWizard by default in most C# projects will be sufficient to give us access to the class without explicitly indicating the namespace.
The right hand pane of WinCV tells us which assembly the class is defined in - the screenshot shows us that System.DateTime is defined in mscorlib.dll. This information is useful to indicate if we need to link in any assemblies when we compile, in order to have access to the class. Again, the above screenshot tells us that we are OK for the DateTime class, since it is defined in mscorlib.dll, which is, by default, referenced anyway.
Now we've laid the groundwork, the rest of this chapter is devoted to presenting a number of sample C# projects which are designed to illustrate how to carry out some common programming tasks that are made easy by the base classes.
About the Samples
Before we go through the samples in this chapter, we'll quickly go over how we are structuring them. Since in most cases all we want to do is perform a few operations such as writing to a file or accessing some registry keys then displaying the results, it would be simplest to provide console samples - that way we minimize the extraneous code. However in practice, very few Windows applications are written as console applications, and it would be nice to put the output in a more realistic environment. Accordingly, the samples will all be presented as Windows applications, based on a form that has a list box, as shown here.
We haven't yet covered how to write Windows applications in C# - that's the subject of Chapter 8, but we'll give you just enough information here for you to understand how the samples are created.
Each project is created as a C# Windows application: So when we start up the Visual Studio developer environment and select New Project, we fill in the New Project dialog like this (though supplying our own name and path for the project).
Once the project has been created, we use the Toolbox in the developer environment to place a List box on the form - by default this will be called listBox1. The List box is actually an instance of a C# object of type ListBox, from the System.WinForms namespace.
We then examine the code the wizard has generated for us and make the following changes (shown highlighted).
public class Form1 : System.WinForms.Form
{
///
/// Required designer variable
///
private System.ComponentModel.Container components;
private System.WinForms.ListBox listBox1;
private int nItems=0;
public void AddItem(string sItem)
{
object oItem = sItem;
listBox1.InsertItem(nItems,oItem);
++nItems;
}
public Form1()
{
//
// Required for Win Form Designer support
//
InitializeComponent();
//
// TODO: Add any constructor code after InitializeComponent call
//
AddItem("An item of output");
AddItem("2nd bit of output");
AddItem("More output");
}
...
The code that we are adding is to the Form1 class which represents the entire form (window) created when the program is run. We first add a member field, nItems, and a member function, AddItem(). These are to make it easier for us to add lines of text to the list box. This is normally done by using the member function, InsertItem() of the ListBox class. But in its simplest overload, this function takes two parameters - the zero-based index of where we wish to insert the item, and the item itself, passed as an object (InsertItem() will use the ToString() function to extract the string to be added). Since we wish to add each successive item to the end of the list box, this would require us to keep a count of how many items we have added. Our AddItem() function automates that process for us.
private int nItems=0;
public void AddItem(string sItem)
{
object oItem = sItem;
listBox1.InsertItem(nItems,oItem);
++nItems;
}
I should mention we could also add the items to the list box with the line of code
listBox1.Items.Add(oItem);
though either way our function does marginally simplify the code.
We then actually add the items in the Form1 constructor. In this case we have simply added three strings.
AddItem("An item of output");
AddItem("2nd bit of output");
AddItem("More output");
In all the subsequent samples these three lines will be replaced by the code to do whatever processing is required to illustrate the task in hand, followed by AddItem() calls to display the results. Each of the projects in this chapter were created in essentially the same way to the above example. Note however that in the following samples, we've also changed the name of the Form1 class and the namespace that it appears in. The developer environment by default gives us a namespace that has the same name as the project, however Microsoft guidelines say that the namespace should start with the company name (which makes sense, as you would not have any name clashes with other company's classes). So for all the projects here we'll use the namespace Wrox.BookSamples.CSharpPreview.ChBaseClasses.
You should bear in mind when reading through the samples that some of the classes may be modified before the .NET SDK is finally released. Hence they will give you a good idea of how to carry out tasks, but some of the names or signatures of methods may be slightly different. Also in many cases there are several classes or methods whose functionality overlaps. Just because we've presented a certain way of doing something doesn't mean there won't be alternative ways of doing the same task.
Manipulating Dates and Times
Our first samples will demonstrate how to access the date-time functionality provided by the base classes. There are two classes of relevance here: DateTime and TimeSpan, both of which are in the System namespace. We start off by displaying the current date and time in various different formats, using this code:
namespace Wrox.SampleCode.CSharpPreview.ChBaseClasses
{
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.WinForms;
using System.Data;
public class FormDisplayDateTimes : System.WinForms.Form
{
... as before
/// <summary>
/// Summary description for FormDisplayDateTimes.
/// </summary>
public FormDisplayDateTimes()
{
//
// Required for Win Form Designer support
//
InitializeComponent();
//
// TODO: Add any constructor code after InitializeComponent call
//
DateTime dtCurrTime = DateTime.Now;
AddItem("Current Time is " + dtCurrTime.ToString());
AddItem("Year is " + dtCurrTime.Year.ToString());
AddItem("Month is " + dtCurrTime.Month.ToString());
AddItem("Day of month is " + dtCurrTime.Day.ToString());
AddItem("Day of week is " + dtCurrTime.DayOfWeek.ToString());
AddItem("Hour is " + dtCurrTime.Hour.ToString());
AddItem("Minute is " + dtCurrTime.Minute.ToString());
AddItem("Second is " + dtCurrTime.Second.ToString());
AddItem("Millisecond is " + dtCurrTime.Millisecond.ToString());
AddItem("ShortDateString is " + dtCurrTime.ToShortDateString());
AddItem("LongDateString is " + dtCurrTime.ToLongDateString());
AddItem("ShortTimeString is " + dtCurrTime.ToShortTimeString());
AddItem("LongTimeString is " + dtCurrTime.ToLongTimeString());
}
As explained earlier, we are adding our code to the constructor of the FormDisplayDateTimes class in our project. (FormDisplayDateTimes was Form1 in the generated code but we've changed its name to a more meaningful class name.)
We first instantiate a variable dtCurrTime of class DateTime, and initialize it using the static property of the DateTime class, Now, which returns the current date and time. We then use various properties, fields and methods to extract portions of the current date and time. This code produces the following output:
Figure 6
...
public class FormTimeSpans : System.WinForms.Form
{
... as before
public FormTimeSpans()
{
//
// Required for Win Form Designer support
//
InitializeComponent();
//
// TODO: Add any constructor code after InitializeComponent call
//
// constructor: TimeSpan(days, hours, minutes, seconds)
TimeSpan Span = new TimeSpan(4,2,15,0);
// initialize date to 1 Jan 2000, 12 pm
// constructor: DateTime(year,month,day,hours,minutes,seconds,
// milliseconds)
DateTime dtOld = new DateTime(2000,1,1,12,0,0,0);
DateTime dtNew = dtOld + Span;
AddItem("Original date was " + dtOld.ToLongDateString() +
" " + dtOld.ToShortTimeString());
AddItem("Adding time span of " + Span.ToString());
AddItem("Result is " + dtNew.ToLongDateString() + " " +
dtNew.ToShortTimeString());
AddItem("");
AddItem("Time span broken down is:");
AddItem("Days: " + Span.Days.ToString());
AddItem("Hours: " + Span.Hours.ToString());
AddItem("Minutes: " + Span.Minutes.ToString());
AddItem("Seconds: " + Span.Seconds.ToString());
AddItem("Milliseconds: " + Span.Milliseconds.ToString());
AddItem("Ticks: " + Span.Ticks.ToString());
AddItem("");
AddItem("TicksPerSecond: " + TimeSpan.TicksPerSecond.ToString());
AddItem("TicksPerHour: " + TimeSpan.TicksPerHour.ToString());
}
In this sample we see the new operator being used to construct DateTime and TimeSpan instances of given value. Both these classes have several constructors with different numbers of parameters depending on how precisely you wish to specify the time. We add the span on to the time and display the results. In displaying the results we use the ToLongDateString() method of the DateTime class to get the date in plain English, but the ToShortTimeString() method to get the time (using ToLongTimeString() would give us milliseconds as well). We then use various properties of the TimeSpan class to show the days, hours, minutes, seconds, milliseconds and ticks. Ticks are the smallest unit allowed by the TimeSpan class and measure one ten-millionth of a second, as indicated by a couple of static fields that give conversion factors, which we also display.
The above code gives this output:
Figure 7
