All .NET Framework applications deal with system types in one way or another. Whether it is User Interface (UI) components in Microsoft Windows and Web applications or integer data returned by a Web service method, all are instances of a .NET Framework system type. It is impossible to create a .NET Framework application without using system types. As a result, to be able to create robust applications and become a productive .NET Framework developer, you need to have a good understanding of system types. In addition to the system types that the .NET Framework provides, you can also create custom system types, such as classes and structures, and use interfaces to define their functionality. By using interfaces to define the functionality of system types, you can write reusable and extensible object-oriented components.

This module describes the purpose of the system types that the .NET Framework provides and their usage in code. This module also describes how to implement some of the newer additions to the .NET Framework 2.0, such as generics and Nullable types. In addition, this module introduces how to use exception classes and attributes. Finally, this module describes how to implement commonly used interfaces in the .NET Framework.

Examining Base System Types

Lesson Introduction

In the .NET Framework 2.0, functionalities are encapsulated into objects and objects are instances of system types. The .NET Framework comes with many prebuilt system types known as base system types. These system types encapsulate common tasks that you can use to create .NET Framework applications easily and rapidly. For example, to create a Windows application, you need not write code to communicate to the .NET Framework how to create a window. Instead, you can use a base system type known as Windows Form that contains the definition and behavior of a window. As a result, all you need to do is to include an object of the Windows Form system type in your code.

This lesson describes the base system types. You will identify the differences between value types and reference types. This lesson also describes boxing and unboxing between value types and reference types. A good understanding of these basic programming concepts will help you in designing any type of project in the .NET Framework.

What Are System Types?

Today we’re going to be talking about the use of simple data types within the .NET Framework. Most applications you’re creating, particularly business applications, must store data of some type. Data will exist within these applications in many forms. Data can be used to represent very simple types within your applications or also very complex types. Examples of more complex types may be an employee or a customer that’s being represented within your application. Companies that create software development platforms understand that you will need definitions for data within your application and will typically provide prebuilt definitions in their environment for you. Prebuilt types of data are known as system types. For example, you may have a Boolean data type, which represents a true or false value, and a floating-point data type, which will represent a floating-point number. Simple data types are also known in the industry as a primitive data type, or primitive data types. Examples of primitive data types are typically your numeric types as well as your character data type and your Boolean type. Most compilers maintain detailed instructions on what each primitive type will be allowed to do, whereas some compilers do not.

Data stored within your application typically gets stored within a variable. Now when a variable is created it’s assigned a data type, which is used to determine the type of data that can be stored within the variable. Software development environments are classified based on how their compilers manage data types. We have two types of compilers within the industry that are very well known. We have strongly typed environments and loosely typed environments.

Within a loosely typed environment, you typically have the flexibility to store multiple types of data with a single variable. For instance, a variable on one line of code may have the date-time value; the very next line of code may have a stream value within it. That may seem appealing to some but it also can have disadvantages. Examples of loosely typed environments can be VBScript, JavaScript, as well as FoxPro. Loosely typed environments are not capable of enforcing what’s known as type safety. Type safety means that they can guarantee there’s a particular type of data within a location memory or a variable within a given time. Again, they can’t guarantee that because each variable is allowed to accommodate any type of data that can be stored inside of it. Loosely typed environment typically provides you the flexibility to store multiple types of data in a single variable. For instance, you may have a variable within one line of code that contains a date-time value, and the next line of code contains a stream value. Examples of loosely typed environments are VBScript, JavaScript, and FoxPro.

Loosely typed environments are not capable of enforcing what’s known as type safety. Type safety means that it cannot guarantee there’s a particular type of data within a location memory or variable within a given time. Again it cannot do that because it has to support any possible type of value within a variable. Now loosely typed environments, in order for the compiler to accommodate this, behind the scenes it’s performing implicit type conversions that many times will result in undefined behavior within your environment. Additionally, loosely typed environments typically do not use memory very efficiently, and they don’t do this because, again, a variable must be able to accommodate any possible type of value, so when a variable is initialized, or declared, the compiler must allocate a large chunk of memory to each variable. Instead of being very efficient with memory, it must allocate a large chunk of memory for each variable. Again, it leads to very inefficient use of memory.

Now we also have what’s known as a strongly typed environment. In a strongly typed environment every variable must be explicitly assigned a data type when it’s declared. Only data accommodated by the assigned data type will be allowed to be stored within a variable. Strongly typed environments can ensure type safety, because, again, they only allow values to be stored in the variable that comply with the assigned data type, so they can always guarantee a particular type of data in a variable at any given time. All the rules applicable to an assigned data type must be adhered to for a variable, and the compiler can also take advantage of very efficient use of memory as well. It’s only going to assign and allocate memory to a variable that will accommodate the data type assigned to that variable and no more. So you’re much more efficient than a loosely typed environment.

