Data Types

The data type variable defines the type of data that can be stored in it, as well as the format in which that data is stored (and the amount of memory that the system needs to allocate for the variable). The following table lists the data types supported by C# and Visual Basic .NET, as well as the Microsoft .NET Framework SDK types to which they map. The data types marked with an asterisk don’t have a native representation, but you can still access these data types by using the appropriate System type when declaring the variable. Why cover Visual Basic .NET types? If you are creating a class to be used by other developers, knowing how the types match between C# and Visual Basic .NET is critical, both to ensure that the correct type is used, and to document the class in a Visual Basic .NET programmer-friendly way. The good news is that, unlike in the 32 bit Win32 world of Visual Basic 6 and Visual C++ 6, an integer in both environments is the same size and has the same numeric range.

The data type of a variable is determined at the time the variable is declared. This will be discussed further in the section titled “Declaring Variables” later in this chapter. Some data types (such as the Date type) do not have language specific implementations. In Table 3-1, there is an asterisk (*) in the cells of types without the corresponding language-specific data types. Some data types are not Common Language Specification (CLS) compliant, and are noted with a cross (†) in the .NET data type column.

Value Types vs. Reference Types

In .NET development, there are two categories of data types: value types and reference types. Although understanding the distinction between these types isn’t absolutely necessary if you want to develop ASP.NET applications, it can help you better understand how these data types operate and how to deal with error messages resulting from coding errors. (Not that those ever happen, right?)

Value types are data types that store their data directly as values in memory. They include all the numeric types (int32, short, single, and so on), structures (custom data types based on System.ValueType), and enumerations (custom types that represent a defined set of values), as well as boolean, char, and date types. Value types are accessed directly, as in the following example:

int myInt; // C# declaration for an int3 // Expression to assign the value 123 directly to the variabl myInt = 123;

Reference types are data types that store a reference to another memory location that contains the data, which is usually based on a class, such as the String class in the .NET Framework. Reference types include Object (which acts as a replacement for Visual Basic’s Variant type, no longer supported in .NET), String, and all Arrays, as well as instances of custom classes. Reference types are accessed through members of the class to which the type holds a reference, as in the following example:

// Define a clas class myClass  public int myInt  // declare an instance of the clas myClass myClassInstance // Allocate space for the clas myClass = new myClass() // Expression to assign the value 123 to myClass member myIn myClass.myInt = 123;

Unlike value types, in which all you need to do is declare the variable and set a value, reference types must be declared and then have space allocated for them, using the new keyword in the example.

Lifetime

Lifetime refers to the span of time from when the variable is declared to when it is destroyed. The lifetime of a variable depends on where it is declared.

For example, the lifetime of a variable declared inside a procedure is limited to the execution of the procedure. After the procedure has finished executing, the variable is destroyed and the memory it occupied is reclaimed. An example is shown here:

// C# metho private void HelloWorld(  String HelloString string hellostring HelloString = "Hello World!" hellostring = HelloString Message.Text += HelloString Message.Text += "<br/>" Message.Text += hellostring // Both HelloString and hellostring will disappea //  after the next line.. }

When this procedure completes, the variables HelloString and hellostring no longer exist. Their lifetime has ended. If HelloString had been declared outside the procedure, as in this next fragment of code, its lifetime would be until the instance of the class containing it was destroyed.

// Declare string outside of metho String HelloString // C# metho void HelloWorld(  HelloString = "Hello World!" Message.Text += HelloString // HelloString will still exis //  after the next line.. }

C# variables can also be declared as static. Static variables exist for the life of the class, and even if there are many instances of the class, there is only a single instance of the static variable. Static variables must be declared as members of the class rather than inside a single method.

Scope

Scope, also known as visibility, refers to the region of code in which a variable can be accessed. The scope of a variable depends on where the variable is declared, and in Visual C# .NET it can include the following levels.

• Block-level Variables declared within curly braces, {}, for instance in an if or while statement, are referred to as block-level variables. Although the scope of block-level variables is limited to the block in which they’re declared, their lifetime is that of the procedure in which the block appears.

• Procedure-level Also known as local variables, these are visible only within the procedure in which they’re declared.

• Module-level In modules, classes, or structures, any variable declared outside of a procedure is referred to as a module-level variable. The accessibility of module-level variables is determined by any accessibility keywords used in their declaration (see the section titled “Accessibility” later in this chapter).

• Namespace-level Variables declared at module level but given public accessibility (public or internal), are referred to as namespace-level variables. They’re available to any procedure in the same namespace that contains the module in which the variable is declared.

Namespaces

A namespace is a container used for scoping. Namespaces can contain classes, structures, enumerations, interfaces, and delegates. By using namespaces, you can have more than one class in a given program with the same name, so long as the classes reside in different namespaces. Using namespaces can help ensure that code created by multiple teams of developers can be combined to create larger systems without name collisions.

Namespaces declared in C# use the namespace { } syntax, where the classes and other types to be contained within the namespace are bracketed by the curly braces.

Namespaces can also be nested within other namespaces, forming a hierarchical tree structure. This structure enables you to combine classes in logical groupings, making it easier for those using your namespaces to find the classes they’re looking for.

Following these guidelines will make your application more memory-efficient and will make maintaining your code easier.

There is one significant difference in how scope works in C# vs. C++. The following code would work in C++, but fail in C#:

private void ScopeTest(  int foo foo = 2 if ( foo != 2   // This would work in C++, fail in C int foo foo = 7  // In C++, foo would now be equal to the number 2, and th //foo declared inside the if statement is not visibl //or available /* In C#, if the only instance of foo was declared insid the if statement, foo would not be visible o available, but you would still be unable t declare a variable named foo * }

In this contrived example, even though the second copy of foo is declared within the braces of the if statement, the compiler will generate an error and fail to compile the code because that second instance of foo would hide the first instance. In C++, the second declaration of foo would declare a variable visible only inside the if statement, hiding the previous value of foo. You can, however, declare a variable at the class level and then declare a variable of the same name, even with a different type, within a method of that class.

There are a couple of guidelines to follow regarding lifetime and scope:

• Limit your variables to the narrowest possible scope that will allow you to accomplish your objectives.

• Avoid using the same name for variables of different scope within the same module even where it is allowed. Using the same name in such situations can lead to confusion and errors.

• Because module-level and static variables all continue to consume memory as long as the class or module is running, you should use them only when necessary.

Accessibility

The last important concept in variable declaration is accessibility. The accessibility of a variable determines whether it can be accessed from outside the module (or application) in which it’s declared. In C#, accessibility is determined through the use of one the following modifiers.

• public Variables declared with the public keyword are accessible from anywhere in the same module (or class) in which they’re declared, the namespace containing that module, and any other applications that refer to the application in which they’re declared. They can only be used at the module or class level.

• internal Variables declared with the internal keyword are accessible from anywhere in the same module (or class) in which they’re declared, as well as the namespace containing that module.

• protected Variables declared with the protected keyword are accessible only within the class in which they’re declared or a class that inherits from that class. (See the section titled “Using Inheritance” later in this chapter.) The protected keyword can be combined with the internal keyword and can be used only to declare class members.

• private Variables declared with the private keyword are accessible only from the module, class, or structure in which they’re declared. In classes or modules, declaring a variable with no modifier or as private has the same effect on the variable’s accessibility, but private makes your intentions more explicit. The private keyword cannot be used within a procedure.

  Note

  In C#, all variables must be declared before they can be used. Failure to declare a variable will result in a compiler error. In Visual Basic .NET and some other languages, it’s possible (but not advisable) to use variables without first declaring them.