C# Data Types

In C#, variables are categorized into the following types:

• Value types
• Reference types
• Pointer types

Value Types

Value type variables can be assigned a value directly. They are derived from the class System.ValueType.

Value types directly contain data. For example, types like int, char, and float store numbers, characters, and floating-point numbers, respectively. When you declare an int type, the system allocates memory to store the value.

The following table lists the available value types in C# 2010:

To get the exact size of a type or a variable on a particular platform, you can use the sizeof method. The expression sizeof(type) yields the storage size of the object or type in bytes. Below is an example to get the storage size of the int type on any machine:

Example

using System;

namespace DataTypeApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Size of int: {0}", sizeof(int));
            Console.ReadLine();
        }
    }
}

When the above code is compiled and executed, it produces the following result:

Size of int: 4

Reference Types

Reference types do not contain the actual data stored in a variable, but they contain a reference to the variable.

In other words, they point to a memory location. When you have multiple variables, reference types can point to a memory location. If the data in the memory location is changed by one variable, other variables automatically reflect this value change. Built-in reference types include: object, dynamic, and string.

Object Type

The Object Type is the ultimate base class for all data types in the C# Common Type System (CTS). Object is an alias for the System.Object class. So, object type can be assigned values of any other type (value types, reference types, predefined types, or user-defined types). However, type conversion is required before assigning values.

When a value type is converted to object type, it is called boxing; conversely, when an object type is converted to a value type, it is called unboxing.

object obj;
obj = 100; // This is boxing

Dynamic Type

You can store any type of value in the dynamic data type variable. Type checking for these variables takes place at runtime.

Syntax for declaring a dynamic type:

dynamic <variable_name> = value;

For example:

dynamic d = 20;

Dynamic types are similar to object types, but type checking for object type variables occurs at compile time, while type checking for dynamic type variables occurs at runtime.

String Type

The String type allows you to assign any string value to a variable. The String type is an alias for the System.String class. It is derived from the Object type. Values of the String type can be assigned in two forms: quoted and @-quoted.

For example:

String str = "tutorialpro.org";

An @-quoted string:

@"tutorialpro.org";

A C# string prefixed with @ (called a "verbatim string") treats escape characters () as regular characters, for example:

string str = @"C:\Windows";

Which is equivalent to:

string str = "C:\\Windows";

An @-quoted string can span multiple lines, and newline characters and indentation spaces are included in the string length.

string str = @"<script type=""text/javascript"">
    &lt;!--
    -->
</script>";

User-defined reference types include: class, interface, or delegate. These types will be discussed in later chapters.

Pointer Types

Pointer type variables store the memory address of another type. Pointers in C# have the same functionality as those in C or C++.

The syntax for declaring a pointer type is:

type* identifier;

For example:

char* cptr;
int* iptr;

Pointer types will be discussed in the section on "unsafe code."