C# Adventure 04: Input

When you type the name of a static class, or an instance name, IntelliSense will show the properties and methods that you can use for the class or the instance, even for ones that you create yourself.

In the above image WriteLine is shown with "+ 18 overloads". Overloaded methods can be used in multiple ways because they have several definitions.

There are two common errors for new programmers to watch out for: accidentally attempting to declare a variable again and unintentionally changing the case of a keyword or identifier.

Declaring vs. Assigning a New Value

Precede the variable name (identifier) with the data type only when declaring a variable. When using the variable later don't include the data type again. If you do, the compiler will assume you are trying to declare a different variable with the same identifier and will show an error.

Example: If we create our variable CharacterName with the value 'John Doe' and then later want to change it to be 'Jane Doe', we would do something like this:

//declare variable and initialize it
string CharacterName = "John Doe";

//change the value
CharacterName= "Jane Doe";

The following example will not compile. The error will be something like "local variable named 'CharacterName' is already defined in this scope".

string CharacterName = "John Doe";
string CharacterName= "Jane Doe"; //this line will trigger an error

Case Sensitive

C# is case sensitive. Keep the capitalization the same when using variable names.

string CharacterName = "John Doe";
Charactername = "Jane Doe"; //this line will trigger an error

This example will cause an error. If you try it, you'll see something similar to "The name 'Charactername' does not exist in the current context". The compiler will think that CharacterName and Charactername are two different entities.

Two considerations for variable declaration placement are coding conventions and scope.

Coding Conventions

It is a common practice to have C# variable declarations at the top of a code block. We'll have ours inside the method Main, right after the opening curly brace.

An example of three variables declared together:

using System;

namespace Adventure
{
    class Program
    {
        static void Main()
        {
            //variable declarations
            string CharacterName = "John Doe";
            string Location = "Starting Area";
            string Companion = "Parrot";

            Console.WriteLine("Game Title");
            Console.WriteLine("Welcome to ...");
            Console.ReadKey();
        }
    }
}

The Main method is the entry point to our application, and the statements inside the method's curly braces {} will run as soon as the application is launched. Later we'll look at adding code to areas aside from Main.

Scope

Scope is the area within your program that an entity can be referenced without using a qualified path to it.

We previously looked at an example of a fully qualified path showing the namespace (System), the class (Console), and finally the method (WriteLine).

System.Console.WriteLine("");

In the example below, what do you think will be written out to the console window when it runs?

using System;

namespace Lunch
{
    class Program
    {
        string Food = "A yummy substance";

        static void Main()
        {
            string Food = "Something that can be eaten";
           
            Console.WriteLine(Food);
            Console.ReadKey();
        }
    }
}

Which of these will it be?

• A yummy substance
• Something that can be eaten

If you guessed "Something that can be eaten", you were right!

Even though there are two variables with the same name, they are in different scope areas. Because the command to write out the value of Food is in the same scope as the variable with "Something that can be eaten" as the value, that is what is written out.

If both variables named Food were in the same scope there would be an error because they would both be defined with the same identifier.

using System;

namespace Lunch
{
    class Program
    {
        static void Main()
        {
            string Food = "Something that can be eaten";
            string Food = "A yummy substance"; //this line will cause an error
           
            Console.WriteLine(Food);
            Console.ReadKey();
        }
    }
}

4.2 Instructions for Player.

using System;

namespace Adventure
{
    class Program
    {
        static void Main()
        {
            string CharacterName = "John Doe";

            Console.WriteLine("Game Title");
            Console.WriteLine("Welcome to ...");
            Console.WriteLine("What would you like your character's name to be?");
           
            Console.ReadKey();
        }
    }
}

We've used Console.Read() to keep our Console Window open. Read() reads in from the standard input stream, and a side effect of this is that the Console Window will stay open until something is read in.

Why are we now using Console.ReadLine()?

There are two better methods for reading in input than using Read().

• Console.ReadLine(): Reads the next line of characters entered.
• Console.ReadKey(): Obtains the next character entered.

So if you want to read in a name, word, or other string, you should use Console.ReadLine(). If you are only going to read in a single character, you can use Console.ReadKey() but using characters is different than using strings. Since you already know how to work with strings, you might want to stick with Console.ReadLine() for now.

You can use Console.ReadLine() or Console.ReadKey() to keep your Console Window open, too, but remember that keeping the window open is a side effect, it isn't the primary purpose of these methods.

Strongly-Typed Language

C# is a "strongly-typed" language. This means that variables (and some other elements) all have a specific type.

Types

A type has important information for the compiler such as how much storage space a variable of that type needs, and the kinds of operations or actions that are valid for it.

An example of an operation would be using the + symbol between two variables. If the variables are numbers, such as integers, you will get a sum of the two numbers added together. If the variables are strings, they will be concatenated.

int apples = 1;
int oranges = 2;

string breakfast = "cereal";
string dinner = "sandwich";

Console.WriteLine(apples + oranges);
Console.WriteLine(breakfast + dinner);
Console.Read();

Integers and strings act differently when the + operator is used. Running the above code will produce the following written to the console window:

The number on the first line is the result of 1 + 2.

The second line has two words (two strings) that have been joined together with the + operator.

Implicit Typing

"Implicit typing" is declaring variables without stating the data type; instead the keyword "var" is used. There are some restrictions on when and how implicit typing can be used, and these types of variables need to be initialized with a value.

Instead of stating that the CharacterName variable will be a string:

string CharacterName;

You can alternatively write this:

var CharacterName="";

A value (even an empty string) had to be assigned. Just "var CharacterName;" would raise an error.

Declare your variables for this project with a data type. Explicitly state the data type until you are building advanced projects and have a deeper understanding of the language.

If you've forgotten where Visual Studio saves your project folder, you can check the location in the new project dialog box. For example: "c:\users\YourUserName\documents\visual studio 2015\Projects".