1

Getting Started
C# is pronounced as "C sharp". It is a new programming language that enables programmers in
quickly building solutions for the Microsoft .NET platform.

Today, one cannot, just cannot, afford to ignore C#. It is our considered opinion that it holds
immense promise and we are going to try our best, through this book, to help you realize its
potential. Be assured, we are not going to teach you just another programming language. It is our
intention to help you apply C# in practical situations, to actually implement your newly acquired
knowledge on the Net.

With this brief introduction, let us embark on a path that will take you to new adventures in the
world of Internet. In this chapter, we will get you started with C# by introducing a few very
simple programs. For remember, even a journey of a thousand miles must begin with a single
step.

We assume that you have no prior knowledge of any programming language. But before we get
ensnared in the fascinating world of C#, let's make a directory where we will save all our work.
In order to do so, click on Start, Programs, then go to Accessories and select Command Prompt
(Windows 2000) or the MS-DOS Prompt as it is called in Windows 98. Once you are at the
command prompt create a directory called csharp (md csharp) and change to this directory (cd
csharp). Now type the command 'edit a.cs', which will open the MS-DOS editor - the world's
simplest editor.

C:\csharp>edit a.cs

Yes, we very well understand how you must be yearning to write your first C# program and get
it working. But before we do that, there are certain intricacies that you must understand. What
a.cs refers to is called the filename or program name. Here we have named our file or program
a.cs. Why a.cs? Well, before we began writing this book, we consulted a renowned astrologer
who predicted that if we named our first file a.cs then great luck would be showered on us. Not
wanting to quarrel with the stars, we named our file a.cs. But you are free to go ahead and call
your file any name you want. But then do so at your own risk! Remember, forewarned is
forearmed!
Jokes aside, 'cs' is the extension used for C# files. They say of all the things you wear, your
expression is the most important. Notwithstanding this, one does look more dapper in a suit
rather than a vapid shirt and trousers. Similarly, though it is not mandatory to provide the
extension 'cs', you can make a filename seem more impressive by giving it an extension. To
reiterate, you could have given the extension say 'ws' too; it does not matter. But absent minded
as we are, it is more prudent to give appropriate extensions while naming files.

As the first step, we will understand the basic structure of a C# program.

a.cs

class zzz

Here we start with the word class zzz followed by open and close curly braces. A class is nothing
but a collection --- a collection of everything that the programming language contains. It is like a
packet or a container, which can hold anything. Hence everything in a C# program must be
enclosed within a class. We have named our class zzz, again you could have named it anything
else but if you would rather follow our naming convention (for reasons well amplified above!),
name it zzz.

Now for the part that you've been eagerly waiting for!

In order to execute the program, go to the File menu, and click on Exit. You will get a dialog box
asking you whether you want to save the file or not, say yes. Now that we have typed and saved
our file we need to execute it. The compiler creates executable code. The command used to call
the C# compiler is csc followed by the program name. Since our program name is a.cs, the
command csc a.cs will call the compiler. A compiler is a program which understands the C#
programming language. Thus the word class is part and parcel of the C# language. Microsoft lets
you freely download the C# compiler from their web site :
http://msdn.microsoft.com/library/default.asp. Select .Net Framework SDK under .NET
Development. Choose the Download option to download the sdk which is around 127 MB large.
Install the product on your machine cause if you don’t, none of the following programs will
work. Also, Internet Explorer 5.5 and Microsoft Data Access Components(2.7) must be installed
prior to installing the sdk

Once done, type the command as follows:

C:\csharp>csc a.cs

You will see the following output on your screen in the dos box.
Microsoft (R) Visual C# Compiler Version 7.00.9254 [CLR version v1.0.2914] Copyright (C)
Microsoft Corp 2000-2001. All rights reserved.

error CS5001: Program ‘a.exe’ does not have an entry point defined

Just as the excitement was beginning to grow, our program returns with an error message. Don't
worry, occasional failure is the price of improvement.

The error message starts with an error number CS5001 followed by a cryptic message, which we
do not understand.

We are aware of the fact that everything has a beginning and an end. Similarly, a C# program
also has a start and an end. Ah! Now you realize why the error occurred. We forgot to tell C#
where to start executing our program from. This starting point is also called an entry point.

You can specify the entry point by adding static void Main() to your program, just as we have
done below.

a.cs

class zzz

static void Main()

Compile the above code giving the command as csc a.cs. Voila! Now no errors.

The compiler will now generate an exe file called a.exe. Giving the command dir at the
command prompt will prove the same. On keen observation you will notice that among the 2
files listed, there is a file by the name a.exe. Simply type 'a' at the command prompt, your
program will now be executed!

C:\csharp>a

The program will run but shows no output on our screen. But, at least we get no errors.

The words, static and void, will be explained to you a little later, in the right perspective. Thus if
you had felt the beginnings of a massive headache, you can breathe easy! Anything followed by
'(' and ')' brackets is called a function. So, it is obvious that Main is nothing but a function. Here
we are creating a function called Main. It is followed by the '{' and '}' curly braces. Note that the
letter M in Main is capital. Thus C# requires a function called Main, which is the first function
that will be executed. Failure to do so will result in an error. Ergo, whenever you see a word
beginning with an open '(' and close bracket ')', C# and most other programming languages call it
a function. The { signifies the start of a function and the } signifies the end of the function. The
guys who designed the language decided to use {} braces instead of start and end. When you tell
people that you are learning a programming language, you are actually learning to use {} braces
to specify the beginning and end of a function. These rules have to be remembered by rote. You
have no choice.

