A Microsoft employee (Anders Hejlsberg) invented a nifty computer language. He called it Cool but changed the name to C# (pronounced “C sharp”), to emphasize it’s higher than an earlier language, called C. (It’s also higher than a C variant called C++.)

C# tries to combine the best features of Visual Basic, Java, C, and C++:

C# is also influenced by an older programming language called Pascal. Before inventing C#, Anders Hejlsberg had already invented two famous Pascal versions (Turbo Pascal and Delphi) and a famous Java version (J++); he was an extremely experienced designer when he invented C#. He knew what was wrong with Pascal, Java, C++, and Visual Basic and how to improve them.

Microsoft recommends using Visual Basic to create simple programs but C# to create bigger projects. Microsoft considers Visual Basic and C# to be the most important computer languages to learn.

You already learned Visual Basic. Now let’s tackle C#.

Modern C#, called Visual C#, is part of Visual Studio. Get Visual Studio’s free version, called Visual Studio Community, by copying it from Microsoft’s Website, using the method on page 563 (“Copy the Community”). This chapter assumes you’ve done that, so you have Visual C# 2015.

Visual C# 2015 understands these commands:

It also understands these functions:

Here’s how to enjoy programming in C#.

Start Visual Studio

To start using Visual Studio, type “vi” in the Windows 10 Search box (which is next to the Start button) then click
“Visual Studio 2015: Desktop app”.

If you haven’t used Visual Studio before, the computer says “Sign in”. To reply, do this:

You see the Start Page window.

Start a new program

Click “New Project” (which is near the screen’s left edge) then “Visual C#” then “Console Application”.

Double-click in the Name box (which is near the screen’s bottom). Type a name for your project (such as Joymaker). At the end of your typing, press the Enter key.

Type your program

The computer starts typing the program for you. The computer types:

Let’s write a program that makes the computer say “I love you”. To do that, insert 2 extra lines, so the program becomes this:

Here’s how to insert those line:

The computer indents the lines for you, automatically.

You must type a semicolon at the end of each simple line. But there’s no semicolon at the end of a structure line (a line that’s blank or says just “{” or “}” or is immediately above “{”).

Important line The most important line is the one that says:

It makes the computer write “I love you” onto the screen.

Helper line To make Console.WriteLine work properly, you must put this helper line near the program’s bottom, just above the 3 final “}” lines:

That makes the computer pause until the human has read the computer’s output and presses a key.

You must put that helper line in every normal program.

Run the program

To run your program, click “Start” (which is at the screen’s top center) or press the F5 key. (If the “F5” is blue or tiny or the computer is new by Microsoft, HP, Lenovo, or Toshiba, that key works just while you hold down the Fn key, which is left of the Space bar.)

If you did everything correctly, you see the console window (which has white letters on a black background and resembles the DOS command-prompt screen). The console window shows the computer’s output. It shows:

When you finish admiring that output, press the Enter key (or Space bar or any other normal key) or click the console window’s X button.

If you want to run the program again, click “Start” again.

If you want to edit the program, retype the parts you wish then click “Start” again (which makes the computer debug and run the new version).

Final steps

Similar to Visual Basic, so read “Final steps” on page 566, but change “Funmaker” to “Joymaker” if you named your program “Joymaker”.

Multiple lines

Your program can contain several lines. For example, to make the computer say —

type these lines:

Below them, type the helper line:

If you say Write instead of WriteLine, the computer won’t press the Enter key at the end of its writing. For example, if you type:

the computer will write “I love you” without pressing Enter, then write “Let’s get married”, so you see this:

 

The computer can do math. For example, this line makes the computer do 4+2:

It makes the computer write this answer on your screen:

If you have 750 apples and buy 12 more, how many apples will you have altogether? This line writes the answer:

That line makes the computer write “You will have ”, then write the answer to 750 + 12 (which is 762), then write “apples”, so you see this:

Like most other languages (such as Basic, JavaScript, Java, and C++), C# lets you use the symbols +, -, *, /, parentheses, decimal points, and e notation.

Types of numbers

C# handles 5 types of numbers well.

One type of number is called an integer (or int). An integer contains no decimal point and no e and is between -2147483648 and 2147483647. For example, -27 and 30000 are ints. Each int consumes 4 bytes (32 bits) of RAM.

