Chapter 4. Types and References: Getting the Reference

What would your apps be without data? Think about it for a minute. Without data, your programs are... well, it’s actually hard to imagine writing code without data. You need information from your users, and you use that to look up or produce new information to give back to them. In fact, almost everything you do in programming involves working with data in one way or another. In this chapter, you’ll learn the ins and outs of C#’s data types and references, see how to work with data in your program, and even learn a few more things about objects (guess what...objects are data, too!).

Ryan is looking to improve his game

Ryan is a game master—a really good one. He hosts a group that meets at his place every week to play different role-playing games (or RPGs), and like any good game master, he really works hard to keep things interesting for the players.

Storytelling, fantasy, and mechanics

Ryan is a particularly good storyteller, and over the last few months he’s created an intricate fantasy world for his party. But he’s not so happy with the mechanics of the game that they’ve been playing. Can we find a way to help Ryan improve his RPG?

Character sheets store different types of data on paper

If you’ve ever played an RPG, you’ve seen character sheets: a page with details, statistics, background information, and any other notes you’ll see about a character. If you wanted to make a class to hold a character sheet, what types would you use for the fields?

A variable’s type determines what kind of data it can store

There are many types built into C#, and you’ll use them to store many different kinds of data. You’ve already seen some of the most common ones, like int, string, bool, and float. But there are a few that you haven’t seen, and they can really come in handy, too.

Here are some types you’ll use a lot.

int can store any whole number from –2,147,483,648 to 2,147,483,647. Whole numbers don’t have decimal points.
float can store real numbers from ±1.5 × 10^–45 to ±3.4 × 10³⁸ with up to 8 significant figures.
string can hold text of any length (including the empty string "").
double can store real numbers from ±5.0 × 10^–324 to ±1.7 × 10³⁰⁸ with up to 16 significant figures. Double is really common when you’re working with XAML properties.
bool is a Boolean value—it’s either true or false. You’ll use it to represent anything that only has two options: it can either be one thing or another, but nothing else.

C# has several types for whole numbers

C# has several different types for whole numbers. This may seem a little weird. Why have so many types for numbers without decimals? For most of the programs in this book, it won’t matter if we use an int or a long. But if you’re writing a program that has to keep track of millions and millions of whole number values, then choosing a smaller whole number type like byte instead of a bigger type like long can save you a lot of memory.

byte can store any whole number between 0 and 255.
sbyte can store any whole number from –128 to 127.
short can store any whole number from –32,768 to 32,767.
long can store any whole number from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.

Did you notice that byte only stores positive numbers, while sbyte stores negative numbers? They both have 256 possible values. The difference is that like short and long, sbyte can have a negative sign—which is why those are called signed types, and the “s” in sbyte stands for signed. And just like byte is the unsigned version of sbyte, there are unsigned versions of short, int, and long that start with “u”:

ushort can store any whole number from 0 to 65,535.
uint can store any whole number from 0 to 4,294,967,295.
ulong can store any whole number from 0 to 18,446,744,073,709,551,615.

Types for storing really HUGE and really tiny numbers

Sometimes seven significant figures just isn’t precise enough. And, believe it or not, sometimes 10³⁸ isn’t big enough and 10^–45 isn’t small enough. A lot of programs written for finance or scientific research run into these problems all the time, so C# gives us multiple floating-point types to handle huge and tiny values:

float can store any number from ±1.5 × 10^–45 to ±3.4 × 10³⁸ with 7 significant digits.
double can store any number from ±5.0 × 10^–324 to ±1.7 × 10³⁰⁸ with 15-16 significant digits.
decimal can store any number from ±1.0 × 10^–28 to ±7.9 × 10²⁸ with 28–29 significant digits. When your program needs to deal with money or currency, you always want to use a decimal to store the number.

Note

The decimal type has a lot more precision (way more significant digits) which is why it’s appropriate for financial calculations.

Floating-point numbers Up Close

The float and double types are called “floating-point” because the decimal point can move (as opposed to a “fixed point” number, which always has the same number of decimal places). That range may look complicated, but it’s actually pretty straightforward. “Significant figures” represents the precision of the number: 1,048,415, 104.8415, and .0000001048415 all have 7 significant figures. So when a float can store real numbers as big as 3.4 x 10³⁸ or as small as -1.5x10^-45, that means it can store numbers as big as eight digits followed by 30 zeroes, or as small as 37 zeroes followed by eight digits.

Note

If it’s been a while since you’ve used exponents, 3.4x10³⁸ means 34 followed by 37 zeroes, and –1.5x10^–45 is –.000000...(44 zeroes)...00015.

Float and double can also have special values, including both positive and negative zero, positive and negative infinity, and a special value called NaN (not-a-number) that represents, well, a value that isn’t a number at all. They also have static methods that let you test for those special values. Try running this loop:

for (float f = 10; float.IsFinite(f); f *= f)
{
    Console.WriteLine(f);
}

Now try that same loop with double:

for (double d = 10; double.IsFinite(d); d *= d)
{
    Console.WriteLine(d);
}

Let’s talk about strings

You’ve written code that works with strings. But what, exactly, is a string?

In any .NET app, a string is an object. Its full class name is System.String—in other words, the class name is String and it’s in the System namespace (just like Random class you used). When you use the C# string keyword, you’re working with System.String objects. In fact, you can replace string with System.String in any of the code you’ve written so far and it will still work! (The string keyword is called an alias—as far as your C# code is concerned, string and System.String mean the same thing.)

There are also two special values for strings: an empty string "" (or a string with no characters), and a null string, or a string that isn’t set to anything at all. We’ll talk more about null later in the chapter.

Strings are made up of characters—specifically, Unicode characters (which we’ll learn a lot more about later in the book). Sometimes you need to store a single character like Q or j or $, and when you do you’ll use the char type. Literal values for char are always inside single quotes (’x’, ’3’). You can include escape sequences in the quotes, too (’\n’ is a line break, ’\t’ is a tab). You can write an escape sequence in your C# code using two characters, but your program stores each escape sequence as a single character in memory.

And finally, there’s one more important type: object. If a variable has object as its type, you can assign any value to it. The object keyword is also an alias—it’s the same as System.Object.

A literal is a value written directly into your code

A literal is a number, string, or other fixed value that you include in your code. You’ve already used plenty of literals—here are some examples of numbers, strings, and other literals that you’ve used:

So when you type “int i = 5;”, the 5 is a literal.

Use suffixes to give your literals types

When you added statements like this in Unity, you may have wondered about the F:

   InvokeRepeating("AddABall", 1.5F, 1);

Note

C# assumes that a whole number literal without a suffix (like 371) is an int, and one with a decimal point (like 27.4) is a double.

Did you notice that your program won’t build if you leave off the F in the literals 1.5F and 0.75F? That’s because literals have types. Every literal is automatically assigned a type, and C# has rules about how you can combine different types. You can see for yourself how that works. Add this line to any C# program:

   int wholeNumber = 14.7;

When you try to build your program, the IDE will show you this error in the error list:

The IDE is telling you is that the literal 14.7 has a type—it’s a double. You can use a suffix to change its type—try changing it to a float by sticking an F on the end (14.7F) or a decimal by adding M (14.7M—the M actually stands for “money”). The error message now says it can’t convert float or decimal. Add a D (or leave off the suffix entirely) and the error goes away.