Now we are ready to add some code in our program. In order to do so, add the line
WriteLine("Hell"), just as we have done below.

a.cs

class zzz

static void Main()

WriteLine("Hell")

Oops! The astrologer had promised showers of luck! Even a drizzle seems far away! Executing
the above program results in the following error:

Compiler Error

a.cs(5,18): error CS1002: ; expected

The error message begins with the file name, a.cs followed by round brackets containing the line
number and the column number, where the error occurred. The compiler informs us that it found
an error on line number 5 and column number 18 and it expects a ;.

As the cliché goes, when the going gets tough, the tough get going. So we shouldn't lose heart as
yet; let's understand why this error occurred.
Look at WriteLine within the brackets; doesn't it ring a bell? Isn't WriteLine a function too? But
here we do not have the curly braces following it. This is because here we are not creating a
function like we created Main. Then what is it that we are doing? We are calling a function
called WriteLine, which has already been created.

The error says ';' expected. Though it is obvious to us that the statement has ended, unfortunately
for you and me, C# isn't so smart. It requires a semi-colon to tell it loud and clear that the
statement has ended. Merely pressing enter does not suffice. Though not so for other
programming languages, in C# it is mandatory to use a semi-colon. Alas! Each programming
language has its own rules!

At this juncture, an intelligent question would be - But why semi-colon? Why not any other
punctuation mark? We don't know for sure but perhaps the developers of C# were asked to select
a character that would indicate the end of a statement. The non-compromising species that we
are, they could not arrive at a consensus. Result? Grandma's recipe of eene meene mina mo!
When they stopped, their finger was pointing at the semi-colon, hence they selected the same.

Thus rules are rules; as preposterous as they may sound, they must be followed.

Add the semi-colon and execute the program. Also languages like ABAP/4 from SAP ends lines
with a dot (full stop). Thus we expect to understand programming in English. Every language
expects an end of statement/command terminator. Every language expects a symbol to denote
when the user has finished saying something. In C# it is a ; , other languages have their own
symbols. Remember that the statement or function WriteLine was written on line number 5
hence the error reported line number 5.

a.cs

class zzz

static void Main()

WriteLine("Hell");

Compiler Error

a.cs(5,1): error CS0103: The name 'WriteLine' does not exist in the class or namespace 'zzz'
Another error! We are extremely disappointed, it just doesn't seem our day. However we firmly
believe that you may be disappointed if you fail, but are surely doomed if you don't try. And we
don't want to be doomed do we? So let's keep our chin up and carry on.

But you know what's most irritatingly bothersome? Why are all error messages so difficult to
understand? Well, with the experience that we have gained over the years we have learnt that if
error messages could be understood then we wouldn't get them in the first place!

In any case, to be truly candid, the error occurred because we pulled a fast one on you! We are
calling a function WriteLine but in fact no such function exists. The accurate name of the
function is not WriteLine but System.Console.WriteLine. Microsoft is known to fancy big names
and here is one more example. In any case, let's execute the program.

a.cs

class zzz

static void Main()

System.Console.WriteLine("Hell");

Output

Hell

Finally, no errors! Surely you feel blessed! It displays the word 'Hell', and we suspect that's
exactly what you are going through right now. But if you follow our programs step by step we
assure you that heaven is not too far away.

Now remove all the extra spaces and 'enters' from your program, just as we have done below and
compile the program again.

a.cs

class zzz {static void Main() {System.Console.WriteLine("Hell");}}

Output

Hell

You will notice that doing so does not give any errors. Just like the previous program, it displays
'Hell'. The C# compiler is not affected by it. But using spaces and 'enters' definitely make your
program neater and thereby more readable. The effect is especially appreciated in large programs
and more so when someone else has to go through them. Having said that, anyway, the first thing
that C# compiler does is removes all the spaces and enters from the program code you have
written.

In the next program, we have called WriteLine function twice.

a.cs

class zzz

static void Main()

System.Console.WriteLine("Hell");

System.Console.WriteLine("Bye");

Output

Hell

Bye

On executing this program, 'Hell' and 'Bye' are displayed on two separate lines. Here, we are not
required to give anything that has the 'enter' effect, WriteLine automatically prints on a new line
each time. Which simply means you can call a function as many times as you like.

In the next illustration, let's understand how functions are called and created. Here we are calling
a function abc().

a.cs
class zzz

static void Main()

abc();

Compiler Error

a.cs(5,1): error CS0103: The name 'abc' does not exist in the class or namespace 'zzz'

On executing this program you will get, what else, but an error. Peter Drucker, the famed
management guru had once said that the better a man is, the more mistakes he will make, for the
more new things he will try. So there you go - next time you encounter an error, simply tell
yourself that you have just become better at whatever you are doing.

In any case, the error says that abc does not exist. Here we are calling a function called abc(), but
where is abc() defined or created ? It is not a function that has been provided by C# to us free of
charge. It is our own homegrown function that we are calling. The lesson here is that we cannot
call a function without first creating it. So, to rectify this error we will first create a function abc.
Our next example demonstrates this.

a.cs

class zzz

static void Main()

abc();

static void abc()

