Most operators are binary, meaning that they work on two operands, as shown in the following pseudocode:

var resultOfOperation = firstOperand operator secondOperand;

Examples of binary operators include adding and multiplying, as shown in the following code:

int x = 5;
int y = 3;
int resultOfAdding = x + y;
int resultOfMultiplying = x * y;

Some operators are unary, meaning they work on a single operand, and can apply before or after the operand, as shown in the following pseudocode:

var resultOfOperation = onlyOperand operator; 
var resultOfOperation2 = operator onlyOperand;

Examples of unary operators include incrementors and retrieving a type or its size in bytes, as shown in the following code:

int x = 5;
int postfixIncrement = x++;
int prefixIncrement = ++x;
Type theTypeOfAnInteger = typeof(int); 
int howManyBytesInAnInteger = sizeof(int);

var resultOfOperation = firstOperand firstOperator 
  secondOperand secondOperator thirdOperand;

Exploring unary operators

Exploring binary arithmetic operators

If the first operand is a floating-point number, such as g with the value 11.0, then the divide operator returns a floating-point value, such as 3.6666666666665, rather than a whole number.

Assignment operators

You have already been using the most common assignment operator, =.

int p = 6;
p += 3; // equivalent to p = p + 3;
p -= 3; // equivalent to p = p - 3;
p *= 3; // equivalent to p = p * 3;
p /= 3; // equivalent to p = p / 3;

Exploring logical operators

1. Use your preferred coding tool to add a new console app to the Chapter03 workspace/solution named BooleanOperators.
   1. In Visual Studio Code, select BooleanOperators as the active OmniSharp project. When you see the pop-up warning message saying that required assets are missing, click Yes to add them.
   2. In Visual Studio, set the start up project for the solution to the current selection.

      Good Practice: Remember to statically import the System.Console type to simplify statements.

2. In Program.cs, add statements to declare two Boolean variables with values of true and false, and then output truth tables showing the results of applying AND, OR, and XOR (exclusive OR) logical operators, as shown in the following code:

   bool a = true;
   bool b = false;
   WriteLine($"AND  | a     | b    ");
   WriteLine($"a    | {a & a,-5} | {a & b,-5} ");
   WriteLine($"b    | {b & a,-5} | {b & b,-5} ");
   WriteLine();
   WriteLine($"OR   | a     | b    ");
   WriteLine($"a    | {a | a,-5} | {a | b,-5} ");
   WriteLine($"b    | {b | a,-5} | {b | b,-5} ");
   WriteLine();
   WriteLine($"XOR  | a     | b    ");
   WriteLine($"a    | {a ^ a,-5} | {a ^ b,-5} ");
   WriteLine($"b    | {b ^ a,-5} | {b ^ b,-5} ");
   

3. Run the code and note the results, as shown in the following output:

   AND  | a     | b    
   a    | True  | False 
   b    | False | False 
   OR   | a     | b    
   a    | True  | True  
   b    | True  | False 
   XOR  | a     | b    
   a    | False | True  
   b    | True  | False
   

Exploring conditional logical operators

A function executes statements and then returns a value. That value could be a Boolean value like true that is used in a Boolean operation. Let's make use of conditional logical operators:

Exploring bitwise and binary shift operators

Let's explore bitwise and binary shift operators:

The 80 result is because the bits in it were shifted three columns to the left, so the 1-bits moved into the 64- and 16-bit columns and 64 + 16 = 80. This is the equivalent of multiplying by 8, but CPUs can perform a bit-shift faster. The 3 result is because the 1-bits in b were shifted one column into the 2- and 1-bit columns.

We can illustrate the operations by converting the integer values into binary strings of zeros and ones:

1. At the bottom of Program.cs, add a function to convert an integer value into a binary (Base2) string of up to eight zeros and ones, as shown in the following code:

   static string ToBinaryString(int value)
   {
     return Convert.ToString(value, toBase: 2).PadLeft(8, '0');
   }
   

2. Above the function, add statements to output a, b, and the results of the various bitwise operators, as shown in the following code:

   WriteLine();
   WriteLine("Outputting integers as binary:");
   WriteLine($"a =     {ToBinaryString(a)}");
   WriteLine($"b =     {ToBinaryString(b)}");
   WriteLine($"a & b = {ToBinaryString(a & b)}");
   WriteLine($"a | b = {ToBinaryString(a | b)}");
   WriteLine($"a ^ b = {ToBinaryString(a ^ b)}");
   

3. Run the code and note the results, as shown in the following output:

   Outputting integers as binary:
   a =     00001010
   b =     00000110
   a & b = 00000010
   a | b = 00001110
   a ^ b = 00001100
   