A variable is like a data to-go cup

All of your data takes up space in memory. (Remember the heap from the last chapter?) So part of your job is to think about how much space you’re going to need whenever you use a string or a number in your program. That’s one of the reasons you use variables. They let you set aside enough space in memory to store your data.

Note

Not all data ends up on the heap. Value types usually keep their data in another part of memory called the stack. You’ll learn all about that later in the book.

Think of a variable like a cup that you keep your data in. C# uses a bunch of different kinds of cups to hold different kinds of data. And just like the different sizes of cups at the coffee shop, there are different sizes of variables, too.

Convert this!

Use the Convert class to explore bits and bytes

You’ve always heard that programming is about 1’s and 0’s. .NET has a static Convert class in .NET that converts between different numeric data types. Let’s use it to see an example of how the bytes and bytes work with whole numbers.

A bit is a single 1 or 0. A byte is 8 bits, so a byte variable holds an 8-bit number, which means it’s a number that can be represented with up to 8 bits. What does that look like? Let’s use the Convert class convert binary numbers to bytes:

Bytes can hold numbers between 0 and 255 because it uses 8 bits of memory—an 8-bit number is a binary number between 0 and 11111111 binary (or 0 and 255 decimal).

A short is a 16-bit value. Let’s use Convert.ToInt16 convert the binary value 111111111111111 (15 1’s) to a short. And an int is a 32-bit value, so we’ll :use Convert.ToInt32 to convert the 31 1’s to an int:

Convert.ToInt16("111111111111111", 2); // returns 32767
Convert.ToInt32("1111111111111111111111111111111", 2); // returns 2147483647

Other types come in different sizes, too

Numbers that have decimal places are stored differently than whole numbers, and the different floating-point types take up different amounts of memory. You can handle most of your numbers that have decimal places using float, the smallest data type that stores decimals. If you need to be more precise, use a double. And if you’re writing a financial application where you’ll be storing currency values, you’ll always want to use the decimal type.

Oh, and one more thing: don’t use double for money or currency, only use decimal.

We’ve talked about strings, so you know that the C# compiler also can handle characters and non-numeric types. The char type holds one character, and string is used for lots of characters “strung” together. There’s no set size for a string object, either. It expands to hold as much data as you need to store in it. The bool data type is used to store true or false values, like the ones you’ve used for your if statements.

Note

The different floating-point types take up different amounts of memory: float is smallest, and double is largest.

10 pounds of data in a 5-pound bag

When you declare your variable as one type, the C# compiler allocates (or reserves) all of the memory it would need to store the maximum value of that type. Even if the value is nowhere near the upper boundary of the type you’ve declared, the compiler will see the cup it’s in, not the number inside. So this won’t work:

   int leaguesUnderTheSea = 20000;
   short smallerLeagues = leaguesUnderTheSea;

20,000 would fit into a short, no problem. But since leaguesUnderTheSea is declared as an int, C# sees it as int-sized and considers it too big to put in a short container. But the compiler won’t make those translations for you on the fly. You need to make sure that you’re using the right type for the data you’re working with.

Casting lets you copy values that C# can’t automatically convert to another type

Let’s see what happens when you try to assign a decimal value to an int variable.

Do this!

Create a new Console App project and add this code to the Main method:
Try building your program. You should get the same CS0266 error you saw earlier:

Look closely at the last few words of the error message: “are you missing a cast?” That’s the C# compiler giving you a really useful hint about how to fix the problem.
Make the error go away by casting the decimal to an int. You do this by adding the type that you want to convert to in parentheses: (int). Once you change the second line so it looks like this, your program will compile and run:

So what happened?

The C# compiler won’t let you assign a value to a variable if it’s the wrong type—even if that variable can hold the value just fine! It turns out that a LOT of bugs are caused by type problems, and the compiler is helping by nudging you in the right direction. When you use casting, you’re essentially making a promise to the compiler that you know the types are different, and that in this particular instance it’s OK for C# to cram the data into the new variable.

When you cast a value that’s too big, C# adjusts it to fit its new container

You’ve already seen that a decimal can be cast to an int. It turns out that any number can be cast to any other number. But that doesn’t mean the value stays intact through the casting. If you cast an int variable that’s set to 365 to a byte variable, 365 is too big for the byte. But instead of giving you an error, the value will just wrap around: for example, 256 cast to a byte will have a value of 0. 257 would be converted to 1, 258 to 2, etc., up to 365, which will end up being 109. And once you get back to 255 again, the conversion value “wraps” back to zero.

If you use + (or *, /, or -) with two different numeric types, the operator automatically converts the smaller type to the bigger one. Here’s an example:

  int myInt = 36;
  float myFloat = 16.4F;
  myFloat = myInt + myFloat;

Since an int can fit into a float but a float can’t fit into an int, the + operator converts myInt to a float before adding it to myFloat.

Yes! When you concatenate strings, C# converts values.

When you use the + operator to combine a string with another value, it’s called concatenation. And when you concatenate a string with an int, bool, float, or another value type, it automatically converts the value. But this kind of conversion is different from casting, because under the hood it’s really calling the ToString method for the value... and one thing that .NET guarantees is that every object has a ToString method that converts it to a string (but it’s up to the individual class to determine if that string makes sense.)

C# does some conversion automatically

There are two important conversions that don’t require you to do casting. The first is the automatic conversion that happens any time you use arithmetic operators, like in this example:

The other way C# converts types for you automatically is when you use the + operator to concatenate strings (which just means sticking one string on the end of another, like you’ve been doing with message boxes). When you use + to concatenate a string with something that’s another type, it automatically converts the numbers to strings for you. Here’s an example—try adding these lines to any C# program. The first two lines are fine, but the third one won’t compile.

   long number = 139401930;
   string text = "Player score: " + number;
   text = number;

The C# compiler gives you this error on the third line:

ScoreText.text is a string field, so when you used the + operator to concatenate a string it assigned the value just fine. But when you try to assign x to it directly, it doesn’t have a way to automatically convert the long value to a string. But you can convert it to a string really easily by calling its ToString method.

When you call a method, the arguments need to be compatible with the types of the parameters

In the last chapter, you used the Random class to choose a random number from 1 up to (but not including) 5, and used it to pick a suit for a playing card:

   int value = random.Next(1, 5);

Try changing the first argument from 1 to 1.0:

   int value = random.Next(1.0, 5);

You’re passing a double literal to a method that’s expecting an int value. So it shouldn’t surprise you that the compiler won’t build your program—instead, it shows an error:

Note

When the compiler gives you an “invalid argument” error, it means that you tried to call a method with variables whose types didn’t match the method’s parameters.

Sometimes C# can do the conversion automatically. It doesn’t know how to convert a double to an int (like converting 1.0 to 1), but it does know how to convert an int to a double (like converting 1 to 1.0).

The C# compiler knows how convert a whole number to a floating-point.
And it knows how to convert a whole number type to another whole number type, or a floating-point type to another floating-point type.
But it can only do those conversions if the type it’s converting from is the same size or smaller than the type it’s converting to. So it can convert an int to a long or a float to a double, but it can’t convert a long to an int or a double to a float.

But Random.Next isn’t the only method that will give you compiler errors if you try to pass it a variable whose type doesn’t match the parameter. All methods will do that, even the ones you write yourself. Add this method to a Console App:

public int MyMethod(bool add3) {
   int value = 12;
 
   if (add3)
      value += 3;
   else
      value -= 2;

   return value;
}

Try passing it a string or long—you’ll get one of those CS1503 errors telling you it can’t convert the argument to a bool. And by the way, a lot of people have trouble remembering the difference between parameter and argument. So just to be clear:

A parameter is what you define in your method. An argument is what you pass to it. You can pass a byte argument to a method with an int parameter.

there are no Dumb Questions

Q: That last if statement only said if (add3). Is that the same thing as if (add3 == true)?

A: Yes. Let’s take another look at that if/else statement:

  if (add3)
     value += 3;
  else
     value -= 2;

An if statement always checks if something’s true. So because the type of the add3 variable is Boolean, it evaluates to either true or false, which means we didn’t have to explicitly include == true.

You also check if something’s false using ! (an exclamation point, or the NOT operator). Writing if (!add3) is the same thing as writing if (add3 == false).

In our code examples from now on, if we’re using the conditional test to check a Boolean variable, you’ll usually just see us write if (add3) or if (!add3), and not use == to explicitly check to see if the Boolean is true or false.

Q: You didn’t include curly braces in the if or else blocks, either. Does that mean they’re optional?

A: Yes—but only if there’s a single statement in the if or else block. We could leave out the { curly braces } because there was just one statement in the if block (return 45;) and one statement in the else block (return 61;). If we wanted to add another statement to one of those blocks, we’d have to use curly braces for it:

  if (add3)
     value += 3;
  else {
     Console.WriteLine("Subtracting 2");
     value -= 2;
  }

Be careful when you leave out curly braces because it’s easy to accidentally write code that doesn’t do what you want it to do. It never hurts to add curly braces, but it’s also good to get used to seeing if statements both with and without them.

Bullet Points