{
System.Console.WriteLine ("Hell");

Output

Hell

In the function abc, we have included only one statement- WriteLine within the curly braces. The
'{' and '}' braces indicate the beginning and the end of this function. Alternatively, a function can
contain millions of lines of code that will be executed when the function is called. Since
everything is contained in a class, our function abc is also created within the class zzz but outside
Main. But the function is called from Main. On executing the program, 'Hell' is displayed. This is
because we have included the code for 'Hell' to be displayed in the function abc. Thus, when the
control reaches the line abc(); it searches for that function and executes the code within that
function. We will explain static and void later as promised.

You can call as many functions as you like from your program. But you must remember to
separate each one with a semi-colon. The next program illustrates this.

a.cs

class zzz

static void Main()

abc();

pqr();

abc();

static void abc()

System.Console.WriteLine ("I am ABC");

}

static void pqr()

System.Console.WriteLine ("I am PQR ");

Output

I am ABC

I am PQR

I am ABC

At first the function abc is called, then pqr and then again we are calling abc. On executing this
program 'I am ABC', 'I am PQR' and 'I am ABC' will be displayed. This is because we have
included the code for these lines to be displayed in the respective functions.

In the following program we are calling the function pqr from abc and not from Main.

a.cs

class zzz

static void Main()

abc();

static void abc()

pqr();
System.Console.WriteLine ("I am ABC");

static void pqr()

System.Console.WriteLine ("I am PQR ");

Output

I am PQR

I am ABC

In the function abc, we are first calling pqr and then displaying 'I am ABC' using the WriteLine
function. Hence, first 'I am PQR' is displayed and then 'I am ABC'. Thus, this program
demonstrates how functions can be called from other functions.

Now that we have created our own functions abc and pqr, we have an intuitive understanding of
how C# created the function System.Console.WriteLine. The next program uses the printing or
formatting capabilities of the WriteLine function.

a.cs

class zzz

static void Main()

System.Console.WriteLine("100 {0}",100);

Output
100 100

The zero in the curly braces means that after the first comma there is some value and that it
should display this value. You cannot differentiate between the two 100's. The {0} is replaced
with 100, the number, which follows the first comma. If you don't like the number 100, use the
number 420 instead. We won't mind - at least it's something that some of you can easily identify
with!

The program below is simply an extension of the above.

a.cs

class zzz

static void Main()

System.Console.WriteLine("100 {0},{1}",100,200);

Output

100 100,200

Here the {0} is replaced with 100 and {1} is replaced with 200. The comma (,) separates the two
numbers. Thus {0} means the first number and {1} means the second. C# likes to count from
zero and not one.

a.cs

class zzz

static void Main()

ii;
ii=20;

System.Console.WriteLine ("{0}",ii);

Compiler Error

a.cs(5,1): error CS0201: Only assignment, call, increment, decrement, and new expressions can
be used as a statement

a.cs(5,1): error CS0103: The name 'ii' does not exist in the class or namespace 'zzz'

a.cs(6,1): error CS0103: The name 'ii' does not exist in the class or namespace 'zzz'

a.cs(7,33): error CS0103: The name 'ii' does not exist in the class or namespace 'zzz'

Experience is knowing a lot more of things you shouldn't. But now that you have decided to
embark upon this book, let's see what you should know!! Executing this program results in a
large number of errors as shown above. Let's understand the rationale behind it. Here we have
included a strange word --- ii. This word ii is being given a value of 20 as ii=20. But C# is a shy
program. It does not speak to strangers! Here ii is nothing but a stranger to C#. C# does not know
who or what ii is. You can't just write words that you feel good about. So, in order to rectify this
error we must tell C# who ii is.

Our next program will demonstrate how this can be done.

a.cs

class zzz

static void Main()

int ii;

ii=20;

System.Console.WriteLine ("{0}",ii);

}
}

Output

20

Note that in this program we have added the word int before ii. The word int indicates that ii is
an integer or a number. Each time we create our own word like ii, C# wants to know what we
will store in this word. We will understand this better and in totality in just a little while. Here we
are initializing ii to 20 or giving it a value of 20 by writing ii = 20. Why 20? Maybe because we
are feeling very youthful today! Following this we have the WriteLine function. Now, it is a
known fact that jaggery is a good substitute for sugar. Similarly, in C# you can substitute a
number with a word. So, in WriteLine we have used the word ii instead of a number. The word ii
gets replaced with the value 20. So, on executing the program, the number 20 is displayed.

You may be wondering as to why should you ever use a word when you can use a number
directly. Our next program will enlighten you on this.

a.cs

class zzz

static void Main()

int ii;

ii=20;

System.Console.WriteLine ("{0}",ii);

ii=30;

System.Console.WriteLine ("{0}",ii);

ii=ii+10;

System.Console.WriteLine ("{0}",ii);

ii=ii+1;

System.Console.WriteLine ("{0}",ii);
ii++;

System.Console.WriteLine ("{0}",ii);

Output

20

30

40

41

42

The first three lines of this program are identical to those of our previous one. Thus in the first,
the WriteLine function will display the number 20. Thereafter, by saying ii=30 we are initializing
the word ii to a value 30. In effect, we are changing the value of ii from 20 to 30. So, WriteLine
will now display 30.

For conceptual understanding, we earlier introduced ii as a word. However, in the software

world, it has another name; it is actually called a variable.

Thus, a variable is a word whose value varies or changes. ii initially had a value 20 that changed
to 30.

Coming back to what the word int means- when you say int, int means integer or number. When
we say int ii, it means that the variable ii will store a number. ii could also be used to store the
letters of the alphabet like the names of people. It could also store a date. But here we wanted ii
to store a number. So, we have to tell C# in advance as to what the variable is going to store.
Hence we say int ii. C# understands the word int as int is a part of the C# programming
language.