An unsigned integer (or uint) resembles an integer but must not have a minus sign, and it can be between 0 and 4294967295. For example, 3000000000 is a uint, though it’s too big to be an int.

A long resembles an integer but can be longer: it can be between -9223372036854775808 and 9223372036854775807. Each long consumes 8 bytes (64 bits) of RAM.

An unsigned long (or ulong) resembles a long but must not have a minus sign, and it can be between 0 and 18446744073709551615.

A double-precision number (or a double) contains a decimal point or an E. For example, -27.0 and 3E4 are doubles. A double can be up to 1.7976931348623158E308, and you can put a minus sign before it. Each double consumes 8 bytes of RAM. If you write a decimal point, put a digit (such as 0) after it.

Writing When Console.WriteLine makes the computer write an answer on your screen, the computer takes this shortcut: to write a double containing many digits after the decimal point, the computer writes just the first 15 significant digits; and if the only digits after the decimal point are zeros, the computer doesn’t bother writing those zeros or the decimal point.

Operations While you’re writing a math problem,
if you include a double (such as 5.0), the computer makes the answer be a double. For example, the answer to 5.0 + 3 is the double 8.0, though the computer doesn’t bother writing the .0 on your screen.

If you feed the computer a problem that involves just ints, the computer tries to make the answer be an int. If the answer’s too big to be an int, the computer gripes. For example, if you write —

the computer will gripe (because 3000 and 1000000 are both ints but the answer is too big to be an int). You should rewrite the problem to include a double, like this —

or —

or:

Then the answer will be a double (3000000000.0), which the computer will write on the screen in this shortcut form:

If you feed the computer a math problem whose answer is too big to be a double, the computer will give up and typically say the answer is:

The tiniest double that the computer handles well is 1e-308. If you feed the computer a math problem whose answer is tinier than that, the computer will either handle the rightmost digits inaccurately or give up, saying the answer is 0.0.

Dividing ints Since combining ints gives an answer that’s an int, 11 / 4 is this int: 2. So 11 / 4 is not 2.75. If you say —

the computer will write just:

If you want the computer to write 2.75 instead, say you want a double, by putting decimal points in the problem, like this:

That makes the computer write:

Dividing by 0 If you ask the computer to divide by 0, the computer will gripe.

Dividing by 0.0 If you ask the computer to divide by 0.0, the computer will get creative.

For example, if you say —

the computer will try to divide 5.0 by 0.0, give up (because you can’t divide by 0), and say the answer is:

If you say —

the computer will try to divide -5 by 0, give up (because you can’t divide by 0), and say the answer is:

If you say —

the computer will try to divide 0 by 0, give up (because you can’t divide by 0), get confused, and say the answer is —

which means “Not a Number”.

Advanced math

The computer can do advanced math. For example, it can compute square roots. This line makes the computer print the square root of 9:

The computer will print 3.

Besides Sqrt, you can use other advanced-math functions:

 

Like Basic and other languages, C# lets you use variables. For example, you can say:

A variable’s name can be short (such as n) or long (such as town_population_in_2001). The name can contain letters, digits, and underscores, but not blank spaces. The name must begin with a letter or underscore, not a digit.

Before using a variable, say what type of thing the variable stands for. For example, if n and town_population_in_2001 will stand for numbers that are ints and mortgage_rate will stand for a double, your program should say:

If x is a variable, your program should say one these lines:

If n is an integer that starts at 3, you can say —

but you can combine those two lines into this single line:

Here’s how to say “n is an integer that starts at 3, and population_in_2001 is an integer that starts at 27000”:

If you want x to be the string “I love you”, say —

or combine those lines, like this:

Increase

The symbol ++ means “increase”. For example, ++n means “increase n”.

These lines increase n:

The n starts at 3 and increases to 4, so the computer prints 4.

Saying ++n gives the same answer as
n = n + 1, but the computer handles ++n faster.

The symbol ++ increases the number by 1, even if the number is a decimal. For example, if x is 17.4 and you say ++x, the x will become 18.4.

Decrease

The opposite of ++ is --. The symbol -- means “decrease”. For example, --n means “decrease n”. Saying --n gives the same answer as n = n - 1 but faster.

