C# Adventure 05: Classes and Objects

In this section of the Adventure Game series we'll re-conceptualize our existing code as classes. We'll also talk about how C# is an object-oriented language and how to create custom classes for our application.

Classes and Objects

Object-oriented programming models a problem by organizing it as a collection of discrete objects. Classes are defined that serve as templates for objects that have common attributes and/or behaviors. Objects are instances of a class. You can make several objects from a class, and each can have unique information.

The relationship between a class and objects that are instances of the class is like the relationship between a recipe and cookies. The recipe and the cookie are not the same thing. Using the recipe, you can make lots of cookies. You can even individually decorate each cookie so that it looks unique. Each cookie will have common attributes that are defined by the recipe.

Just like the recipe and a cookie made from the recipe are not the same thing, a class and an object are not the same, either.

Another example is a blueprint for a birdhouse. If you have a blueprint, you can make a lot of birdhouses. You can even customize each if you'd like, but they will all share elements that make them houses for birds. The blueprint and the resulting houses are not the same thing.

Static

The keyword static allows a member of a class to be used without creating an instance of the class first. We've used classes in our code but we haven't created any objects yet. We'll walk through how to do that when we add code to our Item class.

OO is a complex idea. Don't worry if you aren't comfortable with it right away. After you make a few applications with custom classes it will make more sense.

OO and C#

C# is an object-oriented programming language. In the simple code we have, you can already see how OO is integrated with C#:

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?");
            CharacterName = Console.ReadLine();

            Console.WriteLine("Your character is now named " + CharacterName + "!");
            Console.ReadKey();
        }
    }
}

Visual Studio's default template created a class for us: Program. The class has one method: Main().

Diagramming the class in UML would look like this:

All of the statements for our application are currently in Main(), the entry point for the application. It is a best practice to keep the code in Main() at a minimum, plus it will give us more options on how we can structure what we are building.

Let's restructure what we've written with custom classes.

Quick Quiz

Class Creation

How you model your class depends on how you conceptualize your application. There is no one "right" way to build a class; as long as you are following the language's rules you have a lot of freedom in expression.

Here is one way in which we could organize our Adventure Game code:

• Program: The base class for our application that has the entry point, Main().
• Game: A general class that will store data about the current game being played. We won't create instances of this class, so we will make it static.
• Item: A class that we will make instances of to create unique items the player can interact with.

The two new classes can be diagrammed with placeholders for now:

We could break our game down even further with classes for characters and other game elements. We'll stay with this simple structure, though, for this beginning game.

Shared Namespace

All three of our classes will be in the same namespace, Adventure. Imagine our Adventure namespace as a container with three smaller containers (our three classes) nested inside. Each class is itself a container for its attributes and methods.

You can see the hierarchy easier with the code collapsed and simplified like this:

namespace Adventure
{
    class Game {}
    class Item {}
    class Program { [...] }
}

There are a couple of ways to create new classes. One way is to include them in the same code file we've been working with. Another is to create a new file for each class.

When you start creating larger projects you will probably prefer adding a new class as a separate file. For some new programmers, however, keeping all the code in a single file is easier to understand.

We'll add our code to the existing file for now.

Add the two new classes ("Game" and "Item") to your project.

    class Game {}
    class Item {}

The class definition starts with the keyword "class" and then an identifier. Following the identifier is a code block (a set of curly braces). Statements will be added inside the code block soon.

The order of the classes doesn't matter, but be sure that they are properly opened and closed, and that they are nested inside the Adventure namespace, not each other.

static void Main() {
	Console.WriteLine("Hello World!");
	Console.ReadLine();
}

static void Main() 
{
	Console.WriteLine("Hello World!");
	Console.ReadLine();
}

static void Main() {Console.WriteLine("Hello World!");Console.ReadLine();}

Comments

Comments are notes within your code that are ignored by the compiler. They are useful for many reasons, including outlining your thought process, or for notes on what you'd like to add.

Comment Examples

You can start a single line comment with two slashes like this:

//single line comment

A multi-line comment is started with a slash and an asterisk, then closed with an asterisk and a slash, like this:

/* 
multiple line comment
*/

Add Comments

Add comments to indicate you are the author, and the date the application was created. Also include a credit to programmingisfun.com (the code is licensed CC BY).

Example Code

Your code should look something like this:

/*
 * [Your Title]
 * by Your Name, Date
 *  
 * This work is a derivative of 
 * "C# Adventure Game" by http://programmingisfun.com, used under CC BY.
 * https://creativecommons.org/licenses/by/4.0/
 */
using System;

namespace Adventure
{
    class Game
    {
    }
    class Item
    {
    }
    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?");
            CharacterName = Console.ReadLine();

            Console.WriteLine("Great! Your character is now named " + CharacterName);
            Console.ReadKey();
        }
    }
}

Press play (F5) to compile and run your application to make sure there are no errors.

In the next section we'll begin moving statements out of our Main() function, and into our new classes.

Quick Quiz

To Do: Practice

Practice what you've learned. Make another version of your Madlib, and learn how to add a title to the console window's title bar.

Assignments

• Add a custom class to your Madlib (with attributes and methods). Walk-through: Simple C# Madlib (Part Two).
• Learn how to modify the console window's properties. Read: Console Application Window Properties.

Code Files

If you have errors, or just want to check how your code compares in terms of progress, the code examples for this chapter are linked below.

• 5.1 New Classes

Next Step

In the next section we'll discuss more about methods and expand our code!