Integer types

C# supports eight predefined integer types, shown in the following table.

Open table as spreadsheet

Name	CTS Type	Description	Range (min:max)
sbyte	System.SByte	8-bit signed integer	-128:127 (-27:27-1)
short	System.Int16	16-bit signed integer	-32,768:32,767 (-215:215-1)
int	System.Int32	32-bit signed integer	-2,147,483,648:2,147,483,647 (-231:231-1)
longt	System.Int64	64-bit signed integer	-9,223,372,036,854,775,808: 9,223,372,036,854,775,807 (-263:263-1)
byte	System.Byte	8-bit unsigned integer	0:255 (0:28-1)
ushort	System.UInt16	16-bit unsigned integer	0:65,535 (0:216-1)
uint	System.UInt32	32-bit unsigned integer	0:4,294,967,295 (0:232-1)
ulong	System.UInt64	64-bit unsigned integer	0:18,446,744,073,709,551,615 (0:264-1)

Future versions of Windows will target 64-bit processors, which can move bits into and out of memory in larger chunks to achieve faster processing times. Consequently, C# supports a rich palette of signed and unsigned integer types ranging in size from 8 to 64 bits.

Many of these type names will be new to Visual Basic. C++ and Java developers should be careful; some of the names of C# types are the same as C++ and Java types, but the types have different definitions. For example, in C#, an int is always a 32-bit signed integer. In C++ an int is a signed integer, but the number of bits is platform-dependent (32 bits on Windows). In C#, all data types have been defined in a platform-independent manner to allow for the possible future porting of C# and .NET to other platforms.

A byte is the standard 8-bit type for values in the range 0 to 255 inclusive. Be aware that, in keeping with its emphasis on type safety, C# regards the byte type and the char type as completely distinct, and any programmatic conversions between the two must be explicitly requested. Also be aware that unlike the other types in the integer family, a byte type is by default unsigned. Its signed version bears the special name sbyte.

With .NET, a short is no longer quite so short; it is now 16 bits long. The int type is 32 bits long. The long type reserves 64 bits for values. All integer-type variables can be assigned values in decimal or in hex notation. The latter require the 0x prefix:

long x = 0x12ab;

If there is any ambiguity about whether an integer is int, uint, long, or ulong, it will default to an int. To specify which of the other integer types the value should take, you can append one of the following characters to the number:

uint ui = 1234U;
long l = 1234L;
ulong ul = 1234UL;

You can also use lowercase u and l, although the latter could be confused with the integer 1 (one).

Floating-Point Types

Although C# provides a plethora of integer data types, it supports floating-point types as well. They will be familiar to C and C++ programmers.

Open table as spreadsheet

Name	CTS Type	Description	Significant Figures	Range (approximate)
float	System.Single	32-bit single-precision floating point	7	±1.5 × 10−45 to ±3.4 × 1038
double	System.Double	64-bit double-precision floating point	15/16	±5.0 × 10 −324 to ±1.7 × 10308

The float data type is for smaller floating-point values, for which less precision is required. The double data type is bulkier than the float data type but offers twice the precision (15 digits).

If you hard-code in a non-integer number (such as 12.3) in your code, the compiler will normally assume that you want the number interpreted as a double. If you want to specify that the value is a float, you append the character F (or f) to it:

float f = 12.3F;

The decimal Type

In addition, there is a decimal type representing higher-precision floating-point numbers, as shown in the following table.

Open table as spreadsheet

Name	CTS Type	Description	Significant Figures	Range (approximate)
decimal	System.Decimal	128-bit high precision decimal notation	28	±1.0 × 10−28 to ±7.9 × 1028

One of the great things about the CTS and C# is the provision of a dedicated decimal type for financial calculations. How you use the 28 digits that the decimal type provides is up to you. In other words, you can track smaller dollar amounts with greater accuracy for cents or larger dollar amounts with more rounding in the fractional area. You should bear in mind, however, that decimal is not implemented under the hood as a primitive type, so using decimal will have a performance impact your calculations.

To specify that your number is of a decimal type rather than a double, float, or an integer, you can append the M (or m) character to the value, as shown in the following example:

decimal d = 12.30M;

The Boolean Type

The C# bool type is used to contain Boolean values of either true or false.

Open table as spreadsheet

Name	CTS Type	Description	Significant Figures	Range (approximate)
decimal	System.Decimal	128-bit high precision decimal notation	28	±1.0 × 10−28 to ±7.9 × 1028

You cannot implicitly convert bool values to and from integer values. If a variable (or a function return type) is declared as a bool, you can only use values of true and false. You will get an error if you try to use zero for false and a non-zero value for true.

The Character Type

For storing the value of a single character, C# supports the char data type.

Open table as spreadsheet

Name	CTS Type	Values
char	System.Char	Represents a single 16-bit (Unicode) character

Although this data type has a superficial resemblance to the char type provided by C and C++, there is a significant difference. C++ char represents an 8-bit character, whereas a C# char contains 16 bits. This is part of the reason that implicit conversions between the char type and the 8-bit byte type are not permitted.

Although 8 bits may be enough to encode every character in the English language and the digits 0–9, they aren’t enough to encode every character in more expansive symbol systems (such as Chinese). In a gesture toward universality, the computer industry is moving away from the 8-bit character set and toward the 16-bit Unicode scheme, of which the ASCII encoding is a subset.

