Author: Greg

Introduction

In this segment of the introduction to programming concepts, you’ll learn about the basics of some additional common programming elements by adding in some conditions. When this section is done, you’ll be ready to start discussing more significant programming concepts, and will be able to handle the solid fundamental lessons, building some simple programs that build up core skills.

Hello, World – enhanced

Up to this point, we’ve only worked in a limited fashion with actual code; it was very important to discuss key concepts before we dove right in. Now that we have looked at concepts like data types, we’re ready to expand the function of our HelloWorld program. Rather than modifying the existing code, however, we’re going to add another project into the solution we started, and use that to build a slightly more advanced version of the original application.

Open up Visual Studio 2019. You’ll end up at the launch menu, where you should see the HelloWorld.sln solution we made in our prior lesson. Go ahead and click on that entry to get started.

Our existing application should open up with the source code for the HelloWorld file.

We’re going to create a second project within the solution, and use that to make our expanded program. From the File menu in the upper left hand corner of the window, select New > Project. Since we have already created a Console App (.NET Framework) before, it will show up under “Recent project teamplates”. Click it once to highlight it, and click the “Next” button.

We are presented with the “Configure your new project” screen.

For Project name, enter HelloAdvancedWorld. Change “Solution” from “Create new solution” to “Add to solution”. The location should default to the fold containing the existing HelloWorld solution. The solution name field will be grayed out, but will say “HelloWorld”. Finally, make sure you’re set to the latest Framework. For my system, this is .NET Framework 4.7.2. Click on the “Create” button. A quick note, it is also possible to add projects in using the “Solution Explorer” panel on the right side of the Visual Studio Screen. You simply right click on the solution name, scroll down to “add” and click on “New project”. The process will be nearly the same, though the “Configure your new project” window will look like the one below, instead of the one we saw above.

You should now notice a few changes. First, in the “Solution Explorer” panel, we’ll see our new project, “HelloAdvancedWorld”, along with the existing “HelloWorld”. Each project will have a few elements underneath: Properties, References, App.config and Program.cs. Now at first, it might seem odd that there are two entries for each of these, but realize that each project has it’s own folder in the solution (both in the application and on your hard drive), and the elements of each project are independent of each other.

Additionally, the main toolbar up above now has an additional drop down menu in it. After “Debug” and “Any CPU”, we should now see “HelloWorld”, followed by the play arrow / Start button.

If you click on that drop-down, you’ll see our other project, HelloAdvancedWorld, as an option.

If you change to our new project, you’ll be able to run that project instead of the original one. And you can always change back if you need to. Also note; if you change which project is the Active one in this menu, the title of that project will take on a bold font face in the Solution Explorer.

In the new Project.cs, replace the existing code with this:

using System;

namespace HelloAdvancedWorld
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello, world!");
            Console.ReadKey();
        }
    }
}

This is the same as the code from the original project, with two small differences. First, we’ve removed all of the using statements we don’t need. Second, you should see that the namespace on this version is HelloAdvancedWorld. If you recall in the Getting Stated with Visual Studio 2019 article, I mentioned that a namespace is a sort of container for code. The common practice in C sharp and many other C-styles languages is to have a namespace that matches the project name. A namespace allows you to have multiple blocks of code in there which are then all part of the same “package”. The advantage of this is, if you use a meaningful naming convention for your namespace values, if you have a component that has a similar name to a component from another project or library, the C sharp compiler will understand that you mean this specific version; it’s a way of clarifying which blocks of code you are referring to when names of those code blocks could overlap.

For now, HelloWorld and HelloWorldAdvanced are sufficient. In later projects, we’ll look at better ways to organize using the namespace approach, and you’ll be able to see how it benefits you to have unique namespace values.

If we run this program, nothing new is going to happen yet, because it matches the original HelloWorld application exactly. It’s time to change that a bit.

Let’s replace lines 9 and 10 with some new code:

Console.Write("What is your name? ");
string myName = Console.ReadLine();

Console.WriteLine("Hello, " + myName + "!");
Console.ReadKey();

Make sure you switched that drop-down to “HelloWorldAdvanced”, then go ahead and run the project.

You should be prompted for your name. Go ahead and type in your first name, then hit enter.

It might not seem like much, but you actually did accomplish something important. You received input from the user, and you used it to display back out a message. It’s an important first step in building something much larger. Go ahead and exit the application by pressing any key, or closing that window.

So what did we do? Let’s look at the code. I’m only going to focus on the 4 critical lines, but here’s the total code we have.

using System;

namespace HelloAdvancedWorld
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("What is your name? ");
            string myName = Console.ReadLine();

            Console.WriteLine("Hello, " + myName + "!");
            Console.ReadKey();
        }
    }
}

Line 9 – We’re writing out the message “What is your name? “. The extra space character at the end is to allow us to make the input look a bit neater. Note how this line is “Console.Write” instead of “Console.WriteLine”. I mentioned in a prior article that WriteLine automatically adds a carriage return, or a new line character, at the end of the display process. Write does not add on the character. By using the “Write” command, we can then read in the input directly after the display; it’s a nice way of setting up an input form. It doesn’t affect anything, logically, but it’s nice to know we have that sort of option.

Line 10 – We start out by declaring a variable named myName, with a type of “string”. This means we’re creating a placeholder and assigning it an easy to remember name. Next, the = sign indicates that we’re going to store something into that variable. In the simplest of terms, we’ll need to store in a value that is of the string type. Remember that numbers can be included in a string, but if you use them, they’re being used for non-calculation functions; in other words, they hold no significant mathematical value, they’re just more character that we’re going to display.

