Coding Expressions and Statements

In Chapter 1, you saw how to write, compile, and execute a C# program. The example program had a single statement in the Main method. In this chapter, you’ll learn how to write more statements and add logic to your program. For efficiency, many of the examples in the rest of the book are snippets, but you can still add these statements inside of a Main method to compile and get a better feel for C# syntax. There will be plenty of complete programs too.

Writing Simple Statements

By combining language operators and syntax, you can build expressions and statements in C#. Here are a few examples of simple C# statements.

Each of the examples in the previous code listing have common syntactical elements: type, variable identifier, assignment operator, value, and statement completion. The types are int, char, and string, which represent a number, a character, and a sequence of characters respectively. These are a few of the several built-in types that C# offers. Variables are a name that can be used in later code. The = operator assigns the right-hand side of the expression to the left-hand side. Each statement ends with a semicolon.

The previous example showed how to declare a variable and perform assignment at the same time, but that isn’t necessarily required. As long as you declare a variable before trying to use it, you’ll be okay. Here’s a separate declaration.

And the variable’s later assignment.

Note: C# is case sensitive, so “title” and “Title” are two separate variable names.  

Overview of C# Types and Operators

C# is a strongly typed language, meaning that the compiler won’t implicitly convert between incompatible types. For example, you can’t assign a string to an int or an int to a string—at least, not implicitly. The following code will not compile.

The “359” with double quotes is a string, and the 7 without quotes is an int. While you can’t perform conversions implicitly, there are ways to do this explicitly. For example, you’ll often receive text input from a user that should be an int or another type. The following code listing shows a couple examples of how to perform such tasks explicitly.

In the previous listing, Parse will convert the string to an int if the string represents a valid int. Calling ToString on any value will always produce a string that will compile.

In addition to the previous conversion examples, C# has a cast operator that lets you convert between types that allow explicit conversions. Let’s say you have a double, which is a 64-bit floating point type, and want to assign that to an int, which is a 32-bit whole number. You could cast it like this:

Without the cast operator, you would receive a compiler error because a double is not an int. Essentially, the C# compiler is protecting you from shooting yourself in the foot because assigning a double to an int means that you lose precision. In the previous example, roundedLength becomes 5. Using the cast operator allows you to tell the C# compiler that you know this operation could be dangerous in the wrong circumstances, but makes sense for your particular situation.

The following table lists the built-in types so you can see what is available:

Table 1: Built-In Types

You should add a suffix to a number when the meaning would be ambiguous. In the following example, the m suffix ensures the 9.95 literal is treated as a decimal number:

You can assign Unicode values directly to a char. The following example shows how to assign a carriage return.

You can also obtain the Unicode value of a character with a cast operator as shown here.

So far, you’ve only seen statements with the assignment operator, but C# has many other operators that allow you to perform all of the logical operations you would expect of any general purpose programming language. The following table lists some of the available operators.

Table 2: C# Operators

Prefix operators change the value of the variable before assignment, and postfix operators change a variable after assignment, as demonstrated in the following sample.

In the previous code listing, both val1 and val2 are 6. The val3 variable is 1, but val4 is 2 because the postfix operator evaluates after assignment.

The ternary operator offers simple syntax for if-then-else logic. Here’s an example:

On the left side of ? is a Boolean expression, priceGain > 2m. If that is true, which it is in this example, the ternary operator returns the first value between ? and :, which is "Buy". Otherwise, the ternary operator would return the value after the :, which is "Sell". This statement assigns the result of the ternary operator, "Buy", to the string variable, action.

In addition to the built-in types, the FCL has many types you will use on a daily basis. One of these is DateTime, which represents a date and time. Here’s a quick demo showing a couple things you can do with a DateTime.

The previous code shows how to get the current DateTime, a short representation of a date (e.g., 12/8/2014), a long representation of the date and time (everything spelled out), the default numeric representation, and how to use DateTime methods for calculations.

Tip: Search the FCL before creating your own library of types. Many of the common types you use every day, like DateTime, will already exist.

Operator Precedence and Associativity

The C# operators listed in Table 2 outlines operators in their general order of precedence. The precedence defines which operators evaluate first. Operators of higher precedence evaluate before operators of lower precedence.

Assignment and conditional operators are right-associative and all other operators are left-associative. You can change the normal order of operations by using parentheses as shown in the following code listing.

In the previous code, result1 is 17, but result2 is 25.

Formatting Strings

There are different ways to build and format strings in C#: concatenation, numeric format strings, or string interpolation. The following code listing demonstrates string concatenation.

This prints “Hello, Joe!” to the console. The following example does the same thing, but uses string.Format.

The string.Format takes a format string that has numeric placeholders in curly braces. It’s 0-based, so the first placeholder is {0}. The parameters following the string are placed into the format string in the order they appear. Since name is the first (and only) parameter, string.Format replaces {0} with Joe to create "Hello, Joe!" as a string. As a convenience in console applications, WriteLine uses the same formatting. The following code accomplishes the same task as the two lines in the previous code listing.

Going a little further, string formatting is more powerful, allowing you to specify column lengths, alignment, and value formatting as shown in the following code.

In this example, the first placeholder consumes 10 characters in length. The default alignment is right, but the minus sign changes that to align on the left. On the second placeholder, the C is a currency format string.

Note: There are many string formatting options. You can visit https://msdn.microsoft.com/en-us/library/dwhawy9k(v=vs.110).aspx for standard formats, https://msdn.microsoft.com/en-us/library/0c899ak8(v=vs.110).aspx for custom formats, and https://msdn.microsoft.com/en-us/library/az4se3k1(v=vs.110).aspx for DateTime formats.

