This lesson will get you started with C# by introducing a
few very simple programs. Here are the objectives of this lesson:
¯ Understand
the basic structure of a C# program.
¯ Obtain
a basic familiarization of what a "Namespace" is.
¯ Obtain
a basic understanding of what a Class is.
¯ Learn
what a Main method does.
¯ Learn
how to obtain command-line input.
¯ Learn
about console input/output (I/O).
A Simple C# Program
There are basic elements that all
C# executable programs have and that's what we'll concentrate on for this first
lesson, starting off with a simple C# program. After reviewing the code in
Listing 1-1, I'll explain the basic concepts that will follow for all C#
programs we will write throughout this tutorial. Please see Listing 1-1 to view
this first program
.
.
Warning: C# is
case-sensitive.
Listing 1-1. A Simple Welcome Program: Welcome.cs
// Namespace Declaration
using System;
// Program start class
class WelcomeCSS
{
// Main begins
program execution.
static void Main()
{
// Write to
console
Console.WriteLine("Welcome to the C# Station Tutorial!");
}
}
The program in Listing 1-1 has 4 primary elements, a
namespace declaration, a class, a Main method, and a program statement. It can
be compiled with the following command line:
csc.exe Welcome.cs
This produces a file named Welcome.exe, which can then be
executed. Other programs can be compiled similarly by substituting their file
name instead of Welcome.cs. For more help about command line options, type
"csc -help" on the command line. The file name and the class name can
be totally different.
Note for VS.NET Users: The screen will run and close quickly
when launching this program from Visual Studio .NET. To prevent this, add the
following code as the last line in the Main method:
// keep screen from going away
// when run from VS.NET
Console.ReadLine();
Note: The command-line is a window that allows you to run
commands and programs by typing the text in manually. It is often refered to as
the DOS prompt, which was the operating system people used years ago, before
Windows. The .NET Framework SDK, which is free, uses mostly command line tools.
Therefore, I wrote this tutorial so that anyone would be able to use it. Do a search
through Windows Explorer for "csc.exe", which is the C# compiler.
When you know its location, add that location to your Windows path. Then open
the command window by going to the Windows Start menu, selecting Run, and
typing cmd.exe. This blog post might be helpful: How to set the path in Windows
7.
The first thing you should be aware of is that C# is
case-sensitive. The word "Main" is not the same as its lower case
spelling, "main". They are different identifiers. If you are coming
from a language that is not case sensitive, this will trip you up several times
until you become accustomed to it.
The namespace declaration, using System;, indicates that you
are referencing the System namespace. Namespaces contain groups of code that
can be called upon by C# programs. With the using System; declaration, you are
telling your program that it can reference the code in the System namespace
without pre-pending the word System to every reference. I'll discuss this in
more detail in Lesson 06: Namespaces, which is dedicated specifically to
namespaces.
The class declaration, class Welcome CSS, contains the data
and method definitions that your program uses to execute. A class is one of a
few different types of elements your program can use to describe objects, such
as structs, interfaces , delegates, and enums, which will be discussed in more
detail in Lesson 12: Structs, Lesson 13: Interfaces, Lesson 14: Delegates, and
Lesson 17: Enums, respectively. This particular class has no data, but it does
have one method. This method defines the behavior of this class (or what it is
capable of doing). I'll discuss classes more in Lesson 07: Introduction to
Classes. We'll be covering a lot of information about classes throughout this
tutorial.
The one method within the WelcomeCSS class tells what this
class will do when executed. The method name, Main, is reserved for the
starting point of a program. Main is often called the "entry point"
and if you ever receive a compiler error message saying that it can't find the
entry point, it means that you tried to compile an executable program without a
Main method.
A static modifier precedes the word Main, meaning that this
method works in this specific class only, rather than an instance of the class.
This is necessary, because when a program begins, no object instances exist.
I'll tell you more about classes, objects, and instances in Lesson 07:
Introduction to Classes.
Every method must have a return type. In this case it is
void, which means that Main does not return a value. Every method also has a
parameter list following its name with zero or more parameters between
parenthesis. For simplicity, we did not add parameters to Main. Later in this
lesson you'll see what type of parameter the Main method can have. You'll learn
more about methods in Lesson 05: Methods.
The Main method specifies its behavior with the
Console.WriteLine(...) statement. Console is a class in the System namespace.
WriteLine(...) is a method in the Console class. We use the ".", dot,
operator to separate subordinate program elements. Note that we could also
write this statement as System.Console.WriteLine(...). This follows the pattern
"namespace.class.method" as a fully qualified statement. Had we left
out the using System declaration at the top of the program, it would have been
mandatory for us to use the fully qualified form System.Console.WriteLine(...).
This statement is what causes the string, "Welcome to the C# Station
Tutorial!" to print on the console screen.
Observe that comments are marked with "//". These
are single line comments, meaning that they are valid until the end-of-line. If
you wish to span multiple lines with a comment, begin with "/*" and
end with "*/". Everything in between is part of the comment. Comments
are ignored when your program compiles. They are there to document what your
program does in plain English (or the native language you speak with every
day).
All statements end with a ";", semi-colon. Classes
and methods begin with "{", left curly brace, and end with a
"}", right curly brace. Any statements within and including
"{" and "}" define a block. Blocks define scope (or
lifetime and visibility) of program elements.
Accepting Command-Line Input
In the previous example, you simply ran the program and it
produced output. However, many programs are written to accept command-line
input. This makes it easier to write automated scripts that can invoke your
program and pass information to it. If you look at many of the programs,
including Windows OS utilities, that you use everyday; most of them have some
type of command-line interface. For example, if you type Notepad.exe MyFile.txt
(assuming the file exists), then the Notepad program will open your MyFile.txt
file so you can begin editing it. You can make your programs accept command-line
input also, as shown in Listing 1-2, which shows a program that accepts a name
from the command line and writes it to the console.
Danger! Regardless of the fact that I documented the proper
use of command-line arguments before and after Listing 1-2, some people still
send me email to complain that they get an error or tell me there's a bug in my
program. In fact, I get more email on this one subject than any other in the
whole tutorial. Please read the instructions to include the command-line argument.
<Smile />
Note: When running the NamedWelcome.exe application in
Listing 1-2, you must supply a command-line argument. For example, type the
name of the program, followed by your name: NamedWelcome YourName. This is the
purpose of Listing 1-2 - to show you how to handle command-line input.
Therefore, you must provide an argument on the command-line for the program to
work. If you are running Visual Studio, right-click on the project in Solution
Explorer, select Properties, click the Debug tab, locate Start Options, and
type YourName into Command line arguments. If you forget to to enter YourName
on the command-line or enter it into the project properties, as I just
explained, you will receive an exception that says "Index was outside the
bounds of the array." To keep the program simple and concentrate only on
the subject of handling command-line input, I didn't add exception handling.
Besides, I haven't taught you how to add exception handling to your program yet
- but I will. In Lesson 15: Introduction to Exception Handling, you'll learn
more about exceptions and how to handle them properly.
Listing 1-2. Getting Command-Line Input: NamedWelcome.cs
// Namespace Declaration
using System;
// Program start class
class NamedWelcome
{
// Main begins
program execution.
static void
Main(string[] args)
{
// Write to
console
Console.WriteLine("Hello, {0}!", args[0]);
Console.WriteLine("Welcome to the C# Station Tutorial!");
}
}
Tip: Remember to add your name to the command-line, i.e.
"NamedWelcome Joe". If you don't, your program will crash. I'll show
you in Lesson 15: Introduction to Exception Handling how to detect and avoid
such error conditions.
If you are using an IDE, like Visual Studio, see your IDE's
help documentation on how to set the command-line option via project
properties. i.e. in Visual Studio 2010, double-click the Properties folder in
your solution project, click the Debug tab, and add your name to Command Line
Arguments. The actual step can/will differ between IDE's and versions, so
please consult your IDE documentation for more information.
In Listing 1-2, you'll notice an entry in the Main method's
parameter list. The parameter name is args, which you'll use to refer to the
parameter later in your program. The string[] expression defines the type of
parameter that args is. The string type holds characters. These characters
could form a single word, or multiple words. The "[]", square
brackets denote an Array, which is like a list. Therefore, the type of the args
parameter, is a list of words from the command-line. Anytime you add string[]
args to the parameter list of the Main method, the C# compiler emits code that
parses command-line arguments and loads the command-line arguments into args.
By reading args, you have access to all arguments, minus the application name,
that were typed on the command-line.
You'll also notice an additional Console.WriteLine(...)
statement within the Main method. The argument list within this statement is
different than before. It has a formatted string with a "{0}"
parameter embedded in it. The first parameter in a formatted string begins at
number 0, the second is 1, and so on. The "{0}" parameter means that
the next argument following the end quote will determine what goes in that
position. Hold that thought, and now we'll look at the next argument following
the end quote.
The args[0] argument refers to the first string in the args
array. The first element of an Array is number 0, the second is number 1, and
so on. For example, if I typed NamedWelcome Joe on the command-line, the value
of args[0] would be "Joe". This is a little tricky because you know
that you typed NamedWelcome.exe on the command-line, but C# doesn't include the
executable application name in the args list - only the first parameter after
the executable application.
Returning to the embedded "{0}" parameter in the
formatted string: Since args[0] is the first argument, after the formatted
string, of the Console.WriteLine() statement, its value will be placed into the
first embedded parameter of the formatted string. When this command is
executed, the value of args[0], which is "Joe" will replace
"{0}" in the formatted string. Upon execution of the command-line with
"NamedWelcome Joe", the output will be as follows:
Hello, Joe!
Welcome to the C# Station Tutorial!
Interacting via the Command-Line
Besides command-line input, another way to provide input to
a program is via the Console. Typically, it works like this: You prompt the user
for some input, they type something in and press the Enter key, and you read
their input and take some action. Listing 1-3 shows how to obtain interactive
input from the user.
Listing 1-3. Getting Interactive Input:
InteractiveWelcome.cs
// Namespace Declaration
using System;
// Program start class
class InteractiveWelcome
{
// Main begins
program execution.
public static void
Main()
{
// Write to
console/get input
Console.Write("What is your name?: ");
Console.Write("Hello,
{0}! ", Console.ReadLine());
Console.WriteLine("Welcome to the C# Station Tutorial!");
}
}
In Listing 1-3, the Main method doesn't have any parameters
-- mostly because it isn't necessary this time. Notice also that I prefixed the
Main method declaration with the public keyword. The public keyword means that
any class outside of this one can access that class member. For Main, it
doesn't matter because your code would never call Main, but as you go through
this tutorial, you'll see how you can create classes with members that must be
public so they can be used. The default access is private, which means that
only members inside of the same class can access it. Keywords such as public
and private are referred to as access modifiers. Lesson 19: Encapsulation
discusses access modifiers in more depth.
There are three statements inside of Main and the first two
are different from the third. They are Console.Write(...) instead of
Console.WriteLine(...). The difference is that the Console.Write(...) statement
writes to the console and stops on the same line, but the
Console.WriteLine(...) goes to the next line after writing to the console.
The first statement simply writes "What is your name?:
" to the console.
The second statement doesn't write anything until its
arguments are properly evaluated. The first argument after the formatted string
is Console.ReadLine(). This causes the program to wait for user input at the
console. After the user types input, their name in this case, they must press
the Enter key. The return value from this method replaces the "{0}"
parameter of the formatted string and is written to the console. This line
could have also been written like this:
string name = Console.ReadLine();
Console.Write("Hello, {0}! ", name);
The last statement writes to the console as described
earlier. Upon execution of the command-line with
"InteractiveWelcome", the output will be as follows:
>What is your Name?
<type your name here> [Enter Key]
>Hello, <your name here>! Welcome to the C# Station Tutorial!
Summary
Now you know the basic structure of a C# program. using
statements let you reference a namespace and allow code to have shorter and
more readable notation. The Main method is the entry point to start a C#
program. You can capture command-line input when an application is run by
reading items from a string[] (string array) parameter to your Main method.
Interactive I/O can be performed with the ReadLine, Write and WriteLine methods
of the Console class.