The variable ii started with the value 20 and is now holding a value 30. In the next line we have
ii=ii+10. The 'equal to' sign makes this statement look complicated. To avoid confusion, always
start by looking to the right of the 'equal to' sign. To the right of the equal to sign we have ii+10.
Since ii is holding the value 30, ii+10 is read as 30+10, which evaluates to 40. Hence ii=ii+10
will now be read as ii=40. This value 40 is given to the variable on the left-hand side. Now that ii
has a value 40, WriteLine will display 40. Similarly, we say ii=ii+1. Here the value of ii is
incremented by one. And the new value of ii, which is 41 will be displayed by WriteLine. In the
next line we have ii++. Note that ii=ii+1 and ii++ do the same thing. They both increment the
value of ii by 1. Hence WriteLine will now print the number 42.

This is a big problem with programming languages. As there are many ways to skin a cat, there
are also many ways to increase the value of a variable. So ii = ii + 1 and ii++ do the same thing.

A programmer thus has the choice to use either of the two ways to do the same thing. There you
go ---as you can see, first time programmers have unfortunately a lot to learn.

In daily life, a hundred different people can do the same chore in a hundred different ways.
Similarly, in programming there is more than one way of doing a particular thing. Programming
becomes a problem because of redundancy. Since there are two ways of doing the same thing
you have to learn them both and that can be very confusing. Of course, it is at your discretion to
choose the method you are comfortable with. Henceforth, even though there may be many other
ways of doing a particular thing, we will teach you only one method that we find appropriate.

A variable is a word that stores a value. This value can be changed at will by the programmer.
Wherever we can use a number, we can also use a variable.

The next program may seem alien to you. This is because it speaks the truth. If it finds that a
condition is true it outputs true and if it finds the condition to be false it outputs false. Very
unlike some of you, who would do just the opposite!

a.cs

class zzz

static void Main()

System.Console.WriteLine ("{0}", 5 > 2);

System.Console.WriteLine ("{0}", 5 < 2);

System.Console.WriteLine ("{0}", 2 < 2);

System.Console.WriteLine ("{0}", 2 <= 2);

System.Console.WriteLine ("{0}", 2 != 2);

System.Console.WriteLine ("{0}", 2 !=3);

}
}

Output

True

False

False

True

False

True

Let's understand this program line by line as usual.

Here the first line says WriteLine("{0}", 5 > 2); Is 5 > 2 ? Yes. So the condition 5 > 2 evaluates
to true. Hence the {0} in WriteLine is replaced with True and the WriteLine function displays
True. 5 > 2 is called a condition. A condition is like a question which has to result in a yes or no
or a true or false. In this case the number 5 is greater than the number 2 and hence the function
evaluates to true. C# understands the words true and false.

In the second WriteLine we have the condition 5 < 2. Is 5 < 2? No. So the condition 5 < 2
evaluates to false and hence WriteLine displays False. Similarly, the next condition 2 < 2 is not
true and hence False is displayed.

In the next statement we have 2 <= 2. Here the first sign being '<' it is first checked whether 2 <
2? No, 2 is not less than 2. So then the second sign '=' is checked i.e., whether 2 = 2? Yes. So the
condition 2 <= 2 evaluates to true and WriteLine displays True. <= is thus two conditions in
one .

In the next WriteLine we have the condition 2 != 2. '!=' means 'not equal to'. But 2 is equal to 2,
hence the condition evaluates to false and False is displayed. The comparison is false, therefore
the condition is false.

In the last statement we have the condition 2 != 3. Is 2 != 3? Yes 2 is not equal to 3, so the
condition evaluates to true and True is displayed. This True and False is a special data type in
C#. It is called 'Bool' or boolean derived from Boolean algebra.

a.cs

class zzz

{
static void Main()

bool ii;

ii=true;

System.Console.WriteLine ("{0}", ii);

ii=false;

System.Console.WriteLine ("{0}", ii);

Output

True

False

In our previous programs we used the data type int for the variable ii. This meant that ii could
store integers or numbers. Similarly, you can now initialize ii to either true or false. This is
possible by using the data type bool for ii. A data type means the type of data a variable can hold.
Therefore, here we are saying bool ii. In the first case we are initializing ii to true. So in
WriteLine, {0} is replaced with true. In the second case ii is initialized to false and {0} is
replaced with false.

In a gist, we now know that variables can be either bool or logical or they can contain the words
True or False. Also, variables can also contain numbers.

Let's see how C# distinguishes between data types.

a.cs

class zzz

static void Main()

{
bool ii; int jj;

ii=10;

jj=false;

Executing the above program gives the following errors:

Compiler Error

a.cs(6,4): error CS0031: Constant value '10' cannot be converted to a 'bool'

a.cs(7,4): error CS0029: Cannot implicitly convert type 'bool' to 'int'

If you want the rainbow, you gotta put up with some rain. So let’s understand the reason behind the
errors. Here C# is internally saying that it distinguishes between data types. In that sense C# is very petty
about what values you give to variables. Bool can't mix with int and vice versa. Since ii is a bool you can't
initialize it to 10, which is a number. C# is very strict about this. And because jj is an int you can't
initialize it to false. So you have to be very careful about how you initialize your variables. After all it
doesn't make sense to ask someone who is good at driving to teach computers and vice versa. Everyone
has his or her place in life. Similarly, variables also have their place. Hence a variable declared as a bool
can only have values true or false. Similarly, int can have only numbers or integers, it cannot take true or
false values.

Our next program is similar to one of the previous programs.

a.cs

class zzz

static void Main()

bool ii;

ii=6 < 7;

System.Console.WriteLine ("{0}", ii);

}
}

