//This array contains 4 int values, which default to 0

//Here, the valid indexes are b[0], b[1], b[2], b[3] int[] b = new int[4];

//An array can be initialized directly or with the new keyword

//evens.Length will return 6

//foreach (int p in primes) iterates through the elements in primes int[] evens = { 2, 4, 6, 8, 10, 12 };

int[] primes = new int[] {2, 3, 5, 7, 11, 101, 9876543211 };

//This example shows a 2 by 2 string array

//Here, names[0,0] = "Katie" and names[1,1] = "Bianca"

string[,] names = { { "Katie", "Sydney" }, { "Edmund", "Bianca"} };

//This example shows an array of arrays.

//Here, x[0] is an int array of length three with values 1, 2, 3.

//Also, x[1][1] = 12 and x[2][4] = 25.

//Attempting to reference x[3] or x[1][2] will throw an exception int[][] x = { { 1, 2, 3 }, { 11, 12 }, { 21, 22, 23, 24, 25} };

A.4.3 MAIN

A program has to start somewhere. In C and C++ programs, the global procedure main is the defined entry point for the program. This starting point is referred to as the entry point for the program.

In C#, a class must define a static method called Main to serve as the entry point. The method must have one of the following signatures.

static void Main()

static void Main(string[] args)

static int Main()

static int Main(string[] args)

A program will return a value if the Main method returns a value. A program can receive command-line arguments by specifying an array of string objects as the only parameter to the Main method.

If two or more classes in a program contain a Main method, then the /main switch must be used with the C# compiler to specify which method to consider the entry point for the program.

A.4.4 BOXING

By definition, the object class is a reference type. However, it also serves as the ultimate base class for all types, including the built-in types. As a result, value types such as int and bool can be used wherever an object instance is required. For example, the ArrayList class represents a dynamically-sized array, and includes an Add method to add an object to the array. This method is declared as follows:

public virtual int Add(object value);

Within the Add method, a reference type is expected. So what happens when a value type is passed into this method? Clearly, an explicit mechanism for treating value types as a reference type is required.

This mechanism is called boxing. Boxing implicitly copies the data in a value type into an object instance allocated on the heap. For example:

//Boxing of an integer constant object obj = 123;

//Boxing of an int type. ArrayList list = new ArrayList(); int x = 32768;

list.Add(x);

A boxed value is converted back into a value type through a process called unboxing. Conceptually, boxing and unboxing happens automatically and the programmer can remain blissfully unaware of this concept. Boxed values can be treated as their unboxed equivalents. For example:

int n = 5;

object obj = 123;

if (obj is int)

n = (int) obj;

These statements are perfectly legal, and result in the value of 123 for the variable n. The reason boxing is important is because of the performance implications involved. The boxing and unboxing of values takes time, and this can seriously impact the performance of an application.

Note in particular that boxing occurs when a structure, which is a value type, is cast to an interface, which is a reference type. For this reason, care should be taken when creating structures that support one or more interfaces. In such a situation, the performance implications of boxing might warrant using a class instead of a structure.

A.4.5 DOCUMENTATION

A final topic worth mentioning in this appendix is that of automated documentation. C# supports a set of XML-style tags that can be used in comments and extracted by the compiler. Such comments must begin with a triple-slash (///) and can occur before the declaration of most types and type members.

The C# compiler supports the /doc switch to generate the XML documentation file. Details on this process and the resulting output are available in the .NET documentation.

The following table provides a summary of the tags that are currently recognized by the compiler. An example using the <summary> tag appears in section 5.2.1 on page 134.

C# documentation tags

A P P E N D I X B

.NET namespaces

This appendix provides an overview of some of the System namespaces provided by Microsoft in the .NET Framework, and discusses their relationship to Windows Forms applications. For a complete list of namespaces in .NET, see the .NET Framework Class Library documentation.

The System namespace contains the commonly-used types1 required by .NET programs and libraries, as well as services such as data type conversion, environment management, and mathematical operations. In particular, most of the classes mentioned in Appendix A that implement core functionality such as the built-in types, enumerations, and delegates are included in this namespace. Members of this namespace are discussed throughout the book as they are used in the sample programs.

1 The word type is used in the C# sense here, as defined in Appendix A. More generally, a type can be a class, structure, interface, enumeration, or a delegate. By definition, a namespace defines one or more types.

674