C# 6 introduced a new way to format strings, called string interpolation. It’s a shorthand syntax that lets you replace numeric placeholders with expressions as follows:

The $ prefix is required. Here, the value from the item variable replaces {item} and the value from the amount variable replaces {amount}. Similar to numeric placeholders, you can include additional formatting.

The nameof operator prints out the name “item”, demonstrating how you can use expressions in placeholders. You can also see the space and currency formatting on item and amount.

Branching Statements

You can use either an if—else or switch statement in your code for branching logic. When you only need to execute code for a true condition, use an if statement as in the following sample.

The curly braces are optional in this example because there is only one statement to execute if priceGain > 2m. However, they would be required for multiple statements. This is true for all branching and logic statements. You can also have an else case, as shown in the following listing.

Whenever the Boolean condition of the if statement is false, as it is in the previous code sample where priceGain <= 2m, the else clause executes. In this case, action3 becomes "Buy". Of course, you can have multiple conditions by adding more else if clauses.

In the previous example, you can see a more complex Boolean expression in the else if clause. When priceGain is 2.5, the value of action4 becomes "Do Nothing". The && is a logical operator that succeeds if both the expression on the left and right are true. The logical || operator succeeds if either the expression on the left or right is true. These operators also perform short-circuit operations where the expression on the right doesn’t execute if the expression on the left causes the whole expression to not be true. In the case of the else if in Code Listing 25, if priceGain were 2m or less, the && operator would not evaluate the priceGain <= 3 expression because the entire operation is already false. Once a branch of the if statement executes, no other branches are evaluated or executed.

Notice that I set action4 to null. The null keyword means no value. I’ll talk about null in the next chapter and explain where you can use it.

An if statement is good for either simple branching or complex conditions, such as the previous else if clause. However, when you have multiple cases and all expressions are constant values, such as an int or string, you might prefer a switch statement. The following example uses a switch statement to select appropriate equipment based on a weather forecast.

The switch statement tries to match a value, currentWeather in this example, with one of its case statements. It uses the default case for no match. All case statements must be terminated with a break statement. The only time fall-through is allowed is when a case has no body, as demonstrated with the "cold" case and default, which both set equipment to "jacket". Since currentWeather is "rain", equipment becomes "umbrella" and no other cases execute.

Beyond branching statements, you also need the ability to perform a set of operations multiple times, which is where C# loops come in. Before discussing loops, let’s look at arrays and collections, which hold data that loops can use.

Arrays and Collections

Sometimes you need to group a number of items together in a collection to manage them in memory. For this, you can either use arrays or one of the many collection types in the .NET Framework. The following sample demonstrates how to create an array.

Here, I’ve declared and initialized the array with three values. Arrays and collections are 0-based, so firstOdd is 1 and lastOdd is 5. The [x] syntax, where x is a number, is referred to as an indexer because it allows you to access the array at the location specified by the index. Here’s another example that uses string instead of int.

In this example, I instantiated an array to hold three strings. All of the strings equal null by default. This code sets the second string to "Joe".

In addition to arrays, you can use all types of data structures, such as List, Stack, Queue, and more, which are part of the FCL. The following example shows how to use a List. Remember to add a using clause for System.Collections.Generic to use the List<T> type.

In this sample, I instantiated a new List collection. The <decimal> is a generic type indicating that this is a strongly typed list that can only hold values of type decimal; it’s a List of decimal. That list has two items. Notice how I used the array-like indexer syntax to read the second item in the (0-based) stockPrices list.

Looping Statements

C# supports several loops, including for, foreach, while, and do. The code listings that follow perform similar logic.

The for loop initializes i to 0, makes sure i is less than the number of items in the temperature array, executes the Console.WriteLine, and then increments i. It continues executing until the condition (i < temperatures.Length) is false, and then moves on to the next statement in the program.

The foreach loop used in Code Listing 31 is simpler and will execute for each value in the temperatures array.

Next is an example of a while loop.

The while loop evaluates the condition and executes if it’s true. Notice that I initialized tempCount to 0 and increment tempCount inside of the loop on each iteration.

Finally, the following example shows how to write a do-while loop.

A do-while loop is good for when you want to execute logic at least one time. This example increments tempCount2 as a parameter to Console.WriteLine. Remember, the postfix operator changes the variable after evaluation.

Wrapping Up

Here’s a calculator program that pulls together some of the concepts from this chapter, plus some extra features. You can type this into your editor and execute it for practice.

The previous program demonstrates a do-while loop, an if statement, a switch statement, and a basic console communication with the user.

There are a couple string features here that you haven’t seen yet. The first is where the program uses Console.ReadLine to read input text from the user for the input string. Notice the indexer syntax to read the first character from the string. You can read any character of a string this way. Also, look at the bottom of the program where it prints "Your result is " + result, which concatenates a string with the number. Using the + operator for concatenation is a simple way to build strings. Another way to build a string is with a type named StringBuilder, which you can use like this:

You’ll also need to add a using System.Text; clause to the top of the file. After you’ve used the concatenate operator, +, about four times on the same string, you might consider rewriting with a StringBuilder instead. The string type is immutable, meaning that you can’t modify it. This also means that every concatenation operation causes the CLR to create a new string in-memory.

The calculator program also has multiline and single-line comments that aren’t compiled, but help you document the code as you need. Here’s the multi-line comment:

Here’s the single-line comment:

An extension of the single-line comment is a convention that uses three slashes and a set of XML tags, known as documentation comments.

Summary

C# has a full set of operators and types that allow you to write a wide range of expressions and statements. With branching statements and loops, you can write logic of your choosing. All of the code in this chapter has been in the Main method, but clearly that’s inadequate and you’ll quickly grow out of that. The next chapter explores some new C# features to help organize code with methods and properties.