Output

True

Here ii is a variable of type bool. In the next statement we have ii = 6 < 7. As you already know,
in such a case you should start by looking to the right of the 'equal to sign'. Because 6 is less
than 7 the condition evaluates to true and ii will be initialized to true. Hence {0} is replaced with
the value of ii, which is true and True is displayed.

C# is called a strongly typed language because you cannot initialize a variable of type int to a
variable of type bool. The reason C# is very strict about this is because this system eliminates a
large number of sloppy programming errors. Some languages like C on which C# is based on do
not care what values you initialize your variables to. C# is stricter than even Java. In some ways,
it's like your mother when it comes to telling you what you are doing wrong in life. Thus it is
extremely difficult to make dumb errors in C#. Remember when you are writing code in C#, the
compiler is always peering down your shoulder making sure you do not get away with any
errors.

If Statement

So far the code that we have written is rather useless. This is because it always gets executed.
Life is enjoyable only because it is unpredictable. We don't know what tomorrow is going to
bring. Variety is the spice of life! Similarly, we would like to write computer programs, which
add spice to programming. We want to write programs that behave differently depending upon
different situations or circumstances. And this can be achieved with the help of the if statement.
So fasten your seatbelts and get set to ride!

The next few programs will demonstrate the usefulness and application of the if statement.

a.cs

class zzz

static void Main()

if ( false )

System.Console.WriteLine ("Hi");

}
}

Compiler Warning

a.cs(6,1): warning CS0162: Unreachable code detected

In this program we have included the word 'if' followed by false in round brackets. This is the if
statement and its syntax. Syntax is the grammar in writing. Thus we have no choice but to abide
by the rules. It is called a statement because anything that C# recognizes is called a statement.
When you run this program, you realize that there is no output. So this program will simply
display nothing. Now you know why we get the above warning as our code will never get
executed.

Let's understand the rationale behind it.

The if statement lets you include decision making in your program. It decides whether to execute
the next line or not. When the if statement evaluates to false then the next line is ignored. The if
statement brings with it the power to decide whether certain code should be executed or not.

The following program will make this concept clearer.

a.cs

class zzz

static void Main()

if ( false )

System.Console.WriteLine ("Hi");

System.Console.WriteLine ("Bye");

Output

Bye
The if statement looks at the immediate next line, it doesn't look at the line after that. Since the if
statement influences only one line, you will see only Bye displayed and not Hi. Same warning
again.

But if you want both the statements to be affected by the if then enclose them within curly
braces. This is illustrated below.

a.cs

class zzz

static void Main()

if ( false )

System.Console.WriteLine ("Hi");

System.Console.WriteLine ("Bye");

Here we have included both the lines of code within the braces. Now the if statement will affect
both the lines of code. The condition being false, nothing is displayed. Thus, the if statement
gives us the option to execute or not to execute a certain piece of code.

If we always use false then the code will never be called. But what did we tell you about
conditions? They return either true or false. So, in the next program we have 3 > 8 as the
condition. Since 3 is not greater than 8 the condition evaluates to false. Since there are no curly
braces, only the next line is affected by the if statement. Hence only Bye is displayed.

a.cs

class zzz

{
static void Main()

if ( 3 > 8 )

System.Console.WriteLine ("Hi");

System.Console.WriteLine ("Bye");

Output

Bye

Let's look at another variation of this program. Now, the interesting part is that wherever you can
use a condition you can also use a variable which is of type bool, which we know evaluates to
either true or false.

a.cs

class zzz

static void Main()

bool ii;

ii=true;

if ( ii )

System.Console.WriteLine ("Hi");

System.Console.WriteLine ("Bye");

}
}

Output

Hi

Bye

Here the variable ii is declared as a bool and then initialized to true. In the next line we have if
(ii). The variable ii holds the value true and hence the if condition evaluates to true. The
condition being true both Hi and Bye are displayed. Note that here both the statements are
included in the curly braces resulting in both the statements being affected by the if statement.
Thus the if statement is affecting a block of statements. Declaration is another way of saying that
we are creating a variable.

In the following program we have an if with the else. If the if condition evaluates to true then the
statement following it is called but if it evaluates to false then the else is called.

a.cs

class zzz

static void Main()

if ( false )

System.Console.WriteLine ("Hi");

else

System.Console.WriteLine ("Bye");

Output

Bye
Here, since the condition evaluates to false the else is called and hence Bye is displayed. Thus
the additional else statement specifies a statement that is executed when the condition is false.
This construction covers all possibilities, as a condition can be either true or false. In an 'if-else'
construct one of them have to be executed. Computer programs are said to be made intelligent
because of the if statement. The more the use of the if statement, the more intelligent your
program becomes. The if statement is one of the main building blocks of any programming
language. Thus all programming languages have to have a if statement.

Loops

The if statement is the cornerstone of programming because it lends intelligence and a decision
making power to the language. The second important constituent of any programming language
is a looping construct. In a program many times you would need to repeat instructions. In C#, the
for statement is one form of a loop that lets you repeat statements. However, as we already know,
a statement can also be a block of statements, thus it also allows repetition of multiple
statements.

Our next program explains the for loop.

a.cs

class zzz

static void Main()

int ii;

for ( ii = 1; ii <= 5; ii++)

