The decimal type is a 128-bit high-precision floating-point number. It provides 28 decimal digits of precision and is used in financial calculations where rounding cannot be tolerated. This example illustrates three of the many methods available to decimal type. Also observe that when assigning a literal value to a decimal type, the M suffix must be used.

decimal iRate = 3.9834M;         // decimal requires M 
iRate = decimal.Round(iRate,2);  // Returns 3.98
decimal dividend = 512.0M;
decimal divisor = 51.0M;
decimal p = decimal.Parse("100.05");
// Next statement returns remainder = 2
decimal rem = decimal.Remainder(dividend,divisor);

The only possible values of a bool type are true and false. It is not possible to cast a bool value to an integer—for example, convert true to a 1, or to cast a 1 or 0 to a bool.

bool bt = true;
string bStr = bt.ToString(); // returns "true"
bt = (bool) 1;               // fails

The char type represents a 16-bit Unicode character and is implemented as an unsigned integer. A char type accepts a variety of assignments: a character value placed between individual quote marks (' '); a casted numeric value; or an escape sequence. As the example illustrates, char also has a number of useful methods provided by the System.Char structure:

myChar =  'B';       // 'B' has an ASCII value of 66
myChar = (char) 66;  // Equivalent to 'B'
myChar = 'u0042';   // Unicode escape sequence
myChar = 'x0042';   // Hex escape sequence
myChar = '	';       // Simple esc sequence:horizontal tab
bool bt;
string pattern = "123abcd?";
myChar = pattern[0];                  // '1'
bt = char.IsLetter(pattern,3);        // true  ('a')
bt = char.IsNumber(pattern,3);        // false
bt = char.IsLower(pattern,0);         // false ('1')
bt = char.IsPunctuation(pattern,7);   // true  ('?')
bt = char.IsLetterOrDigit(pattern,1); // true
bt = char.IsNumber(pattern,2);        // true  ('3')
string kstr="K";
char k = char.Parse(kstr);

A byte is an 8-bit unsigned integer with a value from 0 to 255. An sbyte is an 8-bit signed integer with a value from –128 to 127.

byte[] b = {0x00, 0x12, 0x34, 0x56, 0xAA, 0x55, 0xFF};
string s = b[4].ToString(); // returns 170
char myChar = (char) b[3];

These represent 16-, 32-, and 64-bit signed integer values, respectively. The unsigned versions are also available (ushort, uint, ulong).

short i16 = 200;
i16 = 0xC8 ;     // hex value for 200
int i32 = i16;   // no casting required 

These are represented in 32-bit single-precision and 64-bit double-precision formats. In .NET 1.x, single is referred to as float.

float xFloat = 24567.66F;
int xInt = Convert.ToInt32(xFloat);  // returns 24567
int xInt2 = (int) xFloat;
if(xInt == xInt2) {  }               // False
string xStr = Convert.ToString(xFloat);
single zero = 0;
if (Single.IsNaN(0 / zero)) {  }     // True
double xDouble = 124.56D;

Note that the F suffix is used when assigning a literal value to a single type, and D is optional for a double type.

The primitive numeric types include Parse and TryParse methods that are used to convert a string of numbers to the specified numeric type. This code illustrates:

short shParse  = Int16.Parse("100");
int iParse     = Int32.Parse("100");
long lparse    = Int64.Parse("100");
decimal dParse = decimal.Parse("99.99");
float sParse   = float.Parse("99.99");
double dbParse = double.Parse("99.99");

TryParse, introduced in .NET 2.0, provides conditional parsing. It returns a boolean value indicating whether the parse is successful, which provides a way to avoid formal exception handling code. The following example uses an Int32 type to demonstrate the two forms of TryParse:

int result;
// parse string and place result in result parameter
bool ok = Int32.TryParse("100", out result); 
bool ok = Int32.TryParse("100", NumberStyles.Integer, null,
                         out result);