Line 10 finished off with Console.ReadLine(), followed by a semi-colon. The Console object, part of our System library, allows for both input and output to the command line / console window. In this case, Console.ReadLine() indicates that the program will continue reading in characters until it encounters a carriage return / new line character – indication that you have pressed your enter key. So the entirety of this line reads as: create a new string variable, call it, myName, and use it to hold the value that the Console reads in, up until the point that the user presses the enter key. It might sound like a lot, but the syntax actually is pretty simply if you stop to think about it.

Line 11 is just a blank line, and remember that the computer will just ignore those blank lines and spaces. It’s convenient to us for organizing code, but the computer doesn’t care if you’re not ordering it to do anything there; it just moves to the next instruction.

Line 12 – Now that we have a value for “myName”, we are going to print it out as part of a message. We indicate that we are going to perform a Write to the Console. We’ve used Console.WriteLine before, so let’s take a look at the information that we’re sending in between the parenthesis. “Hello, ” + myName + “!” turns into “Hello, Greg!” if we type in my name when prompted. The data in the parenthesis is a string; but it is one that is concatenating a variable into the rest of a hard-coded string; in other words, we’re using the actual text “Hello, ” and concatenating (or adding on) the value of the myName variable; then we add on another actual text string, the final exclamation point. When working with string, you can concatenate multiple string together by using a + and either a literal string encased in double quotes, or a variable that can output data as a string. It is possible to output actual numeric variables as string as well. There are other ways of printing out the data, using essentially a substitution approach. I’ll cover that in just a little bit.

Line 13 – This should also be familiar from the original HelloWorld application. This command is essentially pausing for more input; the difference is that this time, the input will be any single character. Whatever we press will qualify as a read key, and the program will move to the next instruction. However, given that there aren’t any more instructions, the program will simply end. If we did not include this line, the prior line printing our message would execute and the program would exit immediately. And in all likelihood, no one would have been able to read the message fast enough to know what it said. So this is useful to make sure you can see everything that appears on the screen, and not quit until you’re really ready to do so.

So much code, so little action

It might seem like we had to go through a lot to make that little bit happen; and in some ways, that is very true. However, the fact is that we’ve learned how to process both input AND output, and that covers a big chunk of what we do with programming. Remember that a computer is primarily a device to speed up mundane, repetitious processes, or to handle complex calculations rapidly without error. So being able to read and write output is a major part of the process; having the ability to process data would be of little use if you could never set up what to calculate, or never see the results of those calculations.

And the truth is, as we build more sophisticated programs, some (or much) of the code will be repeatable and reusable, so while a simple program like Hello, World seems like a lot of work for a very minimal payoff, remember that it’s really serving as a foundation for building something more meaningful. Boiling water isn’t exactly exciting or special, but if you don’t learn how to boil water properly, there are a lot of dishes you’d never be able to cook properly, if at all.

Success doesn’t mean having an answer…

So what do we do if a person is prompted for data and just hits enter? Well, under our current program, the output would be: “Hello, “. Well, that’s not really correct, is it? They could put in any sort of value and it would at least seem plausibly correct. But what about if they leave it blank? Maybe we should do something different. Let’s use a condition to handle that.

We’re going to modify our code a bit. Replace the code on line 12 with the following:

if (myName == string.Empty)
{
    Console.WriteLine("Hello.  You didn't tell me your name!");
}
else
{
    Console.WriteLine("Hello, " + myName + "!");
}

Now, run your program again, and when prompted for your name, just press enter.

Now, by not putting in any value, we get a different message. Let’s break down the new code.

Line 12 – This is a test for a condition; commonly, we can use the key word “if” to indicate that we need to test one or more conditions for truth – hence the name “if statement”. If statements are one type of conditional test; we check to see if one or more conditions evaluates to true, and if they do, we will execute the code nested in curly braces following the “if” line.

Now, some languages will let you state “if” followed immediately by the condition. Most proper languages, however, require you to put your test inside at least a single set of parenthesis. So in this case, we’ll check to see if myName is equal to an empty string. “if (myName == string.Empty)” is literally able to translate into “if the value of myName is equal to an empty string”. The double equal sign is critical here. Remember from earlier, we used a single equal sign to set myName to the value of the Console.ReadLine. If you used a single equal symbol during the condition test, you’d be trying to say “if I store an empty string into myName”. First, this would mean that you’re overwriting the value that was already stored in your variable; second, it would conceivably mean that any time you hit this logical test, the result would always be true – you’d always be able to store the variable. Some languages allow this sort of syntax; C Sharp, however, will thrown an error, because it is expecting the conditions in the parenthesis to be something it can evaluate. Storing a variable is an action, not an evaluation, so the compiler won’t even let you do this. A double equal (==) always indicates comparison. The string.Empty portion of our condition actually is a property that translates into a string with no characters. This means that there is technically a string, it’s just that it has no significance. It is possible to have a string variable that is set to nothing (also called null) which has a different meaning. Null values are something we will discuss another time. For now, we’ll move on.

Line 13 is an opening curly brace that is matched by the closing brace on line 15. And the line in between is what will happen when we have met the condition of an empty string.

Line 16 – Else is the alternative, default condition that is assumed if the conditional check is not met. It is a ways of saying “if any other test we did did not succeed, we’ll do this instead”. The else statement must always follow the closing curly brace of a prior “if” condition. Then the bracketed code following it will execute instead of the initial conditional block.

There is a problem with this code, however. If you run the application, a user might decide to hit the space bar instead, and then hit enter. This is a problem; we’re only alerting them that they didn’t enter a name if they have a string that has no characters. We haven’t accounted for a string that has characters that are all blank spaces.

Go ahead and run the application and you’ll see what I mean.

Well, that isn’t any good. What we need to do is test to make sure they’re not just entering a string consisting of blank characters. But there is a problem; that string could be up to 2 billion or more characters in length; and if we want to check for a string with that many possible spaces, it means we’d need to test each case individually. That means having to check for 2 billion possibilities!

