Integer Types

There are eight C# integer types, as shown in Table 2.1. This variety allows you to select a data type large enough to hold its intended range of values without wasting resources.

Included in Table 2.1 (and in Tables 2.2 and 2.3) is a column for the full name of each type; we discuss the literal suffix later in the chapter. All the fundamental types in C# have both a short name and a full name. The full name corresponds to the type as it is named in the Base Class Library (BCL). This name, which is the same across all languages, uniquely identifies the type within an assembly. Because of the fundamental nature of these types, C# also supplies keywords as short names or abbreviations for the full names of fundamental types. From the compiler’s perspective, both names refer to the same type, producing identical code. In fact, an examination of the resultant Common Intermediate Language (CIL) code would provide no indication of which name was used.

Although C# supports using both the full BCL name and the keyword, as developers we are left with the choice of which to use when. Rather than switching back and forth, it is better to use one or the other consistently. For this reason, C# developers generally use the C# keyword form—choosing, for example, int rather than System.Int32 and string rather than System.String (or a possible shortcut of String).

The choice for consistency frequently may be at odds with other guidelines. For example, given the guideline to use the C# keyword in place of the BCL name, there may be occasions when you find yourself maintaining a file (or library of files) with the opposite style. In these cases, it would be better to stay consistent with the previous style than to inject a new style and inconsistencies in the conventions. Even so, if the “style” was a bad coding practice that was likely to introduce bugs and obstruct successful maintenance, by all means correct the issue throughout.

Floating-Point Types (float, double)

Floating-point numbers have varying degrees of precision, and binary floating-point types can represent numbers exactly only if they are a fraction with a power of 2 as the denominator. If you were to set the value of a floating-point variable to be 0.1, it could very easily be represented as 0.0999999999999999 or 0.10000000000000001 or some other number very close to 0.1. Similarly, setting a variable to a large number such as Avogadro’s number, 6.02 × 10²³, could lead to a representation error of approximately 10⁸, which after all is a tiny fraction of that number. The accuracy of a floating-point number is in proportion to the magnitude of the number it represents. A floating-point number is precise to a certain number of significant digits, not by a fixed value such as ±0.01. Starting with .NET Core 3.0, there are at most 17 significant digits for a double and 9 significant digits for a float (assuming the number wasn’t converted from a string as described in the Advanced Block: Floating-Point Types Dissected). ¹

1. Prior to .NET Core 3.0, the number of bits (binary digits) converts to 15 decimal digits, with a remainder that contributes to a sixteenth decimal digit as expressed in Table 2.2. Specifically, numbers between 1.7 × 10³⁰⁷ and less than 1 × 10³⁰⁸ have only 15 significant digits. However, numbers ranging from 1 × 10³⁰⁸ to 1.7 × 10³⁰⁸ will have 16 significant digits. A similar range of significant digits occurs with the decimal type as well.

C# supports the two binary floating-point number types listed in Table 2.2. Binary numbers appear as base 10 (denary) numbers for human readability.

A decimal is represented by ±N * 10^k where the following is true:

• N, the mantissa, is a positive 96-bit integer.

• k, the exponent, is given by -28 <= k <= 0.

In contrast, a binary float is any number ±N * 2^k where the following is true:

• N is a positive 24-bit (for float) or 53-bit (for double) integer.

• k is an integer ranging from -149 to +104 for float and from -1074 to +970 for double.

Decimal Type

C# also provides a decimal floating-point type with 128-bit precision (see Table 2.3). This type is suitable for financial calculations.

Unlike binary floating-point numbers, the decimal type maintains exact accuracy for all denary numbers within its range. With the decimal type, therefore, a value of 0.1 is exactly 0.1. However, while the decimal type has greater precision than the floating-point types, it has a smaller range. Thus, conversions from floating-point types to the decimal type may result in overflow errors. Also, calculations with decimal are slightly (generally imperceptibly) slower.

Literal Values

A literal value is a representation of a constant value within source code. For example, if you want to have System.Console.WriteLine() print out the integer value 42 and the double value 1.618034, you could use the code shown in Listing 2.1.

Listing 2.1: Specifying Literal Values

Click here to view code image

System.Console.WriteLine(42);

System.Console.WriteLine(1.618034);

Output 2.1 shows the results of Listing 2.1.

Output 2.1

42
1.618034

By default, when you specify a literal number with a decimal point, the compiler interprets it as a double type. Conversely, a literal value with no decimal point generally defaults to an int, assuming the value is not too large to be stored in a 32-bit integer. If the value is too large, the compiler will interpret it as a long. Furthermore, the C# compiler allows assignment to a numeric type other than an int, assuming the literal value is appropriate for the target data type. short s = 42 and byte b = 77 are allowed, for example. However, this is appropriate only for constant values; b = s is not allowed without additional syntax, as discussed in the section “Conversions between Data Types” later in this chapter.

As previously discussed in this section, there are many different numeric types in C#. In Listing 2.2, a literal value is placed within C# code. Since numbers with a decimal point will default to the double data type, the output, shown in Output 2.2, is 1.61803398874989 (the last digit, 5, is missing), corresponding to the expected accuracy of a double.

Listing 2.2: Specifying a Literal double

Click here to view code image

System.Console.WriteLine(1.618033988749895);

Output 2.2

1.61803398874989

To view the intended number with its full accuracy, you must declare explicitly the literal value as a decimal type by appending an M (or m) (see Listing 2.3 and Output 2.3).

Listing 2.3: Specifying a Literal decimal

Click here to view code image

System.Console.WriteLine(1.618033988749895M);

Output 2.3

1.61803398874985

Now the output of Listing 2.3 is as expected: 1.618033988749895. Note that d is the abbreviation for double. To remember that m should be used to identify a decimal, remember that “m is for monetary calculations.”

You can also add a suffix to a value to explicitly declare a literal as a float or double by using the F and D suffixes, respectively. For integer data types, the suffixes are U, L, LU, and UL. The type of an integer literal can be determined as follows:

• Numeric literals with no suffix resolve to the first data type that can store the value, in this order: int, uint, long, and ulong.

• Numeric literals with the suffix U resolve to the first data type that can store the value, in the order uint and then ulong.

• Numeric literals with the suffix L resolve to the first data type that can store the value, in the order long and then ulong.

• If the numeric literal has the suffix UL or LU, it is of type ulong.

Note that suffixes for literals are case insensitive. However, uppercase is generally preferred to avoid any ambiguity between the lowercase letter l and the digit 1.

On occasion, numbers can get quite large and difficult to read. To overcome the readability problem, C# 7.0 added support for a digit separator, an underscore (_), when expressing a numeric literal, as shown in Listing 2.4.

Listing 2.4: Specifying Digit Separator

Click here to view code image

System.Console.WriteLine(9_814_072_356);

In this case, we separate the digits into thousands (threes), but this is not required by C#. You can use the digit separator to create whatever grouping you like as long as the underscore occurs between the first and last digits. In fact, you can even have multiple underscores side by side—with no digit between them.

In addition, you may wish to use exponential notation instead of writing out several zeroes before or after the decimal point (whether using a digit separator or not). To use exponential notation, supply the e or E infix, follow the infix character with a positive or negative integer number, and complete the literal with the appropriate data type suffix. For example, you could print out Avogadro’s number as a float, as shown in Listing 2.5 and Output 2.4.

Listing 2.5: Exponential Notation

Click here to view code image

System.Console.WriteLine(6.023E23F);

Output 2.4

6.023E+23

In all discussions of literal numeric values so far, we have covered only base 10 type values. C# also supports the ability to specify hexadecimal values. To specify a hexadecimal value, prefix the value with 0x and then use any hexadecimal series of digits, as shown in Listing 2.6.

Listing 2.6: Hexadecimal Literal Value

Click here to view code image

// Display the value 42 using a hexadecimal literal
System.Console.WriteLine(0x002A);

Output 2.5 shows the results of Listing 2.6. Note that this code still displays 42, not 0x002A.

Output 2.5

42

Starting with C# 7.0, you can also represent numbers as binary values (see Listing 2.7).

Listing 2.7: Binary Literal Value

Click here to view code image

// Display the value 42 using a binary literal
System.Console.WriteLine(0b101010);

The syntax is like the hexadecimal syntax except with 0b as the prefix (an uppercase B is also allowed). See the Beginner Topic: Bits and Bytes in Chapter 4 for an explanation of binary notation and the conversion between binary and decimal.

Note that starting with C# 7.2, you can place the digit separator after the x for a hexadecimal literal or the b for a binary literal.

Boolean Type (bool)

Another C# primitive is a Boolean or conditional type, bool, which represents true or false in conditional statements and expressions. Allowable values are the keywords true and false. The BCL name for bool is System.Boolean. For example, to compare two strings in a case-insensitive manner, you call the string.Compare() method and pass a bool literal true (see Listing 2.10).

Listing 2.10: A Case-Insensitive Comparison of Two Strings

Click here to view code image

string option;
...
int comparison = string.Compare(option, "/Help", true);

In this case, you make a case-insensitive comparison of the contents of the variable option with the literal text /Help and assign the result to comparison.

Although theoretically a single bit could hold the value of a Boolean, the size of bool is 1 byte.

Character Type (char)

A char type represents 16-bit characters whose set of possible values are drawn from the Unicode character set’s UTF-16 encoding. A char is the same size as a 16-bit unsigned integer (ushort), which represents values between 0 and 65,535. However, char is a unique type in C# and code should treat it as such.

The BCL name for char is System.Char.

To construct a literal char, place the character within single quotes, as in 'A'. Allowable characters comprise the full range of keyboard characters, including letters, numbers, and special symbols.

Some characters cannot be placed directly into the source code and instead require special handling. These characters are prefixed with a backslash () followed by a special character code. In combination, the backslash and special character code constitute an escape sequence. For example, represents a newline and represents a tab. Since a backslash indicates the beginning of an escape sequence, it can no longer identify a simple backslash; instead, you need to use \ to represent a single backslash character.

Listing 2.11 writes out one single quote because the character represented by ' corresponds to a single quote.

Listing 2.11: Displaying a Single Quote Using an Escape Sequence

Click here to view code image

class SingleQuote
{
  static void Main()
  {
      System.Console.WriteLine(''');
  }
}

In addition to showing the escape sequences, Table 2.4 includes the Unicode representation of characters.

You can represent any character using Unicode encoding. To do so, prefix the Unicode value with u. You represent Unicode characters in hexadecimal notation. The letter A, for example, is the hexadecimal value 0x41. Listing 2.12 uses Unicode characters to display a smiley face (:)), and Output 2.8 shows the results.

Listing 2.12: Using Unicode Encoding to Display a Smiley Face

Click here to view code image

System.Console.Write('u003A');

System.Console.WriteLine('u0029');

Output 2.8

:)

Strings

A finite sequence of zero or more characters is called a string. The string type in C# is string, whose BCL name is System.String. The string type includes some special characteristics that may be unexpected to developers familiar with other programming languages. In addition to the string literal format discussed in Chapter 1, strings include a “verbatim string” prefix character of @, support for string interpolation with the $ prefix character, and the potentially surprising fact that strings are immutable.

class DuelOfWits
{
  static void Main()
  {
      System.Console.Write(
          ""Truly, you have a dizzying intellect."");
      System.Console.Write("
"Wait 'til I get going!"
");
  }
}

"Truly, you have a dizzying intellect."

"Wait 'til I get going!"

class Triangle
{
  static void Main()
  {
      System.Console.Write(@"begin
             /
            /  
           /    
          /      
         /________
end");
  }
}

begin
             /
            /  
           /    
          /      
         /________
end

System.Console.WriteLine($"Your full name is {firstName} {lastName}.");

System.Console.WriteLine($@"Your full name is:
    { firstName } { lastName }");

System.Console.WriteLine($@"Your full name is: {
    firstName } { lastName }");

static string string.Format(
    string format,
    ...)

string text, firstName, lastName;
//...
text = string.Format("Your full name is {0} {1}.",
  firstName, lastName);
// Display
// "Your full name is <firstName> <lastName>."
System.Console.WriteLine(text);

static string string.Concat(
    string str0,
    string str1)

string text, firstName, lastName;
//...
text = string.Concat(firstName, lastName);
// Display "<firstName><lastName>", notice
// that there is no space between names
System.Console.WriteLine(text);

static int string.Compare(
    string str0,
    string str1)

string option;
//...
// String comparison in which case matters
int result = string.Compare(option, "/help");
 
// Display:
//     0 if equal
//     negative if option < /help
//     positive if option > /help
System.Console.WriteLine(result);

string option;
//...
// Case-insensitive string comparison
int result = string.Compare(
     option, "/Help", true);
 
// Display:
//     0 if equal
//     < 0 if option < /help
//     > 0 if option > /help
System.Console.WriteLine(result);

bool StartsWith(
    string value)
bool EndsWith(
    string value)

string lastName
//...
bool isPhd = lastName.EndsWith("Ph.D.");
bool isDr = lastName.StartsWith("Dr.");

string ToLower()
string ToUpper()

string severity = "warning";
// Display the severity in uppercase
System.Console.WriteLine(severity.ToUpper());

string Trim()
string Trim(...)
string TrimEnd()
string TrimStart()

// Remove any whitespace from
// both the start and end
username = username.Trim();

string text =
  "indiscriminate bulletin";
// Remove 'i' and 'n' from both the start or end
text = text.Trim("in".ToCharArray());
// Display: discriminate bullet
System.Console.WriteLine(text);

string Replace(
    string oldValue,
    string newValue)

string filename;
//...
// Remove ?'s from anywhere in the string
filename = filename.Replace("?", "");;

class PalindromeLength
{
  static void Main()
  {
      string palindrome;
      System.Console.Write("Enter a palindrome: ");
      palindrome = System.Console.ReadLine();
      System.Console.WriteLine(
          $"The palindrome "{palindrome}" is"
          + $" {palindrome.Length} characters.");
  }
}

Enter a palindrome: Never odd or even
The palindrome "Never odd or even" is 17 characters.

class Uppercase
{
  static void Main()
  {
      string text;

      System.Console.Write("Enter text: ");
      text = System.Console.ReadLine();

      // UNEXPECTED:  Does not convert text to uppercase  
      text.ToUpper();                                                          

      System.Console.WriteLine(text);
  }
}

Enter text: This is a test of the emergency broadcast system.
This is a test of the emergency broadcast system.

class Uppercase
{
  static void Main()
  {
      string text, uppercase;

      System.Console.Write("Enter text: ");
      text = System.Console.ReadLine();
      // Return a new string in uppercase
      uppercase = text.ToUpper();                        

      System.Console.WriteLine(uppercase);
  }
}

Enter text: This is a test of the emergency broadcast system.
THIS IS A TEST OF THE EMERGENCY BROADCAST SYSTEM.

text = text.ToUpper();

null and void

Two additional keywords relating to types are null and void. The null value, identified with the null keyword, indicates that the variable does not refer to any valid object. void is used to indicate the absence of a type or the absence of any value altogether.

Explicit Cast

In C#, you cast using the cast operator. By specifying the type you would like the variable converted to within parentheses, you acknowledge that if an explicit cast is occurring, there may be a loss of precision and data, or an exception may result. The code in Listing 2.20 converts a long to an int and explicitly tells the system to attempt the operation.

Listing 2.20: Explicit Cast Example

With the cast operator, the programmer essentially says to the compiler, “Trust me, I know what I am doing. I know that the value will fit into the target type.” Making such a choice will cause the compiler to allow the conversion. However, with an explicit conversion, there is still a chance that an error, in the form of an exception, might occur while executing if the data is not converted successfully. It is therefore the programmer’s responsibility to ensure the data is successfully converted, or else to provide the necessary error-handling code when the conversion fails.

You cannot convert any type to any other type simply because you designate the conversion explicitly using the cast operator. The compiler will still check that the operation is valid. For example, you cannot convert a long to a bool. No such conversion is defined and, therefore, the compiler does not allow such a cast.

Implicit Conversion

In other instances, such as when going from an int type to a long type, there is no loss of precision, and no fundamental change in the value of the type occurs. In these cases, the code needs to specify only the assignment operator; the conversion is implicit. In other words, the compiler is able to determine that such a conversion will work correctly. The code in Listing 2.24 converts from an int to a long by simply using the assignment operator.

Listing 2.24: Not Using the Cast Operator for an Implicit Conversion

Click here to view code image

int intNumber = 31416;
long longNumber = intNumber;

Even when no explicit cast operator is required (because an implicit conversion is allowed), it is still possible to include the cast operator (see Listing 2.25).

Listing 2.25: Using the Cast Operator for an Implicit Cast

Click here to view code image

int intNumber = 31416;
long longNumber = (long) intNumber;

Type Conversion without Casting

No conversion is defined from a string to a numeric type, so methods such as Parse() are required. Each numeric data type includes a Parse() function that enables conversion from a string to the corresponding numeric type. Listing 2.26 demonstrates this call.

Listing 2.26: Using float.Parse() to Convert a string to a Numeric Data Type

Click here to view code image

string text = "9.11E-31";
float kgElectronMass = float.Parse(text);

Another special type is available for converting one type to the next. This type is System.Convert, and an example of its use appears in Listing 2.27.

Listing 2.27: Type Conversion Using System.Convert

Click here to view code image

string middleCText = "261.626";
double middleC = System.Convert.ToDouble(middleCText);
bool boolean = System.Convert.ToBoolean(middleC);

System.Convert supports only a small number of types and is not extensible. It allows conversion from any of the types bool, char, sbyte, short, int, long, ushort, uint, ulong, float, double, decimal, DateTime, and string to any other of those types.

Furthermore, all types support a ToString() method that can be used to provide a string representation of a type. Listing 2.28 demonstrates how to use this method. The resultant output is shown in Output 2.17.

Listing 2.28: Using ToString() to Convert to a string

Click here to view code image

bool boolean = true;
string text = boolean.ToString();
// Display "True"
System.Console.WriteLine(text);

Output 2.17

True

For the majority of types, the ToString() method returns the name of the data type rather than a string representation of the data. The string representation is returned only if the type has an explicit implementation of ToString(). One last point to make is that it is possible to code custom conversion methods, and many such methods are available for classes in the runtime.

The key difference between Parse() and TryParse() is that TryParse() won’t throw an exception if it fails. Frequently, the conversion from a string to a numeric type depends on a user entering the text. It is expected, in such scenarios, that the user will enter invalid data that will not parse successfully. By using TryParse() rather than Parse(), you can avoid throwing exceptions in expected situations. (The expected situation in this case is that the user will enter invalid data, and we try to avoid throwing exceptions for expected scenarios.)