In the second form of this method, the first parameter is the text string being parsed, and the second parameter is a NumberStyles enumeration that describes what the input string may contain. The value is returned in the fourth parameter.

Table 2-4 summarizes the basic numerical operators. The precedence in which these operators are applied during the evaluation of an expression is shown in parentheses, with 1 being the highest precedence.

+
-

*
/
%

int x = 60;
int y = 15;
int z = x * y / 2;  // 450
y = x % 29 ;  // remainder is 2

++
--

x = 5;
Console.WriteLine(x++) // x = 5 
Console.WriteLine(++x) // x = 6

>>
<<

byte x = 10; // binary 10 is 01010
int result = x << 1; // 20 = 10100
result = x >> 2;     //  5 = 00101

&
|
^

byte x = 12;        //    001100
byte y = 11;        //    001011
int result = x & y; //8 = 001000
result = x ^ y;     //7 = 000111

Core Note

C# does not provide an exponentiation operator. Instead, use the Math.Pow() method to raise a number to a power, and Math.Exp() to raise e to a power.

Relational operators are used to compare two values and determine their relationship. They are generally used in conjunction with conditional operators to form more complex decision constructs. Table 2-5 provides a summary of C# relational and conditional operators.

==
!=

<
<=
>
>=

&&
||

&
|

Note the two forms of the logical AND/OR operations. The && and || operators do not evaluate the second expression if the first is false—a technique known as short circuit evaluation. The & and | operators always evaluate both expressions. They are used primarily when the expression values are returned from a method and you want to ensure that the methods are called.

In addition to the operators in Table 2-5, C# supports a ?: operator for conditionally assigning a value to a variable. As this example shows, it is basically shorthand for using an if-else statement:

string pass;
int grade=74;
If(grade >= 70) pass="pass"; else pass="fail";
//     expression   ? op1  : op2
pass = (grade >= 70)  ? "pass" : "fail";

If the expression is true, the ?: operator returns the first value; if it's false, the second is returned.

The C# language provides if and switch conditional constructs that should be quite familiar to C++ and Java programmers. Table 2-6 provides a summary of these statements.

if (boolean expression) {
   // statements
} else {
   // statements
}

if (bmi < 24.9) {
   weight = "normal";
   riskFactor = 2;
} else {
   weight = "over";
   riskFactor=6;
}

switch (expression) 
{
   case constant expression:
      // statements;
      // break/goto/return()
   case constant expression:
      // statements;
      // break/goto/return()
   default:
      // statements;
      // break/goto/return()
}

switch (ndx)
{
   case 1:
      fabric = "cotton";
      blend = "100%";
      break;
   case 2:  // combine 2 & 3 
   case 3:
      fabric = "cotton";
      blend = "60%";
      break;
   default:  // optional
      fabric = "cotton";
      blend = "50%";
      break;
}

Syntax:

if ( boolean expression ) statement
if ( boolean expression ) statement1 else statement2

C# if statements behave as they do in other languages. The only issue you may encounter is how to format the statements when nesting multiple if-else clauses.

// Nested if statements
if (age > 16)                         if (age > 16)
{                                        if (sex == "M")
   if (sex == "M")                          type = "Man";
   {                                     else
      type = "Man";                         type = "Woman" ;
   } else {                           else
      type = "Woman" ;                   type = "child";
   }
} else {  
   type = "child";
}

Both code segments are equivalent. The right-hand form takes advantage of the fact that curly braces are not required to surround single statements; and the subordinate if clause is regarded as a single statement, despite the fact that it takes several lines. The actual coding style selected is not as important as agreeing on a single style to be used.

Syntax:

switch( expression ) {switch block}

The expression is one of the int types, a character, or a string. The switch block consists of case labels—and an optional default label—associated with a constant expression that must implicitly convert to the same type as the expression. Here is an example using a string expression:

// switch with string expression
using System;
public class MyApp 
{
   static void Main(String[] args)
   {
      switch (args[0]) 
      {
         case "COTTON":   // is case sensitive
         case "cotton":
              Console.WriteLine("A good natural fiber.");
              goto case "natural";
         case "polyester":
              Console.WriteLine("A no-iron synthetic fiber.");
              break;
         case "natural":
              Console.WriteLine("A Natural Fiber. ");
              break;
         default:
              Console.WriteLine("Fiber is unknown.");
              break;
      }
   }
}

The most important things to observe in this example are as follows:

Syntax:

while ( boolean expression ) { body }

The statement(s) in the loop body are executed until the boolean expression is false. The loop does not execute if the expression is initially false.

Example:

byte[] r = {0x00, 0x12, 0x34, 0x56, 0xAA, 0x55, 0xFF};
int ndx=0;
int totVal = 0;
while (ndx <=6) 
{
   totVal +=    r[ndx];   
   ndx += 1;
}

Syntax:

do { do-body } while ( boolean expression );

This is similar to the while statement except that the evaluation is performed at the end of the iteration. Consequently, this loop executes at least once.

Example:

byte[] r = {0x00, 0x12, 0x34, 0x56, 0xAA, 0x55, 0xFF};
int ndx=0;
int totVal = 0;
do 
{
   totVal += r[ndx];
   ndx += 1;
}
while (ndx <= 6);      

Syntax:

for ( [initialization]; [termination condition]; [iteration] )
     { for-body }

The for construct contains initialization, a termination condition, and the iteration statement to be used in the loop. All are optional. The initialization is executed once, and then the condition is checked; as long as it is true, the iteration update occurs after the body is executed. The iteration statement is usually a simple increment to the control variable, but may be any operation.

Example:

int[] r = {80, 88, 90, 72, 68, 94, 83};
int totVal = 0;
for (int ndx = 0; ndx <= 6; ndx++) {
   totVal += r[ndx];
}

If any of the clauses in the for statement are left out, they must be accounted for elsewhere in the code. This example illustrates how omission of the for-iteration clause is handled:

for   (ndx = 0; ndx < 6; )
{
   totVal += r[ndx];
   ndx++;          // increment here
}

You can also leave out all of the for clauses:

for (;;) { body   }   // equivalent to while(true) { body }

A return, goto, or break statement is required to exit this loop.

Syntax:

foreach ( type identifier in collection )  { body }

The type and identifier declare the iteration variable. This construct loops once for each element in the collection and sets the iteration variable to the value of the current collection element. The iteration variable is read-only, and a compile error occurs if the program attempts to set its value.

For demonstration purposes, we will use an array as the collection. Keep in mind, however, that it is not restricted to an array. There is a useful set of collection classes defined in .NET that work equally well with foreach. We look at those in Chapter 4, “Working with Objects in C#.”

Example:

int totVal = 0;
foreach (int arrayVal in r)
{
   totVal += arrayVal;
}

In a one-dimensional array, iteration begins with index 0 and moves in ascending order. In a multi-dimensional array, iteration occurs through the rightmost index first. For example, in a two-dimensional array, iteration begins in the first column and moves across the row. When it reaches the end, it moves to the next row of the first column and iterates that row.

It is often necessary to terminate a loop, or redirect the flow of statements within the loop body, based on conditions that arise during an iteration. For example, a while (true) loop obviously requires that the loop termination logic exists in the body. Table 2-7 summarizes the principal statements used to redirect the program flow.

while (true) {
   ndx+=1;
   if (ndx >10) break;
}

while (ndx <10) {
   ndx +=1;
   if(ndx %2 =1) continue;
   totVal += ndx;
}

goto
identifier;

goto case exp;

goto default;