Fortunately, we don’t need to do something crazy like that. Instead, we’re going to modify line 12 from this:

if (myName == string.Empty)

to this:

if (myName.Trim() == string.Empty)

Trim() is a method that exists on all string variables, and on all methods or functions that generate a string as a return value. The Trim() method in it’s basic form removes any blank characters before the first non-blank character, and after the last non-blank character. So for example, if you had a string with a value of: ” Test “, the Trim() method would turn that into “Test”, without any spaces before or after the first and last T. By applying that method to our variable, we will only print our hello message if we have a value in myName that consists of visible characters.

Comment your concerns

Let’s be honest; you’re probably not going to carry this website around with you all the time – so you won’t necessarily have my documents ready to explain what we did here handy immediately. If only there was a way to leave a note for ourselves in our programs that explains what we did, but will not actually be treated like instructions for the program itself. Well of course, we can do that!

The notes we want to leave for ourselves are called “comments”. And every language has them in some form. In most C-styles languages, comments can be made in one of two ways. The first, is to put to forward slashes next to each other, like so:

//this is a single line comment

The single line comment starts the moment you have the two slashes, and continues on until the end of that line. The nice thing about this is that you can put them after an actual programming command, like so.

int i = 0; // Initialize the variable to 0

The second option is to use /* and then use */ at the end of the comment. This allows for multiple-line comments. This way, if you have a longer explanation, you can prevent a need to scroll sideways a long distance to read the whole message.

/* This is an example of a multiple-line comment.  It makes it
   very easy to read this comment if you don't need to scroll sideways
   to read all of it.  This is a great way to leave detailed explanations
   in your code.  That's a very good habit to get into. */

All of those lines will be ignored by the compiler now. There is one other great use of the commenting system – it’s good for temporarily disabling a block of code for testing, or to disable a block of code if you’re replacing it with a new block of code, so you can compare what was there previously. Like so:

   /* if (i == 0)
   {
       Console.Write(" Print out a value ");
   } */

   if (i < 1) // Changed to this to handle negative values - less than 0
   {
        Console.Write(" Print out a value ");
   }

Now that you know this, I will give you a piece of advice – DO NOT HESITATE TO LEAVE YOURSELF COMMENTS. Trust me when I say, commenting your code, regardless of the language, regardless of the platform, is an invaluable capability. Never feel that it’s ridiculous to leave yourself a lot of notes. The more effort you put into leaving detailed, meaningful notes, the less of a strain it is later to remember what you did, and why.

Nesting Code

We’ve already discussed nesting code to some extent, using the curly braces { and } to block out code. Let’s take that a step further by getting some additional information from the user and nesting our code to process it. First, comment out the “if… else” block on lines 12 – 19. You can either do a series of single line comments, or use the multi-line comment approach by placing /* at the start of the block and */ at the end of the block.

//if (myName.Trim() == string.Empty)
//{
//    Console.WriteLine("Hello.  You didn't tell me your name!");
//}
//else
//{
//    Console.WriteLine("Hello, " + myName + "!");
//}

/*if (myName.Trim() == string.Empty)
{
    Console.WriteLine("Hello.  You didn't tell me your name!");
}
else
{
    Console.WriteLine("Hello, " + myName + "!");
}*/

One neat trick to make you aware of with Visual Studio is that you can select a bunch of lines, press the control key (Ctrl) and then press the k key, then release and press the c key. This will turn all of the selected lines into comments. By using the Ctrl key, pressing k and then u, you can un-comment those same lines. It’s a handy shortcut to know.

OK. Let’s add a comment in to keep track of out code. On line 10, before the creation of our variable, hit your enter key, so we can put in a new line. Then go back to the new, blank line, and type in a comment that says “Get variable for name”. That should leave your variable creation on line 11. Create an extra line on 12 so we can space out the next block of code. Then add in a console write for “What is your gender (m/f) ?” Go to the next line and leave a comment that says “Get variable for gender”. Finally, add in a line to create another variable of type string, call it myGender, and set it equal to “Console.ReadLine();” When you’re done, the new block of code should look like this.

Console.Write("What is your name? ");
//Get variable for name
string myName = Console.ReadLine();

Console.Write("What is your gender? ");
//Get variable for gender
string myGender = Console.ReadLine();

Next, let’s write some more code to handle using this input. First, we’ll determine the output based on the gender. This will introduce us to a few concepts. We’re going to do a test for multiple conditions. We want to see if the gender is equal to an ‘m’, an ‘f’, or any other value; we will then print out an appropriate message. Here’s the code we can plug in to do this.

//Check if myGender is set to an f or an m
if (myGender.Trim() == "f" || myGender.Trim() == "m")
{
    //Start printing the message for a specified gender
    Console.Write("You specified a gender of: ");
    
    //If gender is f
    if (myGender.Trim() == "f")
    {
        //finish print - female
        Console.WriteLine("female.");
    }
    //If gender is m
    else
    {
        //finish print - male
        Console.WriteLine("male.");
    }
}
//If gender is not f or m
else
{
    //Print alternative message
    Console.WriteLine("You specified a gender of other or did not specify a gender.");
}

Phew! That’s a lot of code, isn’t it? This code should follow the line where we read in the myGender variable. I put in an extra blank line just to keep things a bit easier to read. Go ahead and run the application 3 times. For each run, enter a different value for the Gender question. Try m, f and o. If you want, you can try any other value for the 3rd test. You can even leave it blank.

• 

• 

• 

You should be able to get an answer of male, female and our “other” message. Now, try running it one more time, and this time, make your gender a capital M or capital F. You might see something you don’t want.

We put in M. Why didn’t we get the male message? Our condition was case sensitive. We have a few ways we can deal with this. The first is to do multiple tests, the second will allow us to streamline our coding. But first, let’s talk about our “if” statements.

When we did our first test, we said:

if (myGender.Trim() == "f" || myGender.Trim() == "m")

This translates into: if we trim the value of myGender of blank space and get a value of f, or if we trim the value of myGender of blank spaces and we get a value of m, we’re going to proceed into this part of our logic. The alternative condition(s) will be met about 18 lines later, with the line that simply states “else”. The double pipe characters || indicates a logical “or” statement. On most models of keyboard, the pipe characters are found on the same key as the backslash key \, which is usually near the backspace key. A pair of these characters will always be a logical OR. If you wanted to say AND, you’d use two ampersands instead &&.

So here we’ll checking for an f or m, and a failure to match those values will jump down to the else statement. Inside, we print out the star of our message about the gender. Note that I used the Console.Write and NOT Console.WriteLine – this way we can print the actual answer on the same line. This isn’t necessary, it’s just an aesthetic choice. The only problem here is, a user might put in a capital M or F… and though it’s the same letter, the fact that it’s capital means that our code will not execute.

One way we could do this is to test for those two additional conditions. First, we could modify our initial test to say this:

if (myGender.Trim() == "f" || myGender.Trim() == "F" || myGender.Trim() == "m" || myGender.Trim() == "M")

This works, and if you do that, you’ll have part of the solution we need. Of course, we’ll also need to modify the blocks that finish the print, specifically the condition that tests for female. Our else will handle either option for male. But there is an easier way.

C sharp allow for operations that are “chainable”. In other words, we can have the results of one operation passed to another operation on the same data object. And with data types like strings, there are actually a number of additional methods that we can chain on. In this case, we can use a method called “Upper” or “Lower” to transform all the characters in the string to one case, and then we can compare against just that single case. So we could convert our logic to this, which will be shorter, and yet perform the same exact operation.

if (myGender.Trim().Upper() == "F" || myGender.Trim().Upper() == "M")

We could then do the exact same thing for the further test for printing the female message. Again, we don’t need to do anything for the male message, because we’re not testing an individual condition.

Now, that we have that part done, we can expand our “alternative” answers. What if we wanted to differentiate between non-specified and other? Enter the next step of conditions… else if.

Else if let’s us chain a series of conditional tests, one sequence after another. In this case, we can modify our block to work like this (please note, I am skipping the internal content for the male and female option to focus on the else if portion).

//Check if myGender is set to an f or an m
if (myGender.Trim().ToUpper() == "F" || myGender.Trim().ToUpper() == "M")
{
    //Our logic to clarify M and F still goes in here.
    //I omitted it to keep this shorter.
}
//If gender is not f or m, but was specified
else if (myGender.Trim().ToUpper() != "F" && myGender.Trim().ToUpper() != "M")
{
    //Print alternative message
    Console.WriteLine("You specified a gender of other.");
}
//If gender is not f or m or other value
else
{
    //Print unspecified message message
    Console.WriteLine("You did not specify a gender.");
}

If you run a series of tests, you’ll see our logic split out more, and the answers are a bit more detailed when it comes to the other / no answer options. Likewise, a capital M or F will yield the correct response.

Another way we could write this code would be to split out the Male and Female options, like so:

//Check if myGender is set to an F
if (myGender.Trim().ToUpper() == "F")
{
    //Write female
    Console.Write("You specified a gender of: female");
}
//Check if myGender is set to an M
else if (myGender.Trim().ToUpper() != "M")
{
    //Write female
    Console.Write("You specified a gender of: male");
}
//If gender is not f or m, but was specified
else if (myGender.Trim().ToUpper() != "F" && myGender.Trim().ToUpper() != "M")
{
    //Print alternative message
    Console.WriteLine("You specified a gender of other.");
}
//If gender is not f or m or other value
else
{
    //Print unspecified message message
    Console.WriteLine("You did not specify a gender.");
}

We could also switch the “non-specified message” and the “other” message and simplify the cases as well.

//Check if myGender is set to an F
if (myGender.Trim().ToUpper() == "F")
{
    //Write female
    Console.Write("You specified a gender of: female");
}
//Check if myGender is set to an M
else if (myGender.Trim().ToUpper() != "M")
{
    //Write female
    Console.Write("You specified a gender of: male");
}
//If gender is not specified
else if (myGender.Trim() == string.Empty)
{
    //Print unspecified message
    Console.WriteLine("You did not specify a gender.");
}
//If gender is populated, but not recognized
else
{
    //Print alternative message
    Console.WriteLine("You specified a gender of other.");
}

There is even an option so we don’t need to use the double equal == sign for comparison. There is a chainable method on string objects called “equals” which take in the parameter of a string, or can take the string.Empty property.

//Check if myGender is set to an F
if (myGender.Trim().ToUpper().Equals("F"))
{
    //Write female
    Console.Write("You specified a gender of: female");
}
//Check if myGender is set to an M
else if (myGender.Trim().ToUpper().Equals("M"))
{
    //Write female
    Console.Write("You specified a gender of: male");
}
//If gender is not specified
else if (myGender.Trim().Equals(string.Empty))
{
    //Print unspecified message
    Console.WriteLine("You did not specify a gender.");
}
//If gender is populated, but not recognized
else
{
    //Print alternative message
    Console.WriteLine("You specified a gender of other.");
}

Why are there so many alternative ways to do this?

At this point, you’re probably wondering why all these alternative methods exist for accomplishing essentially the same thing? The answer is that more elaborate conditions to test for are more optimally achieved through the use of alternate tests. Much like you can often describe the route to get between two different places using a number of different streets and routes, you can use different combinations of logic to achieve a desired outcome.

Which is the right way to do it? The answer may annoy you at first, but it’s the one that works. What I mean is, the approach you take needs to be the one that accomplishes what you want, but your best bet is to lay out the conditions on paper, and try to keep the rules as simple as you can. When you do that, you’ll fine that the conditional logic will be easier to handle.