Miscellaneous operators

nameof and sizeof are convenient operators when working with types:

• nameof returns the short name (without the namespace) of a variable, type, or member as a string value, which is useful when outputting exception messages.
• sizeof returns the size in bytes of simple types, which is useful for determining the efficiency of data storage.

int age = 47;
// How many operators in the following statement?
char firstDigit = age.ToString()[0];
// There are four operators:
// = is the assignment operator
// . is the member access operator
// () is the invocation operator
// [] is the indexer access operator

Understanding selection statements

Branching with the if statement

The if statement can be combined with other if statements as else if branches, as shown in the following code:

if (expression1)
{
  // runs if expression1 is true
}
else if (expression2)
{
  // runs if expression1 is false and expression2 if true
}
else if (expression3)
{
  // runs if expression1 and expression2 are false
  // and expression3 is true
}
else
{
  // runs if all expressions are false
}

Let's write some code to explore selection statements like if:

1. Use your preferred coding tool to add a new Console Application to the Chapter03 workspace/solution named SelectionStatements.
2. In Visual Studio Code, select SelectionStatements as the active OmniSharp project.
3. In Program.cs, type statements to check if a password is at least eight characters, as shown in the following code:

   string password = "ninja";
   if (password.Length < 8)
   {
     WriteLine("Your password is too short. Use at least 8 characters.");
   }
   else
   {
     WriteLine("Your password is strong.");
   }
   

4. Run the code and note the result, as shown in the following output:

    Your password is too short. Use at least 8 characters.
   

Why you should always use braces with if statements

if (password.Length < 8)
  WriteLine("Your password is too short. Use at least 8 characters."); 
else
  WriteLine("Your password is strong.");

This style of if statement should be avoided because it can introduce serious bugs, for example, the infamous #gotofail bug in Apple's iPhone iOS operating system.

Just because you can leave out the curly braces doesn't mean you should. Your code is not "more efficient" without them; instead, it is less maintainable and potentially more dangerous.

Pattern matching with the if statement

1. Add statements so that if the value stored in the variable named o is an int, then the value is assigned to the local variable named i, which can then be used inside the if statement. This is safer than using the variable named o because we know for sure that i is an int variable and not something else, as shown in the following code:

   // add and remove the "" to change the behavior
   object o = "3"; 
   int j = 4;
   if (o is int i)
   {
     WriteLine($"{i} x {j} = {i * j}");
   }
   else
   {
     WriteLine("o is not an int so it cannot multiply!");
   }
   

2. Run the code and view the results, as shown in the following output:

   o is not an int so it cannot multiply!
   

3. Delete the double-quote characters around the "3" value so that the value stored in the variable named o is an int type instead of a string type.
4. Rerun the code to view the results, as shown in the following output:

   3 x 4 = 12
   

Branching with the switch statement

• The break keyword (like case 1 in the following code)
• Or the goto case keywords (like case 2 in the following code)
• Or they should have no statements (like case 3 in the following code)
• Or the goto keyword that references a named label (like case 5 in the following code)
• Or the return keyword to leave the current function (not shown in the code)

Let's write some code to explore the switch statements:

Pattern matching with the switch statement

Let's see an example of pattern matching with the switch statement using a folder path. If you are using macOS, then swap the commented statement that sets the path variable and replace my username with your user folder name:

In .NET, there are multiple subtypes of Stream, including FileStream and MemoryStream. In C# 7.0 and later, your code can more concisely branch, based on the subtype of stream, and declare and assign a local variable to safely use it. You will learn more about the System.IO namespace and the Stream type in Chapter 9, Working with Files, Streams, and Serialization.

Additionally, case statements can include a when keyword to perform more specific pattern matching. In the first case statement in the preceding code, s will only be a match if the stream is a FileStream and its CanWrite property is true.

Simplifying switch statements with switch expressions

In C# 8.0 or later, you can simplify switch statements using switch expressions.

Let's implement the previous code that used a switch statement using a switch expression so that you can compare the two styles:

Understanding iteration statements

Looping with the while statement

Looping with the do statement

1. Type statements to define a do loop, as shown in the following code:

   string? password;
   do
   {
     Write("Enter your password: "); 
     password = ReadLine();
   }
   while (password != "Pa$$w0rd");
   WriteLine("Correct!");
   

2. Run the code, and note that you are prompted to enter your password repeatedly until you enter it correctly, as shown in the following output:

   Enter your password: password 
   Enter your password: 12345678 
   Enter your password: ninja
   Enter your password: correct horse battery staple 
   Enter your password: Pa$$w0rd
   Correct!
   

