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 size="2">
using System;
// Program start class
class WelcomeCSS
{
// Main begins program execution.
size="2">
static size="2">void Main()
{
color="#008000" size="2">
// 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. If you can't figure out how to add something to your path,
get a friend to help you. With all the different versions of Windows available,
I don't have the time in this tutorial, which is about C# language programming,
to show you how to use your operating system. Then open the command window by going
to the Windows Start menu, selecting Run, and typing
cmd.exe.
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 WelcomeCSS, 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.
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 size="2">
using System;
// Program start class
class NamedWelcome
{
// Main begins program execution.
size="2">
static size="2">void Main(string size="2">[] args)
{
// Write to console
Console.WriteLine("Hello, {0}!", args[0]);
Console.WriteLine("Welcome to the C#
Station Tutorial!");
}
}
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.
size="2"> public
static size="2">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 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.
This is just the beginning, the first of many lessons. I invite you back to take
Lesson 2: Expressions, Types, and Variables.
Your feedback and constructive contributions are welcome. Please feel free
to contact me for feedback or comments you may have about this lesson.
