4/18/24, 1:15 AM C# in a Nutshell - Code Listings

Chapter 2 - C# Language Basics

A First C# Program

Syntax Basics

Type Basics

Numeric Types
Numeric Types

// The signed integral types are sbyte, short, int, long:

int i = -1;
i.Dump();

// The unsigned integral types are byte, ushort, uint and ulong:
byte b = 255;
b.Dump();

// The real types are float, double and decimal:

double d = 1.23;
d.Dump();

// (See book for a table comparing each of the numeric types)

Numeric Literals

// Integral literals can use decimal or hexadecimal notation; hexadecimal is denoted with the 0x prefix:
int x = 127;
long y = 0x7F;

//From C# 7, you can insert an underscore anywhere inside a numeric literal to make it more readable:
int million = 1_000_000;

//C# 7 also lets you specify numbers in binary with the 0b prefix:
var b = 0b1010_1011_1100_1101_1110_1111;

//Real literals can use decimal and/or exponential notation. For example:
double d = 1.5;
double doubleMillion = 1E06;

// Numeric literal type inference:

Console.WriteLine ( 1.0.GetType()); // Double (double)
Console.WriteLine ( 1E06.GetType()); // Double (double)
Console.WriteLine ( 1.GetType()); // Int32 (int)
Console.WriteLine (0xF0000000.GetType()); // UInt32 (uint)
Console.WriteLine (0x100000000.GetType()); // Int64 (long)

Numeric Suffixes

// Numeric literals can be suffixed with a character to indicate their type:

// F = float
// D = double
// M = decimal
// U = uint
// L = long
// UL = ulong

long i = 5; // No suffix needed: Implicit lossless conversion from int literal to long

// The D suffix is redundant in that all literals with a decimal point are inferred to be double:
double x = 4.0;

// The F and M suffixes are the most useful:

float f = 4.5F; // Will not compile without the F suffix
decimal d = -1.23M; // Will not compile without the M suffix.

Numeric Conversions

// Integral conversions are implicit when the destination type can represent every possible value
// of the source type. Otherwise, an explicit conversion is required:

https://www.albahari.com/nutshell/E12-CH02.aspx 1/4
4/18/24, 1:15 AM C# in a Nutshell - Code Listings
int x = 12345; // int is a 32-bit integral
long y = x; // Implicit conversion to 64-bit integral
short z = (short)x; // Explicit conversion to 16-bit integral

// All integral types may be implicitly converted to all floating-point numbers:

int i = 1;
float f = i;

// The reverse conversion must be explicit:

int iExplicit = (int)f;

// Implicitly converting a large integral type to a floating-point type preserves magnitude but may
// occasionally lose precision:

int i1 = 100000001;
float f1 = i1; // Magnitude preserved, precision lost
int i2 = (int)f1; // 100000000

Increment and Decrement Operators

// The increment and decrement operators (++, --) increment and decrement numeric types by 1.
// The operator can either precede or follow the variable, depending on whether you want the
// value before or after the increment/decrement:

int x = 0, y = 0;
Console.WriteLine (x++); // Outputs 0; x is now 1
Console.WriteLine (++y); // Outputs 1; x is now 1

Integral Division

// Integral division truncates remainders:

int a = 2 / 3; // 0

// Division by zero is an error:

int b = 0;
int c = 5 / b; // throws DivisionByZeroException

Integral Overflow

// By default, integral arithmetic operations overflow silently:

int a = int.MinValue;
a--;
Console.WriteLine (a == int.MaxValue); // True

Overflow Checking

// You can add the checked keyword to force overflow checking:

int a = 1000000;
int b = 1000000;

// The following code throws OverflowExceptions:

int c = checked (a * b); // Checks just the expression.

// Checks all expressions in statement block:

checked
{
int c2 = a * b;
c2.Dump();
}

Overflow Checking with Constant Expressions

// Compile-time overflows are special in that they're checked by default:

int x = int.MaxValue + 1; // Compile-time error

// You have to use unchecked to disable this:

int y = unchecked (int.MaxValue + 1); // No errors

8- and 16-bit literals

https://www.albahari.com/nutshell/E12-CH02.aspx 2/4
4/18/24, 1:15 AM C# in a Nutshell - Code Listings

// The 8- and 16-bit integral types are byte, sbyte, short, and ushort. These types lack their
// own arithmetic operators, so C# implicitly converts them to larger types as required.
// This can cause a compile-time error when trying to assign the result back to a small integral type:

short x = 1, y = 1;
short z = x + y; // Compile-time error

// In this case, x and y are implicitly converted to int so that the addition can be performed.
// To make this compile, we must add an explicit cast:

short z = (short) (x + y); // OK

Special float and double Values

// Reminder when using LINQPad: You can highlight any section of code and
// hit F5 to execute just that selection!

// Unlike integral types, floating-point types have values that certain operations treat specially,
// namely NaN (Not a Number), +∞, −∞, and −0:
Console.WriteLine (double.NegativeInfinity); // -Infinity

// Dividing a nonzero number by zero results in an infinite value:

Console.WriteLine ( 1.0 / 0.0); // Infinity
Console.WriteLine (-1.0 / 0.0); // -Infinity
Console.WriteLine ( 1.0 / -0.0); // -Infinity
Console.WriteLine (-1.0 / -0.0); // Infinity

// Dividing zero by zero, or subtracting infinity from infinity, results in a NaN:

Console.WriteLine ( 0.0 / 0.0); // NaN
Console.WriteLine ((1.0 / 0.0) - (1.0 / 0.0)); // NaN

// When using ==, a NaN value is never equal to another value, even another NaN value:
Console.WriteLine (0.0 / 0.0 == double.NaN); // False

// To test whether a value is NaN, you must use the float.IsNaN or double.IsNaN method:
Console.WriteLine (double.IsNaN (0.0 / 0.0)); // True

// When using object.Equals, however, two NaN values are equal:

Console.WriteLine (object.Equals (0.0 / 0.0, double.NaN)); // True

Real Number Rounding Errors

// Unlike decimal, float and double can cannot precisely represent numbers with a base-10
// fractional component:
{
float x = 0.1f; // Not quite 0.1
Console.WriteLine (x + x + x + x + x + x + x + x + x + x); // 1.0000001
}
{
decimal y = 0.1m; // Exactly 0.1
Console.WriteLine (y + y + y + y + y + y + y + y + y + y); // 1.0
}

// Neither double nor decimal can precisely represent a fractional number whose base 10
// representation is recurring:

decimal m = 1M / 6M; // 0.1666666666666666666666666667M

double d = 1.0 / 6.0; // 0.16666666666666666

m.Dump ("m"); d.Dump ("d");

// This leads to accumulated rounding errors:

decimal notQuiteWholeM = m+m+m+m+m+m; // 1.0000000000000000000000000002M
double notQuiteWholeD = d+d+d+d+d+d; // 0.99999999999999989

// which breaks equality and comparison operations:

Console.WriteLine (notQuiteWholeM == 1M); // False
Console.WriteLine (notQuiteWholeD < 1.0); // True

Boolean Type and Operators

Strings and Characters

Arrays

Variables and Parameters

https://www.albahari.com/nutshell/E12-CH02.aspx 3/4
4/18/24, 1:15 AM C# in a Nutshell - Code Listings
Expressions and Operators

Null Operators

Statements

Namespaces

C# 12
in a Nutshell
About the Book

Code Listings
C# 12 in a Nutshell
C# 10 in a Nutshell
C# 9.0 in a Nutshell
C# 8.0 in a Nutshell
C# 7.0 in a Nutshell

Extras

Contact

Buy print or Kindle edition

Buy PDF edition

Read via O'Reilly subscription

https://www.albahari.com/nutshell/E12-CH02.aspx 4/4