3. As an optional challenge, add statements so that the user can only make ten attempts before an error message is displayed.

Looping with the for statement

• An initializer expression, which executes once at the start of the loop.
• A conditional expression, which executes on every iteration at the start of the loop to check whether the looping should continue.
• An iterator expression, which executes on every loop at the bottom of the statement.

The for statement is commonly used with an integer counter. Let's explore some code:

1. Type a for statement to output the numbers 1 to 10, as shown in the following code:

   for (int y = 1; y <= 10; y++)
   {
     WriteLine(y);
   }
   

2. Run the code to view the result, which should be the numbers 1 to 10.

Looping with the foreach statement

It is used to perform a block of statements on each item in a sequence, for example, an array or collection. Each item is usually read-only, and if the sequence structure is modified during iteration, for example, by adding or removing an item, then an exception will be thrown.

Try the following example:

Understanding how foreach works internally

A creator of any type that represents multiple items, like an array or collection, should make sure that a programmer can use the foreach statement to enumerate through the type's items.

Technically, the foreach statement will work on any type that follows these rules:

1. The type must have a method named GetEnumerator that returns an object.
2. The returned object must have a property named Current and a method named MoveNext.
3. The MoveNext method must change the value of Current and return true if there are more items to enumerate through or return false if there are no more items.

The compiler turns the foreach statement in the preceding example into something like the following pseudocode:

IEnumerator e = names.GetEnumerator();
while (e.MoveNext())
{
  string name = (string)e.Current; // Current is read-only!
  WriteLine($"{name} has {name.Length} characters.");
}

Due to the use of an iterator, the variable declared in a foreach statement cannot be used to modify the value of the current item.

Casting and converting between types

You will often need to convert values of variables between different types. For example, data input is often entered as text at the console, so it is initially stored in a variable of the string type, but it then needs to be converted into a date/time, or number, or some other data type, depending on how it should be stored and processed.

Sometimes you will need to convert between number types, like between an integer and a floating point, before performing calculations.

Casting numbers implicitly and explicitly

Converting with the System.Convert type

Let's write some code to see this in action:

1. At the top of Program.cs, statically import the System.Convert class, as shown in the following code:

   using static System.Convert;
   

2. At the bottom of Program.cs, type statements to declare and assign a value to a double variable, convert it to an integer, and then write both values to the console, as shown in the following code:

   double g = 9.8;
   int h = ToInt32(g); // a method of System.Convert
   WriteLine($"g is {g} and h is {h}");
   

3. Run the code and view the result, as shown in the following output:

   g is 9.8 and h is 10
   

Rounding numbers

You have now seen that the cast operator trims the decimal part of a real number and that the System.Convert methods round up or down. However, what is the rule for rounding?

Understanding the default rounding rules

In British primary schools for children aged 5 to 11, pupils are taught to round up if the decimal part is .5 or higher and round down if the decimal part is less.

1. Type statements to declare and assign an array of double values, convert each of them to an integer, and then write the result to the console, as shown in the following code:

   double[] doubles = new[]
     { 9.49, 9.5, 9.51, 10.49, 10.5, 10.51 };
   foreach (double n in doubles)
   {
     WriteLine($"ToInt32({n}) is {ToInt32(n)}");
   }
   

2. Run the code and view the result, as shown in the following output:

   ToInt32(9.49) is 9
   ToInt32(9.5) is 10
   ToInt32(9.51) is 10
   ToInt32(10.49) is 10
   ToInt32(10.5) is 10
   ToInt32(10.51) is 11
   

We have shown that the rule for rounding in C# is subtly different from the primary school rule:

• It always rounds down if the decimal part is less than the midpoint .5.
• It always rounds up if the decimal part is more than the midpoint .5.
• It will round up if the decimal part is the midpoint .5 and the non-decimal part is odd, but it will round down if the non-decimal part is even.

Taking control of rounding rules

You can take control of the rounding rules by using the Round method of the Math class:

Converting from any type to a string

Let's convert some types into a string:

1. Type statements to declare some variables, convert them to their string representation, and write them to the console, as shown in the following code:

   int number = 12; 
   WriteLine(number.ToString());
   bool boolean = true; 
   WriteLine(boolean.ToString());
   DateTime now = DateTime.Now; 
   WriteLine(now.ToString());
   object me = new(); 
   WriteLine(me.ToString());
   

2. Run the code and view the result, as shown in the following output:

   12
   True
   02/28/2021 17:33:54
   System.Object
   

Converting from a binary object to a string

When you have a binary object like an image or video that you want to either store or transmit, you sometimes do not want to send the raw bits because you do not know how those bits could be misinterpreted, for example, by the network protocol transmitting them or another operating system that is reading the store binary object.