Frankly, that last sample of logic is probably the simplest looking of all the ways I’ve shown you. It kept each condition to its own block, and minimized the number of cases to test for. This might not be the best way to do it in all cases, but given that it’s simple to walk through, this approach works just fine here.

Go ahead and add back in the responses to the name, however you’d like to. You can just uncomment the code we had before, though if you’d like to specify more details, or to play around with the logic some more, go ahead! This will help you to get a better handle on playing with logical conditions.

Our final version of this file will look like this:

using System;

namespace HelloAdvancedWorld
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("What is your name? ");
            //Get variable for name
            string myName = Console.ReadLine();

            Console.Write("What is your gender? ");
            //Get variable for gender
            string myGender = Console.ReadLine();

            //Check if myGender is set to an F
            if (myGender.Trim().ToUpper().Equals("F"))
            {
                //Write female
                Console.Write("You specified a gender of: female");
            }
            //Check if myGender is set to an M
            else if (myGender.Trim().ToUpper().Equals("M"))
            {
                //Write female
                Console.Write("You specified a gender of: male");
            }
            //If gender is not specified
            else if (myGender.Trim().Equals(string.Empty))
            {
                //Print unspecified message
                Console.WriteLine("You did not specify a gender.");
            }
            //If gender is populated, but not recognized
            else
            {
                //Print alternative message
                Console.WriteLine("You specified a gender of other.");
            }

            //If no name was specified
            if (myName.Trim() == string.Empty)
            {
                //Tell us that we didn't remember the name
                Console.WriteLine("Hello.  You didn't tell me your name!");
            }
            //Otherwise
            else
            {
                //Say hello to the name.
                Console.WriteLine("Hello, " + myName + "!");
            }
            Console.ReadKey();
        }
    }
}

It’s a lot of code, and it doesn’t go too much; but we’re actually accomplishing a few things here that make for a good demonstration. At this stage, we have a good starting point for our logical demonstration. We understand a bit about multiple conditions, we’ve looked at how we can simplify that process, and we’ve learned about how we can have multiple cases with a fair amount of ease (using the if…else if…else approach).

Conclusion

So far we’ve expanded our functionality from a very simple hello application that just prints a message into one that processes some input and churns out responses based on what we typed in. Our next step will be to learn about another step of programming; namely loops and repetition. That will be another long lesson, but it’s another major step towards being able to produce more expansive projects.

Introduction

In this article, we’ll examine the anatomy of a C Sharp program in a bit of detail, and relate in some of the concepts we’ve discussed prior to this.

A Basic Application

If you recall the prior application we wrote, our “Hello, world” application, we had a bunch of lines of code that were used to make something relatively simple happen. We will use this simply application to understand what elements are essential for an application. The answer is, not much.

Open up Visual Studio and when you are prompted to open an existing project or start a new one, click on the solution for the prior application we created (the one called HelloWorld). You should see our code from last time open again.

using System;
using System.Collection.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloWorld
{
	class Program
	{
		static void Main(string args[])
		{
			Console.WriteLine("Hello, world!");
			Console.ReadKey();
		}
	}
}

This example, which I covered in the article where we set up Visual Studio, is a simple application which opens up a console (command line) window, prints “Hello, world!” and then waits for you to press any key on your keyboard. When you do, the program ends. Simple, right? It’s not fancy, but it demonstrates that applications need to be complex.

In the case of this application, we’re not really intending for anything critical to happen. So let’s look at the actual breakdown of what’s happening, and why.

The first 5 lines of the application all start with “using”. and have some text after it. The first line in Visual Studio will be bright, whereas the other 4 will be more of a gray color. These lines are declarations of libraries that will be used in this particular file of the application. Or rather, these are the 5 default libraries that Visual Studio THINKS we’re likely to need for our application. The 1st line is the only actual one that is used. That’s why it’s shown with lighter text.

Initially when we created the application, the file did not include the lines that start with “Console”. At that stage, all of the “using” statements were dimmed to indicate that none of them was in use. If we remove the 2 – 5 lines and press the play button at the top of our Visual Studio window, the application will run exactly the same as it did the last time, without any errors. So does that mean we didn’t need those lines? Yes… in this case. If you stop the program, try removing the “using System;” line and try running the application again. You’ll get a message that says that the build failed, and will ask if you’d like to run the last successful build. You can answer no and let’s look at the code again.

You should now see a red, rippled underline on both of the Console lines. That red underline indicates that there is an issue with the code. If you hover over it, you’ll see a warning that “The name ‘Console’ does not exist in the current context”.

If you click on the link that says “Show potential fixes”, you’ll get a further menu.

This gives you options for how you can fix your code. The first option is “using System;” and clicking it will re-add the line to the top of the file for the System library.

Now, if you hit the play button again, the application will build and run.

Libraries

You really don’t want to have to create all of the necessary underlying code necessary to print text on a screen. It’s actually a lot of work to build a fundamental base set of functionality like that; it’s a lot of effort, and frankly, there are already sets of code that do the work for you. That’s what a library is. It’s a collection of logic and instructions for how to perform one or more operations, conveniently packaged up for your use.

In simpler terms; all the stuff you need to regularly do are available to use without you needing to manually create it for each project. The System library contains many of the basic functions that are used throughout your application, especially in terms of handling input from a user and displaying output back to them.

Other libraries exist which handle functions of a different nature. When we need those functions, we can add them simply by adding the appropriate library with a using declaration.

The significance of the semi-colon

You may have notices, looking at the code in the demonstration program, that numerous lines ended with a semi-colon. The semi-color character ( ; ) is used as an end-of-instruction indicator. This is actually a common trait in many languages that follow the syntax of the programming language of C – C Sharp is one such language.