There are value types for variables that hold different sizes of numbers. The biggest numbers should be of the type long and the smallest ones (up to 255) can be declared as bytes.
Every value type has a size, and you can’t put a value of a bigger type into a smaller variable, no matter what the actual size of the data is.
When you’re using literal values, use the F suffix to indicate a float (15.6F) and M for a decimal (36.12M).
Use the decimal type for money and currency. Floating-point precision is... well, it’s a little weird.
There are a few types (like short to int) that C# knows how to convert automatically (an implicit conversion). When the compiler won’t let you set a variable equal to a value of a different type, that’s when you need to cast it.
To cast a value—explicit conversion—to another type, put the target type in parentheses in front of the value.
There are some keywords that are reserved by the language and you can’t name your variables with them. They’re words (like for, while, using, new, and others that do specific things in the language.
C# can do some conversions automatically, like int to double or float to double.
A parameter is what you define in your method. An argument is what you pass to it.
When you build your code in the IDE, it uses the C# compiler to turn it into an executable program.
You can use methods on the static Convert class to convert values between different types.

Ryan is constantly improving his game

Good game masters are dedicated to creating the best experience they can for their players. Ryan’s players are about to embark on a new campaign with a brand new set of characters, and he thinks a few tweaks to the formula that they use for their ability scores could make things more interesting.

Let’s help Ryan experiment with ability scores

Ryan’s been experimenting with ways to tweak the ability score calculation. He’s pretty sure that he has the formula mostly right—but he’d really like to tweak the numbers.

Ryan likes the overall formula: 4d6 roll, divide, subtract, round down, use a minimum value. But he’s not sure that the actual numbers are right.

Sharpen your pencil

We’ve built a class to help Ryan calculate ability scores. To use it, you set its Starting4D6Roll, DivideBy, SubtractBy, and Minimum fields—or just leave the values set in their declarations—and call its CalculateAbilityScore method. Unfortunately, there’s one line of code that has problems. Circle the line of code with problems and write down what’s wrong with it.

See if you can spot the problem without typing the class into your IDE. Can you find the broken line that will a cause compiler error?

class AbilityScoreCalculator
{
    public int Roll = 14;
    public double DivideBy = 1.75;
    public int AddAmount = 2;
    public int Minimum = 3;
    public int Score;

    public void CalculateAbilityScore()
    {
        // Divide the starting roll
        double divided = Roll / DivideBy;

        // Add to the result
        int added = AddAmount += divided;

        // Make sure it’s greater than the minimum
        if (added < Minimum)
        {
            Score = Minimum;
        } else
        {
            Score = added;
        }
    }
}

After you circle the line of code that has problems, write down the problems that you found with it.

......................................................................

Exercise

Let’s build a console app to test the AbilityScoreCalculator class. Create a new Console App project and add the AbilityScoreCalculator class from the “Sharpen your pencil” exercise—it won’t build properly yet..In this exercise, first you’ll fix the class, then you’ll create program that uses it.

1. Fix the problems in the line of code that you circled in the “Sharpen your pencil” exercise.

2. Add the Main method. Everything in it should be familiar—except for one method that it uses, Console.ReadKey:

        char keyChar = Console.ReadKey(true).KeyChar;

Console.ReadKey reads a single key from the console. When you pass the argument true it intercepts the input so that it doesn’t get printed to the console. Adding .KeyChar causes it to return the key pressed as a char type.

Note

You’ll use a single instance of AbilityScoreCalculator, using the user input to update its fields so it remembers a new default value for the next iteration of the while loop.

Here’s the full Main method—add it to your program:

static void Main(string[] args)
{
    AbilityScoreCalculator calculator = new AbilityScoreCalculator();
    while (true)
    {
        calculator.Roll = ReadInt(calculator.Roll, "Starting 4d6 roll");
        calculator.DivideBy = ReadDouble(calculator.DivideBy, "Divide by");
        calculator.AddAmount = ReadInt(calculator.AddAmount, "Add amount");
        calculator.Minimum = ReadInt(calculator.Minimum, "Minimum");
        calculator.CalculateAbilityScore();
        Console.WriteLine("Calculated ability score: " + calculator.Score);
        Console.WriteLine("Press Q to quit, any other key to continue");
        char keyChar = Console.ReadKey(true).KeyChar;
        if ((keyChar == ’Q’) || (keyChar == ’q’)) return;
    }
}

3. Implement the ReadInt method, which takes two parameters: a prompt to display to the user, and a default value. It writes the prompt to the console, followed by the default value in square brackets. Then it reads a line from the console and attempts to parse it. If it can parse it, it uses that value; otherwise, it uses the default value.

/// <summary>
/// Writes a prompt and reads an int value from the console.
/// </summary>
/// <param name="lastUsedValue">The default value.</param>
/// <param name="prompt">Prompt to print to the console.</param>
/// <returns>The int value read, or the default value if unable to parse</returns>
static int ReadInt(int lastUsedValue, string prompt)
{ 
    // Write the prompt followed by [default value]:
    // Read the line from the input and try to parse it
    // If it can be parsed, write " using value" + value to the console
    // Otherwise write " using default value" + lastUsedValue to the console
}

4. Add a ReadDouble method that’s exactly like ReadInt, except that it uses double.TryParse instead of int.TryParse. The double.TryParse method works exactly like int.TryParse, except its out variable needs to be a double, not an int.

Exercise Solution

Here are the ReadInt and ReadDouble methods that display a prompt that includes the default value, read a line from the console, try to convert it to an int or a double, and either use the converted value or the default value, writing a message to the console with the value returned.

Use casting to fix the problematic line of code in AbilityScoreCalculator

If you tried adding the AbilityScoreCalculator class to the project without making any changes, you saw a “Cannot implicitly convert type” error on this line:

int added = AddAmount += divided;

It caused that error because AddAmount += divided returns a double value, which can’t be assigned to the int variable subtracted. You can fix it by casting divided to an int, so adding it to AddAmount returns another int.

This line of code now compiles—but there’s still a problem! Can you spot it?

Note

Looks like we can’t answer the “Sharpen your pencil” exercise just yet!

You’re right, Ryan. There’s a bug in the code.

Ryan wants to try out different values to use in his ability score formula, so we used a loop to make the app ask for those values over and over again.

To make it easier for Ryan to just change one value at a time, we included a feature in the app that remembers the last values he entered and presents them as default options. We implemented that feature by keeping an instance of the AbilityScoreCalculator class in memory, and updating its fields in each iteration of the while loop.

But something’s gone wrong with the app. It remembers most of the values just fine, but it remembers the wrong number for the “add amount” default value. In the first iteration Ryan entered 5, but it gave him 10 as a default option. He entered 7, but it says he default 12. What’s going on?

Sleuth it out

When you’re debugging code, you’re acting like a code detective. Something is causing the bug, so your job is to identify suspects and retrace their steps. Let’s do an investigation and see if we can apprehend the culprit, Sherlock Holmes style.

The problem seems to be isolated to the “add amount” value, so let’s start by looking for any line of code that touches the AddAmount field. Here’s a line in the Main method that uses the AddAmount field—put a breakpoint on it:

And here’s another one in the AbilityScoreCalculator.CalculateAbilityScore method—breakpoint that suspect, too:

Now run your program. When your Main method breaks, select calculator.AddAmount and add a watch (if you just right-click on AddAmount and choose “Add Watch” from the menu, it will only add a watch for AddAmount and not calculator.AddAmount). Does anything look weird there? We’re not seeing anything unusual. It seems to read the value and update it just fine. Okay, that’s probably not the issue—you can disable or remove that breakpoint.

Continue running your program. When the breakpoint in AbilityScoreCalculator.CalculateAbilityScore hits, add a watch for AddAmount. According to Ryan’s formula, this line of code is supposed to add AddAmount to the result of dividing the roll result. Now step over the statement and...

Wait, what?! AddAmount changed. But... but that’s not supposed to happen—it’s impossible! Right? As Sherlock Holmes said, “When you have eliminated the impossible, whatever remains, however improbable, must be the truth.”

It looks like we’ve sleuthed out the source of the problem. That statement is supposed to cast divided to an int to round it down to a whole number, then add it to AddAmount and store the result in added. But it also has an unexpected side-effect: it’s updating AddAmount with the sum. And the reason is that the statement uses the += operator, which returns the sum but assigns the sum to AddAmount.

And now we can finally fix Ryan’s bug

Now that you know what’s happening, you can fix the bug—and it turns out to be a pretty small change. You just need to change the statement to use + instead of +=:

Sharpen your pencil Solution

Note

Now that we’ve found the problem, we can finally answer the “Sharpen your pencil” exercise.

After you circle the line of code that has problems, write down the problems that you found with it.

First, it won’t compile because AddAmount += divided is a double, so a cast needs to happen to assign it to an int. Second, it uses += and not +, which causes the line to update AddAmount.

there are no Dumb Questions

Q: I’m still not clear on the difference between the + operator and the += operator. How do they work, and why would I use one and not the other?

A: There are several operators that you can combine with an equal sign. They include += for adding, -= for subtracting, /= for dividing, *= for multiplying, and %= for remainder. Operators like + that combine two values are called binary operators. Some people find this name a little confusing, because “binary” refers to the fact that the operator combines two values—“binary” means “involving two things”—not that it somehow operates only on binary numbers.

For a binary operator, you can do something called compound assignment, which means instead of this:

and it means the same thing. The compound assignment x op= y is equivalent to x = x op y (that’s the technical way of explaining it). They do exactly the same thing.

Note

Operators like += or *= that combine a binary operator with an equals sign are called compound assignment operators.

Q: But then how did the added variable get updated?

A: What caused confusion in the score calculator is that assignment operator = also returns a value. You can do this:

int q = (a = b + c)

Which will calculate a = b + c as usual. But since the = operator returns a value it will update q with the result as well. So:

int added = AddAmount += divided;

is just like doing this:

int added = (AddAmount = AddAmount + divided);

which causes AddAmount to increased by divided, but also stores that result in added as well

Q: Wait, what? The equals operator returns a value?

A: Yes, = returns the value being set. So in this code:

int first;
int second = (first = 4);

Then both first and second will end up equal to 4. Open up a Console App and use the debugger. It really works!

Try this!

Try adding this if/else statement to a console app:

if (0.1M + 0.2M == 0.3M) Console.WriteLine("They’re equal");
else Console.WriteLine("They aren’t equal");

You’ll see a green squiggle under the second Console — it’s an Unreachable code detected warning. The C# compiler knows that 0.1 + 0.2 is always equal to 0.3, so the code will never reach the else part of the statement. Run the code—it prints They’re equal to the console.

Next, change the float literals to doubles (remember, literals like 0.1 default to double):

if (0.1 + 0.2 == 0.3) Console.WriteLine("They’re equal");
else Console.WriteLine("They aren’t equal");

Strange. The warning moved to the first line of the if statement. Try running the program. Hold on, that can’t be right! It printed They aren’t equal to the console. How is 0.1 + 0.2 not equal to 0.3?

Now do one more thing. Change 0.3 to 0.30000000000000004 (with 15 zeroes between the 3 and 4.). Now it prints They’re equal again. So apparently 0.1D plus 0.2D equals 0.30000000000000004D.

Note

Wait what?!

Exactly. Decimal has a lot more precision than double or float, so it avoids the 0.30000000000000004 problem.

Some floating-point types—not just in C#, but in most programming languages!—can give you rare weird errors. This is so strange! How can 0.1 + 0.2 be 0.30000000000000004?

It turns out that there are some numbers that just can’t be exactly represented as a double—it has to do with how they’re stored as binary data (0s and 1s in memory). For example, .1D is not exactly .1. Try multiplying .1D * .1D— you get 0.010000000000000002, not 0.01. But .1M * .1M gives you the right answer. That’s why floats and doubles are really useful for a lot of things (like positioning a GameObject in Unity). But if you need more rigid precision— like for a financial app that deals with money—decimal is the way to go.

there are no Dumb Questions

Q: I’m still not clear on the difference between conversion and casting. Can you explain it a little more clearly?

A: Conversion is a general, all-purpose term for converting data from one type to another. Casting is a much more specific operation, with explicit rules about which types can be cast to other types, and what to do when the data for the value from doesn’t quite match the type it’s being cast to. You just saw an example of one of those rules—when a floating-point number is cast to an int, it’s rounded down by dropping any decimal value. And you saw another rule earlier about wrapping for whole number types, where a number that’s too big to fit into the type it’s being cast to is wrapped using the remainder operator.

Q: Hold on a minute. Earlier you had me “wrap” numbers myself using the mod function on my calculator app. But now you’re talking about remainders. What’s the difference?

A: Sure. Mod and remainder are very similar operations. For positive numbers they’re exactly the same: A % B is the remainder when you divide B into A: 5 % 2 is the remainder of 5 ÷ 2, or 1. (If you’re trying to remember how long division works, that just means that 5 ÷ 2 is equal to 2 × 2 + 1, so the rounded quotient is 2 and the remainder is 1.) But when you start dealing with negative numbers, there’s a difference between mod (or modulus) and remainder. You can see for yourself: your calculator will tell you that -397 mod 17 = 11, but if you use the C# remainder operator you’ll get -397 % 17 = -6.

Q: Ryan’s formula had me dividing two values and then rounding the result down to the nearest whole number. How does that fit in with casting?

A: Let’s say you have some floating-point values:

float f1 = 185.26F;
double d2 = .0000316D;
decimal m3 = 37.26M;

and you want to cast them to int values so you can assign them to int variables i1, i2, and i3. We know that those int variables can only hold whole numbers, so your program needs to do something to the decimal part of the number.

So C# has a simple rule: it drops the decimal and rounds down: f1 becaomes 185, d2 becomes 0, and m3 becomes 37. But don’t take our word for it—write your own C# code that casts those three floating-point values to int to see what happens.

Note

There’s a whole web page dedicated to the 0.30000000000000004 problem! Check out https://0.30000000000000004.com/ to see examples in a lot of different languages.

Note

The 0.1D + 0.2D != 0.3D example is an edge case, or a problem or situation that only happens under certain rare conditions, usually when a parameter is at one of its extremes (like a very big or very small number). If you want to learn more about it, read this great article by Jon Skeet about how floating-point numbers are stored in memory in .NET. You can read it here: https://csharpindepth.com/Articles/FloatingPoint

Note

Jon gave us some amazing technical review feedback for the 1st edition of this book that made a huge difference for us. Thanks so much, Jon!

Use reference variables to access your objects

When you create a new object, you use a new statement to instantiate, like new Guy() in your program the end of the last chapter—the new statement created a new Guy object on the heap. But you still needed a way to access that object, and that’s where a variable like joe came in: Guy joe = new Guy(). Let’s dig a little deeper into exactly what’s going on there.

The new statement creates the instance, but just creating that instance isn’t enough. You need a reference to the object. So you created a reference variable: a variable of type Guy with a name, like joe. So joe is a reference to the new Guy object you created. Any time you want to use that particular guy, you can reference it with the reference variable called joe.

When you have a variable that’s an object type, it’s a reference variable: a reference to a particular object. Let’s just make sure we get the terminology right since we’ll be using it a lot. We’ll use the first two lines of the “Joe and Bob” program from the last chapter:

References are like sticky notes for your objects

In your kitchen, you probably have containers of salt and sugar. If you switched their labels, it would make for a pretty disgusting meal— even though the labels changed, the contents of the containers stayed the same. References are like labels. You can move labels around and point them at different things, but it’s the object that dictates what methods and data are available, not the reference itself—and you can copy references just like you copy values.

Note

A reference is like a label that your code uses to talk about a specific object. You use it to access fields and call methods on an object that it points to.

We stuck a lot of sticky notes on that object! In this particular case, there are a lot of different references to this same Guy object—because a lot of different methods use him for different things Each reference has a different name that makes sense in its context.

That’s why it can be really useful to have multiple references pointing to the same instance. So you could say Guy dad = joe, and then call dad.GiveCash() (that’s what Joe’s kid does every day). But if you want to write code that works with an object, you need a reference to that object. If you don’t have that reference, you have no way to access the object.

If there aren’t any more references, your object gets garbage-collected

If all of the labels come off of an object, programs can no longer access that object. That means C# can mark the object for garbage collection. That’s when C# gets rid of any unreferenced objects and reclaims the memory those objects took up for your program’s use.

Here’s some code that creates an object.

And just to recap what we’ve been talking about: when you use the new statement, you’re telling C# to create an object. When you take a reference variable like joe and assign it to that object, it’s like you’re slapping a new sticky note on it.
```
    Guy joe = new Guy() { Cash = 50, Name = "Joe" };
```
Now let’s create our second object.

Now we’ll have two Guy object instances and two reference variables: one variable (joe) for the first Guy object, and another variable (bob) for the second.
```
    Guy bob = new Guy() { Cash = 100, Name = "Bob" };
```
Let’s take the reference to the first Guy object and change it to point to the second Guy object.

Take a really close look at what you’re doing when you create a new Guy object. You’re taking a variable and using the = assignment operator to set it—in this case, to a reference that’s returned by the new statement. That assignment works because you can copy a reference just like you copy a value.

So let’s go ahead and copy that value
```
    joe = bob;
```
That tells C# to take make joe point to the same object that bob does. Now the joe and bob variables both point to the same object.
there’s no longer a reference to the first Guy object... so it gets garbage-collected.

Now that joe is pointing to the same object as bob, there’s no longer a reference to the Guy object it used to point to. So what happens? C# marks the object for garbage collection, and eventually trashes it. Poof—it’s gone!

Note

For an object to stay in the heap, it has to be referenced. Some time after the last reference to the object disappears, so does the object.

Multiple references and their side effects

you can pet the dog in head first c#

public partial class Dog {
  public void GetPet() {
    Console.WriteLine("Woof!");
  }
}

You’ve got to be careful when you start moving around reference variables. Lots of times, it might seem like you’re simply pointing a variable to a different object. But you could end up removing all references to another object in the process. That’s not a bad thing, but it may not be what you intended. Take a look:

Dog rover = new Dog();
rover.Breed = "Greyhound";

Objects: 1

References: 1

Dog fido = new Dog();
fido.Breed = "Beagle";
Dog spot = rover;

Objects: 2

References: 3

Dog lucky = new Dog();
lucky.Breed = "Dachshund";
fido = rover;

Objects: 2

References: 4

Garbage Collection Exposed

This week’s interview:

The .NET Common Language Runtime

Head First: So, we understand that you do a pretty important job for us. Can you tell us a little more about what you do?

Common Language Runtime (CLR): In a lot of ways, it’s pretty simple. I run your code. Any time you’re using a .NET app, I’m making it work.

Head First: What do you mean by making it work?

CLR: I take care of the low-level “stuff ” for you by doing a sort of “translation” between your program and the computer running it. When we talk about instantiating objects or doing garbage collection, I’m the one that’s managing all of those things.

Head First: So how does that work, exactly?

CLR: Well, when you run a program on Windows, Linux, MacOS, or most other operating systems, the OS loads machine language from a binary.

Head First: I’m going to stop you right there. Can you back up and tell us what machine language is?

CLR: Sure. A program written in machine language is made up of code that’s executed directly by the CPU—and it’s a whole lot less readable than C#.

Head First: If the CPU is executing the actual machine code, what does the OS do?

CLR: The OS makes sure each program gets its own process, respects the system’s security rules, and provides APIs.

Head First: And for our readers who don’t know what an API is?

CLR: An API—or application programming interface—is a set of methods provided by an OS, library, or program. OS APIs help you do things like work with the file system and interact with hardware. But they’re often pretty difficult to use—especially for memory management—and they vary from OS to OS.

Head First: So back to your job. You mentioned a binary. What exactly is that?

CLR: A binary is a file that’s (usually) created by a compiler, a program whose job it is to convert high-level language into low-level code like machine code. Windows binaries usually end with .exe or .dll.

Head First: But I’m guessing that there’s a twist here. You said “low-level code like machine code”—does that mean there are other kinds of low-level code?

CLR: Exactly. I don’t run the same machine language as the CPU. When you build your C# code, Visual Studio asks the C# compiler to create Common Intermediate Language (CIL). That’s what I run. C# code is turned into CIL, which I read and execute.

Head First: You mentioned managing memory. Is that where garbage collection fits into all of this?

CLR: Yes! One really, really useful thing that I do for you is that I tightly manage your computer’s memory by figuring out when your program’s finished with certain objects. When it is, I get rid of them for you to free up that memory. That’s something programmers used to have to do themselves—but thanks to me, it’s something that you don’t have to be bothered with. You might not know it at the time, but I’ve been making your job of learning C# a whole lot easier.

Head First: You mentioned Windows binaries. But what if I’m running .NET programs on Mac and Linux? Are you doing the same thing for those OSes?

CLR: If you’re using a Mac or Linux—or running Mono on Windows— then you’re technically not using me. You’re using my cousin, the Mono Runtime, which implements the same ECMA Common Language Infrastructure (CLI) that I do. So when it comes to all the stuff I’ve talked about so far, we both do exactly the same thing.

Exercise

Your job is to create a .NET Core Console App with an Elephant class that matches the class diagram and uses its fields and methods to generate output that matches the example output.

Create a new .NET Core Console App and add the Elephant class.

Add an Elephant class to the project. Have a look at the Elephant class diagram—you’ll need an int field called EarSize and a string field called Name. Add them, and make sure both are public. Then add a method called WhoAmI that writes two lines to the console to tell you the name and ear size of the elephant. Look at the example output to see exactly what it’s supposed to print.

Create two Elephant instances and a reference.

Use object initializers to instantiate two Elephant objects:

Elephant lucinda = new Elephant() { Name = "Lucinda", EarSize = 33 };
Elephant lloyd = new Elephant() { Name = "Lloyd", EarSize = 40 };

Call their WhoAmI methods.

When the user presses 1 call lloyd.WhoAmI. When the user presses 2, call lucinda.WhoAmI. Make sure that the output matches the example.
Now for the fun part: swap the references.

Here’s the interesting part of this exercise. When the user presses 3, make the app call a method that exchanges the two references. You’ll need to write that method. After first you swap references, pressing 1 should write Lucinda’s message to the console, and pressing 2 should write Lloyd’s message. If you swap the references again, everything should go back to normal.

Two references mean TWO variables that can change the same object’s data

Besides losing all the references to an object, when you have multiple references to an object, you can unintentionally change an object. In other words, one reference to an object may change that object, while another reference to that object has no idea that something has changed. Let’s see how that works.

Do this!

Add one more “else if ” block to your Main method. Can you guess what will happen once it runs?

Now go ahead and run your program. Here’s what you’ll see:

You pressed 4
My name is Lucinda
My ears are 4321 inches tall.

You pressed 1
Calling lloyd.WhoAmI()
My name is Lucinda
My ears are 4321 inches tall.

You pressed 2
Calling lucinda.WhoAmI()
My name is Lucinda
My ears are 4321 inches tall.

After you press 4 and run the new code that you added, both the lloyd and lucinda variables contain the same reference to the second Elephant object. pressing 1 to call lloyd.WhoAmI prints exactly the same message as pressing 2 to call lucinda.WhoAmI. And swapping them makes no difference because you’re swapping two identical references.

Objects use references to talk to each other

So far, you’ve seen forms talk to objects by using reference variables to call their methods and check their fields. Objects can call one another’s methods using references, too. In fact, there’s nothing that a form can do that your objects can’t do, because your form is just another object. And when objects talk to each other, one useful keyword that they have is this. Any time an object uses the this keyword, it’s referring to itself—it’s a reference that points to the object that calls it. Let’s see what that looks like by modifying the Elephant class so instances can call each others’ methods.

Add a method that lets an elephant hear a message.

Let’s add a method to the Elephant class. Its first parameter is a message from another Elephant object. Its second parameter is the Elephant object that sent the message.

Do this!
```
  public void HearMessage(string message, Elephant whoSaidIt) {
      Console.WriteLine(Name + " heard a message");
      Console.WriteLine(whoSaidIt.Name + " said this: " + message);
  }
```
Here’s what it looks like when it’s called:
```
  lloyd.HearMessage("Hi", lucinda);
```
We called Lloyd’s TellMe method, and passed it two parameters: the string "Hi" and a reference to Lucinda’s object. The method uses its whoSaidIt parameter to access the Name parameter of whatever elephant was passed into TellMe using its second parameter.
Add a method that lets an elephant send a message.

Now let’s add this SpeakTos method to the Elephant class. It uses a special keyword: this. That’s a reference that lets an object get a reference to itself.

Let’s take a closer look at what’s going on.

When we call the Lucinda object’s SpeakTo method:
```
lucinda.SpeakTo(lloyd, "Hi, Lloyd!");
```
It calls the Lloyd object’s HearMessage method like this:

Call the new methods.

Add one more else if block to the Main method to make the Lucinda object send a message to the Lloyd object:

else if (input == ’4’)
{
    lloyd = lucinda;
    lloyd.EarSize = 4321;
    lloyd.WhoAmI();
}
else if (input == ’5’)
{
     lucinda.SpeakTo(lloyd, "Hi, Lloyd!");
}
else
{
   return;
}

Note

The “this” keyword lets an object get a reference to itself.

Now run your program and press 5. You should see this output:

You pressed 5
Lloyd heard a message
Lucinda said this: Hi, Lloyd!

Use the debugger to understand what’s going on.

Place a breakpoint on the statement that you just added to the Main method:
1. Run your program and press 5.
2. When it hits the breakpoint, use Debug >> Step Into (F11) to step into the Speak To method.
3. Add a watch for Name to show you which Elephant object you’re inside. You’re currently inside the Lucinda object—which makes sense because the Main method called Lucinda.SpeakTo.
4. Hover over the this keyword at the end of the line and expand it. It’s a reference to the Lucinda object.
  
  Hover over whoToTalkTo and expand it—it’s a reference to the Lloyd object.
5. The SpeakTo method has one statement—it calls whoToTalkTo.HearMessage. Step into it.
6. You should now be inside the HearMessage method. Check your watch again—now the value of the Name field is “Lloyd”—the Lucinda object called the Lloyd object’s HearMessage method.
7. Hover over whoSaidIt and expand it. It’s a reference to the Lucinda object.

Finish stepping through the code. Take a few minutes and really understand what’s going on.

Arrays hold multiple values

Note

Strings and arrays are different from the other data types you’ve seen in this chapter because they’re the only ones without a set size (think about that for a bit).

If you have to keep track of a lot of data of the same type, like a list of prices or a group of dogs, you can do it in an array. What makes an array special is that it’s a group of variables that’s treated as one object. An array gives you a way of storing and changing more than one piece of data without having to keep track of each variable individually. When you create an array, you declare it just like any other variable, with a name and a type—except the type is followed by square brackets:

bool[] myArray;

Use the new keyword to create an array. Let’s create an array with 15 bool elements:

myArray = new bool[15];

Use square brackets to set one of the values in the array. This statement sets the value of the fifth element of myArray to true by using square brackets and specifying the index 4. It’s the fifth one because the first is myArray[0], the second is myArray[1], etc.:

myArray[4] = false;

Note

You use the new keyword to create an array because it’s an object—so an array variable is a kind of reference variable. In C#, arrays are zero-based, which means the first element has index zero.

Use each element in an array like it’s a normal variable

When you use an array, first you need to declare a reference variable that points to the array. Then you need to create the array object using the new statement, specifying how big you want the array to be. Then you can set the elements in the array. Here’s an example of code that declares and fills up an array—and what’s happening on the heap when you do it. The first element in the array has an index of zero.

Note

The prices variable is a reference, just like any other object reference. The object it points to is an array of decimals values, all in one chunk on the heap.

// declare a new 7-element decimal array
decimal[] prices = new decimal[7];
prices[0] = 12.37M;
prices[1] = 6_193.70M;
// we didn’t set the element
// at index 2, it remains
// the default value of 0
prices[3] = 1193.60M;
prices[4] = 58_000_000_000M;
prices[5] = 72.19M;
prices[6] = 74.8M;

Arrays can contain reference variables

You can create an array of object references just like you create an array of numbers or strings. Arrays don’t care what type of variable they store; it’s up to you. So you can have an array of ints, or an array of Duck objects, with no problem.

Note

When you set or retrieve an element from an array, the number inside the brackets is called the index. The first element in the array has an index of zero.

Here’s code that creates an array of seven Dog variables. The line that initializes the array only creates reference variables. Since there are only two new Dog() lines, only two actual instances of the Dog class are created.

Note

The first line of code only created the array, not the instances. The array is a list of seven Dog reference variables—but only two Dog objects have been created.

null means a reference points to nothing

There’s another important keyword that you’ll use with objects. When you create a new reference and don’t set it to anything, it has a value. It starts off set to null, which means it’s not pointing to any object at all. Let’s have a closer look at it:

Yes. The null keyword can be very useful.

There are a few ways you see null used in typical programs. The most common way is making sure a reference points to an object:

   if (lloyd == null) {

That test will return true if the lloyd reference is set to null.

Another way you’ll see the null keyword used is when you want your object to get garbage-collected. If you’ve got a reference to an object and you’re finished with the object, setting the reference to null will immediately mark it for collection (unless there’s another reference to it somewhere).

there are no Dumb Questions

Q: I’m still not sure I get how references work.

A: References are the way you use all of the methods and fields in an object. If you create a reference to a Dog object, you can then use that reference to access any methods you’ve created for the Dog object. If the Dog class has (nonstatic) methods called Bark and Fetch, you can create a reference called spot, and then you can use that to call spot.Bark() or spot.Fetch(). You can also change information in the fields for the object using the reference (so you could change a Breed field using spot.Breed).

Q: Then doesn’t that mean that every time I change a value through a reference I’m changing it for all of the other references to that object, too?

A: Yes. If the rover variable contains a reference to the same object as spot, changing rover.Breed to “beagle” would make it so that spot.Breed was “beagle.”

Q: Remind me again—what does this do?

A: this is a special variable that you can only use inside an object. When you’re inside a class, you use this to refer to any field or method of that particular instance. It’s especially useful when you’re working with a class whose methods call other classes. One object can use it to send a reference to itself to another object. So if Spot calls one of Rover’s methods passing this as a parameter, he’s giving Rover a reference to the Spot object.

Q: You keep talking about garbage collecting, but what’s actually doing the collecting?

A: Every .NET app runs inside the Common Language Runtime (or the Mono Runtime if you’re running your apps on a Mac, Linux, or using Mono on Windows). The CLR does a lot of stuff, but there are two really important things the CLR does that we’re concerned about right now. First, it executes your code—specifically, the output produced by the C# compiler. And second, it manages the memory that your program uses. That means that it keeps track of all of your objects, figures out when the last reference to the object disappears and frees up the memory that it was using. The .NET team at Microsoft and the Mono team at Xamarin (which was a separate company for many years, but is now a part of Microsoft) have done an enormous amount of work making sure that it’s fast and efficient.

Q: I still don’t get that stuff about different types holding different sized values. Can you go over that one more time?

A: Sure. The thing about variables is they assign a size to your number no matter how big its value is. So if you name a variable and give it a long type even though the number is really small (like, say, 5), the CLR sets aside enough memory for it to get really big. When you think about it, that’s really useful. After all, they’re called variables because they change all the time.

The CLR assumes you know what you’re doing and you’re not going to give a variable a type that you don’t need. So even though the number might not be big now, there’s a chance that after some math happens, it’ll change. The CLR gives it enough memory to handle whatever type of number you call it.

Note

Any time you’ve got code in an object that’s going to be instantiated, the instance can use the special this variable that has a reference to itself.

Game design... and beyond

Tabletop Games

There’s a rich history to tabletop games – and, as it turns out, a long history of tabletop games influencing video games, at least as early as the very first commercial role-playing game.

The first edition of Dungeons and Dragons (D&D) was released in 1974, and that same year games with names like “dungeon” and “dnd” started popping up on university mainframe computers.
You’ve used the Random class to create numbers. The idea of games based on random numbers has a long history—for example, tabletop games that use dice, cards, spinners, and other sources of randomness.
We saw in the last chapter how a paper prototype can be a valuable first step in designing a video game. Paper prototypes have a strong resemblance to tabletop games. In fact, you can often turn the paper prototype of a video game into a playable tabletop game, and use it to test some game mechanics.
You can use tabletop games – especially card games and board games – as learning tools to understand the more general concept of game mechanics. Dealing, shuffling, dice rolling, rules for moving pieces around the board, use of a sand timer, and rules for cooperative play are all examples of mechanics.
Take a minute and read the rules of the game Go Fish in the first section of the Wikipedia page for the game: https://en.wikipedia.org/wiki/Go_Fish – the mechanics of Go Fish include dealing cards, asking another player for a card, saying “Go Fish” when asked for a card you don’t have, determining the winner, etc.

Note

If you’ve never played Go Fish, take a few minutes and read the rules. We’ll use them later in the book!

Even if we’re not writing code for video games, there’s a lot we can learn from tabletop games.

A lot of our programs depend on random numbers. For example, you’ve already used the Random class to create random numbers for several of your apps. But most of us don’t actually have a lot of real-world experience with genuine random numbers... except when we play games. Rolling dice, shuffling cards, spinning spinners, flipping coins... these are all great examples of random number generators. The Random class is .NET’s random number generator that you’ll use in many of your programs, and your experience using random numbers playing tabletop games will make it a lot easier for you to understand what it does.

A Random Test Drive

You’ll be using the .NET Random class throughout the book, so let’s get to know it better by kicking its tires and taking it for a spin. Fire up Visual Studio and follow along—and make sure you run your code multiple times, since you’ll get different random numbers each time.

Create a new console app—all of this code will go in the Main method. Start by creating a new instance of Random, generating a random int, and writing it to the console.

   Random random = new Random();
   int randomInt = random.Next();
   Console.WriteLine(randomInt);

Specify a maximum value to get random numbers from 0 up to—but not including— the maximum value. A maximum of 10 generates random numbers from 0 to 9.

   int zeroToNine = random.Next(10);
   Console.WriteLine(zeroToNine);

Now simulate a the roll of a die. We can specify a minimum and maximum value. A minimum of 1 and maximum of 7 generates random numbers from 1 to 6.

   int dieRoll = random.Next(1, 7);
   Console.WriteLine(dieRoll);

The NextDouble method generates random double values. Hover over the method name to see a tooltip—it generates a floating-point number from 0.0 up to 1.0.

   double randomDouble = random.NextDouble();

You can use multiply a random double to generate much larger random numbers. So if you want a random double value from 1 to 100, multiply the random double by 100.

   Console.WriteLine(randomDouble * 100);

Use casting to convert the random double to other types. Try running this code a bunch of times—you’ll see tiny precision differences in the float and decimal values.

   Console.WriteLine((float)randomDouble * 100F);
   Console.WriteLine((decimal)randomDouble * 100M);

Use a maximum value of 2 to simulate a coin toss. That generates a random value of either 0 or 1. Use the special Convert class, which has a static ToBoolean method that will convert it to a boolean value.

   int zeroOrOne = random.Next(2);
   bool coinFlip = Convert.ToBoolean(zeroOrOne);
   Console.WriteLine(coinFlip);

Welcome to Sloppy Joe’s Budget House o’ Discount Sandwiches!

Sloppy Joe has a pile of meat, a whole lotta bread, and more condiments than you can shake a stick at. But what he doesn’t have is a menu! Can you build a program that makes a new random menu for him every day? You definitely can... with a new WPF app project, some arrays, and a couple of useful new techniques.

Do this!

Start with the fields for a new MenuItem class.

Have a look at the class diagram. It has four fields: an instance of Random and three arrays to hold the various sandwich parts. The array fields use collection initializers, which let you define the items in an array by putting them inside curly braces.

class MenuItem
{
    public Random Randomizer = new Random();

    public string[] Proteins = { "Roast beef", "Salami", "Turkey",
                "Ham", "Pastrami", "Tofu" };
    public string[] Condiments = { "yellow mustard", "brown mustard",
                "honey mustard", "mayo", "relish", "french dressing" };
    public string[] Breads = { "rye", "white", "wheat", "pumpernickel", "a roll" };
}

Add the GenerateMenuItem method.

This method uses the same Random.Next method you’ve seen many times to random items from the arrays in the Proteins, Condiments, and Breads fields and concatenate them together into a string.

public string GenerateMenuItem()
{
    string randomProtein = Proteins[Randomizer.Next(Proteins.Length)];
    string randomCondiment = Condiments[Randomizer.Next(Condiments.Length)];
    string randomBread = Breads[Randomizer.Next(Breads.Length)];
    return randomProtein + " with " + randomCondiment + " on " + randomBread;
}

Add the RandomPrice method.

This method makes a random price by converting two random ints to decimals to make a random price between 2.01 and 5.97. Have a close look at the last line—it returns price.ToString("c"). The parameter to the ToString method is a format. In this case, the "c" format tells ToString to format the value with the local currency: if you’re in the United States you’ll see a $; in the UK you’ll get a £, in the E.U. you’ll see €, etc.
```
public string RandomPrice()
{
    decimal bucks = Randomizer.Next(2, 5);
    decimal cents = Randomizer.Next(1, 98);
    decimal price = bucks + (cents * .01M);
    return price.ToString("c");
}
```
Create the XAML to lay out the window.

Your app will display random menu items in a window with two columns, a wide one for the menu item and a narrow one for the price. Each cell in the grid has a TextBlock control with its FontSize set to 18px—except for the bottom row, which just has a single right-aligned TextBlock that spans both columns. The window’s title is “Welcome to Sloppy Joe’s Budget House o’ Discount Sandwiches!” and it’s got a height of 350 and width of 550. And the Grid has a Margin of 20.

We’re building on the XAML you learned in the last two WPF projects. You can lay it out in the designer, type it in by hand, or do some of each.
Here’s the Code-Behind for your XAML window.

The menu is generated by a method called MakeTheMenu, which your window calls right after it calls InitializeComponent. It uses an array of MenuIttem classes to generate each item in the menu. We want the first three items to be normal menu items. The next two are only served on bagels. And the last is a special item with its own set of ingredients.

How it works...

Note

If your computer is fast enough, your program may not run into this problem. But if you run it on a much slower computer, you’ll see it.
Run your program and behold the new randomly generated menu.

Uh... something’s wrong. The prices on the menu are all the same. And the menu items are weird—the first three are the same, so are the next two, and they all seem to have the same protein. What’s going on?

It turns out that the .NET Random class is actually a pseudo-random number generator, which means that it uses a mathematical formula to generate a sequence of numbers that can pass certain statistical tests for randomness. That makes them good enough to use in any app we’ll build (but don’t use it as part of a security system that depends on truly random numbers!). That’s why the method is called Next—you’re getting the next number in the sequence. The formula starts with a “seed value”—it uses that value to find the next one in the sequence. When you create a new instance of Random, it uses the system clock to “seed” the formula, but you can provide your own seed. Try using the C# Interactive window to call new Random(12345).Next() a bunch of times. You’re telling it to create a new instance of Random with the same seed value (12345), so the Next method will give you the same “random” number each time.

So when you see a bunch of different instances of Random give you the same value, it’s because they were all seeded close enough that the system clock didn’t change time, so they all have the same seed value. So how do we fix this? Easy—just use a single instance of Random by making the Randomizer field static so all MenuItems share a single Random instance:
```
public static Random Randomizer = new Random();
```
Run your program again—now the menu will be randomized.

Bullet Points

The new keyword returns a reference to an object that you can store in a reference variable.
You can have multiple references to the same object. You can change an object with one reference and access the results of that change with another.
For an object to stay in the heap, it has to be referenced. Once the last reference to an object disappears, it eventually gets garbage-collected and the memory it used is reclaimed.
Your .NET programs run in the Common Language Runtime, a “layer” between the OS and your program. The C# compiler builds your code into Common Intermediate Language (CIL), which the CLR executes.
The this keyword lets an object get a reference to itself.
Arrays are objects that hold multiple values. They can contain either values or references.
Declare array variables by putting square brackets after the type in the variable declaration (like bool[] trueFalseValues or Dog[] kennel).
Use the new keyword to create a new array, specifying the array length in square brackets (like new bool[15] or new Dog[3]).
Use the Length method on an array to get its length (like kennel.Length).
Access an array value using its index in square brackets (like bool[3] or Dog[0]). Array indexes start at 0.
null means a reference points to nothing. The null keyword is useful for testing if a reference is null, or clearing a reference variable so an object will get marked for garbage collection.
Use collection initializers to initialize arrays by setting the array equal to the new keyword followed by the array type followed by a comma-delimited list in curly braces (like new int[] { 8, 6, 7, 5, 3, 0, 9 }). The array type is optional when setting a variable or field value in the same statement where it’s declared.
You can pass a format parameter to an object or value’s ToString method. If you’re calling a numeric type’s ToString method, passing it a value of "c" formats the value as a local currency.
The .NET Random class is a pseudo-random number generator seeded by the system clock. Use a single instance of Random to avoid multiple instances with the same seed generating the same sequence of numbers.