Strange short cuts

If you use the following short cuts, your programs will be briefer and run faster.

Instead of saying n = n + 2, say n += 2, which means “n’s increase is 2”. Similarly, instead of saying n = n * 3, say n *= 3, which means “n’s multiplier is 3”.

Instead of saying ++n and then giving another command, say ++n in the middle of the other command. For example, instead of saying —

say:

That’s pronounced: “j is 7 times an increased n”. So if n was 2, saying j = 7 * ++n makes n become 3 and j become 21.

Notice that when you say j = 7 * ++n, the computer increases n before computing j. If you say j = 7 * n++ instead, the computer increases n after computing j; so j = 7 * n++ has the same effect as saying:

Input a string

These lines make the computer ask for your name:

Below them, remember to put the helper line:

When you run that program (by pressing the F5 key), here’s what happens.…

The top line makes the computer write this question:

The next line makes the string x be the answer you type. For example, if you answer “What is your name?” by typing “Maria” (and then pressing Enter), the computer will read your answer and make string x be what the computer reads; so x will be “Maria”, and the next line will make the computer write:

So when you run that program, here’s the whole conversation that occurs between the computer and you:

Just for fun, run that program again and pretend you’re somebody else.…

When the computer asks for your name, if you say something weird, the computer will give you a weird reply.…

Input a double

To make x be a string that the human inputs, you’ve learned to say this:

To make x be a double-precision number that the human inputs, say this instead:

That’s because Console.ReadLine() considers the human’s input to be a string, and Convert.ToDouble converts that string to a double.

Examples These lines make the computer predict how old a human will be ten years from now:

The top line makes the computer ask, “How old are you?” The middle line makes age be the result of converting, to a double-precision number, the human’s input. The bottom line makes the computer write the answer.

For example, if the human is 27 years old, the chat between the computer and the human looks like this:

If the human is 27.5 years old, the chat can look like this:

These lines make the computer convert feet to inches:

Input an integer

To make x be an integer that the human inputs, say this instead:

That’s because Convert.ToInt32 converts a string to a 32-bit integer.

To make x be a special type of integer that the human inputs, say one of these:

Arrays

Instead of being just a number, x can be a list of numbers.

Example For example, if you want x to be this list of integers —

type this:

In that line, the symbol “int[]” means “int list”. Notice that when you type the list of numbers, you must put commas between the numbers and put the entire list of numbers in braces, {}. On your keyboard, the “{” symbol is to the right of the P key and requires you to hold down the Shift key.

In x’s list, the starting number (which is 81) is called x₀ (which is pronounced “x subscripted by zero” or “x sub 0” or just “x 0”). The next number (which is 52) is called x₁ (which is pronounced “x subscripted by one” or “x sub 1” or just “x 1”). The next number is called x₂. Then comes x₃. So the four numbers in the list are called x₀, x₁, x₂, and x₃.

To make the computer say what x₂ is, type this line:

That line makes the computer write x₂, which is 207, so the computer will write:

Altogether, the lines say:

The first line says the integer-list x is { 81, 52, 207, 19 }. The second line makes the computer write x₂’s number, which is 207.

Jargon Notice this jargon:

Different types Instead of having integers, you can have different types. For example, you can say:

You can even say:

Uninitialized Instead of typing a line that includes x’s list of numbers, you can type the numbers underneath, if you warn the computer how many numbers will be in the list, like this:

The top line says x will be a new list of 3 doubles, called x₀, x₁, and x₂. The next lines say x₀ is 200.1, x₁ is 700.4, and x₂ is 53.2. The bottom line makes the computer say their sum:

Tables If you want x to be a table having 2 rows and 3 columns of double-precision numbers, say:

Since C# always starts counting at 0 (not 1), the number in the table’s top left corner is called x[0, 0].

 

Like most computer languages, C# lets you say “if”, “while”, “for”, and “goto” and create comments and subroutines. Here’s how.…

If

If a person’s age is less than 18, let’s make the computer say “You are still a minor.” Here’s the fundamental line:

Notice you must put parentheses after the word “if”.

If a person’s age is less than 18, let’s make the computer say “You are still a minor.” and also say “Ah, the joys of youth!” and “I wish I could be as young as you!” Here’s how to say all that:

Since that “if” line is above the “{”, the “if” line is a structure line and does not end in a semicolon.

How to type To type the symbol “{”, do this: while holding down the Shift key, tap the “[” key (which is next to the P key). To type the symbol “}”, do this: while holding down the Shift key, tap the “]” key.

When you type a line, don’t worry about indenting it: when you finish typing the line (and press Enter), the computer will indent it the correct amount, automatically.

 

Complete program Here’s how to put that structure into a complete program:

If the person’s age is less than 18, the computer will write “You are still a minor.” and “Ah, the joys of youth!” and “I wish I could be as young as you!” If the person’s age is not less than 18, the computer will write “You are an adult.” and “Now we can have some adult fun!” Regardless of the person’s age, the computer will end the conversation by writing “Glad to have met you.”

Since the computer types the top lines for you and also types the 3 braces at the program’s bottom, you type just the lines in the middle, starting with:

Fancy “if” The “if” statement uses this notation:

Here’s how to type the symbol “|”: while holding down the Shift key, tap the “\” key.

Look at that table carefully! Notice that in the “if” statement, you should use double symbols: you should say “==” instead of “=”, say “&&” instead of “&”, and say “||” instead of “|”.

If you accidentally say “=” instead of “==”, the computer will gripe. If you accidentally say “&” instead of “&&” or say “|” instead of “||”, the computer will say right answers but too slowly.

The symbol “<” compares just numbers, not strings. Instead of writing —

you must write:

While

Let’s make the computer write the word “love” repeatedly, like this:

This line does it:

The “while (1)” means: do repeatedly. The computer will do cout <<“love ” repeatedly, looping forever — or until you abort the program (by clicking the console window’s X button).

Let’s make the computer start at 20 and keep counting, so the computer will write:

These lines do it:

They write faster than you can read.

In that program, if you say “while (i < 30)” instead of “while (true)”, the computer will do the loop just while i remains less than 30; the computer will write just:

 

To let that program run properly, make sure its bottom includes the helper line saying “Console.ReadKey()”, so altogether the program looks like this:

Instead of saying “while (i < 30)”, you can say “while (i <= 29)”.

For

Here’s a more natural way to get that output of numbers from 20 to 29:

The “for (int i = 20; i <= 29; ++i)” means:

In that “for” statement, if you change the “++i” to “i += 3”, the computer will increase i by 3 instead of by 1, so the computer will write:

The “for” statement is quite flexible. You can even say “for (int i = 20; i < 100; i *= 2)”, which makes i start at 20 and keep doubling, so the computer writes:

Like “if” and “while”, the “for” statement can sit atop a group of indented lines that are in braces.

Goto

You can say “goto”. For example, if you say “goto yummy”, the computer will go to the line whose name is yummy:

The computer will write:

Exceptions

These lines try to make x be how many children the human has:

Those lines ask the human “How many children do you have?” then wait for the human’s response then try to convert that string to an integer (such as 2 or 0) and call it x. But what happens if the human does not input an integer? What if human inputs a number that includes a decimal point? What if the human types a word, such as “none” or “one” or “many”? What if the human types a phrase, such as “not sure” or “too many” or “none of your business” or “my girlfriend was pregnant but hasn’t told me yet whether she got an abortion”? In those errant situations (which are called exceptions), the computer can’t do Convert.ToInt32 and will instead abort the program, show the human all the program’s lines, and highlight the problematic line. Then the human will be upset and confused!

To avoid upsetting people, change those lines to this group of lines instead:

The group begins with a label (AskAboutKids) and makes the computer ask “How many children do you have?” Then the computer will try to do this line:

If the computer fails to do that line (because what the person typed can’t be converted to an integer), the computer won’t gripe; instead, it will catch the error and do the lines indented under “catch”. Those lines are called the catch block (or
exception handler). They make the computer say “Please type an integer” then go back to the beginning of AskAboutKids, to give the human another opportunity to answer the question correctly.

If the human doesn’t know what an “integer” is, phrase the advice differently: make the computer write “Please type a simple number without a decimal point”.

Comments

To put a comment in your program, begin the comment with the symbol //. The computer ignores everything that’s to the right of //. Here’s an example:

The computer ignores all the comments, which are to the right of //.

While you type the program, the computer makes each // and each comment turn green. Then the computer ignores everything that’s turned green, so the computer writes just:

Subroutines

Like most other languages, C# lets you invent subroutines and give them names. For example, here’s how to invent a subroutine called “insult” and use it in the Main routine:

The computer will write:

In that program, the lines beginning with “static void Main(string[] args)” define the Main routine. The bottom few lines, beginning with “static void insult()”, define the subroutine called “insult”.

Whenever you write a subroutine’s name, you must put parentheses afterwards, like this: insult(). Those parentheses tell the computer: insult’s a subroutine, not a variable.

To write a subroutine’s definition simply, begin the definition by saying “static void”.

Here’s another example of a main routine and subroutine:

The Main routine says to laugh. The subroutine defines “laugh” to mean: write “ha ” a hundred times.

Let’s create a more flexible subroutine, so that whenever the Main routine says laugh(2), the computer will write “ha ha ”and Enter; whenever the Main routine says laugh(5), the computer will write “ha ha ha ha ha ” and Enter; and so on. Here’s how:

The computer will print:

Average Let’s define the “average” of a pair of integers, so that “average(3, 7)” means the average of 3 and 7 (which is 5), and so a Main routine saying “i = average(3, 7)” makes i be 5.

This subroutine defines the “average” of all pairs of integers:

The top line says, “Here’s how to find the average of any two integers, a and b, and make the average be an integer.” The next line says, “Return to the main routine, with this answer: (a + b) / 2.”

Here’s a complete program:

In that program, the Main routine is:

You can shorten it, like this:

You can shorten it further, like this:

To make that program handle double-precision numbers instead of integers, change each int to double. After changing to double, the program will still work, even if you don’t change 3 to 3.0 and don’t change 7 to 7.0.

Like Visual Basic, C# lets you easily create Windows forms. Here’s how.

Start C# (by typing “vi” in the Windows 10 Search box, then clicking “Visual Studio 2015: Desktop app” then “New Project” then “Visual C#”).

Click “Windows Forms Application”.

Double-click in the Name box (which is near the screen’s bottom). Type a name for your project (such as Joymaker). At the end of your typing, press the Enter key.

You see an object, called the Form1 window. Double-click in that window (below “Form1”). That tells the computer you want to write a program (subroutine) about that window.

The computer starts writing the subroutine for you. The computer writes:

The line saying “private void Form1_Load” is the subroutine’s header. Below that, between the braces (the symbols “{” and “}”), insert lines that tell the computer what to do when Form1 is loaded (appears). The lines you insert are called the subroutine’s body.

Simplest example

Let’s make the Form1 window say “I love you”. To do that, type this line —

The computer automatically indents that line for you, so the subroutine becomes:

To run your program, click “Start” (which is at the screen’s top center). Then you see the Form1 window again; but instead of saying “Form1”, it tries to say the text:

(To see all that, maximize that Form1 window by clicking its Maximize button, which is left of its X.)

When you’ve finished admiring the Form1 window, stop the program by clicking the Form1 window’s X button. Then you see the subroutine again:

If you wish, edit the subroutine. For example, try changing the Text line to this:

Math

The Text line can include math calculations, but you must convert the answer to a string, since Text must be a string. For example, to make the computer write the answer to 4 + 2, type this line:

Message box

To create a message box saying “Your hair is messy”, type this line:

To create a message box saying the answer to 4 + 2, type this line:

Property list

Click the “Form1.cs [Design]” tab, so you see the Form1 window itself. Then click (just once) in the middle of the Form1 window.

Then the screen’s bottom-right corner shows a list whose title is:

That list is called Form1’s main property list (or
property window). It looks the same as if you were using Visual Basic. To explore it, reread my chapter about Visual Basic.

See the toolbox

Click the “Form1.vb [Design]” tab then “View” (which is near the screen’s top-left corner) then “Toolbox”. Then you see 10 toolbox categories:

(If you don’t see that whole list yet, scroll down.)

The toolbox looks the same way as if you were using Visual Basic. To explore how to use its tools, reread pages 576-584, starting with “See common controls”.