The .NET Framework is an example of a strongly typed environment. All variable expression within the .NET Framework must be strongly typed. The .NET Framework is also capable of performing type safety checks, and if you have any issues or mismatches within your code, it must be corrected for data types. It must be corrected before your code can be compiled. We have two types of system types in the .NET Framework. There are value types and reference types.

Prior to .NET, it was common that programming languages would maintain their own data type definitions, which may not exactly be compatible with the data type definitions of another language. For instance, you may define a variable of type integer within one programming language and it would support a different range of integers than a data type integer within another programming language. This presented a major obstacle to programmers who were attempting to get applications created in multiple languages to intercommunicate with each other. In recent years, there has been an attempt in the industry to standardize data types of definitions that are supported by the various programming languages. Now, the .NET Framework provides a common set of data types, known as a Common Type System, or CTS. There are more than 25 programming languages available in the industry that are striving to be .NET compliant with five of these languages coming from Microsoft. A primary requirement for a language to be considered .NET compliant is for it to support the Common Type System, or CTS. Programming languages that support the CTS can very easily intercommunicate, and the CTS is also in a major aspect to it being easy to move from one .NET compliant language to another.

All types that are in support of the .NET Framework derive from the same base type, which is System.Object. Many data type definitions maintained by the various .NET compliant programming languages also map directly into these CTS types. For example, if you create a variable of type Integer in VB, or a variable of type int in C#, both of those will map into a System.Int32 CTS type. The Integer in VB—that data type—and the int in C# are the same data type, and they act as aliases for System.Int32 data type—the CTS type. Both categories of system types in the .NET Framework, value types and reference types, display common intrinsic behavior because they derive from System.Object.

Key Points

1. System types are defined to meet the most common requirements of data types in a programming language.
2. Based on the system types in a development environment, you can classify an environment as loosely typed or strongly typed.
3. A loosely typed development environment provides you the flexibility to store different types of data inside a variable.
4. In a strongly typed environment, every system type is strictly defined.
5. The .NET Framework is a strongly typed development environment.
6. The .NET Framework provides a common set of system types referred to as the CTS.
7. All system types in CTS are derived from the same base type, System.Object.

What Are Value Types?

Value types are system types that contain the actual data assigned to them instead of a reference to the actual data. You can use value types such as System.Char, System.Int32, and System.Single in the .NET Framework to store characters, integers, and floating-point numbers, respectively.

Working of value types: – Value types are stored in the stack section of computer memory. You can imagine a stack as a block of memory allocated for each program at run time. During program execution, when a function call is made, all value type variables of the calling function are pushed on to the program stack.

As soon as the function returns control to the caller, the value types of that function are released from the stack and the memory used by the value type is released automatically.

The size and lifetime of variables on the stack are determined at compile time. As a result, the allocation and de-allocation of variables on the stack is rapid.

When you pass a value type from one function to another, a copy of the value is passed instead of its reference. This means that you can modify the values in both functions independently.

This is useful when you want to pass only a value from a function, say A, to another function, B, but do not want B to affect the original copy of the value being passed.

For example, you have variables such as width and height and you pass them to a function called GetArea. In this case, the function should be able to read the values of the two variables so that it can calculate the area, but it does not make sense to allow it to change the original values.

Introducing two types of value types:- The .NET Framework provides two types of value types, built-in and user-defined. Built-in value types are also referred to as simple or primitive value types. Built-in value types, such as System.Int32, are defined in the CLR; and as a result, are the most efficiently managed types in the .NET Framework.

Each built-in type in the .NET Framework is directly mapped to a corresponding primitive type in a programming language. For example, System.Int32 is mapped to Integer in Visual Basic and int in C#. This mapping of built-in types in the .NET Framework to language-specific primitive types makes the data types compatible and the .NET Framework languages completely interoperable.

You can define a class and declare two variables x and y to store the values of the x and y coordinates on the screen. However, for the CLR to use a class to store two simple values x and y involves a performance overhead. To avoid this, you can create user-defined value types in the .NET Framework, such as structure, constant, and enumeration. You can use the user-defined value types to create custom value types that make the .NET Framework fully extensible.

Defining structure, constant, Enumeration:- The user-defined value type, structure, is similar to a class and represents a data structure that contains member variables and functions. You will find structures useful in situations where you need to store logically related values in one value type.