1. Type statements to create an array of bytes randomly populated with byte values, write each byte nicely formatted to the console, and then write the same bytes converted to Base64 to the console, as shown in the following code:

   // allocate array of 128 bytes
   byte[] binaryObject = new byte[128];
   // populate array with random bytes
   (new Random()).NextBytes(binaryObject); 
   WriteLine("Binary Object as bytes:");
   for(int index = 0; index < binaryObject.Length; index++)
   {
     Write($"{binaryObject[index]:X} ");
   }
   WriteLine();
   // convert to Base64 string and output as text
   string encoded = ToBase64String(binaryObject);
   WriteLine($"Binary Object as Base64: {encoded}");
   

   By default, an int value would output assuming decimal notation, that is, base10. You can use format codes such as :X to format the value using hexadecimal notation.

2. Run the code and view the result, as shown in the following output:

   Binary Object as bytes:
   B3 4D 55 DE 2D E BB CF BE 4D E6 53 C3 C2 9B 67 3 45 F9 E5 20 61 7E 4F 7A 81 EC 49 F0 49 1D 8E D4 F7 DB 54 AF A0 81 5 B8 BE CE F8 36 90 7A D4 36 42
   4 75 81 1B AB 51 CE 5 63 AC 22 72 DE 74 2F 57 7F CB E7 47 B7 62 C3 F4 2D
   61 93 85 18 EA 6 17 12 AE 44 A8 D B8 4C 89 85 A9 3C D5 E2 46 E0 59 C9 DF
   10 AF ED EF 8AA1 B1 8D EE 4A BE 48 EC 79 A5 A 5F 2F 30 87 4A C7 7F 5D C1 D
   26 EE
   Binary Object as Base64: s01V3i0Ou8++TeZTw8KbZwNF +eUgYX5PeoHsSfBJHY7U99tU r6CBBbi+zvg2kHrUNkIEdYEbq1HOBWOsInLedC9Xf8vnR7diw/QtYZOFGOoGFxKuRKgNuEyJha k81eJG4FnJ3xCv7e+KobGN7kq+SO x5pQpfLzCHSsd/XcENJu4=
   

Parsing from strings to numbers or dates and times

The second most common conversion is from strings to numbers or date and time values.

The opposite of ToString is Parse. Only a few types have a Parse method, including all the number types and DateTime.

Let's see Parse in action:

As well as the preceding exception message, you will see a stack trace. I have not included stack traces in this book because they take up too much space.

Avoiding exceptions using the TryParse method

The out keyword is required to allow the TryParse method to set the count variable when the conversion works.

Let's see TryParse in action:

You can also use methods of the System.Convert type to convert string values into other types; however, like the Parse method, it gives an error if it cannot convert.

Handling exceptions

When an exception is thrown, the thread is suspended and if the calling code has defined a try-catch statement, then it is given a chance to handle the exception. If the current method does not handle it, then its calling method is given a chance, and so on up the call stack.

As you have seen, the default behavior of a console application or a .NET Interactive notebook is to output a message about the exception, including a stack trace, and then stop running the code. The application is terminated. This is better than allowing the code to continue executing in a potentially corrupt state. Your code should only catch and handle exceptions that it understands and can properly fix.

Wrapping error-prone code in a try block

We don't have to do anything inside the catch block. Let's see this in action:

1. Use your preferred coding tool to add a new Console Application to the Chapter03 workspace/solution named HandlingExceptions.
2. In Visual Studio Code, select HandlingExceptions as the active OmniSharp project.
3. Type statements to prompt the user to enter their age and then write their age to the console, as shown in the following code:

   WriteLine("Before parsing"); 
   Write("What is your age? "); 
   string? input = ReadLine(); // or use "49" in a notebook
   try
   {
     int age = int.Parse(input); 
     WriteLine($"You are {age} years old.");
   }
   catch
   {
   }
   WriteLine("After parsing");
   

   You will see the following compiler message: Warning CS8604 Possible null reference argument for parameter 's' in 'int int.Parse(string s)'. By default in new .NET 6 projects, Microsoft has enabled nullable reference types so you will see many more compiler warnings like this. In production code, you should add code to check for null and handle that possibility appropriately. In this book, I will not include these null checks because the code samples are not designed to be production quality and null checks everywhere will clutter the code and use up valuable pages. In this case, it is impossible for input to be null because the user must press Enter for ReadLine to return and that will return an empty string. You will see hundreds of more examples of potentially null variables throughout the code samples in this book. Those warnings are safe to ignore for the book code examples. You only need similar warnings when you write your own production code. You will see more about null handling in Chapter 6, Implementing Interfaces and Inheriting Classes.

   This code includes two messages to indicate before parsing and after parsing to make clearer the flow through the code. These will be especially useful as the example code grows more complex.