public int FindMatch(string myColor)
{
   string[] colorsAvail("blueaqua",
      "red", "green","navyblue");
   int loc;
   int matches=0;
   foreach (colorType in colorsAvail)
   {
      loc = colortype.IndexOf(myColor);
      if (loc >=0) goto Found;
      continue;
Found: 
      matches += 1;
   }   
      return(matches);
}

return
[expression] ;

public double Area(double w, double l) 
{ 
   return w * l;
}

There are few occasions where the use of a goto statement improves program logic. The goto default version may be useful in eliminating redundant code inside a switch block, but aside from that, avoid its use.

The #if related directives are used to selectively determine which code is included during compilation. Any code placed between the #if statement and #endif statement is included or excluded based on whether the #if condition is true or false. This is a powerful feature that is used most often for debug purposes. Here is an example that illustrates the concept:

#define DEBUG
using System;
public class MyApp 
{      
   public static void Main() 
   {
      #if (DEBUG)
         Console.WriteLine("Debug Mode");      
      #else
         Console.WriteLine("Release Mode");
      #endif
   }
}

Any #define directives must be placed at the beginning of the .cs file. A conditional compilation symbol has two states: defined or undefined. In this example, the DEBUG symbol is defined and the subsequent #if (DEBUG) statement evaluates to true. The explicit use of the #define directive permits you to control the debug state of each source file. Note that if you are using Visual Studio, you can specify a Debug build that results in the DEBUG symbol being automatically defined for each file in the project. No explicit #define directive is required.

You can also define a symbol on the C# compile command line using the /Define switch:

csc /Define:DEBUG myproject.cs

Compiling code with this statement is equivalent to including a #Define DEBUG statement in the source code.

Diagnostic directives issue warning and error messages that are treated just like any other compile-time errors and warnings. The #warning directive allows compilation to continue, whereas the #error terminates it.