For example, you are writing a small phone directory application, which stores the names, addresses, and telephone numbers of businesses. It is ideal to use some sort of a custom structure that provides properties such as BusinessName, Address, and Telephone to store their respective values

Another type of user-defined value type is constant. A constant is like a normal value type variable that holds a value on the stack. However, you assign a value to a constant at the time of its declaration, and its value cannot be changed or reassigned.

You can create constants by using the const keyword in Visual Basic and C#. You can use constants to represent values that do not change.

For example, you want to store the value of pi in a class called Calculator. Pi has a definite value of 3.1416; and as a result, instead of storing this value in a normal floating-point variable that can always be changed, you can store this value in a constant.

The third type of user-defined value type is an enumeration, which is a list of named integer constants. Each constant in an enumeration is mapped to an integer value, which begins at zero, by default, and increments the subsequent constant values by one.

You use enumerations when you need to select from a fixed number of choices at compile time. This is because you can use enumerations to define a fixed set of values for a property.

The code example defines the enumeration Color. For example, the ForeColor property of a Textbox control in Windows Forms uses the Color enumeration to specify the foreground color of the control. You assign an enumerated color value to the ForeColor property of the TextBox control.

What Are Reference Types?

Reference types are system types that contain a reference to assigned data but do not contain the actual data. The data for reference types is stored in an object, which is stored in a separate memory space.

When you work with reference types, both stack and heap memory are used. Unlike a stack where data is stored in a fixed size, in a heap, blocks of memory are allocated in arbitrary order and the sizes of the blocks are not known until run time.

The data of a reference type is stored on a heap while its reference is stored on a stack. In the code example, a reference to the actual value, Hello, is stored on the stack while the value, Hello, is stored on the heap.

You can create objects on heap memory by explicitly allocating space for the objects by using the new operator. In the .NET Framework, you can create a reference and then point the reference to an object allocated on the heap.

For example, a reference type object, vehicle1, of the Vehicle class is instantiated on the heap by using the new operator.

Multiple reference type variables can refer to the same memory location. In the code example, when you copy the reference type variable, vehicle1, to a new reference type variable, vehicle2, both the variables on the stack reference the same Vehicle class object on the heap.

If one of the reference type variables modifies the value in the memory location, the other variables automatically reflect the modified value.

The .NET Framework provides predefined reference types in the form of classes and interfaces. You use the class and interface keywords to create your own classes and interfaces, respectively. Classes are like templates based on which objects are created.

Classes contain members, such as variables, methods, and properties, which represent the state and behavior of a particular object.

You can create instances of class types by using object-creation expressions. The code example shows the creation of the emp1 object of the class type, Employee class.

In addition to creating your own classes, you can use the predefined classes available in the .NET Framework. Each class belongs to a specific namespace, depending on its purpose.

For example, you use the classes in the System.Windows.Forms namespace to develop Windows applications. You use the classes in the System.Web.UI.WebControls namespace to develop Web applications. You use the classes in the System.Data.SqlClient namespace to develop database applications.

The other predefined reference type available in the .NET Framework is interface. An interface defines standard behavior for classes in a hierarchy. An interface contains properties, events, and function declarations.

However, the functions in an interface are only declared and do not have a body. Interfaces require classes to implement their functionality. The code example defines an interface, IAccount.

What Is Boxing and Unboxing?

What would you do when a collection accepts only reference type data and you want to add an integer, which is a value type, to the collection? The .NET Framework provides a solution. You can convert the data through boxing before adding it to the collection. To retrieve that data as an integer from the collection, you can perform unboxing. As a result, boxing and unboxing make it simple for you to use value types when a reference type is expected.

In most cases, boxing occurs implicitly. For example, when passing a value type parameter to a method that accepts a reference type, boxing takes place implicitly. Unlike boxing, unboxing is always performed explicitly. During unboxing, you need to take care that the boxed value can be unboxed only to the same type from which it was boxed. For example, if you box an Int32 to an object, you can unbox the boxed Int32 value only to an Int32type.

Boxing: – Boxing is the conversion of a value type to a reference type. During boxing, memory is allocated on the heap to store a copy of the value type instance and the internal data required to create a valid reference object. After the memory is allocated, the value type instance is copied to the newly allocated heap memory and the address of the object is returned. This address is now a reference type.

The following code example shows the conversion of an integer variable a to an object o by using boxing. The value stored in the variable a is changed from 100 to 200. The example shows that the object o keeps the original value, 100.

Visual Basic

Dim a as Integer = 100

Dim o as Object = a

a = 200

Console.WriteLine(”The value-type value = {0}”, a)