4. Run the code, enter 49, and view the result, as shown in the following output:

   Before parsing
   What is your age? 49
   You are 49 years old. 
   After parsing
   

5. Run the code, enter Kermit, and view the result, as shown in the following output:

   Before parsing
   What is your age? Kermit
   After parsing
   

Catching all exceptions

1. Add an exception variable declaration to the catch block and use it to write information about the exception to the console, as shown in the following code:

   catch (Exception ex)
   {
     WriteLine($"{ex.GetType()} says {ex.Message}");
   }
   

2. Run the code, enter Kermit again, and view the result, as shown in the following output:

   Before parsing
   What is your age? Kermit
   System.FormatException says Input string was not in a correct format. 
   After parsing
   

Catching specific exceptions

The order in which you catch exceptions is important. The correct order is related to the inheritance hierarchy of the exception types. You will learn about inheritance in Chapter 5, Building Your Own Types with Object-Oriented Programming. However, don't worry too much about this—the compiler will give you build errors if you get exceptions in the wrong order anyway.

Catching with filters

Write("Enter an amount: ");
string? amount = ReadLine();
try
{
  decimal amountValue = decimal.Parse(amount);
}
catch (FormatException) when (amount.Contains("$"))
{
  WriteLine("Amounts cannot use the dollar sign!");
}
catch (FormatException)
{
  WriteLine("Amounts must only contain digits!");
}

Checking for overflow

Earlier, we saw that when casting between number types, it was possible to lose information, for example, when casting from a long variable to an int variable. If the value stored in a type is too big, it will overflow.

Throwing overflow exceptions with the checked statement

Disabling compiler overflow checks with the unchecked statement

A related keyword is unchecked. This keyword switches off overflow checks performed by the compiler within a block of code. Let's see how to do this:

Of course, it would be rare that you would want to explicitly switch off a check like this because it allows an overflow to occur. But perhaps you can think of a scenario where you might want that behavior.

Practicing and exploring

Test your knowledge and understanding by answering some questions, get some hands-on practice, and explore with deeper research into this chapter's topics.

Exercise 3.1 – Test your knowledge

Answer the following questions:

1. What happens when you divide an int variable by 0?
2. What happens when you divide a double variable by 0?
3. What happens when you overflow an int variable, that is, set it to a value beyond its range?
4. What is the difference between x = y++; and x = ++y;?
5. What is the difference between break, continue, and return when used inside a loop statement?
6. What are the three parts of a for statement and which of them are required?
7. What is the difference between the = and == operators?
8. Does the following statement compile?

   for ( ; true; ) ;
   

9. What does the underscore _ represent in a switch expression?
10. What interface must an object implement to be enumerated over by using the foreach statement?

Exercise 3.2 – Explore loops and overflow

What will happen if this code executes?

int max = 500;
for (byte i = 0; i < max; i++)
{
  WriteLine(i);
}

Create a console application in Chapter03 named Exercise02 and enter the preceding code. Run the console application and view the output. What happens?

What code could you add (don't change any of the preceding code) to warn us about the problem?

Exercise 3.3 – Practice loops and operators

FizzBuzz is a group word game for children to teach them about division. Players take turns to count incrementally, replacing any number divisible by three with the word fizz, any number divisible by five with the word buzz, and any number divisible by both with fizzbuzz.

Create a console application in Chapter03 named Exercise03 that outputs a simulated FizzBuzz game counting up to 100. The output should look something like Figure 3.2:

Figure 3.2: A simulated FizzBuzz game output

Exercise 3.4 – Practice exception handling

Create a console application in Chapter03 named Exercise04 that asks the user for two numbers in the range 0-255 and then divides the first number by the second:

Enter a number between 0 and 255: 100
Enter another number between 0 and 255: 8
100 divided by 8 is 12

Write exception handlers to catch any thrown errors, as shown in the following output:

Enter a number between 0 and 255: apples
Enter another number between 0 and 255: bananas 
FormatException: Input string was not in a correct format.

Exercise 3.5 – Test your knowledge of operators

What are the values of x and y after the following statements execute?

1. Increment and addition operators:

   x = 3;
   y = 2 + ++x;
   

2. Binary shift operators:

   x = 3 << 2;
   y = 10 >> 1;
   

3. Bitwise operators:

   x = 10 & 8;
   y = 10 | 7;
   

Exercise 3.6 – Explore topics

Use the links on the following page to learn about the topics covered in this chapter in more detail: