The CTS has a type hierarchy that provides a base set of data types used by all the .NET programming languages. The root data type for all data types in the .NET Framework is System.Object.

The most common use of data types is declaring variables, as shown in the preceding section. When you initialize a variable, either through assignment or the new operator, the computer uses the variable's data type to know how to allocate the memory for the variable. You can use two basic kinds of data types in .NET:

The easiest way to know the difference between value types and reference types is to look at how you declare and initialize variables of either type. Reference types use the new operator, whereas value types don't.

For example, the following code declares a variable of the value type integer by using the C# keyword int:

int i = 1;

System.Object o = new System.Object();

Value types and reference types are stored differently in memory, which contributes to why they're used differently. Value types are stored on the stack, and reference types are stored on the managed heap. The stack — more specifically, the call stack — is an area of memory set aside for managing the execution of your program. You can visualize the stack as one memory address stacked on top of another. The heap, however, is a large pool of memory where objects that require longer life spans can live. (Longer life span means that the object needs to live beyond the execution of a single function on the call stack.)

The stack is more efficient to access than the heap because the stack discards a variable stored in memory as soon as the variable goes out of scope. Variables stored in the heap, however, are managed by the .NET garbage collector. The new operator requests storage to be allocated on the heap for the variable. The garbage collector clears the variable out of memory when it determines that the variable is no longer being used by your program, which might not correspond to the point in time when your program stops using the variable.

By being stored on the stack, value types are directly accessible. Reference type variables, however, return a reference to an address on the heap where the variable's value is actually stored. Figure 2-1 shows an example of value types and reference types in memory. The reference to a reference type is stored on the stack, which is how your program knows how to access the variable.

Figure 2-1. Value types are stored on the stack, and reference types are stored on the heap.

Another key difference between value types and reference types is how they're handled by assignments. When you assign a variable of a value type, the contents of the value type are copied. When you assign a reference type, only the reference is passed along.

The difference in how value types and reference types are assigned is attributable to how they're stored in memory. A reference type stores only a memory address that points to the actual value. When you copy a reference type, you copy the memory address stored on the stack.

The following code sample uses value types, and the value for variable i is copied to the variable j:

private void TestValueTypes()
{
  int i;
  int j;
  i = 8;
  j = i;
  i = 5;
}

When this code executes, j has the value 8, and i has the value 5. j and i are independent variables. The value from i is copied to j.

Now, look at how code using reference types does this. Note that the variables start out pointing to two separate values but wind up pointing to the same value:

private void TestReferenceTypes()
{
  System.Data.DataSet ds1 = new DataSet("DataSet 1");
  System.Data.DataSet ds2 = new DataSet("DataSet 2");
  ds2 = ds1;
  ds1.DataSetName = "My DataSet";
}

The statement ds2 = ds1; assigns the value referenced in the variable ds1 to the variable ds2. What happens to the value originally referenced by ds2? It's still there, but it can no longer be accessed because ds2 let go of it, as you can see in Figure 2-2. Eventually, the garbage collector recognizes that the object is no longer in use and destroys it.

Figure 2-2. Multiple variables can reference the same value.

You may think it's silly that someone would create two variables and then assign one to the other. After you start creating an application, you'd be surprised how easy it is to pass a variable by reference and not understand why your data isn't what you expected.

You need to understand the differences between value types and reference types. Table 2-1 compares value types and reference types.

If you've done any programming at all, you're probably familiar with data types, such as char and integer. These are value types in the .NET Framework. The CTS provides a set of built-in value types.

Your programming language provides a set of primitive data types that map to the built-in value type in the CTS. Table 2-2 lists the value types in .NET and their respective keywords in Visual Basic and C#. When you use one of these keywords as a data type in your program, it's compiled as the underlying .NET data type listed.

You might notice that many data types represent numbers. The amount of memory used by each of these data types corresponds to the range of values that the data type can store.

Most of the .NET programming languages have a keyword for a data type that represents strings. Strings aren't value types: They're reference types. See the next section, "Popular reference types," to read more about strings.

In addition to the value types listed previously, the .NET Framework includes two other programming elements that define value types:

Figure 2-3. Enumerations define a set of constants.

