Figure 2-2 Memory map for the declaration of value-type variables in Visual C#

Creating GS1 - 12 in Visual C# Figure 2-2 Memory map for the declaration of value-type variables

PART I Reference-type variables are made up of two parts: the reference on the stack and the object on the heap The creation of the object and the reference to the object is commonly known as the instantiation of the object In order to create an object on the heap, we go through two steps, as follows: 1 Declare the variable reference 2 Instantiate the object on the heap by calling the new operator The following two lines of code perform these actions:

City objMimico; objMimico = new City(); //Declare objMimico to be a reference to an //object of City type //Call the constructor of the City class to return //a reference that is stored in the objMimico reference

The two lines can be combined into one:

City objMimico = new City();

The result in memory can be seen in Figure 2-3 Once we are done with the object, and have reassigned the reference to another object, set the reference to null, or let the reference go out of scope; the object will then be destroyed by the garbage collector The garbage collector is explained in the Memory Management section, later in this chapter

The C# language is a strongly typed language every variable must be assigned a data type and that data type cannot be changed after the declaration One result of the strong typing in C# is that the compiler will not allow you to assign values to the wrong data type: a double value to an int, or a string value to an int, for example However, the compiler will accept assignments that are valid, even though they might use different data types: assigning an int to a long is valid because the long is larger than the int This type of conversion is called implicit conversion In order to convert between different types that might not be allowed without intervention, you can use casting (giving hints to the compiler about what to do) or use conversion functions based on the primitive types defined in the NET Framework In the following sections we will look at both types of conversions

Implicit conversions are used when a variable of a smaller data type is assigned to a larger one The data types must be compatible for the implicit conversion to take place In the following example, all assignments are valid and the conversions are implicit:

int x = 42; short s = 12; int y; long l; float f; double d; float const PI = 314159; l = x; // int -> long d = PI; // float -> double y = s; // short -> int f = l; // long -> float, not exact conversion, but valid

There are times when there is no direct way of converting the value from one type to another, as in this example:

int x; x = SystemReadLine();

SystemReadLine() returns a string, so even if we type in a number, the compiler would still not be able to assign the number (as a string) to the int variable x The solution is to do the following:

int x; x = Int32Parse(SystemReadLine());

The magic in this code is that we use one of the primitive value types as a class (Int32 is the class that defines the 32-bit signed integer that C# uses as the int data type) The numeric classes from the Common Type System all have a Parse() method that will

convert the string to the respective data type The conversion is pure magic, and one almost feels like calling out like Kim the Danish magician: Nothing up my sleeves and Wupti! The conversion is done The mechanics in this conversion make use of a feature in the C# language that seamlessly allows a data type to be switched from a value type to a reference type and back This is the boxing and unboxing process we mentioned in the introduction PART I