The goal for this exercise is to understand how to create your own, simple class, with a method(s) on that class.

---

Defining a new method in a Console app is slightly complicated, in the sense that we have a couple of options open to us. Further, we want to prepare for Object Oriented Programming (OOP), which we’ll cover in more detail later in the term. Towards that end, we will see one way of creating a class with method, and we’ll try to use only that one method (even though there are other options)

In OOP, our overall program is divided up into classes, where each class contains data and functions that we can use. Some classes we will create ourselves, other classes are provided for us to use. Each class defines a category (or type) of software that we will make use of - a software ‘building block’, if you will. You are encouraged to look online for a more detailed explanation, but for the purposes of this course right now, we will restrict ourselves to this simple overview. Especially because this concept should be familiar from prior courses / experience, even if you’re not 100% solid on the topic.

We want to create a method (aka function, or subroutine, or routine, etc) that accomplishes some work for us. Ultimately, we want to call the method, which will result in the program jumping to the new method, executing all the statements (commands) in that method, and returning to where it was.

The basic pattern that we’ll use is to create a class, and within that class, we will create a new method (or methods). Here’s an example:

using System; namespace PCE_StarterProject { class Program { static void Main(string[] args) { Basic_Console_IO bcio = new Basic_Console_IO(); bcio.RunExercise(); } } class Basic_Console_IO { public void RunExercise() { Console.WriteLine("Hello, World!"); Console.WriteLine("Hello, World, again!"); } } }

Example 1 (above)

First, you’ll notice that this is almost identical to code from a previous exercise – you’ve already worked with some OO code! Secondly, the class is everything inside the yellow box (including all the stuff in the orange box, inside the yellow box). The class starts with the lines

    class Basic_Console_IO
    {

And continues until the matching close-curly brace ( } ). Everything between the open and closing curly braces are “inside the class”, and are considered to be a part of the class definition. In this example, we have a single method (in the orange box), but we could add multiple methods if we wanted to. When we define a method, we will (for now) start with ‘public void’, give the method a name, follow the name with open and close parentheses, and then the opening curly brace (which indicates where the method begins. There is a matching close curly brace at the bottom of the orange box that tells C# where the method ends. Inside are the familiar Console.WriteLine commands that you’ve seen previously:

    public void RunExercise()
    {
        Console.WriteLine("Hello, World!");
        Console.WriteLine("Hello, World, again!");
    }

Having written out all the code in the yellow (and orange) box, we have defined our class, and our method. The next question is “How do we call our method?” – this is demonstrated by the code in the green box:

        Basic_Console_IO bcio = new Basic_Console_IO();
        bcio.RunExercise();

As you can see, we first need to create a new object that is an instance of the Basic_Console_IO class. Once we’ve done that, we can call public void methods on the Basic_Console_IO class, using that new object. Here, we’ll name the object bcio (just to give it a name), and then invoke the RunExercise method. Note the syntax for calling the method – name of the object, a dot/period, name of the method (this is case sensitive!), the open and close parentheses, then the semi-colon at the end.

Just to be clear, the flow of execution for this would look like the following.

In Main, the program will create the new object, then call the RunExercise method, which will cause it to jump down to the method (following the blue arrow). The first line of code (which prints "Hello, World!") gets executed, followed by the second line of code in that method. The third thing that happens in the method is that the program jumps back to main (red arrow), ready to do the next thing in the program.

Once you’ve created an object, and called a method, you may call other methods in that same class, like so (note that each method is being put into a separate, orange box:

using System; namespace PCE_StarterProject { class Program { static void Main(string[] args) { Basic_Console_IO bcio = new Basic_Console_IO(); bcio.RunExercise(); } } class Basic_Console_IO { public void RunExercise() { Console.WriteLine("Hello, World!"); Method_Two(); // note that since we're calling // another method on the same object, // we do NOT need to create a new object } public void Method_Two() { Console.WriteLine("Printing something else"); } } }

Example 2 (above)

Based on what you’ve seen above, the pattern of having Main create an object (aka “an instance of a class”), then call the RunExercise method on it should make more sense. In this course, you will typically be given the above code (a starter class, with a RunExercise method, that gets created and called from Main), but it’s good to understand why things work the way they do.

We can also create a class, with a new method on it, in the RunExercise method, if we want. For example:

using System; namespace PCE_StarterProject { class Program { static void Main(string[] args) { Basic_Console_IO bcio = new Basic_Console_IO(); bcio.RunExercise(); } } class Basic_Console_IO { public void RunExercise() { ConsolePrinter cp = new ConsolePrinter(); cp.PrintMessage(); } } public class ConsolePrinter { public void PrintMessage() { Console.WriteLine("Hello, World!"); Method_Two(); // note that since we're calling // another method on the same object, // we do NOT need to create a new object } public void Method_Two() { Console.WriteLine("Printing something else"); } } }

Example 3 (above)

(Classes are in yellow boxes, methods are in orange boxes)

The only difference between this example, and the prior example is that there is an extra step: the RunExercise method creates a second object (of the ConsolePrinter class), and then calls PrintMessage on that other object.