All the classes in the .NET Framework are reference types, so-called because the variable holds a reference to the value — not the actual value itself.

All classes in the CTS derive from System.Object. You could say that makes System.Object the most popular reference type. Hopefully, however, you aren't actually declaring your variables by using the System.Object type. Although doing so isn't incorrect, try to use the most specific data type possible.

C# provides the keyword object, and Visual Basic uses Object to map to the System.Object type in CTS.

One of the most popular reference types is System.String. Many people think that System.String is a value type, but it's actually an array of characters. That's probably because you don't have to use the new operator when you create a new string. You declare and use a string variable similarly to how you use value types, such as integer and Boolean.

Visual Basic and C# both provide a keyword to represent System.String. The following code declares and initializes a string variable:

VB:

Dim s As String = "Hello"

C#:

string s = "Hello";

Another popular reference type is System.Exception. Any time your program throws an exception, the exception you see is a reference type derived from System.Exception.

See the section "Browsing Types," later in this chapter, to see how you can find more reference types in the .NET Framework.

The .NET Framework provides the System.Array class for creating arrays. An array defines a set of data that all have the same data type. You can define an array to use any kind of data type, such as a set of integers or a set of strings. You can even define an array by using your own custom data types.

An array has the following properties:

Declaring arrays is similar to declaring other types of data. In Visual Basic, you append parentheses to the variable's identifier:

Dim dailyWeights() As Integer

To declare a multidimensional array in Visual Basic, you place a comma inside the parentheses for each additional dimension, such as

Dim dailyWeights(,) As Integer

In C#, you append brackets to the element's data type when you declare an array:

int[] dailyWeights;

Similar to Visual Basic, you use commas to create multidimensional arrays:

int[,] dailyWeights;

Dim dailyWeights()() As Integer.

Declaring an array doesn't actually create the array. Because arrays are reference types, you use the new operator to create the array and assign it to the variable you declare. For example, to create an array with five elements and assign it to the one-dimensional dailyWeights array using Visual Basic, you'd type

dailyWeights = New Integer(4) {}

Recall that arrays have a zero-based index. Inside the parentheses, you place the array's upper bound, which is 4 in this example. The array's length is 5 because you start counting at zero.

Use the curly braces to place values into the array, as the following Visual Basic code shows:

dailyWeights = New Integer(4) { 155, 153, 154, 152, 150 }

Here's the equivalent statement in C#:

dailyWeights = new int[5] { 155, 153, 154, 152, 150 };

You may have noticed some subtle differences in syntax between Visual Basic and C#. Most notably, in the Visual Basic statement, you use the upper bound; in C#, you use the array's length. If you switch back and forth a lot between the two languages, maybe you can get a tattoo so that you can keep it straight.

dailyWeights = new int[5] { 155, 153, 154, 152, 150 };
dailyWeights = new int[] { 155, 153, 154, 152, 150 };

Here are three steps to using arrays:

You can perform each step discretely or combine all three steps into one statement, as shown in the following C# statement:

int[] dailyWeights = new int[5] { 155, 153, 154, 152, 150 };

The equivalent statement in Visual Basic is

Dim dailyWeights() As Integer = New Integer(4) {155, 153, 154, 152, 150}

You supply three pieces of information to declare and create an array:

To access the elements in an array, use an indexer to specify the position of the element you wish to access. For example, the following C# code accesses the third element in an array of integers:

dailyWeights[2] = 175;

The .NET Framework provides many kinds of collections that you can use when you need to handle more than one of something at a time. Table 2-3 lists the specialized collection types you can find in the System.Collections namespace.

You can group collection data types in the System.Collections namespace based on the mechanism used to access elements in the collection:

The collection data types found in the System.Collection namespace are all classes. You use the new operator to create a new instance of a collection. The following code shows a Hashtable:

Dim ht As New Hashtable

Important actions you take on collections, such as a Hashtable, include adding and removing elements. A Hashtable is a key-based collection, so you add elements by using a key/value pair. The following code sample shows how to add elements to a Hashtable:

ht.Add("Screen 1", "Shane")
ht.Add("Screen 2", "My Friend Flicka")

Use the Remove method to remove an element from the hashtable:

ht.Remove("Screen 1")

You supply the key when you want to remove the element.

Of course, you aren't limited to using just primitive types and strings in your collections. You can use any data type, including your user-defined data types. For example, instead of placing a movie title in the hashtable, you could place a value created from a Movie class. The Movie class might store a movie's title, actors, release date, and show times. See the earlier section on creating your own types for more information.

The .NET Framework provides two other namespaces for using collection data types:

An important task when working with collections is to be able to step through the elements within the collection. C# and Visual Basic provide the foreach and For Each statements, respectively, for iterating through a collection.

For example, the following code shows iterating through an ArrayList using For Each in Visual Basic:

Dim list As New ArrayList
list.Add(1)
list.Add(2)
list.Add(3)
For Each i as Integer In list
  Dim j As Integer
  j = j + i
Next

The For Each statement in the preceding sample executes once for each element in the ArrayList for a total of three times. On third execution, it's j = 6 because 1 + 2 + 3 = 6.

Keyed collections use the DictionaryEntry structure for iterating through values, as the following C# code sample shows:

Hashtable ht = new Hashtable();
ht.Add("Screen 1", "Shane");
ht.Add("Screen 2", "My Friend Flicka");
foreach (DictionaryEntry de in ht)
{
   lstMovies.Items.Add(de.Key + ":" + de.Value);
}

Figure 2-4 shows an example of the key/value pair from the hashtable in a list box.

Figure 2-4. Iterate through the hashtable to display key/value pairs in a list box.

You have many choices for working with collections. Here are some guidelines to help you decide:

Besides selecting the best type of collection for the job, you must also consider how you'll actually use the collection in your code. If you're creating your own data types, you need to consider how to manage multiples of your data types. You have a few options:

In most cases, you'll probably wrap an existing collection when you want to provide your own custom collections. You have two approaches to wrapping an existing collection:

You'd be quickly overwhelmed if you had to look at all the data types in Object Browser at once. Instead, Object Browser allows you to limit the scope of the types you view at any one time to the following:

To view only the components in the .NET Framework, follow these steps:

Alternatively, you can use the Object Browser Search drop-down list to search for a word. Search is limited to the browsing scope selected in the Browse drop-down list. See Chapter 7 of Book III for an example of using Search in Object Browser.

Figure 2-5. The assemblies from the selected browsing scope appear in the Objects pane.

Object Browser displays data types of all kinds, including classes, enumerations, and interfaces. By default, data types appear in assembly containers; however, there are many different views, such as

To view the data types by namespaces

To view the physical assembly file where data is defined

Figure 2-6. Click an assembly to view information about the assembly.

You can use Object Browser to view all kinds of information about data types, including the following data types:

Here's how to view a data type in Object Browser:

For example, to access the System.Enum data type with the data types grouped by assemblies and object types, follow these steps:

Figure 2-7. Click a data type's member to view its description.

A data type's base data type can give you clues about whether the type is a value type or reference type. Viewing the type's derived data types shows you more specific implementations of the data type that might be more appropriate for you to use.

You can view a data type's base type and any derived types by expanding the data type. In the case of the System.Enum data type, its base type is System.ValueType. Many types are derived from System.Enum, as shown in Figure 2-8.

Figure 2-8. Expand a data type to view its base types and derived types.

You may have noticed that the data types, members, and other items in Object Browser have icons next to them. A different icon is used to represent each kind of data type, such as classes or structures. Search for the topic "Class View and Object Browser Icons" in the Visual Studio Help documentation for a summary of the icons used.

Visual Studio provides several tools for browsing and navigating source code, including

You use the Code Definition window in conjunction with the Class View or Object Browser to view an object's source code. When viewing objects from outside your project, the Code Definition window displays only the source code's type and method declarations and comments. You can't actually view the source code that implements the object.

To use the Code Definition window with Class View, follow these steps:

Figure 2-9. Source code appears in the Code Definition window.

The Code Definition window is a read-only view of the source code. To open the source code file in the Code Editor, right-click the item in the Class View window and choose Go to Definition from the contextual menu.

To view the object in Object Browser, right-click the object in the Class View window and choose Browse Definition from the contextual menu.