IN THIS CHAPTER

Using C# variables, such as integers, as storage lockers

Declaring other types of variables — dates, characters, strings

Handling numeric constants

Changing types and letting the compiler figure out the type

The most fundamental of all concepts in programming is that of the variable. A C# variable is like a small box in which you can store things, particularly numbers, for later use. (The term variable is borrowed from the world of mathematics.)

Unfortunately for programmers, C# places several limitations on variables — limitations that mathematicians don’t have to consider. However, these limits are in place for a reason. They make it easier for C# to understand what you mean by a particular kind of variable and for you to find mistakes in your code. This chapter takes you through the steps for declaring, initializing, and using variables. It also introduces several of the most basic data types in C#.

Declaring a Variable

Mathematicians work with numbers in a precise manner, but in a way that C# could never understand. The mathematician is free to introduce the variables as needed to present an idea in a particular way. Mathematicians use algorithms, a set of procedural steps used to solve a problem, in a way that makes sense to other mathematicians to model real-world needs. Algorithms can appear quite complex, even to other humans, much less C# (it doesn’t understand algorithms except what you tell it in code). For example, the mathematician may say this:

x = y2 + 2y + 1
if k = y + 1 then
x = k2

Programmers must define variables in a particular way that’s more demanding than the mathematician’s looser style. A programmer must tell C# the kind of value that a variable contains and then tell C# specifically what to place in that variable in a manner that C# understands. For example, a C# programmer may write the following bit of code:

int n;
n = 1;

The first line means, “Carve off a small amount of storage in the computer’s memory and assign it the name n.” This step is analogous to reserving one of those storage lockers at the train station and slapping the label n on the side. The second line says, “Store the value 1 in the variable n, thereby replacing whatever that storage location already contains.” The train-locker equivalent is, “Open the train locker, rip out whatever happens to be in there, and shove a 1 in its place.”

The equals symbol (=) is called the assignment operator.

The mathematician says, “n equals 1.” The C# programmer says in a more precise way, “Store the value 1 in the variable n.” (Think about the train locker, and you see why that's easier for C# to understand.) C# operators, such as the assignment operator, tell the computer what you want to do. In other words, operators are verbs and not descriptors. The assignment operator takes the value on its right and stores it in the variable on the left. You discover more about operators in Chapter 4 of this minibook.

What’s an int?

In C#, each variable has a fixed type. When you allocate one of those train lockers, you have to pick the size you need. If you pick an integer locker, for instance, you can’t turn around and hope to stuff the entire state of Texas in it — maybe Rhode Island, but not Texas.

For the example in the preceding section of this chapter, you select a locker that’s designed to handle an integer — C# calls it an int. Integers are the counting numbers 1, 2, 3, and so on, plus 0 and the negative whole numbers –1, –2, –3, and so on.

Before you can use a variable, you must declare it, which means creating a variable with a specific name (label) using code and optionally assigning a value to that variable. After you declare a variable as int, it can hold integer values, as this example demonstrates:

// Declare a variable named n - an empty train locker.
int n;
// Declare an int variable m and initialize it with the value 2.
int m = 2;
// Assign the value stored in m to the variable n.
n = m;

The first line after the comment is a declaration that creates a little storage area, n, designed to hold an integer value. The initial value of n is not specified until it is assigned a value, so this locker is essentially empty. The second declaration not only declares an int variable m but also initializes it with a value of 2, all in one shot.

The term initialize means to assign an initial value. To initialize a variable is to assign it a value for the first time. You don't know for sure what the value of a variable is until it has been initialized. Nobody knows. It’s always an error to use a variable before you initialize it.