The semi-colon is not used on every line. You’ll notice that it’s not at the end of the line that states “namespace HelloWorld” or “static void Main(String args[])”. They are found at the end of all of the using lines, and at the end of the Console lines. These are the lines that actually indicate a step to be taken. Other lines like the namespace or static void main are indicators of a point within a program, or a collection of instructions, but do not actually act as direct instructions themselves.

You’ll come to understand that in time, when you are explicitly indicating a function the computer is to perform at that step, THAT is when you shall need a semi-colon.

Curly Braces

Much like the semi-colon, the curly braces { and } are a special character used for structuring an application. The curly braces are, in fact, a matched set. They indicate a block of code. If you look carefully, you will notice that after we have the namespace HelloWorld text, the next line down is a left-hand or opening curly brace. At the very end of the program is a right-hand or closing curly brace. This is one of the simplest points about organizing your code. These curly braces indicate that everything contained within them is a part of whatever it is that precedes the opening brace.

In other words, the void static main and everything else within the first set of curly braces are a part of the namespace. Additionally, everything within the curly brace set that follows void static main is a part of void static main.

This is known as nesting or blocking – we are indicating that the contents are nested as part of a structure, and that block is nested in a larger structure. The finer details of this we will cover over time, but for now, the most important thing to note is that whatever you open, you must close, and in the appropriate order. The appropriate order is something we’ll cover over time.

One More Pass

So we’re going to look at HelloWorld one more time, and dissect this code with a bit better an understanding of what some of this is. So going back to our full code:

using System;
using System.Collection.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloWorld
{
	class Program
	{
		static void Main(string args[])
		{
			Console.WriteLine("Hello, world!");
			Console.ReadKey();
		}
	}
}

Line 1 – indicate that we need the System library

Line 2 – indicate that we need the System.Collection.Generic library

Line 3 – indicate that we need the System.Linq library

Line 4 – indicate that we need the System.Text library

Line 5 – indicate that we need the System.Threading.Tasks library

Reminder: we included the libraries on lines 2 through 5, but we didn’t ACTUALLY make use of them, so they will show in a dimmer coloring in Visual Studio to indicate that they are not in use. We will discuss at a later time when it’s appropriate to remove those statements.

Line 6 – a blank line. This is not a requirements, but it makes it far easier to organize your code if you segment it some. And extra line returns don’t end up meaning anything in this language, so having some extra space might just make it easier to read.

Line 7 – Indicates that all of the code within the next paid of opening and closing curly braces is part of the namespace of this application. We’ll talk about namespaces more at a later time, and once we do in the proper context, you’ll see a tremendous value in them as an organization and containing element.

Line 8 – the opening curly brace for the HelloWorld Namespace.

Line 9 – indicates that this is a class; a sort of advanced data structure object which we will cover in the near future. The class is of type “Program”. Again, this will be important in the near future. For now, just be aware that the line of code is there.

Line 10 – the curly braces indicating all the following content is part of our “Program” class.

Line 11 – a static method named ‘Main’ that returns nothing (void). Inside of the parenthesis are the words string args followed by a pair of square brackets [ and ]. This is an indicator that our ‘Main’ function (actually method) takes in a parameter that is a string – if you recall from the last article, a string is a group of characters. The [ and ] indicate that the value being passed in is something called an array. We’ll talk about arrays more soon as well. As this is a void function, when it is completed, no data comes back from it. There are other options as well when it comes to this.

Line 12 – a curly brace indicating that the following content is part of the “Main” method;

Line 13 – a call to the Console object that is part of our System library, telling it to write a line of Text to the output window. The output is the literal text “Hello, world!”. This method also automatically causes a carriage return (new line) at the end printing the output. There is another version of this method called “Write” which works very similar, but does NOT include a new line at the end. If you were to have another Console.Write command following it, the text would begin immediately after the end of the first block of text, with no space, and no new lines.

Line 14 – this line is a call to the Console object to wait for the first key to be pressed on the keyboard. Once a key is pressed, the program will continue on to the next instructions. This is a simple way to have a “press any key to continue” hold in your program. And you can make it fun for yourself by waiting to see if a friend searches for the “any” key.

Line 15 – end of the structure that belongs to line 11; closing to the open brace on line 12.

Line 16 – end of the structure that belongs to line 9; closing to the open brace on line 10.

Line 17 – end of the structure that belongs to line 7; closing to the open brace on line 8.

Conclusion

Believe it or not, we actually now have enough fundamentals down to start working on a program in more detail. The next lesson of the introduction will be to modify the HelloWorld program to take a bit of user input and then to return output as a result. After that, you’ll be ready to start working on more intricate and advanced topic. Check back soon for part 4 of the introductory articles.

Introduction

In the prior article, I introduced you to some common concepts and terms in programming. In this article, I’m going to expand on that a bit further. You’ll learn about data types and their affect on functions and methods.

What is a Data Type?

Simply put, a data type is an indicator of what sort of values are used in a particular situation. The simplest way to examine this is to consider variables. In the last article, we learned that a variable is a placeholder for some piece (or pieces) of data. It can be any sort of value we wish to store. But we must understand that there are different types of values. This shouldn’t be entirely surprising. Your first name and last name may be similar types of values, but your birthday is NOT.

What I mean is that if you wanted to store your name into some piece of memory on the computer, your first name and last name would consist of similar types of data; characters. You can’t add your name, or subtract your name. You can really only check if your name matches a certain value, or see if your name contains certain characters. However, there are mathematical functions that can be used with your birthday. We can see how many years have passed since you were born, how many days it is before your next birthday, and more.

Data types give us a way to store and process these pieces of data be forcing them to maintain a standard and structure. In that way, we can know what operations we can perform with that data, and just as important, we can know which operations we CAN’T.

Basic Data Types

