C Type System

Structures

A struct is a value type which can group heterogeneous types together. It can also have constructors and methods . In C++ the concept of class and struct is very close. In C++ a class has default visibility of private and a struct has default visibility of public , and that is the only difference. There is a more fundamental difference in C#.

In C# the key difference between a class and a struct is that a class is a reference type and a struct a value type. A class must be instantiated explicitly using new . The new instance is created on the heap, and memory is managed by the system through a garbage-collection process. Since a default constructor will be created for a struct if none is defined, a struct declared on the stack will be initialized . You may also use new . A new instance of a struct is created on the stack, and the instance will be deallocated when it goes out of scope.

There are different semantics for assignment, whether done explicitly or via call by value mechanism in a method call. For a class, you will get a second object reference, and both object references refer to the same data. For a struct, you will get a completely independent copy of the data in the struct.

A struct is a convenient data structure to use for moving data across a process or machine boundary, and we will use structs in our case study. For example, we will use a struct to represent customer data.

public struct CustomerListItem 
{ 
   public int CustomerId; 
   public string FirstName; 
   public string LastName; 
   public string EmailAddress; 
}

Enumeration Types

The final kind of value type is an enumeration type. An enumeration type is a distinct type with named constants. Every enumeration type has an underlying type, which is one of the following.

• byte

• short

• int

• long

An enumeration type is defined through an enum declaration.

public enum BookingStatus : byte 
{ 
      HotelNotFound,     // 0 implicitly 
      RoomsNotAvailable, // 1 implicitly 
      Ok = 5             // explicit value 
}

If the type is not specified, int is used. By default, the first enum member is assigned the value 0, the second member 1, and so on. Constant values can be explicitly assigned.

You can make use of an enumeration type by declaring a variable of the type indicated in the enum declaration (e.g., BookingStatus ). You can refer to the enumerated values by using the dot notation. Here is some illustrative code:

BookingStatus status; 
status = hotel.ReserveRoom(name, date); 
if (status == BookingStatus.HotelNotFound) 
   Console.WriteLine("Hotel not found"); 
...

Reference Types

A variable of a reference type does not directly contain its data but instead provides a reference to the data stored in the heap. In C# there are the following kinds of reference types:

• Class

• Array

• Interface

• Delegate

Reference types have a special value null , which indicates the absence of an instance.

We have already examined classes in some detail, and we will look at arrays later in this chapter. Interfaces and delegates will be covered in Chapter 5.

Class Types

A class type defines a data structure that has fields, methods, constants, and other kinds of members . Class types support inheritance . Through inheritance a derived class can extend or specialize a base class. We will discuss inheritance in Chapter 4.

Two classes in the .NET Framework Class Library are so important that they have C# reserved words as aliases for them: object and string .

Object

The object class type is the ultimate base type for all types in C#. Every C# type derives directly or indirectly from object . The object keyword in C# is an alias for the predefined System.Object class. System.Object has methods such as ToString , Equals , and Finalize , which we will study later.

String

The string class encapsulates a Unicode character string. The string keyword is an alias for the predefined System.String class. The string type is a sealed class. (A sealed class is one that cannot be used as the base class for any other classes.)

The string class inherits directly from the root object class. String literals are defined using double quotes. There are useful built-in methods for string . For now, note that the Equals method can be used to test for equality of strings.

string a = "hello"; 
if (a.Equals("hello")) 
      Console.WriteLine("equal"); 
else 
      Console.WriteLine("not equal");

There are also overloaded operators:

if (a == "hello") 
      ...

We will study string in detail later in this chapter.

Default Values

Several kinds of variables are automatically initialized to default values:

• Static variables

• Instance variables of class and struct instances

• Array elements

Local variables are not automatically initialized, and you will get a compiler error message if you try to use a local variable that has not been initialized.

The default value of a variable of reference type is null .

The default value of a variable of value type is the value assigned in the default constructor. For simple types this value corresponds to a bit pattern of all zeros:

• For integer types, the default value is 0

• For char , the default value is '\u0000'

• For float , the default value is 0.0f

• For double , the default value is 0.0d

• For decimal , the default value is 0.0m

• For bool , the default value is false

For an enum type, the default value is 0. For a struct type, the default value is obtained by setting all value type fields to their default values, as described above, and all reference type fields to null .

Boxing and Unboxing

One of the strong features of C# is that is has a unified type system. Every type, including the simple built-in types such as int , derive from System.Object . In C# "everything is an object."

A language such as Smalltalk also has such a feature but pays the price of inefficiency for simple types. Languages such as C++ and Java treat simple built-in types differently from objects, thus obtaining efficiency but at the cost of a unified type system.

C# enjoys the best of both worlds through a process known as boxing . Boxing converts a value type such as int or a struct to an object reference and is done implicitly. Unboxing converts a boxed value type (stored on the heap) back to an unboxed simple value (stored on the stack). Unboxing is done through a type cast.

int x = 5; 
object o = x;      // boxing 
x = (int) o;       // unboxing