The final statement in the program assigns the value stored in m, which is 2, to the variable n. The variable n continues to contain the value 2 until it is assigned a new value. (The variable m doesn't lose its value when you assign its value to n. It’s like cloning m.)

Representing Fractions

Integers are useful for most calculations. However, many calculations involve fractions, which simple integers can't accurately represent. The common equation for converting from Fahrenheit to Celsius temperatures demonstrates the problem, like this:

// Convert the temperature 41 degrees Fahrenheit.
int fahr = 41;
int celsius = (fahr - 32) * (5 / 9);

This equation works just fine for some values. For example, 41 degrees Fahrenheit is 5 degrees Celsius.

Okay, try a different value: 100 degrees Fahrenheit. Working through the equation, 100–32 is 68; 68 times 5 is 340; 340 / 9 is 37 when using integers. However, a closer answer is 37.78. Even that’s wrong because it’s really 37.777 … with the 7s repeating forever.

An int can represent only integer numbers. The integer equivalent of 37.78 is 37. This lopping off of the fractional part of a number to get it to fit into an integer variable is called integer truncation.

Truncation is not the same thing as rounding. Truncation lops off the fractional part. Goodbye, Charlie. Rounding picks the closest integer value. Thus, truncating 1.9 results in 1. Rounding 1.9 results in 2.

For temperatures, 37 may be good enough. It’s not like you wear short-sleeved shirts at 37.7 degrees but pull on a sweater at 37 degrees. But integer truncation is unacceptable for many, if not most, applications.

Actually, the problem is much worse than that. An int can't handle the ratio 5/9 either; it always yields the value 0. Consequently, the equation as written in this example calculates celsius as 0 for all values of fahr.

Handling Floating-Point Variables

The limitations of an int variable are unacceptable for some applications. The range generally isn't a problem — the double-zillion range of a 64-bit-long integer should be enough for almost anyone. However, the fact that an int is limited to whole numbers is a bit harder to swallow.

In some cases, you need numbers that can have a nonzero fractional part. Mathematicians call these real numbers. (Somehow that always seemed like a ridiculous name for a number. Are integer numbers somehow unreal?)

Note that a real number can have a nonzero fractional part — that is, 1.5 is a real number, but so is 1.0. For example, 1.0 + 0.1 is 1.1. Just keep that point in mind as you read the rest of this chapter.

Fortunately, C# understands real numbers. Real numbers come in two flavors: floating-point and decimal. Floating-point is the most common type. You can find a description of the decimal type in the section “Using the Decimal Type: Is It an Integer or a Float?” later in this chapter.

Using the Decimal Type: Is It an Integer or a Float?

As explained in previous sections of this chapter, both the integer and floating-point types have their problems. Floating-point variables have rounding problems associated with limits to their accuracy, while int variables just lop off the fractional part of a variable. In some cases, you need a variable type that offers the best of both worlds:

• Like a floating-point variable, it can store fractions.
• Like an integer, numbers of this type offer exact values for use in computations — for example, 12.5 is really 12.5 and not 12.500001.

Fortunately, C# provides such a variable type, called decimal. A decimal variable can represent a number between 10^–28 and 10²⁸ — which represents a lot of zeros! And it does so without rounding problems unless you're dealing with extremely large numbers.

Examining the bool Type: Is It Logical?

Finally, here's a logical variable type, one that can help you get to the truth of the matter. The Boolean type bool can have two values: true or false.

Former C and C++ programmers are accustomed to using the int value 0 (zero) to mean false and nonzero to mean true. That doesn't work in C#.

You declare a bool variable this way:

bool thisIsABool = true;

No direct conversion path exists between bool variables and any other types. In other words, you can't convert a bool directly into something else. (Even if you could, you shouldn’t because it doesn’t make any sense.) In particular, you can’t convert a bool into an int (such as false becoming 0) or a string (such as false becoming the word “false”).

Checking Out Character Types

A program that can do nothing more than spit out numbers may be fine for mathematicians, accountants, insurance agents with their mortality figures, and folks calculating cannon-shell trajectories. (Don't laugh. The original computers were built to generate tables of cannon-shell trajectories to help artillery gunners.) However, for most applications, programs must deal with letters as well as numbers.

C# treats letters in two distinctly different ways: individual characters of type char (usually pronounced char, as in singe or burn) and strings of characters — a type called, cleverly enough, string.

What’s a Value Type?

The variable types described in this chapter are of fixed length — again with the exception of string. A fixed-length variable type always occupies the same amount of memory. So if you assign a = b, C# can transfer the value of b into a without taking extra measures designed to handle variable-length types. In addition, these kinds of variables are stored in a special location called the stack as actual values. You don't need to worry about the stack; you just need to know that it exists as a location in memory. This characteristic is why these types of variables are called value types.

The types int, double, and bool, and their close derivatives (like unsigned int), are intrinsic variable types built right into the processor. The intrinsic variable types plus decimal are also known as value types because variables store the actual data. The string type is neither an intrinsic nor a value type — because the variable actually stores a sort of “pointer” to the string's data, called a reference. The data in the string is actually off in another location. Think of a reference type as you would an address for a house. Knowing the address tells you the location of the house, but you must actually go to the address to find the physical house.

The programmer-defined types explained in Chapter 8 of this minibook, known as reference types, are neither value types nor intrinsic. The string type is a reference type, although the C# compiler does accord it some special treatment because string types are so widely used.

Comparing string and char

Although strings deal with characters, the string type is amazingly different from the char. Of course, certain trivial differences exist. You enclose a character with single quotation marks, as in this example:

'a'

On the other hand, you put double quotation marks around a string:

"this is a string"
"a" // So is this -- see the double quotes?

The rules concerning strings are not the same as those concerning characters. For one thing, you know right up front that a char is a single character, and that's it. For example, the following code makes no sense, either as addition or as concatenation:

char c1 = 'a';
char c2 = 'b';
char c3 = c1 + c2;

Actually, this bit of code almost compiles — but with a completely different meaning from what was intended. These statements convert c1 into an int consisting of the numeric value of c1. C# also converts c2 into an int and then adds the two integers. The error occurs when trying to store the results back into c3 — numeric data may be lost storing an int into the smaller char. In any case, the operation makes no sense.

A string, on the other hand, can be any length. So concatenating two strings, as shown here, does make sense:

string s1 = "a";
string s2 = "b";
string s3 = s1 + s2; // Result is "ab"

As part of its library, C# defines an entire suite of string operations. You find these operations described in Chapter 3 of this minibook.

Calculating Leap Years: DateTime

What if you had to write a program that calculates whether this year is a leap year?

The algorithm looks like this:

It's a leap year if
year is evenly divisible by 4
and, if it happens to be evenly divisible by 100,
it's also evenly divisible by 400

You don’t have enough tools yet to tackle that in C#. But you could just ask the DateTime type (which is a value type, like int):

DateTime thisYear = new DateTime(2020, 1, 1);
bool isLeapYear = DateTime.IsLeapYear(thisYear.Year);

The result for 2020 is true, but for 2021, it's false. (For now, don’t worry about that first line of code, which uses some things you haven’t gotten to yet.)

With the DateTime data type, you can do something like 80 different operations, such as pull out just the month; get the day of the week; add days, hours, minutes, seconds, milliseconds, months, or years to a given date; get the number of days in a given month; and subtract two dates.

The following sample lines use a convenient property of DateTime called Now to capture the present date and time, and one of the numerous DateTime methods that let you convert one time into another:

DateTime thisMoment = DateTime.Now;
DateTime anHourFromNow = thisMoment.AddHours(1);

You can also extract specific parts of a DateTime:

int year = DateTime.Now.Year; // For example, 2021
DayOfWeek dayOfWeek = DateTime.Now.DayOfWeek; // For example, Sunday

If you print that DayOfWeek object, it prints something like “Sunday.” And you can do other handy manipulations of DateTimes:

DateTime date = DateTime.Today; // Get just the date part.
TimeSpan time = thisMoment.TimeOfDay; // Get just the time part.
TimeSpan duration = new TimeSpan(3, 0, 0, 0); // Specify length in days.
DateTime threeDaysFromNow = thisMoment.Add(duration);

The first two lines just extract portions of the information in a DateTime. The next two lines add a duration (length of time) to a DateTime. A duration differs from a moment in time; you specify durations with the TimeSpan class, and moments with DateTime. So the third line sets up a TimeSpan of three days, zero hours, zero minutes, and zero seconds. The fourth line adds the three-day duration to the DateTime representing right now, resulting in a new DateTime whose day component is three greater than the day component for thisMoment.

Subtracting a DateTime from another DateTime (or a TimeSpan from a DateTime) returns a DateTime:

TimeSpan duration1 = new TimeSpan(1, 0, 0); // One hour later.
// Since Today gives 12:00:00 AM, the following gives 1:00:00 AM:
DateTime anHourAfterMidnight = DateTime.Today.Add(duration1);
Console.WriteLine("An hour after midnight will be {0}", anHourAfterMidnight);
DateTime midnight = anHourAfterMidnight.Subtract(duration1);
Console.WriteLine("An hour before 1 AM is {0}", midnight);

The first line of the preceding code creates a TimeSpan of one hour. The next line gets the date (actually, midnight this morning) and adds the one-hour span to it, resulting in a DateTime representing 1:00 a.m. today. The next-to-last line subtracts a one-hour duration from 1:00 a.m. to get 12:00 a.m. (midnight).

Declaring Numeric Constants

There are very few absolutes in life; however, C# does have an absolute: Every expression has a value and a type. In a declaration such as int n, you can easily see that the variable n is an int. Further, you can reasonably assume that the type of a calculation n + 1 is an int. However, what type is the constant 1?

The type of a constant depends on two things: its value and the presence of an optional descriptor letter at the end of the constant. Any integer type between the values of –2,147,483,648 to 2,147,483,647 is assumed to be an int. Numbers larger than 2,147,483,647 are assumed to be long. Any floating-point number is assumed to be a double.

Table 2-4 demonstrates constants that have been declared to be of a particular type. The case of these descriptors is not important; 1U and 1u are equivalent.

Changing Types: The Cast

Humans don’t treat different types of counting numbers differently. For example, a normal person (as distinguished from a C# programmer) doesn’t think about the number 1 as being signed, unsigned, short, or long. Although C# considers these types to be different, even C# realizes that a relationship exists between them. For example, this bit of code converts an int into a long:

int intValue = 10;
long longValue;
longValue = intValue; // This is OK.

An int variable can be converted into a long because any possible value of an int can be stored in a long — and because they are both counting numbers. C# makes the conversion for you automatically without comment. This is called an implicit type conversion.

A conversion in the opposite direction can cause problems, however. For example, this line is illegal:

long longValue = 10;
int intValue;
intValue = longValue; // This is illegal.

Some values that you can store in a long don't fit in an int (4 billion, for example). If you try to shoehorn such a value into an int, C# generates an error because data may be lost during the conversion process. This type of bug is difficult to catch.

But what if you know that the conversion is okay? For example, even though longValue is a long, maybe you know that its value can't exceed 100 in this particular program. In that case, converting the long variable longValue into the int variable intValue would be okay.

You can tell C# that you know what you're doing by means of a cast:

long longValue = 10;
int intValue;
intValue = (int)longValue; // This is now OK.

In a cast, you place the name of the type you want in parentheses and put it immediately in front of the value you want to convert. This cast forces C# to convert the long named longValue into an int and assumes that you know what you're doing. In retrospect, the assertion that you know what you’re doing may seem overly confident, but it’s often valid.

A counting number can be converted into a floating-point number automatically, but converting a floating-point into a counting number requires a cast:

double doubleValue = 10.0;
long longValue = (long)doubleValue;

All conversions to and from a decimal require a cast. In fact, all numeric types can be converted into all other numeric types through the application of a cast. Neither bool nor string can be converted directly into any other type.

Built-in C# methods can convert a number, character, or Boolean into its string equivalent, so to speak. For example, you can convert the bool value true into the string “true”; however, you cannot consider this change a direct conversion. The bool true and the string "true" are completely different things. Later in the book, you learn about the Convert class that goes a long way toward allowing you to convert anything into anything else, including converting bool values into int values, but using the Convert class isn't the same as performing a cast.

Letting the C# Compiler Infer Data Types

So far in this book — well, so far in this chapter — when you declared a variable, you always specified its exact data type, like this:

int i = 5;
string s = "Hello C#";
double d = 1.0;

You're allowed to offload some of that work onto the C# compiler, using the var keyword:

var i = 5;
var s = "Hello C# 4.0";
var d = 1.0;

Now the compiler infers the data type for you — it looks at the stuff on the right side of the assignment to see what type the left side is.

For what it’s worth, Chapter 3 of this minibook shows how to calculate the type of an expression like the ones on the right side of the assignments in the preceding example. Not that you need to do that — the compiler mostly does it for you. Suppose, for example, that you have an initializing expression like this:

var x = 3.0 + 2 - 1.5;

The compiler can figure out that x is a double value. It looks at 3.0 and 1.5 and sees that they're of type double. Then it notices that 2 is an int, which the compiler can convert implicitly to a double for the calculation. All the additional terms in x's initialization expression end up as double types. So the inferred type of x is double.

But now, you can simply utter the magic word var and supply an initialization expression, and the compiler does the rest:

var aVariable = <initialization expression here>;

If you've worked with a scripting language such as JavaScript or VBScript, you may have gotten used to all-purpose-in-one data types. VBScript calls them Variant data types — and a Variant can be anything at all. But does var in C# signify a Variant type? Not at all. The object you declare with var definitely has a C# data type, such as int, string, or double. You just don't have to declare what it is.

What’s really lurking in the variables declared in this example with var? Take a look at this:

var aString = "Hello C# 3.0";
Console.WriteLine(aString.GetType().ToString());

The mumbo jumbo in that WriteLine() statement calls the String.GetType() method on aString to get its C# type. Then it calls the resulting object's ToString() method to display the object’s type. Here’s what you see in the console window:

System.String

The output from this code proves that the compiler correctly inferred the type of aString.

Most of the time, the best practice is to not use var. Save it for when it's necessary. Being explicit about the type of a variable is clearer to anyone reading your code than using var.

You see examples later in which var is definitely called for, and you use it part of the time throughout this book, even sometimes where it's not strictly necessary. You need to see it used, and use it yourself, to internalize it.

You can see var used in other ways: with arrays and collections of data, in Chapter 6 of this minibook, and with anonymous types, in Book 2. Anonymous? Bet you can’t wait.

What’s more, the dynamic type takes var a step further. The var type causes the compiler to infer the type of the variable based on the initialization value. The dynamic keyword does this at runtime, using a set of tools called the Dynamic Language Runtime. You can find more about the dynamic type in Chapter 6 of Book 3.