System.Console.WriteLine ("Hi {0}", ii);

Output

Hi 1

Hi 2

Hi 3
Hi 4

Hi 5

The for has 2 semicolons as part of its syntax or rules. The statement up to the first semicolon is
executed only once. For the first time and only the first time ii is initialized to 1. Remember up to
the first semicolon the statement is executed only once. The statement enclosed within the first
and second semicolon is a condition. The condition checks whether ii <= 5 evaluates to true.
Since this condition evaluates to true, the statement within the open and the close braces gets
executed. If the condition evaluates to false, the statement is ignored and the loop terminates.
The variable ii has a value 1 which is less than 5, so System.Console.WriteLine will be called
which displays 'Hi 1' as the value of ii is 1. After the statement gets executed, the last part of the
for i.e. from the second semicolon to the closing bracket gets executed. ii++ will increase the
value of ii by 1, making it 2. The condition is checked again, is 2 <= 5. The answer here is true,
so 'Hi 2' is displayed. And this roller coaster goes on till the condition is false. When ii has the
value 6, the condition checked is, is 6 <= 5. The answer being false, the for terminates. This is
how the for statement enables the repetition of code.

Our next example will further help to illustrate this.

a.cs

class zzz

static void Main()

int ii;

for ( ii = 1; ii <= 5; ii++)

System.Console.WriteLine ("Hi {0}", ii);

System.Console.WriteLine ("Hi {0}..", ii);

Output

Hi 1
Hi 2

Hi 3

Hi 4

Hi 5

Hi 6..

In this program we have two WriteLine statements. The for loop follows the same rules as the if
statement. Thus in absence of curly braces the for loop will affect only the immediate next
statement. Therefore, the for loop will print numbers from 1 to 5 along with hi. The moment the
for loop terminates, ii with the dots will print Hi 6... This goes to prove that when ii has a value
six, the for loop will terminate.

The following program demonstrates how the for loop enables repetition of multiple statements.

a.cs

class zzz

static void Main()

int ii;

for ( ii = 1; ii <= 5; ii++)

System.Console.WriteLine ("Hi {0}", ii);

System.Console.WriteLine ("Hi {0}..", ii);

}}}

Output

Hi 1

Hi 1..
Hi 2

Hi 2..

Hi 3

Hi 3..

Hi 4

Hi 4..

Hi 5

Hi 5..

Here, both the WriteLine statements are enclosed within curly braces. Therefore, both the
statements are affected by the for loop. Hence, in this case, each number is displayed twice along
with Hi, once without the dot and once with the two dots.

Similar to the for loop is the while loop.

a.cs

class zzz

static void Main()

int ii;

ii=1;

while ( ii <= 5 )

System.Console.WriteLine ("Hi {0}", ii);

}
}

The while loop takes a condition, hence the variable ii is initialized to 1 before entering the loop.
The condition checks whether ii <= 5 evaluates to true. Currently the value of ii is 1. The
condition evaluates to true and the statement within the curly braces is executed.
System.Console.WriteLine is called with Hi and the value of ii. Note that here we are not
changing the value of ii within the loop. Since the value of ii remains 1 the condition always
evaluates to true and the loop will go on forever, indefinitely.

We can't have anything go on forever, can we? There has to be a stop to it somewhere! Our next
program will resolve this problem.

a.cs

class zzz

static void Main()

int ii;

ii=1;

while ( ii <= 5 ){

System.Console.WriteLine ("Hi {0}", ii);

ii++;

Output

Hi 1

Hi 2

Hi 3

Hi 4
 Hi 5

This program is similar to the previous one. The only change that we have made is that we added
the line ii++; thus for the first time Hi 1 is displayed. Then the moment ii++ is encountered the
value of ii is incremented by 1, making it 2. Then the condition, 2 <= 5, is checked. The
condition being true, once again we enter the loop and Hi 2 is displayed. This will go on until ii
becomes 6. Once ii is 6 the condition evaluates to false and the loop terminates.

Your mind may ponder over the question, "Should I use a for or a while?' The for loop is similar
to the while loop. To answer your question in the most simple manner "On Mondays,
Wednesdays, Fridays use for and on Tuesdays, Thursdays, Saturdays use while. Sundays we
assume no one writes code". Alternatively "Toss a coin, heads use while, tails don't use for" ;-)

In other words, it is at your discretion to use the one you are comfortable with. Once again C#
offers you multiple ways of doing the same thing.

The Return statement

Let's understand the return statement with our next example.

a.cs

class zzz

static void Main()

int ii;

ii = abc();

System.Console.WriteLine("hi {0}",ii);

static int abc()

System.Console.WriteLine("abc");

return 100;
}

Output

abc

hi 100

In this program, at first, ii is declared as a variable of type int. Then we start

executing the line ii=abc(); Doesn't the right hand side of the statement ring a bell? Aren't we
calling the function abc() ? Hence at this point the control passes to the function abc().

In the function we have the WriteLine statement, which prints 'abc'. Thereafter, we have a return
statement. It says return 100. In effect, the function abc() is returning a value 100. Thus the
statement ii = abc(); will now be read as ii=100. Now that ii has a value 100, {0} in WriteLine is
replaced with 100 and in turn 100 is displayed.

a.cs

class zzz

static void Main()

int ii;

ii = abc();

System.Console.WriteLine("hi {0}",ii);

static void abc()

System.Console.WriteLine("abc");

return 100;
}

Compiler Error

a.cs(6,6): error CS0029: Cannot implicitly convert type 'void' to 'int'