There are a few common categories of values, and those common categories can then be broken down further into the specific data types that programming languages can handle. It’s important to note that although the general concept of data types apply through programming, some languages will differentiate data types further than others. We’ll talk about that more in a bit, but let’s start with the general categories.

Numeric

Fairly straight forward in concept, numeric data types are exactly what they sound like: those that hold numbers. Whether it’s a whole number (1, 2, 3) or decimal values (0.1, 0.2, 0.3), numeric fields are obviously important because they serve as the foundation of performing computations – and that’s a primary purpose of computer programs.

Character

Character data refers to everything from alphabetic characters (a – z) to punctuation (?,!) to numbers… wait, numbers, too? Yes. Technically, a number can be part of a character data set. In this capacity, you don’t generally use them for mathematical calculations. Your phone number doesn’t play much of a part in a mathematical formula; it doesn’t have to do with alphabetic order, it doesn’t translate into the position of your house… adding 1 to a phone number doesn’t give you any indication of who that number is or where that person can be found; not directly, anyway. So a number as a character is more about recording a value, not about performing a calculation.

Date and Time

Date and time are generally treated as another explicit category of data type, separate from numeric or character data. This is because there are aspects of both numeric and character data combined in these forms of data. You can use dates for calculation, but they can also be about recording a discrete value and not about specific mathematical functions.

Boolean /ˈbo͞olēən/

Boolean values are both a utterly mundane yet very important form of data. They’re utterly mundane in that a boolean value contains one of two values, and that’s it. Their importance is that the two values are TRUE and FALSE. This might not seem like such a big deal, but realistically, they are the basis of every single logical step of a program. Comparing data and determining if it meets certain criteria ultimately always results in a form of a TRUE / FALSE value, and as a result, a boolean value is essentially the indicator of what way to proceed.

Interestingly, you can also look at booleans as a representation of ON and OFF, 1 and 0, YES and NO, and any other bipolar choices. In fact, the entire idea of how computers work is a form of a boolean. Power flowing through a circuit means it is on… this also means that the presence of power is 1, indicates a value that is true, and a value that is YES. If there is no power flowing, it is FALSE, OFF, 0 and NO.

Even more interesting, next time you are in your kitchen or bathroom, take a look at some of your appliances (small ones like blenders, hair dryers, etc). You may notice that the power switch has a 0 and 1 on it, to indicate Off and On. In some cases, the power switch will have a symbol that looks like a 0 with a 1 running through it; those tend to be found on switches that are push button, where as flip buttons tend to have the separate symbols.

Now you have some idea of what they do that. Your appliance is on or off. This will make for a great example later on with our programming.

Specific Data Types

Now that we have a starting idea of how data is defined, we can talk about the specific data types that exist. We’ll start by talking about the data types associated with numbers.

Numeric Data Types

The numeric data types, as described above, cover the range of data used in mathematical calculations. That means everything from simply addition and subtraction all the way to complex formulas like those used in calculus. Don’t worry, we’re not going to make you do all sorts of crazy math problems here. In fact, the whole point of using the computer is to reduce that load to a manageable format.

Integer (Int or Int32)

Integers are whole numbers. That is straight forward enough. The limit to use of integers is that they can only be up to a certain size. That size is a total of 4,294,967,296 values. What that means is that you are limited to what the largest (and smallest) numbers are that you can hold. Integers, as with all numeric fields in programming, are either signed (meaning they have a positive or negative) or unsigned (meaning only positive numbers are possible). If you’re using an unsigned integer, that means you have a range from 0 to 4,294,967,295. If you’re using an unsigned integer, you can hold from -2,147,483,648 to 2,147,483,647.

An integer is created as an INT, and an unsigned integer is created as a UINT

Long (Long or Int64)

A long is a second form of a whole number. The difference is that a long is actually able to handle a much larger range of numbers. The range of numbers allows for up to 18,446,744,073,709,551,616 values. So unsigned long values can go from 0 to 18,446,744,073,709,551,615 ; signed long values can go from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807. Variables of these types are created as LONG and ULONG.

Short (Short or Int16)

A short is a whole number with a range of 65,536 values. They are divided up similarly to the INT and LONG formats, and can be declared as SHORT and USHORT.

Byte (Byte and SByte)

Not quite as commonly used in every day calculations, the byte is a holdover, to some extent, from the early days of having to manually program hardware. A byte is a block of 8 binary bits. That means a range of values from 0 (represented as 00000000 in binary) to 255 (11111111 in binary). Binary is a separate lesson to work through, so for now it’s enough just to be aware that bytes are a data type that exist. One difference between these and the other forms above is that a byte is unsigned by default, and to get a signed version, you need to indicate sbyte; this is as opposed to all the other types that are signed in their default form with an explicit override for unsigned.

Decimal

Of course, we don’t only deal with whole numbers when it comes to mathematics in programming. Otherwise we’d never do anything with monetary values because, honestly, that would be a mess to keep organized. The decimal is a standard format for numbers that have, well, decimals. A decimal number has a range of -79228162514264337593543950335 to 79228162514264337593543950335. But wait, where’s the decimal in that?

Well, the decimal concept gets a bit trickier, because let’s remember that now instead of a fixed increment going up or down (whole numbers are fixed increments going up 1 whole unit or down 1 whole unit) we now have to consider all of the decimal places that appear before OR after a number, so they sizing can be a bit crazy. The fact is that you typically see an ability with a decimal number to go out to 28 or 29 places (before or after a decimal point, or combined before AND after). That means that a value like 0.0000000000000000000000000001 (28 places after the decimal) will actually print as it is. If you have one more decimal place before that 1, the one will disappear off the number. Likewise, if you add numbers BEFORE the decimal, the number of spaces AFTER the decimal will also be truncated (cut off).

