C# ПІДРУЧНИКИ / c# / MS Press - Msdn Training Programming Net Framework With C#

*****************************ILLEGAL FOR NON-TRAINER USE******************************

2Module 3: Working with Components

An Introduction to Key .NET Framework Development Technologies

*****************************ILLEGAL FOR NON-TRAINER USE******************************

To develop applications in the .NET Framework, you should be familiar with the following technologies: Windows Forms, ASP.NET Web Forms, and XML Web services. Your choice of technology, or technologies, depends on the type of software solution that you wish to implement. This topic briefly introduces the technologies and provides references to additional information.

Windows Forms

Windows Forms are used to develop applications in which the client computer handles most of the application processing. Classic Microsoft Win32® desktop applications, such as drawing and graphics applications, data-entry systems, point-of-sale systems, and games, are well suited to Window Forms. All of these applications rely on the power of the desktop computer for processing and for high-performance content display.

The System.Windows.Forms namespace contains the classes used to create

Windows Forms.

4Module 3: Working with Components

" Creating a Simple .NET Framework Component

*****************************ILLEGAL FOR NON-TRAINER USE******************************

Using Namespaces and Declaring the Class

public class StringComponent {...} public class StringComponent {...}

*****************************ILLEGAL FOR NON-TRAINER USE******************************

To create a new namespace that encapsulates the classes that you will be creating, you use the namespace statement, as in the following example:

using System;

namespace CompCS {...}

The following statement denotes that instances of the StringComponent class will now be created by the runtime and managed in the garbage-collected heap.

public class StringComponent {...}

6Module 3: Working with Components

Creating the Class Implementation

*****************************ILLEGAL FOR NON-TRAINER USE******************************

The component provides a wrapper for an array of strings. You can declare a private field of type array of string elements, as in the following example:

private string[ ] stringSet;

The following example shows how to create a public default constructor, which executes each time a new instance of the class is created, and how to assign the stringSet field to an array of strings:

public StringComponent() { stringSet = new string[ ] {

"C# String 0",

"C# String 1",

"C# String 2",

"C# String 3"

};

}

In the preceding example, you can see that the constructor has the same name as the class and does not have a return type.

Implementing Structured Exception Handling

*****************************ILLEGAL FOR NON-TRAINER USE******************************

Programs must be able to uniformly handle errors and exceptions that occur during execution. The common language runtime helps you design errortolerant software by providing a platform for notifying programs of errors in a uniform manner. All .NET Framework methods indicate failure by throwing exceptions.

Traditionally, a language’s error-handling model relied on either the language’s unique way of detecting errors and locating handlers for them, or on the errorhandling mechanism that is provided by the operating system. The runtime implements exception handling with the following features:

!It handles exceptions without regard for the language that generates the exception or the language that will be called upon to handles the exception.

!It does not require any particular language syntax for handling exceptions, but allows each language to define its own syntax.

!It allows exceptions to be thrown across process boundaries and machine boundaries.

Exceptions offer several advantages over other methods of error notification. Failures do not go unnoticed. Invalid values do not continue to propagate through the system. You do not have to check return codes. Exception-handling code can be easily added to increase program reliability. Finally, the runtime’s exception handling is faster than Windows-based C++ error handling.

8Module 3: Working with Components

The component uses the GetString method to return the strings in the stringSet array. You can use a throw statement to implement structured exception handling within the GetString method, as in the following example:

public string GetString(int index) {

if ((index < 0) || (index >= stringSet.Length)) { throw new IndexOutOfRangeException();

}

return stringSet[index];

}

In the preceding example, the program evaluates whether the integer that is passed as an argument to GetString is a valid index for the stringSet array. If the index is invalid, the following statement creates and throws a new object of type IndexOutOfRangeException:

throw new IndexOutOfRangeException();

If the index is valid, the program returns the string element of the stringSet array at that particular index.

Exceptions may be caught by the caller by using a try/catch/finally statement. Place the sections of code that might throw exceptions in a try block and place code that handles exceptions in a catch block. You can also write a finally block that always runs regardless of how the try block runs. The finally block is useful for cleaning up resources after a try block. For example, in C#:

try {

//code that might throw exceptions

}

catch(Exception e) {

//place code that handles exceptions

}

finally {

//place code that runs after try or catch runs

}

In general, it is good programming practice to catch a specific type of exception rather than using the preceding general catch statement that catches any exception.

Structured exception handling replaces the HRESULT-based error-handling system that is used in COM. All .NET Framework exception-handling classes, such as IndexOutOfRangeException and user-defined exceptions, must derive from System.Exception.

For more information about exception handling, see “Handling and Throwing Exceptions” in the .NET Framework SDK documentation.

*****************************ILLEGAL FOR NON-TRAINER USE******************************

To provide the number of string elements in the stringSet array, you create a read-only property called Count, as in the following example:

public int Count {

get { return stringSet.Length; }

}

For Your Information

Point out that the GetString method and Count property may be used by a client to iterate over the component’s string elements. This information will help students when they create the clients in subsequent labs.

Compiling the Component

*****************************ILLEGAL FOR NON-TRAINER USE******************************

To compile the source code for the C# component, first you must save the source file, and then enter the following command from a command prompt window:

Important To use Microsoft Visual Studio® .NET tools within a command prompt window, the command prompt window must have the proper environment settings. The Visual Studio .NET Command Prompt window provides such an environment. To run a Visual Studio .NET Command Prompt window, click Start, All Programs, Microsoft Visual Studio .NET,

Visual Studio .NET Tools, and Visual Studio .NET Command Prompt.

csc /out:CompCS.dll /target:library CompCS.cs

This command directs the compiler to produce the file CompCS.dll. The /target:library switch is required to actually create a DLL library, instead of an executable.