Constant 1 1U 1L 10 10F 1M true false a \n \x123 a string in C#

Generate Code 39 Extended in C# Constant 1 1U 1L 10 10F 1M true false a \n \x123 a string

Type int unsigned int long int (avoid lowercase l; it s too much like the digit 1) double float decimal bool bool char char (the character newline) char (the character whose numeric value is hex 123)1 string string (an empty string); same as StringEmpty

hex is short for hexadecimal (numbers in base 16 rather than in base 10)

Humans don t treat different types of counting numbers differently For example, a normal person (as distinguished from a C# programmer) doesn t think about the number 1 as being signed, unsigned, short, or long Although C# considers these types to be different, even C# realizes that a relationship exists between them For example, this bit of code converts an int into a long:

int intValue = 10; long longValue; longValue = intValue;

An int variable can be converted into a long because any possible value of an int can be stored in a long and because they are both counting numbers C# makes the conversion for you automatically without comment This is called an implicit type conversion A conversion in the opposite direction can cause problems, however For example, this line is illegal:

long longValue = 10; int intValue; intValue = longValue;

Some values that you can store in a long don t fit in an int (4 billion, for example) If you try to shoehorn such a value into an int, C# generates an error because data may be lost during the conversion process This type of bug is difficult to catch But what if you know that the conversion is okay For example, even though longValue is a long, maybe you know that its value can t exceed 100 in this particular program In that case, converting the long variable longValue into the int variable intValue would be okay You can tell C# that you know what you re doing by means of a cast:

long longValue = 10; int intValue; intValue = (int)longValue;

In a cast, you place the name of the type you want in parentheses and put it immediately in front of the value you want to convert This cast says, Go ahead and convert the long named longValue into an int I know what I m doing In retrospect, the assertion that you know what you re doing may seem overly confident, but it s often valid A counting number can be converted into a floating-point number automatically, but converting a floating-point into a counting number requires a cast:

double doubleValue = 100; long longValue = (long)doubleValue;

All conversions to and from a decimal require a cast In fact, all numeric types can be converted into all other numeric types through the application of a cast Neither bool nor string can be converted directly into any other type Built-in C# methods can convert a number, character, or Boolean into its string equivalent, so to speak For example, you can convert the bool value true into the string true ; however, you cannot consider this change a direct conversion The bool true and the string true are completely different things

So far in this book well, so far in this chapter when you declared a variable, you always specified its exact data type, like this:

int i = 5; string s = Hello C# ; double d = 10;

You re allowed to offload some of that work onto the C# compiler, using the var keyword:

var i = 5; var s = Hello C# 40 ; var d = 10;

Now the compiler infers the data type for you it looks at the stuff on the right side of the assignment to see what type the left side is For what it s worth, 3 of this minibook shows how to calculate the type of an expression like the ones on the right side of the assignments in the preceding example Not that you need to do that the compiler mostly does it for you Suppose, for example, you have an initializing expression like this:

var x = 30 + 2 - 15;

The compiler can figure out that x is a double value It looks at 30 and 15 and sees that they re of type double Then it notices that 2 is an int, which the compiler can convert implicitly to a double for the calculation All of the addition terms in x s initialization expression end up as doubles So the inferred type of x is double But now, you can simply utter the magic word var and supply an initialization expression, and the compiler does the rest:

var aVariable = <initialization expression here>;