0.0000000000000000000000543210
2.0000000000000000000000543210
22.000000000000000000000054321
220.00000000000000000000005432
2200.0000000000000000000000543
22000.000000000000000000000054
220000.00000000000000000000005

Line 1 and Line 2 have the same number of places, so even changing the ones place from 0 to 2 doesn’t do anything. However, adding a second place in front of the decimal means that a place at the end of the number is truncated. Keep in mind that truncation is NOT rounding. It is literally the place where the number just drops off.

While it is possible to have longer numbers using scientific notations, for the purposes of programs we’d write, this is more than sufficient, so we will not worry about those specialty cases. If you’re writing a recipe program, a check book program, and even a video game, the chances of getting to numbers more precise than this is limited at best.

Frankly, if you have a recipe calling for a measurement more precise than 0.0000000000000000000000000001 teaspoons of an ingredient, I don’t think I’m going to be following your recipes.

Single and Double

As is the case with the whole numbers, there are a few variations of these decimal numbers as well. The SINGLE and DOUBLE value are versions of a decimal that store numbers with lower limits to the number of places. A single (sometimes called a float) can hold 6 to 9 places, and a double holds 15 to 17).

So the question is probably brewing in your head: why all these versions of numbers? The answer is that in earlier days of programming, computer memory and processing power was far more limited than what it is today.

The processing power of machines at the advent of computing would seem almost laughable now. In fact, the average hand-held calculator holds as much processing power as some of the earliest computers. If you have a smart phone, you probably are holding more processing power in your hand than what the government had available in some of it’s best machines in the early 1950s.

Concerns of storage and memory space and processing power made it critical that values were only made large enough to hold what was really necessary. And it still makes sense to do that today. Why get a 3 ring binder capable of holding 1000 sheets of information if the only thing you intend to store is a piece of paper with your first, middle and last name?

While we don’t need to be quite so strict today in limiting use of memory as was needed 50 or more years ago, it still does slow down and use up the resources of a computer each time you declare a variable. While it might not be significant in one case, thousands of variables could begin to tax a computer over time.

So these different size data types still exist so we can program for what we will need, reasonably, in the future. And if we find that we do need to expand a variable’s size at some later point, it’s not a horrible ordeal in most cases to do that.

For most of the examples we’ll look at for the foreseeable future, we’ll use Int and Decimal values. If there is a special case where we need to use something else, we can review the reasons why at that time.

Character Data Types

As was the case with the numeric data types, there are a few different character data types to consider as well. For our purposes, we’re just going to look at two types for now.

Char

You might hear people pronounce this like the word describing the burned / black portion of barbecued meats. While people will probably overlook that, the truth is that the word is actually pronounced like “care”. It’s actually short for Character, and it is exactly what it sounds like – a single character value. The uses of single character fields might seem minimal, but in actuality, you can use them for quite a few purposes. For now, though, we’ll look at the more common data type.

String

The string is actually a more commonly used character-based data type in many languages. It is a block of character data, and can be used to hold up to 2 billion characters. Yes, you read that right, 2 billion character is the maximum theoretical limit. I saw theoretical, because it’s highly unlikely you’ll actually allocate that much, and frankly, it’d be bad to do so. 2 billion characters is a LOT of data, and having to load and process that much in a single value would be taxing to nearly any computer system. Even if you’re writing a novel that’s about 350 pages, you’re not going to get to those sorts of numbers. A typical page on a standard hard-cover book is about 300 to 350 words. At an average of 5 characters per word, plus one for a space, that translates into 1500 to at most 2100 characters. Even if you double that and say 2400 characters on a page, that still means 735,000 characters in total for a book. That doesn’t even come close to 1% of our memory max limit for a string.

So a string is a pretty versatile form of data in it’s capacity. Strings can be used for storage, can be searched, and compared against other strings. That allows us to do the vast majority of what we need to write most programs. We will use this data type a LOT.

Data Types and Functions or Methods

We’re just going to introduce this concept briefly for now, because there is a lot more we can and will learn about when it comes to data types. But it’s important to understand that data types have importance beyond use for variables. They also have significance in use with Functions or Methods.

When it comes to producing code, we tend to rely on functions and methods, as described in the prior article, to preform multiple tasks or steps that need to be repeatable. In other words, a task to calculate someone’s age based on a birthday is something we don’t want to have to write the code for manually EVERY time we need to use it; for one thing, programs that are meant to handle multiple people, a growing list of them, would never be manageable this way. For another, doing anything like that would defeat the purpose of using a computer at all – automation of process is a big factor in why computers are so valuable.

If we’re going to use functions or methods, it is likely that we’ll need to get feedback or results from those functions and methods at least some of the time. Data types are a part of that process, because they indicate what type of data will come back from a particular function or method. For example, a method that performs a calculation of the age of a person based on their date of birth could just spit out a number to a screen. But what we need that number for some other process later on?

The function could be set up to return the value to us, and we could decide what to do with it later. Initially, many methods are set up with a return type of VOID. Void means there is no return type. We perform some process and then move on. But if we had our age calculating function, we would set it up to take in a date, and return an integer indicating how old the person is; perhaps in years, perhaps in day; maybe it would go deeper depending on the time of birth.

But the fact is, we can set up our functions or methods to indicate what type of data will come back from a set of tasks. When we write code like this, we declare the return type of the method or function to use one of the aforementioned data types. How we do that is something we’ll cover soon. But for now, it’s enough to know that these pieces fit together. The how we’ll cover in time.

Conclusion

This is a good place for us to stop; there is a lot to absorb before we get into writing actual programs, so it’s important that we have groundwork laid out before we just start typing stuff up on our screens. The next article will discuss the actual anatomy of a program in more depth, and we’ll look at the structure of blocks of code and talk about how the terms of part 1 and the data types in part 2 fit into that picture. Once we’ve done that, we can begin to make some serious effort at writing a simple program, and know what we are doing, and why.