Literals of type char are signified by being enclosed in single quotation marks, for example ‘A’. If you try to enclose a character in double quotation marks, the compiler will treat this as a string and throw an error.

As well as representing chars as character literals, you can represent them with four-digit hex Unicode values (for example ‘\u0041’), as integer values with a cast (for example, (char)65), or as hexadecimal values (‘\x0041’). They can also be represented by an escape sequence, as shown in the following table.

Open table as spreadsheet

Escape Sequence	Character
\‘	Single quotation mark
\“	Double quotation mark
\\	Backslash
\0	Null
\a	Alert
\b	Backspace
\f	Form feed
\n	Newline
\r	Carriage return
\t	Tab character
\v	Vertical tab

C++ developers should note that because C# has a native string type, you don’t need to represent strings as arrays of chars.

The object Type

Many programming languages and class hierarchies provide a root type, from which all other objects in the hierarchy are derived. C# and .NET are no exception. In C#, the object type is the ultimate parent type from which all other intrinsic and user-defined types are derived. This is a key feature of C#, which distinguishes it from both Visual Basic and C++, although its behavior here is very similar to Java. All types implicitly derive ultimately from the System.Object class. This means that you can use the object type for two purposes:

• You can use an object reference to bind to an object of any particular subtype. For example, in Chapter 6, “Operators and Casts,” you see how you can use the object type to box a value object on the stack to move it to the heap. object references are also useful in reflection, when code must manipulate objects whose specific types are unknown. This is similar to the role played by a void pointer in C++ or by a Variant data type in VB.

• The object type implements a number of basic, general-purpose methods, which include Equals(), GetHashCode(), GetType(), and ToString(). Responsible user-defined classes may need to provide replacement implementations of some of these methods using an object-oriented technique known as overriding, which is discussed in Chapter 4, “Inheritance.” When you override ToString(), for example, you equip your class with a method for intelligently providing a string representation of itself. If you don’t provide your own implementations for these methods in your classes, the compiler will pick up the implementations in object, which may or may not be correct or sensible in the context of your classes.

The object type is examined in more detail in subsequent chapters.

The string Type

Veterans of C and C++ probably have battle scars from wrestling with C-style strings. A C or C++ string was nothing more than an array of characters, so the client programmer had to do a lot of work just to copy one string to another or to concatenate two strings. In fact, for a generation of C++ programmers, implementing a string class that wrapped up the messy details of these operations was a rite of passage requiring many hours of teeth gnashing and head scratching. Visual Basic programmers had a somewhat easier life, with a string type, while Java people had it even better, with a String class that is in many ways very similar to C# string.

C# recognizes the string keyword, which under the hood is translated to the .NET class, System.String. With it, operations like string concatenation and string copying are a snap:

string str1 = "Hello";
string str2 = "World";
string str3 = str1 + str2; // string concatenation

Despite this style of assignment, string is a reference type. Behind the scenes, a string object is allocated on the heap, not the stack, and when you assign one string variable to another string, you get two references to the same string in memory. However, with string there are some differences from the usual behavior for reference types. For example, should you then make changes to one of these strings, note that this will create an entirely new string object, leaving the other string unchanged. Consider the following code:

using System;

class StringExample
{
   public static int Main()
   {
      string s1 = "a string";
      string s2 = s1;
      Console.WriteLine("s1 is " + s1);
      Console.WriteLine("s2 is " + s2);
      s1 = "another string";
      Console.WriteLine("s1 is now " + s1);
      Console.WriteLine("s2 is now " + s2);
      return 0;
   }
}

The output from this is:

s1 is a string
s2 is a string
s1 is now another string
s2 is now a string

Changing the value of s1 had no effect on s2, contrary to what you’d expect with a reference type! What’s happening here is that when s1 is initialized with the value a string, a new string object is allocated on the heap. When s2 is initialized, the reference points to this same object, so s2 also has the value a string. However, when you now change the value of s1, instead of replacing the original value, a new object will be allocated on the heap for the new value. The s2 variable will still point to the original object, so its value is unchanged. Under the hood, this happens as a result of operator overloading, a topic that is explored in Chapter 6, “Operators and Casts.” In general, the string class has been implemented so that its semantics follow what you would normally intuitively expect for a string.

String literals are enclosed in double quotation marks (“...”); if you attempt to enclose a string in single quotation marks, the compiler will take the value as a char, and throw an error. C# strings can contain the same Unicode and hexadecimal escape sequences as chars. Because these escape sequences start with a backslash, you can’t use this character unescaped in a string. Instead, you need to escape it with two backslashes (\\):

string filepath = "C:\\ProCSharp\\First.cs";

Even if you are confident you can remember to do this all the time, it can prove annoying typing all those double backslashes. Fortunately, C# gives you an alternative. You can prefix a string literal with the at character (@) and all the characters in it will be treated at face value; they won’t be interpreted as escape sequences:

string filepath = @"C:\ProCSharp\First.cs";

This even allows you to include line breaks in your string literals:

string jabberwocky = @"'Twas brillig and the slithy toves
Did gyre and gimble in the wabe.";

Then the value of jabberwocky would be this:

'Twas brillig and the slithy toves
Did gyre and gimble in the wabe.