Console.WriteLine(”The object-type value = {0}”, o)

C#

int a = 100;

object o = a;

a = 200;

Console.WriteLine(”The value-type value = {0}”, a);

Console.WriteLine(”The object-type value = {0}”, o);

Unboxing: – Unboxing is the opposite of boxing. It is the explicit conversion of a reference type to a value type. Unboxing retrieves a reference to the value type contained within an object. An unboxing operation involves checking the object instance to ensure that the object instance is a boxed value of the given value type. The value from the instance is then copied into the value type variable. Unboxing returns a pointer to the data within a boxed object and does not create a copy of the data.

The following code example implements unboxing. The variable o is explicitly converted back to the integer a.

Visual Basic

Dim a as Integer = 1

Dim o as Object = a

a = 100

Console.WriteLine(a)

a = CInt(o)

Console.WriteLine(a)

C#

int a = 1;

Object o = a;

a = 100;

Console.WriteLine(a);

a = (int) o;

Console.WriteLine(a);

Boxing and unboxing are not the only conversions that occur in the .NET Framework. In addition to these methods, the .NET Framework allows data type conversion, which is also known as type casting. You can use type casting in cases where you need to pass one type of value to another type. For example, you need to type cast a Single to an Int32 while passing a floating-point value to an Int32 type. In this case, you can apply type casting to both value types as well as reference types. You can perform type casting either implicitly or explicitly.

The following describes the difference between implicit and explicit casting.

Implicit casting: – Implicit casting does not require any special syntax in the source code. The compiler automatically performs an implicit conversion.

For example, if you define a variable x as Single and you perform some multiplications, the operation produces a result that may be a larger value than what a Single variable can store. As a result, you declare another variable,y, as Double to store the resultant value. Here the compiler performs implicit casting on the resultant Singlevalue before storing it in the Double variable.

Implicit casting is also called widening conversion because narrow data types are converted to wide data types. This also ensures that there is no data loss during the conversion process.

The following code example shows the implementation of implicit casting. In the code, an Int32 type value is assigned to a Double type variable.

Visual Basic

Dim a As Int32

Dim b As Double

a = 100

b = a

C#

Int32 a;

Double b;

a = 100;

b = a;

Explicit casting: – In explicit casting, you convert a wide data type to a narrow data type. For example, you can convert a Double type value to an Int32 type. As a result, explicit casting is also called narrowing conversion. This type of conversion may lead to the possibility of data loss when the value to be converted is beyond the range of the target data type.

In Visual Basic, you can use various conversion functions, such as CInt and CStr whereas in C#, you need to use the cast operator to perform explicit casting.

The .NET Framework also provides some conversion methods that are common to both Visual Basic and C#. These methods are defined as static within the System.Convert class to perform explicit casting.

The following code example implements explicit casting. In this code, an Int64 type value is converted to an Int32type.

Visual Basic

Dim a As Int64 = 100

Dim b As Int32 = 0

b = CInt(a)

C#

Int64 a = 0;

Int32 b = 0;

b = (Int32) a;

The following job aid shows the results of setting Option Strict to On and Off in Visual Basic. It also shows you how to specify the Option Strict setting in the IDE so that the specified setting is applicable for the current or all projects.

Results of Setting Option Strict to On and Off

The Option Strict statement communicates to the Visual Basic compiler whether or not to allow implicit conversions for narrowing conversions. A narrowing conversion means converting a larger data type to a smaller one; and as a result, it may cause data loss. For example, if the Option Strict statement is set to On, Visual Basic will raise a compile time error for the following code:

Option Strict On

Dim i As Integer = 122

Dim b As Byte

b = i

In the above code, you are asking the Visual Basic compiler to implicitly convert Int32 to Byte. Because Int32 is larger than Byte and data may be lost, the Visual Basic compiler raises an error. Instead, if you set Option Strictto Off, the Visual Basic compiler will not raise an error. Here is an example:

Option Strict Off

Dim i As Int32 = 89

Dim b As Byte

b = i

Specifying the Option Strict Setting in the IDE

You can specify the Option Strict setting either for the current project or as a default setting for all projects.

The steps to specify the setting for your current project, for example, CRM, are:

1. In the Visual Studio IDE window, click Project and then click CRM Properties.

2. Click Compile and then select the relevant option in the Option Strict drop-down list.

The steps to specify the default setting for all your projects are:

1. In the Visual Studio IDE window, click Tools and then click Options.

2. Open the Projects and Solutions node and then click VB Defaults.

3. Select the relevant option in the Option Strict drop-down list and then click OK.