#define CLIENT
#define DEBUG
using System;
public class MyApp 
{      
   public static void Main() 
   {
      #if DEBUG && INHOUSE
         #warning Debug is on.  
      #elif DEBUG && CLIENT
         #error Debug not allowed in Client Code.
      #endif
   // Rest of program follows here

In this example, compilation will terminate with an error message since DEBUG and CLIENT are defined.

The region directives are used to mark sections of code as regions. The region directive has no semantic meaning to the C# compiler, but is recognized by Visual Studio.NET, which uses it to hide or collapse code regions. Expect other third-party source management tools to take advantage of these directives.

#region
   // any C# statements
#endregion

Literal values assigned to string variables take two forms: literals enclosed in quotation marks, and verbatim strings that begin with @" and end with a closing double quote ("). The difference between the two is how they handle escape characters. Regular literals respond to the meaning of escape characters, whereas verbatim strings treat them as regular text. Table 2-9 provides a summary of the escape characters that can be placed in strings.

A verbatim string serves the purpose its name implies: to include any character placed between the beginning and ending double quote. The following segment provides several examples of using literals:

string myQuote, path;
myQuote = @"The solution is in the problem.";
myQuote = "The solution
is in the problem.";  
myQuote = "The Unicode representation of f is u0066";
// The next two statements assign the same value to myQuote.
myQuote = @"""The solution is in the problem. """;
myQuote = ""The solution is in the problem. "";
// The next two statements assign the same value to path.
path    = @"c:my documents
otes.txt";
path    = "c:\my documents\notes.txt";
path    = "c:my documents
otes.txt";      // Fails

The regular literal string is normally your best choice because it supports the escape sequences. The verbatim is to be favored when the text contains backslashes. Its most common use is with file path values and Regular Expression matching patterns (discussed in Chapter 5, “C# Text Manipulation and File I/O”).

The System.String class contains a variety of string manipulation members. These include ways to determine a string's length, extract a substring, compare strings, and convert a string to upper- or lowercase. The following examples illustrate some of the more common operations.

// Example 1 - using foreach statement
string myQuote = "The solution is in the problem."; 
foreach (char cc in myQuote)
{
   Console.Write(cc.ToString());
}

// Example 2 - using while loop
int ndx = 0;
while (ndx < myQuote.Length)
{
   Console.Write(myQuote[ndx].ToString());
   ndx += 1;
}

string s1 = "My age = ";
int myAge = 28;
string cat = s1 + myAge;       // My age = 28
MyClass clStr = new MyClass;    
Cat = "Class Name = " + clStr; // Class Name = MyClass

// assume names is an array containing 1000 names
string nameList = "";
foreach (string custName in names)
{
   // This is inefficient and should be avoided.
   nameList = nameList + custName+"<br>";
}

string poem = "In Xanadu did Kubla Khan";
string poemSeg;
poemSeg = poem.Substring(10);     // did Kubla Khan
// second argument specifies length
poemSeg = poem.Substring(0,9);    // In Xanadu

// Method to count the occurrences of text in a given string
public static int CharCount(String strSource,String strToFind)
{
   int iCount=0;  // string type has index of 0
   int iPos=strSource.IndexOf(strToFind);
   while(iPos!=-1)
   {
      iCount++;
      iPos=strSource.IndexOf(strToFind, iPos+1);
   }
   return iCount;
}
public class MyApp
{
   static void Main()     
   {
      string txt = "In Xanadu did Kubla Khan";
      int ct = CharCount(txt, "a"); // ct = 4
   }
}

bool isMatch;
string title = "Ancient Mariner";
isMatch = (title           == "ANCIENT MARINER");    // false
isMatch = (title.ToUpper() == "ANCIENT MARINER");    // true
isMatch = (title           == "Ancient"+" Mariner"); // true
isMatch =  title.Equals("Ancient Mariner");          // true

Enumerated types not only improve program readability, but also minimize code changes when the underlying value changes. In such cases, all references to the value remain valid. Another advantage is that enumerated types are strongly typed. This means, for example, that when an enum type is passed as a parameter, the receiving method must have a matching parameter of the same type; otherwise, a compiler error occurs.

The code segment in Listing 2-2 illustrates these ideas using the Fabric enum from the preceding example.

static double GetPrice(Fabric fab)
{
   switch(fab)
   {
      case Fabric.Cotton: return(3.55);
      case Fabric.Silk:   return(5.65);
      case Fabric.Wool:   return(4.05);
      case Fabric.Rayon:  return(3.20);
      case Fabric.Other:  return(2.50);
      default: return(0.0);
   }
}
static void Main()     
{
   Fabric fab = Fabric.Cotton;
   int fabNum   = (int) fab;             // 1
   string fabType =  fab.ToString();     // "Cotton"
   string fabVal  =  fab.ToString("D");  // "1"
   double cost = GetPrice(fab);          // 3.55
} 

Things to note:

This example shows how easy it is to obtain the symbol name or constant value when the instance of an enum is known—that is, Cotton. But suppose there is a need to determine whether an enum contains a member with a specific symbol or constant value. You could use foreach to loop through the enum members, but there is a better solution. Enumerations implicitly inherit from System.Enum, and this class contains a set of methods that can be used to query an enumeration about its contents.

Three of the more useful System.Enum methods are Enum.IsDefined, Enum.Parse, and Enum.GetName. The first two methods are often used together to determine if a value or symbol is a member of an enum, and then to create an instance of it. The easiest way to understand them is to see them in use. In this example, the enum Fabric is queried to determine if it contains a symbol matching a given string value. If so, an instance of the enum is created and the GetName method is used to print one of its values.

string fabStr = "Cotton";
// Determine if symbol Cotton exists in Fabric enum
if (Enum.IsDefined(typeof(Fabric),fabStr)) 
{
   // Create enum instance
   Fabric fab = (Fabric)Enum.Parse(
                 typeof(Fabric) , fabStr);
   // Output from the following statement is: "Silk"
   Console.WriteLine("Second value of Fabric Enum is: " +
                     Enum.GetName(typeof(Fabric), 2));      
}

The IsDefined method takes two parameters: an enumeration type that the typeof operator returns and a string representing the symbol to be tested for. Another form of this method tests for a specified constant value if a numeric value is passed as the second parameter.

The Parse method takes the same arguments and creates an instance of an enumerated type. The variable fab created here is equivalent to the one created in Listing 2-2. It is important to ensure that the enum member exists before using the Parse method. If it does not, an exception is thrown.

The GetName method returns a string value of the enum whose value is passed as the second argument to the method. In this example, "Silk" is returned because its constant value is 2.

It was not by accident that the values of the Fabric enum were set to powers of 2. Enum members are often used in logical operations where such values have obvious advantages in mapping to unique bit values. You may have code to identify a combination of values:

Fabric cotWool = Fabric.Cotton | Fabric.Wool;
Console.WriteLine(cotWool.ToString());  // Output: 5

It would be more meaningful if the output identified the variable as a combination of wool and cotton. This can be accomplished by adding the [Flags] attribute to the enum declaration:

[Flags]
enum Fabric :short {

The ToString() method checks an enum declaration to see if this attribute is present. If so, it treats the enum as a set of bitmapped flag elements. In this example, it cannot find a symbolic value equal to 5, so it uses the bit pattern “101” and prints the symbols having the bit patterns “001” and “100”. The new output is a comma- delimited list: “Cotton, Wool”.

Syntax:

<type> identifier [ ] = new <type> [n]  [{ initializer list}]

Example:

int[] myRating;         // declares an array
myRating = new int[5];  // creates array and allocates memory
int[] myRating = new int[5] {3,4,7,2,8};
int[] myRating = {3,4,7,2,8};  // shorthand version

// Create array containing instances of an Apparel class.
Apparel myApparel = {new Apparel(), new Apparel(),
                     new Apparel());   

// Set to an enum
Fabric[] enumArray = new Fabric[2];
enumArray[0] = Fabric.Cotton;

// Create a 2-dimensional array with 3 rows and 2 columns
int[ , ] myRatings = {{3 , 7}, {4 , 9}, {2, 6}};

The size of the array is determined from the explicit dimensions or the number of elements in the optional initializer list. If a dimension and an initializer list are both included, the number of elements in the list must match the dimension(s). If no initialization values are specified, the array elements are initialized to 0 for numeric types or null for all others. The CLR enforces bounds checking—any attempt to reference an array index outside its dimensions results in an exception.

The System.Array class defines a number of properties and methods that are used to query an array and manipulate its contents. Array operations include sorting, copying, searching for specific values, and clearing the contents. Table 2-10 summarizes some of the more useful members of the System.Array class.

int[] rank1 =
   (int[]) Array.CreateInstance(typeof(int),4);

d0 = myArray.GetUpperBound(0);
d1=  myArray.GetUpperBound(1);

IndexOf,
LastIndexOf

The members are classified as static or instance. A static member is not associated with any particular array. It operates as a built-in function that takes any array as a parameter. The instance members, on the other hand, are associated with a specific instance of an array. The example shown in Listing 2-3 demonstrates how to use many of these class members.

class MyApp
{
   static void Main()     
   {   
      string[] artists = {"Rembrandt", "Velazquez", 
            "Botticelli", "Goya", "Manet","El Greco"};
      // ..Sort array in ascending order
      Array.Sort(artists);
      // ..Invert the array
      Array.Reverse(artists); 
      PrintArray(artists);  // call method to list array
      int ndx = Array.IndexOf(artists,"Goya");   // ndx = 3
      // ..Clone the array
      string[] artClone = (string[]) artists.Clone();
      // Do arrays point to same address?  
      bool eq = Object.ReferenceEquals(
            artClone[0],artists[0]);  // true  
      Array.Clear(artClone,0,artClone.Length);
      // ..Copy selected members of artists to artClone
      Array.Copy(artists,1,artClone,0,4);
      eq = Object.ReferenceEquals(
            artClone[0],artists[1]);  // true
   }
   // List contents of Array
   public static void PrintArray(string[] strArray)
   {
      for ( int i = 0; i<= strArray.GetUpperBound(0); i++ )  
      {
         Console.WriteLine(strArray[i]);
      }
   }
}

Things to note:

Both reference and value types inherit from the System.Object class. The difference is that almost all reference types inherit directly from it, whereas value types inherit further down the hierarchy—directly from the System.ValueType class.

As the base for all types, System.Object provides a set of methods that you can expect to find on all types. This set includes the ToString method used throughout this chapter, as well as methods to clone a type, create a unique hash code for a type, and compare type instances for equality. Chapter 4 discusses these methods in detail and describes how to implement them on custom classes.

System.ValueType inherits from System.Object. It does not add any members, but does override some of the inherited methods to make them more suitable for value types. For example, Equals() is overridden to return true if the value of two objects' fields match. By definition, all value types implicitly inherit from the ValueType class.

The primary difference between value and reference types is the way the CLR handles their memory requirements. Value types are allocated on a runtime stack, and reference types are placed on a managed heap that is referenced from the stack.

Figure 2-3 illustrates how the value and reference types from our example (refer to Figure 2-1) are represented in memory. Let's step through what happens when an instance of a reference type is created and is then assigned to a second variable:

Apparel myApparel  = new Apparel();
Apparel myApparel2 = myApparel;

Figure 2-3. Memory layout for value and reference types

Creating a reference object can be expensive in time and resources because of the multiple steps and required overhead. However, setting additional references to an existing object is quite efficient, because there is no need to make a physical copy of the object. The reverse is true for value types.

.NET contains a special object type that accepts values of any data type. It provides a generic way to pass parameters and assign values when the type of the value being passed or assigned is not tied to a specific data type. Anything assigned to object must be treated as a reference type and stored on the heap. Consider the following statements:

int age = 17;
object refAge = age;

The first statement creates the variable age and places its value on the stack; the second assigns the value of age to a reference type. It places the value 17 on the heap, adds the overhead pointers described earlier, and adds a stack reference to it. This process of wrapping a value type so that it is treated as a reference type is known as boxing. Conversely, converting a reference type to a value type is known as unboxing and is performed by casting an object to its original type. Here, we unbox the object created in the preceding example:

int newAge = (int) refAge;
string newAge = (string) refAge;   // Fails. InvalidCastException

Note that the value being unboxed must be of the same type as the variable to which it is being cast.

In general, boxing can be ignored because the CLR handles the details transparently. However, it should be considered when designing code that stores large amounts of numeric data in memory. To illustrate, consider the System.Array and ArrayList classes mentioned earlier. Both are reference types, but they perform quite differently when used to store simple data values.

The ArrayList methods are designed to work on the generic object type. Consequently, the ArrayList stores all its items as reference types. If the data to be stored is a value type, it must be boxed before it can be stored. The array, on the other hand, can hold both value and reference types. It treats the reference types as the ArrayList does, but does not box value types.

The following code creates an array and an ArrayList of integer values. As shown in Figure 2-4, the values are stored quite differently in memory.

// Create array with four values
Int[] ages = {1,2,3,4};   

// Place four values in ArrayList
ArrayList ages = new ArrayList();
For (int i=0; i<4; i++) {
   ages.add(i); // expects object parameter
}

Figure 2-4. Memory layout comparison of Array and ArrayList

The array stores the values as unboxed int values; the ArrayList boxes each value. It then adds overhead required by reference types. If your application stores large amounts of data in memory and does not require the special features of the ArrayList, the array is a more efficient implementation. If using .NET 2.0 or later, the List class is the best choice because it eliminates boxing and includes the more flexible ArrayList features.