|
The .NET Framework class library is made up of a set of classes, interfaces, structures, and enumerations that are contained in almost 100 namespaces. This section begins by explaining how to use namespaces in managed C++ code and then goes on to list the major .NET namespaces, together with brief details of their function and content.
You’ve already encountered .NET namespaces in use in managed C++ code when you’ve used the C++ using keyword, as in the following example:
using namespace System::Collections;
As with traditional C++ namespaces, .NET namespaces provide an additional level of scoping that helps you organize code and guard against name clashes. Two classes with the same name can be used in a program, provided that they belong to different namespaces. A type name that includes the namespace information is called the fully qualified name, as in the examples shown here:
System::Collections::ArrayList // the ArrayList class from // System::Collections System::Threading::Thread // the Thread class from // System::Threading
Namespace names in .NET typically consist of more than one word. In managed C++, the components of the name are separated by the scope resolution operator (::). In other .NET languages such as C# and Visual Basic, the components are separated using a period (.), so in Visual Basic, the preceding examples would be:
System.Collections.ArrayList System.Threading.Thread
All classes, interfaces, structures, and enumerations that are part of the .NET Framework class library belong to a namespace. All the namespaces provided by Microsoft begin with one of two prefixes. Those that start with System have been developed as part of the .NET Framework class library, while those beginning with Microsoft have been developed by other product groups within Microsoft.
Namespace names can have any number of components, but there’s no hierarchical relationship implied in names that contain the same root components. The hierarchical nature of namespace names simply gives you a way to organize your classes. So, for example, System::Collections::Specialized and System::Collections both contain collections, yet they aren’t necessarily related in any other way.
Note | Note to Java programmers: although .NET namespaces look very much like Java package names, there’s no relationship between namespace names and directory paths as there is in Java. |
There’s no requirement that all the classes belonging to one namespace are defined in the same DLL or that a single DLL contains classes from only one namespace.
Managed C++ programs use the #using preprocessor directive to import metadata into a program using the Managed Extensions for C++. Remember that metadata is information that describes the types in an assembly, and it includes the fully qualified names of all the types. For example, if the compiler sees a line such as
#using <mscorlib.dll>
it loads the DLL and reads the metadata for all the types that are defined there. Because mscorlib.dll contains most of the core .NET Framework classes, it imports the metadata for a very large number of types.
Note | You can currently only use #using to reference assemblies defined in DLLs. This restriction might be lifted at a later date, but for now, you can reference only in-process components. |
The #using keyword means that you have to know which DLL holds the class or classes you want to use. Your normal source for this information will be the online help, and whenever I mention a namespace in the rest of this chapter, I’ll also say which DLL it belongs to.
Some of the fully qualified names can get rather long. Thus, it’s common to use a traditional using directive to specify namespace names so that you can use unqualified names, as shown here:
// Read the metadata for MSCORLIB #using <mscorlib.dll> // Import all the names using namespace System::Collections; // Now you can use ArrayList without having to qualify it ArrayList* pal = new ArrayList();
The System namespace, defined in mscorlib.dll, contains a lot of fundamental classes, including:
Base classes for commonly used value and reference types, plus the base class for arrays
Events and event handlers
Delegates and interfaces
Attributes
Exceptions
Math
Application environment management
Garbage collection
Local and remote program invocation
Data type conversion
You’ve already met a lot of types from System in earlier chapters, and some of the other classes are rather obscure, so I won’t go through them in detail. There are a few points that are worth mentioning about some of the classes in System, and they’re covered in the following sections.
System implements all the basic types defined by the CTS, and you can find these listed in the following table, which you first saw in Chapter 9.
Value Type | Description | Managed C++ Equivalent Type |
Byte | An 8-bit unsigned integer | char |
SByte | An 8-bit signed integer | signed char |
Int16 | A 16-bit signed integer | short |
Int32 | A 32-bit signed integer | int or long |
Int64 | A 64-bit signed integer | __int64 |
UInt16 | A 16-bit unsigned integer | unsigned short |
UInt32 | A 32-bit unsigned integer | unsigned int or unsigned long |
UInt64 | A 64-bit unsigned integer | unsigned __int64 |
Single | A single-precision 32-bit floating-point number | float |
Double | A double-precision 64-bit floating-point number | double |
Boolean | A Boolean value | bool |
Char | A 16-bit Unicode character | wchar_t |
Decimal | A 96-bit decimal value | Decimal |
IntPtr | A signed integer whose size depends on the platform | No built-in type |
UIntPtr | An unsigned integer whose size depends on the platform | No built-in type |
Note that several of the types—namely the unsigned integer types and SByte— aren’t CLS-compliant, so be wary of using them when you’re writing code that’s going to be used from other .NET languages.
All .NET languages map these types onto native types, so managed C++ maps int onto System::Int32, but you can also use the types directly if you want.
The Single and Double types implement IEEE-754 floating-point arithmetic. For the uninitiated, IEEE-754 floating-point arithmetic means that every operation has a defined result, so you never get a divide-by-zero error when doing floating-point math; instead, you get an answer of infinity. The floating-point classes have values to represent positive and negative infinity and “not a number,” as well as methods to test for them, as shown in the following example:
double top = 1.0; double bottom = 0.0; double result = top/bottom; if (result == Double::PositiveInfinity) Console::WriteLine(S"+infinity"); else if (result == Double::NegativeInfinity) Console::WriteLine(S"-infinity"); else if (result == Double::NaN) Console::WriteLine(S"NaN");
You’ve already met the collections namespaces, System::Collections and
System::Collections::Specialized, in Chapter 12. System::Collections is implemented in mscorlib.dll, while System::Collections::Specialized is implemented in system.dll, so if you want to use both, you’ll have to use two #using statements like the following:
#using <mscorlib.dll> #using <system.dll>
The following table lists the main classes that you’ll find in the System::Collections namespace.
Class | Description |
---|---|
ArrayList | A dynamically growable array |
BitArray | A class that stores a number of Boolean values as the individual bits of an integer |
Hashtable | A hash table that stores objects by hash key |
Queue | A list where objects are added at one end and retrieved from the other end |
SortedList | A linked list whose members are maintained in sorted order |
Stack | A first-in, last-out stack |
The following table shows the main classes that you’ll find in the System::Collections::Specialized namespace.
Class | Description |
---|---|
BitVector32 | A class that stores a number of Boolean values as the individual bits of a 32-bit integer |
ListDictionary | A dictionary implemented using a singly linked list |
NameValueCollection | A sorted collection of string keys and values |
StringCollection | An unsorted collection of strings |
StringDictionary | A hash table with the key strongly typed to be a string rather than an object |
StringEnumerator | An enumerator to work with StringCollection |
The System::Collections namespace also defines a series of interfaces that are used to define the behavior of the collection classes. The collection classes themselves implement one or more of these interfaces, and you can use them as the basis for writing your own collection classes. The main interfaces are listed in the following table.
Interface | Description |
---|---|
ICollection | Defines the size, enumerator, and synchronization methods for all collections |
IComparer | Defines a method for comparing two objects |
IDictionary | Implemented by collections that manage key/value pairs, such as Hashtable and ListDictionary |
IDictionaryEnumerator | Defines methods for enumerating over the items in a dictionary |
IEnumerable | Defines the GetEnumerator method, which returns an IEnumerator; implemented by almost all collections |
IEnumerator | Defines the properties and methods of enumerators |
IHashCodeProvider | Implemented by classes that provide hash code values |
IList | Implemented by classes that define indexed collections of objects |
System::Diagnostics provides a number of classes to
Trace program execution.
Interact with the debugger.
Use the system event log.
Start system processes.
Monitor system performance.
All the classes in System::Diagnostics are implemented in system.dll.
The System::IO namespace, defined in mscorlib.dll, provides the classes that implement the .NET input/output (I/O) functionality. The main classes in this namespace are described in the following table.
Class | Description |
---|---|
BinaryReader | Reads .NET primitive types from a byte stream |
BinaryWriter | Writes .NET primitive types to a byte stream |
Directory | Contains static methods for operating on directories |
DirectoryInfo | Represents a path to a directory, and contains methods for operating on the directory path |
File | Contains static methods for operating on files |
FileInfo | Represents a path to a file, and contains methods for operating on the file path |
FileStream | Reads and writes to files using streams |
FileSystemInfo | The base class for FileInfo and DirectoryInfo |
FileSystemWatcher | Watches for changes in the file system and fires events when changes occur |
IOException | The exception thrown when I/O errors occur |
MemoryStream | Reads and writes streams of bytes to and from memory |
Path | Represents directory strings in a platform-independent way |
Stream | The abstract base for the stream classes |
StreamReader | Reads Unicode characters from a byte stream |
StreamWriter | Writes Unicode characters to a byte stream |
StringReader | Reads Unicode characters from a string |
StringWriter | Writes Unicode characters to a string |
TextReader | The base class for StreamReader and StringReader |
TextWriter | The base class for StreamWriter and StringWriter |
As with all the .NET Framework class library classes, these classes are language- independent. They can be used alongside or in place of the C++ stream classes. You’ll find out more about some of the System::IO classes in Chapter 19.
A number of namespaces provide all the graphics functionality for the .NET Framework:
System::Drawing, which encapsulates the basic GDI+ drawing functionality. The namespace provides simple two-dimensional pixel-oriented graphics.
System::Drawing::Design, which extends System::Drawing to add design-time functionality so that you can extend the Visual Studio .NET interface with custom items.
System::Drawing:Drawing2D, which provides more advanced two- dimensional and vector graphics.
System::Drawing::Imaging, which adds image processing functionality to GDI+.
System::Drawing::Printing, which allows you to customize and control the printing process.
System::Drawing::Text, which adds advanced typography support to GDI+, including the ability to create and use collections of fonts.
The original set of Windows graphics routines was called GDI, for Graphical Device Interface. It provided a very simple set of two-dimensional graphics primitives, so you could draw lines, circles, rectangles, and other simple shapes, as well as strings of text. The .NET Framework has built on this functionality, and its graphics library is called GDI+. You’ll learn more about GDI+ in Chapter 18.
Visual Basic programmers have been used to programming with forms for some time. GUI applications in Visual Basic consist of a number of forms, each of which is a separate top-level window. Developers select controls—such as buttons and list boxes—from the toolbox and drop them onto the form. Every control has properties and methods associated with it; the Visual Basic Property Editor allows interactive modification of properties at design time, and both methods and properties can be accessed from code at run time.
The System::Windows::Forms namespace, which you’ll learn more about in Chapter 16 and Chapter 17, provides Visual Basic-style form-based development to all .NET languages, including C++. This namespace is huge, containing over 300 classes, structures, and enumerations. The following table lists some of the most important classes to give you a feel for what is available.
Class | Description |
Application | Provides methods and properties for managing applications |
AxHost | Wraps Microsoft ActiveX controls so that they can be used as Windows Forms controls |
Button | Represents a Windows button control |
CheckBox | Represents a Windows check box control |
CheckedListBox | Represents a list box control that has a check box to the left of each item |
Clipboard | Gives access to the system clipboard |
ColorDialog | Displays a standard color picker dialog box |
ComboBox | Represents a Windows combo box control |
Control | The base class for all controls |
Cursor | Represents a cursor |
DataGrid | Displays Microsoft ADO.NET data in a scrollable grid |
DateTimePicker | Represents a Windows date-time picker control |
DomainUpDown | Represents a Windows up-down control that displays string values |
FileDialog | The base class to display the standard File Open or File Save dialog boxes |
Form | Represents a window or a dialog box that makes up part of an application’s user interface |
Label | Represents a Windows label control |
ListBox | Represents a Windows list box control |
ListView | Displays a list of items in one of four views |
Panel | Represents a Windows panel control |
RichTextBox | Represents a Windows rich text box control |
StatusBar | Represents a Windows status bar control |
TextBox | Represents a Windows text box control |
ToolBar | Represents a Windows tool bar control |
Networking support is provided by the System::Net and System::Net::Sockets classes. System::Net provides an interface to many of the protocols commonly used today, such as manipulating IP addresses, making DNS lookups, talking to HTTP and FTP servers, managing cookies, and authentication.
System::Net::Sockets provides an implementation of the Berkeley Sockets protocol and provides a .NET wrapper around the Windows WinSock API.
XML is heavily used throughout the .NET Framework, and several namespaces provide support for creating and manipulating XML:
System::Xml, which provides the basic classes needed for processing XML
System::Xml::Schema, which provides support for XML Schemas
System::Xml::Serialization, which lets you serialize .NET objects to and from XML
System::Xml::XPath, which contains the XPath parser and evaluation engine
System::Xml::Xsl, which contains the Extensible Stylesheet Language (XSL) processor
Using these classes, it’s possible to perform all the manipulation of XML that you’ll ever need to do. These classes make the .NET Framework one of the most productive environments for XML programming.
The System::Data namespaces hold the classes that implement ADO.NET, a new version of Microsoft Active Data Objects technology optimized to work with the .NET Framework, which enables you to build components that manage data from a number of data sources. Data from different data sources is provided by data providers, of which there are three shipped with the .NET Framework. The .NET Framework Data Provider for OLE DB uses Microsoft COM-based technology that makes it possible to use many different kinds of data sources—such as relational database tables, Microsoft Excel spreadsheets, and even text files—as if they were databases. The .NET Framework Data Provider for SQL Server works with data from Microsoft SQL Server. Finally, the .NET Framework Data Provider for Oracle makes it possible to work with Oracle databases from .NET code.
The most important class in the System::Data namespaces is DataSet, which represents an in-memory cache of data retrieved from a data source. A DataSet consists of one or more DataTable objects, and these in turn consist of a collection of DataColumn objects.
Because one of the main reasons for introducing the .NET Framework was to make it easier to build Web applications, it’s perhaps no surprise that the .NET Framework contains a number of namespaces related to Web programming. These are all related to Microsoft ASP.NET, the latest version of Microsoft Active Server Pages technology that is optimized to work in the .NET environment.
The most significant of the Web namespaces are listed here:
System::Web, which provides the basic functionality for browser-to- server communication over HTTP, including the HttpRequest and HttpResponse classes that enable an ASP.NET page to exchange data with the client using HTTP
System::Web::Mail, which lets you prepare and send e-mail attachments using the SMTP service built into Windows 2000, Windows XP, and Windows NT
System::Web::Security, which provides classes that implement security in ASP.NET
System::Web::Services, which provides the classes that let you build Web services
System::Web::UI, which contains all the classes that let you build server-side controls
The features provided by two of these namespaces merit particular mention. Web services, in particular, are a great new feature introduced by the .NET Framework. A Web service is a programmable entity living on a Web server that can be accessed using standard Internet protocols. What this means in practice is that you can expose a function on a Web server that others can call. Communication between client and server uses standard protocols, such as HTTP, and data is usually passed to and from the Web service in XML format using SOAP. The use of XML over HTTP makes it possible to access Web services easily from clients written in just about any programming language on any platform. It’s also possible to find out what services a Web server supports, and it’s very easy in Visual Studio .NET to write clients that make use of Web services.
The System::Web::UI namespaces let you build server-side controls. You program these as if they were normal controls, but their code executes on the server. The System::Web::UI::HtmlControls namespace contains classes that represent HTML server controls that map directly onto standard HTML elements, such as buttons and forms. System::Web::UI::WebControls is more abstract and lets you program server-side controls that might not map directly onto HTML.
|