C# Adventure 03: Concepts

In this section we'll discuss basic programming concepts as we review the code we've written. Some of the topics we'll look at include data types, variables, methods, classes, dot notation, and namespaces.

Understanding the Code

Here are our lines of code again:

Console.WriteLine("Your game title here!");
Console.WriteLine("Welcome to ..... You will be exploring the fantastic world of ..... ");
Console.ReadKey();

Output with WriteLine()

The first line writes what is in the parentheses to the console window. Inside of the parentheses we have text (our game title) in quote marks. The quote marks are important. They specify the start and end of a string of characters, and that string is what is printed to the console window.

The second line is similar to the first, we've just put different content inside our quote marks.

Data Types

Data is stored as specific types. We will use several types as we build our game. The word "data" might sound dry, but it is how we work with content in our application. If you want to include a line of dialogue in your game, for example, it will probably be a string data type. If you wanted to check whether something was true or false, you could use a Boolean value. A number could be one of several different types such as an Integer or Decimal.

Input with ReadKey()

The third line "reads" in from the input stream.

Console.ReadKey();

There are three similar elements: Read(), ReadKey(), and ReadLine(). The one we are using here, ReadKey(), acquires the next key pressed by the player. We could use this to detect if the player pressed the enter key, a single number, an arrow key, a function key, the space bar, or any other key.

A side effect of this is that the console window will stay open. If we didn’t have that line, our application would pop open, then close immediately.

Quick Quiz

Understanding the Code: Expanded

Right now, early in our coding adventure, the simple explanation at the top of this page is important to understand. By the time we finish our coding adventure, though, you should have a deeper understanding of what is happening when you write C#.

Read through the rest of this page, but don’t worry if it doesn’t all make sense. There are many layers or levels of understanding in programming. Keep building applications; sometimes you need to code something repeatedly and in slightly different ways before you truly "get" what is happening.

Objects and Classes

C# is an object-oriented language. Code is organized as objects that have properties and behaviors. We've already worked with classes in our project.

A class is a template that you can instantiate an object from. We will work with object instances when we build out our Item class.

So far we've seen two classes in our code. The first is the class Program. We added code to the Main() function inside of the class - we extended what the class is, and what it can do.

class Program

The second is Console that we are referencing from the .NET Framework library. It allows us to do things such as write out text to the console window.

Console.WriteLine("Game Title");

.Net Framework Library

Most of the code in our adventure game comes from the .NET Framework class library. Referencing something in the library is easy if you know how it is structured.

For example, here is the hierarchy for WriteLine():

.NET Framework 1.1 -> System -> Console -> WriteLine()

.NET [Framework] -> System [Namespace] -> Console [Class] -> WriteLine() [Method]

Moving from right to left (specific to general): The method WriteLine() is part of a class, Console. The Console class is part of the System namespace. The System Namespace is part of the .NET Framework.

This can be visualized as a series of nested boxes.

Dot Notation

To reference something from the library you need to let the compiler know the path. The hierarchy path is expressed in code with dots (periods) between elements. This is called dot notation. If we are writing the relationship in our code, we can optionally start with the Namespace (in this case, System).

System.Console.WriteLine("");

The full path shows the namespace (System), then the class (Console) and finally the method (WriteLine).

Console.WriteLine()

System.Console.WriteLine()

Console Class Diagram

Classes have attributes (properties) and operations (methods or functions). Attributes describe properties of a class, and operations describe what a class can do.

Within the Console class is WriteLine(), which is a method. Using UML (Unified Modeling Language), we can diagram the relationship between the Console Class and the WriteLine() method.

There are several operations within the class, but the ones we’ll be using the most in our adventure game are the methods Read, ReadLine, Write, and WriteLine.

• The top row of a class diagram lists the name of the class. In this case, Console.
• The second section lists the attributes (in this case they have been replaced by [...] to simplify the diagram).
• The bottom section lists the operations the class can perform. To simplify the diagram only four are listed here.

We'll use this type of simplified UML diagram throughout the series as we talk about our classes and how we are modifying them.

Example Class Structure

As we discussed previously, an attribute is class information; a property of the class. If we wanted to make a class that defined a pet one of the attributes might be the pet's name. Another might be their age.

A method is something that a class can do. Methods for our Pet class might be Eat(), Sleep(), and Play().

Simplifying Code

Here is a reminder of the code so far:

You can see that my version of Visual Studio has lightened lines 2-5. This is because those lines in the default template aren't actually needed for what we've written so far. Take out those lines to shorten up your code.

We can also make one other change. Line 11 of the screenshot shows:

static void Main(string[] args)

We don't need the text within the parenthesis (those are arguments that are being passed into the Main method). The line of code can be simplified to be:

static void Main()

Take out the arguments within the parenthesis.

Here is a screenshot of how your application might look after simplifying your code (yours should have your own original content, though):

Save your project and test it to make sure there are no errors.

If you do have an error look at the screenshot of the example and see if you are missing a semicolon, parenthesis, or something else that will keep it from compiling. Remember that you can "step" through your code with Visual Studio which is helpful when debugging (Problem Solving in Programming).

Quick Quiz

To Do: Review and Practice

Assignments

1. Create a simple Hello World application. Walk through: C# Hello World.
2. Review terms and concepts (list below).

• Data type
• String
• .NET Framework class library
• System namespace
• Console class
• Console.WriteLine()
• Class
• UML
• Attribute
• Operation
• Method
• Function
• Console.Read()

Code Files

Example code for this chapter:

• 3.1 Simplified Output to Console Window

Next Step

After you complete the Hello World walk through, move on to the next section where we will let our player enter information for the game.