a.cs(12,1): error CS0127: Since 'zzz.abc()' returns void, a return keyword must not be followed
by an object expression

Executing the above program results in errors. Here we have static void abc(). What static
means, we will explain a little later. It is with the intention to enable you to learn better, so please
bear with us. The word void means nothing. So by saying void abc() we are saying that the
function abc() does not return any value. Functions may/maynot return values. Earlier abc
returned an int. When a function returns void as in this case, we are saying that abc cannot return
a value. But in the function code we have written return 100. Therefore, because of this
contradiction we get the error. Note that in the previous program we did not get an error. This
was because we had said static int abc(). Here int signifies the return type of the function. Since
the function returns a number we used int.

In our next example we have made only one addition i.e. we have added
System.Console.WriteLine("Finish"); after the return statement.

a.cs

class zzz

static void Main()

int ii;

ii = abc();

System.Console.WriteLine("hi {0}",ii);

static int abc()

{
System.Console.WriteLine("abc");

return 100;

System.Console.WriteLine("Finish");

Compiler Warning

a.cs(13,1): warning CS0162: Unreachable code detected

Output

abc

hi 100

On executing this program, you will find that the output is the same as the previous program. To
your amazement you do not see the word 'Finish' displayed. No, it is not because C# doesn't like
you. The reason is that anything after the return statement is ignored.

Thus, you may have a hundred WriteLine statements after the return statement but they will all
be ignored. Simply stated, no lines after return statement will get called. That is why the C#
compiler, courteous as it is, gives you a warning and not an error.

More on data types.......

You have already learnt about two data types, int and bool. Our next program introduces a new
data type 'string'.

a.cs

class zzz

static void Main()

string s;

s= "hell";
System.Console.WriteLine(s);

Output

hell

In this program, the variable s is declared as a string. This implies that s will store mainly letters
of the alphabet. Then s is initialized to hell, which is nothing but a collection of the letters of the
alphabet. Note that all strings have to be enclosed within double inverted commas.
System.Console.WriteLine displays the value of the variable s, which is 'hell'. Earlier we wrote a
string in double inverted commas directly. However, this time we are using a variable name
instead.

Now we know the first parameter to the WriteLine function is a string. We earlier named our
variable ii and now we have called it s. Actually, we name our variables depending upon the time
we write our programs. You decide your own rules for naming variables. Anything you enclose
in double quotes is called a string. System.Console.WriteLine is smart enough to display strings,
bools and int.

Let's look at another variation of the above program.

a.cs

class zzz

static void Main()

string s;

s= "hell";

System.Console.WriteLine( "{0}", s);

Output
hell

This program is exactly like the previous one, the only difference being that we have used {0}
instead of writing only s. Here the {0} is replaced with the value of s, which is 'hell'. Thus, using
the {0} is preferable as it understands a large number of data types and how to display their
values.

Consolidating, our next example incorporates all the data types that we have learnt so far.

a.cs

class zzz

static void Main()

string s;

int ii;

bool jj;

ii=10;

jj=false;

s="hell";

System.Console.WriteLine("{0} {1} {2}", ii, jj, s);

Output

10 False hell

Here the variable s is declared as a string. Then ii is declared as int and jj is declared as bool. In
the next three statements we are initializing each of the variables. ii is initialized to 10, jj is
initialized to false and s is initialized to hell. Now, with the help of a single WriteLine statement
we are displaying the values of all the variables. {0} is replaced with 10, {1} is replaced with
False and {2} is replaced with hell. This goes to prove that all the data types can be displayed
together, in a single WriteLine statement. Thus, C# allows all the data types to co-exist in
harmony. Now only if the people of our country could do the same!

Passing parameters to functions

By now you are familiar with functions and how functions are called. The next program
illustrates how parameters are passed to functions.

a.cs

class zzz {

static void Main()

abc(10,false,"hell");

static void abc(int i, bool j, string s)

System.Console.WriteLine("{0} {1} {2}", i,j,s);

Output

10 False hell

We have again used the System.Console.WriteLine function to display values of variables or

merely display text onto the screen. To have it print something on to the screen, we had to give it
the things that we wanted printed. These things are nothing but parameters. We don't pass things
to functions; we pass parameters to functions. So far we never created our own functions with
parameters.

In this program, we are calling the abc function with three things, with three parameters. The
first is a number, the second is a logical value and the third is a string. So, we are passing the
values 10, false and hell to the function abc(); These values must be stored somewhere, but
where? When we create the function abc we have to state the names of three variables along with
their respective data types. This is because the values that we pass will be stored in these
variables. Hence we have the variables i, j and s. These are then displayed using WriteLine.
Therefore, it will output 10, False and hell. This is how parameters are passed to functions in C#.
Remember you decide what names to give to variables. Parameters passed to functions are also
variables.

a.cs

class zzz {

static void Main()

abc(10,false);

static void abc(int i, bool j, string s)

System.Console.WriteLine("{0} {1} {2}", i,j,s);

Compiler Error

a.cs(4,1):error CS1501: No overload for method 'abc' takes '2' arguments

On compiling this program you will encounter the above error. Here we are calling abc with only
two parameters, 10 and false. Whereas the function abc is actually created with three parameters.
We are passing an erroneous number of parameters, hence the error. Lesson? One must pass the
same number of parameters that the function has been created to accept. A mismatch between the
number of parameters being passed and those being accepted will definitely assure you of an
error. Thus as before, C# does a large number of error checks on your code. For, if it allowed the
above function call to go ahead, what would the value of the third parameter s be?

Now change the order of the values that are being passed. Your abc function should look like
this- abc("hell",10, false);

a.cs

class zzz

{
static void Main()

abc("hell",10,false);

static void abc(int i, bool j, string s)

System.Console.WriteLine("{0} {1} {2}", i,j,s);

Compiler Error

a.cs( 5,1): error cs1502: The best overloaded method match for 'zzz.abc(int, bool, string)' has
some invalid arguments

a.cs( 5,5 ): error cs1503: Argument '1': cannot convert from 'string' to 'int'

a.cs(5,12): error cs1503: Argument '2': cannot convert from 'int' to 'bool'

a.cs(5,15): error cs1503: Argument '3': cannot convert from 'bool' to 'string'

On executing this program you will be faced with the above errors. These errors have resulted
due to a data type mismatch. It is somewhat like putting a round pole in a square peg! How is it
going to fit?

While calling the function abc() the first parameter that we are passing is the word "hell". But the
function abc() has been created to accept the first parameter as an int. Remember we told you,
not so long ago, that C# distinguishes between data types. Thus you can't store a string in a
variable of type int. Similarly, the value 10 cannot be stored as a bool and false cannot be stored
as a string. Therefore, not only should the number of parameters being passed and accepted be
the same but also their data types must match.

Like oil and water do not mix, in the same way you cannot give C# an int when it wants a string.
As said earlier, some languages are more forgiving then C# due to which the programmer makes
more mistakes in them.

a.cs
class zzz

static void Main()

abc();

class yyy

static void abc()

System.Console.WriteLine("abc");

Compilation Error

a.cs(5,1): error CS0103: The name 'abc' does not exist in the class or namespace 'zzz'

Seems like we are hooked on to errors!

In this program we have created another class called yyy. We can have as many classes in one .cs
file as we like. This program now has two classes, zzz and yyy. The class zzz has a function
called Main. Main denotes the starting point of our code and as such is the first function to be
called. The class yyy contains a function called abc. Here we are calling the function abc by
saying abc(); in class zzz. But class zzz does not have any function by the name abc. Merely
giving abc(); encourages C# to assume that abc() exists within the class zzz. But our abc function
is contained in yyy. Hence we get an error as we are trying to call a function that exists in
another class.

But we are adamant! We want to use the abc function that yyy has. It's human tendency to want
things that others have! So, in the next program we are calling the function abc in the class yyy
by writing yyy.abc();
a.cs

class zzz

static void Main()

yyy.abc();

class yyy

static void abc()

System.Console.WriteLine("abc");

Compilation Error

a.cs(5,1): error cs0122: 'yyy.abc() is inaccessible due to its protection level.

When we say yyy.abc(); why the dot? yyy is the name of the class and abc() is the name of the
function . Each of these names can be as large as you want, so to separate them a dot is used.
Thus when you want to access a function that belongs to another class you can do so by
specifying the class name and function name separated by a dot. The dot is like the semicolon.
The designers of the language wanted some character as a separator between class name and
function name, they chose the dot, they could have also chosen the semicolon again.

You will now realize why we say Console.WriteLine. Obviously, it means that Console is a class
and within the class Console there is a function called WriteLine.

But to your dismay, on executing this program you still get an error. Well, few people get what
they want, however fewer still want what they get! You may want a particular thing but you will
not get it unless the other party gives you the permission to take it, use it or share it. Your only
other option is to put up a fight!

We get an error here because we haven't used the word public. The whole idea behind C# is its
usability on the net. And the only way you can use it on the net is by having security precautions.
So in C# the default rule is - you can't use anything unless explicitly granted permission. Next
question. How do you grant the necessary permission?

Being its non-violent self, C# grants permission by using the word public. When we say public,
we mean the world at large. So by starting with the word public we are saying that the whole
world is now allowed to use this function as we are explicitly granting you rights. If you don't
use the word public it will give you an access error.

To rectify the error, add the word public just as we have done below.

a.cs

class zzz

static void Main()

yyy.abc();

class yyy

public static void abc()

System.Console.WriteLine("abc");

Output
abc

Finally, we have the correct code! See, one of life's greatest ironies is the fact that when you
finally master a tough job, you make it look easy!! By using the word public in front of the
function abc, we can now call it from zzz by specifying yyy.abc(); Now that the function is
called, WriteLine displays 'abc'.

Our next example will enhance your understanding further.

a.cs

class zzz

static void Main()

yyy.abc();

abc();

zzz.abc();

public static void abc()

System.Console.WriteLine("abc in zzz");

class yyy

public static void abc()

System.Console.WriteLine("abc");
}

Output

abc

abc in zzz

abc in zzz

Now we go a step further. In the above program we have two abc functions, one in class zzz and
one in class yyy. If you want to call the one in yyy then you say yyy.abc(); but if you want to call
the one in zzz then you say zzz.abc() or abc(). The function abc(), by itself, will ask which class
is it? Since abc() is in zzz itself, C# assumes it to zzz.abc(); By implication, if the function exists
within the same class, it is optional to preface the function with the name of the class. When you
execute this program, yyy.abc() will call the abc function in class yyy and WriteLine will display
'abc'. Thereafter, both abc() and zzz.abc() will call the abc function in class zzz. And in each case
WriteLine will display 'abc in zzz'. Thus if you do not preface the function name with the name
of the class, C# will add the name of the class in which you are calling the function. In our case it
is zzz.