Csharp Basics

Authors
Vijay Mukhi (vmukhi@vsnl.com) is one of the pioneers of the Indian Infotech Industry. For
years, he has been the first to teach the emerging technologies in India thus ensuring that India
always has people trained in technologies that the world requires. Vijay has written over 80
books on computers and programming over the last eight years on subjects ranging from C, C++
(The Odyssey Series) to Animation and Networking to ERP. His newly released book ‘Java-
Servlets-JSP’ has covered many aspects of Java in the most simplified form. Vijay abhors
complexities and hence his books showcase the most difficult concepts explained through small
programs, thereby giving a good understanding. Microsoft's .Net technologies is what Vijay is
now focussing on and he aims at writing volumes on it.
Sandeep Shanbhag (sandy.shanbhag@vsnl.com) is a Chartered Accountant by profession, a

technical and financial writer by choice. Under the aegis of Wonderland Investment Consultants,
he has hitherto been writing regular columns for professional journals, websites and newspapers.
Starting out with the aim of leveraging technology to his domain knowledge of finance, this is
his first stepping stone.
Sonal Mukhi (svmukhi@yahoo.com) is a freelance programmer having a widespread exposure

to computer techniques and languages. Sonal has done groundbreaking work on various Internet
Technologies like Java, ActiveX, Perl and more. She has co-authored a few books on computer
programming too.
Introduction
Welcome to the first installment on a series of 12 volumes dedicated to the latest technology to
hit the third rock from the sun. But before diving in and getting both feet wet, a wee bit of
background.
Microsoft has always had a habit of doing things in style. Whether it was the basic yet robust
Disk Operating System (DOS) or the (user-friendly?) Windows Operating System, Microsoft has
always managed to rewrite the rules in the computer world. In fact it won't be exaggeration to
say that today it is thanks to the efforts of Microsoft and the vision of its founder, Bill Gates, that
it is software and not machines, that occupy centrestage. But then that is another story altogether.
Notwithstanding its hegemony over operating systems, it must be said that Microsoft took its
time to wake up to the call of the Internet. Netscape was way ahead in the race, and Internet
Explorer was a distant follower, almost nowhere in the reckoning. Even as users had begun to
write off Microsoft as a non-starter for the web, it has gone and done what he does best ---
pounced back with technology that is more cutting edge than its peers.
Although, Netscape isn't history as yet, most people would rather use a browser that works better
with the latest versions of Windows. Internet Explorer literally chooses itself. Then of course
there are other utility tools like Excel, Word and Power Point - all Microsoft-owned and near-
indispensable.
And now Microsoft has come out with Microsoft.Net, a project until recently called Microsoft's
Next Generation Windows Services architecture. The objective is the integration of the Internet -
to offer software - like Word and Excel - through your browser on the computer as well as on a
range of devices such as the mobile phone and the personal digital assistant (Palm Pilot etc).
The grand design, as it were, is to change the very nature of the way people work presently.
Today we generally use one computer per person. Soon, all we shall be using would be only the
Internet. For all our needs. In other words, whenever you switch your computer on, you would be
connected directly to the Internet and not your hard disk for even the most rudimentary of tasks.
The task is enormous: every package now on offer will need additional code (even recoding). In
the new regime, Microsoft has got Visual Studio .Net which can enable even the most uninitiated
to design complex websites provided of course one is web and design savvy.
And all of this will be made possible through a new programming language called C#
(pronounced C-Sharp).
Why C-Sharp?
When people talk of computer programming languages, there is always a debate on which one is
better. C++, Java, Perl, PHP3… the arguments and counter-points can be endless. However, it is
our considered belief that that C# would be in a sense better than the rest. And there is a reason
for this.
Normally, whenever a new product is introduced, it betters the technologies of its ilk. For
existing technologies evolve with their own pros and cons. Therefore, in 1995, when Sun
introduced Java, it took the best from amongst all languages and added current technology. Now
Microsoft has done the same. Its taken the best features from C++ and Java and morphed them
into this new programming language called C#.
Imagine those who worked on Java when it was launched six years ago. Today a CV boasting of
a six-year experience in Java means the maximum possible. Simple arithmetic - Java was
launched only in '95. Similarly, if you get into C# today, only a Microsoft engineer could have
more working knowledge of it! Therefore, we don't think we need to elaborate further on the
weight that a CV with C# exposure would command! Think for yourself. You may know of
people who have struck lucky in getting a job. But when it comes to keeping it, Lady Luck is
powerless.
Indeed, technology is ruthless, in that, it breaks across all age and seniority barriers. That's the
reason why even a teenager could have as much experience with a new technology as a 40-year-
old. Unfair, but true.
Who should read this book?

Anyone wanting to be on the cutting edge of new technology. The book is written assuming no
prior programming knowledge on the part of the readers. However, we make certain other
assumptions that we shall explain now.
Many a times, on a clear night when we look up at the stars, we can't help but wonder whether
there is intelligent life out there - or are they just like us?
For we don't believe that intellect is a quality that we are born with. In fact we are going to share
a secret with you. It is the secret of success given to us by an old gypsy woman. This magic
mantra has worked with many and we assume you would also use it in your life. In fact this is
the only assumption we make in this book.
The secret is in persistence - nothing in the world can take place of persistence. Talent will not,
nothing is more common than unsuccessful people with talent. Genius will not, unrewarded
genius is almost a proverb. Education will not, the world is full of educated derelicts. Persistence
and determination alone are omnipotent. We hope you agree with the old gypsy apply the maxim
while learning C#.
Now, the mere fact that you are reading this means that you are interested in learning something
new. However, there is a great deal of difference between a person who wants to read a book and
the person who just wants a book to read. We hope you belong to the former category.
Though we attempt to infuse a certain degree of humour in our writing, please do not buy this
book for its jokes. This is no coffee table book or even bedtime reading. This is a book, a
medium, which we hope will do the serious job of teaching the reader a new programming
language.
And how do we propose to go about it? Just like when you eat, no matter how delicious the food
in front of you is, you have to consume it, one mouthful at a time. You just cannot eat it all at
once, can you?
Similarly, when learning, it is always better to take small steps - one concept at a time.
Sometimes, we even repeat the same concept several times, in different ways. For we firmly
believe that if you do the little things well enough, big things will come to you asking to be done.
Incidentally, the entire C# software is available on the Microsoft site, downloadable free of
charge. Detailed instructions are given on the site along with a set of FAQs.
Well, that's that. We agree, it is tough to climb the ladder of success, especially if you're trying to
keep your nose to the grindstone, your shoulders to the wheel, your eye on the ball and your ear
to the ground. Precisely the reason why some people do not recognise opportunity - it often
comes disguised as hard work.
This book presents you with precisely such an opportunity. We hope you grab it with both hands!
Acknowledgements
I wish to thank a number of people who gave me support, new ideas and
inspiration through the process of writing this book.
First and foremost, thanks to Manish Jain, BPB publication for publishing the book.
Special thanks to my co-authors, Sonal and Sandeep, who have put in their very best in the work
assigned to them as without them and their efforts the book would have never seen the light of
day.
Thanks to my cover designers, Altaf Hemani and Kishore Rohra, for designing the cover in a
very short notice.
Thanks to Manish Purohit for putting in all the time he had to verifying the code with the
explanation, testing all the applications in the book and updated them to work under the Release
version of the product.
To, Pradeep Mukhi and Shivanand Shetty, who made it simple for me and my co-authors to
come up with the book.
A long list of friends and my family need a mention here for their patience and cooperation on
this book while it was being written.
-Vijay Mukhi
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'
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;
}
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;
ii=30;
ii=ii+10;
ii=ii+1;
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;
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;

}
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 ("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 )
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 )
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 )
}
}
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 )
else
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);
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);
}}}
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 )
}
}
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 ){
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();
static void 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();
static int abc()
{
return 100;
System.Console.WriteLine("Finish");
Compiler Warning
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);
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);
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()
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()
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()
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();
System.Console.WriteLine("abc in zzz");
class yyy
}
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.
2
Namespaces
Normally, students have an implicit trust in their teachers. For they know that if the blind lead
the blind, both shall fall into the ditch. However, our philosophy is that a good teacher has to be
an even better liar!!
In accordance with this belief, initially we told you that WriteLine is the name of a function.
Then we told you that the name is not WriteLine, it is System.Console.WriteLine. But even that's
not true.
Now comes the moment of truth.
Console is actually the name of a class. Yes, trust us! There is no crying wolf here. The class
Console has a function called WriteLine. Hence the name now becomes Console.WriteLine.
However, that leaves out the word System. Now what does System mean?
Well, a number of functions like WriteLine are available in C#. Some functions will let you print,
some will enable writing of data to disk and others will let you create graphics. The problem that
we are posed with is - how does one remember which function satisfies what purpose?
Wouldn't it make sense if we logically grouped similar functions together? So, Microsoft thought
that all functions that can write to the screen could be made part of one class. All functions that
let you work with pictures could be part of another class. But even then, you will have too many
functions in one class. So they thought of having a single higher logical group. Such that all the
functions that have anything to do with the screen, i.e. whether you are drawing pictures or
writing text, be grouped once again into a higher body. Thus all classes that deal with interacting
with a database could go into a group called Data.
The second problem that we are posed with is that of name clashes. What do we mean by that?
Now, nothing can stop me from creating my own class called Console and include a function
called WriteLine in it. But how will C# know which Console am I referring to? The one that we
created ourselves, or the one that Microsoft has already created. In order to resolve these
problems Microsoft decided to take classes and put them into namespaces. What is a namespace?
It is simply a word. Thus we can logically group everything as per namespaces.
From the above explanation you would have by now guessed that System is nothing but a
namespace. The following programs will help make this concept crystal clear.
a.cs
class zzz
static void Main()
yyy.abc();
abc();
zzz.abc();
System.Console.WriteLine("abc in zzz ");
namespace vijay
class yyy
}
}
Compiler Error
a.cs(5,1): error CS0246: The type or namespace name 'yyy' could not be found (are you missing
a using directive or an assembly reference?)
In the above program, the only change that we have made is that we have now included the class
yyy in a namespace called vijay. On doing so you will realize that the same program that worked
earlier doesn't work anymore. This is because yyy is put in a namespace vijay.
A namespace is nothing but a word with an open and close brace. The entire class is enclosed
within the namespace. If you want to access a function belonging to class yyy from another class
then the only way to do so is by saying vijay.yyy.abc(); Thus you specify the namespace first,
then the name of the class followed by the name of the function, each of them separated by dots.
Thus like Urdu, we read anything from the right and not the left. We start with the name of a
function, then the name of the class and whatever is left is the namespace.
Here zzz has not been given a namespace. If you don't specify a namespace then by default the
class is included in a global namespace. Now change yyy.abc(); to vijay.yyy.abc() and watch the
error disappear.
a.cs
class zzz
static void Main()
vijay.yyy.abc();
abc();
zzz.abc();
{
namespace vijay
class yyy
Output
abc
abc in zzz
abc in zzz
We bet your faces are now beaming! Seems like the secret of happiness is not in doing what one
likes to do but in liking what one has to do. We had to get rid of the error which we have
succeeded in doing. The error has disappeared; the program executes as advertised and it
generates the same output as it did previously.
Thus all the classes and functions created by Vijay can be included in a namespace called vijay.
If Sonal creates a namespace by her name then she can include all the functions and classes
created by her in the namespace sonal. Thus there will be no name clashes at all. These
namespaces that are created by us are called user-defined namespaces whereas System is a pre-
defined namespace. Thus System is a namespace in which a class called Console was created,
which contained a function called WriteLine.
Thus the namespace concept allows us to create logical groups. So all xml related classes can be
in a namespace called xml, web can be in a web namespace and so on and so forth.
But the only problem now is that when you start writing code you have to specify the namespace
first, then the class name followed by the function name. Well, everything is available but for a
price! Our consolation is that it is a very small price to pay.
a.cs
namespace mukhi
class zzz
static void Main()
vijay.yyy.abc();
abc();
zzz.abc();
mukhi.zzz.abc();
namespace vijay
{
class yyy
Output
abc
abc in zzz
abc in zzz
abc in zzz
In the above program, we have two classes zzz and yyy. The class zzz is included in a namespace
called mukhi and the class yyy is included in a namespace called vijay.
So when we say abc(); in Main, Main is in zzz, so you are actually writing mukhi.zzz.abc(); This
is because C# will automatically expand it since the function abc is available within the same
class. Hence it is at your discretion as to how you want to write it. You can say abc(), zzz.abc() or
mukhi.zzz.abc(); finally they all expand to namespace.classname.function name. C# adds the
name of the namespace and the name of the class even if you do not specifically write it. The
concept of namespaces is not very difficult to understand. It allows for a hierarchical grouping of
classes. It tells us which classes are logically grouped. It also avoids classes from having the
same name.
a.cs
class zzz
static void Main()

{
Console.WriteLine("abc in zzz ");
Compiler Error
a.cs(5,1): error CS0246: The type or namespace name 'Console' could not be found (are you
missing a using directive or an assembly reference?)
If we do not enclose our class in a namespace, it becomes part and parcel of the global
namespace ‘ ‘. This namespace does not contain a class called Console. We had mentioned
earlier that the class Console is contained in the namespace System. We do not want to preface
the Console class with the namespace System each and every time. The only reason being that
our fingers will wear out typing the word System over and over again. So C# lets us use a
shorthand by means of which we avoid the pain of having to keep on writing the name of a
namespace over and over again.
a.cs
using System;
class zzz
static void Main()
Console.WriteLine("abc in zzz ");
Output
abc in zzz
The secret here is not in doing great things, but doing a small thing in a great way. We get no
error simply by employing the word using which is part of the C# language. All that using does
is whenever it sees only the name of a class, it goes and adds (in this case) the word System.
Thus we do not have to write the word System over and over again. This works the way
shorthand does.
a.cs
using System;
class zzz
static void Main()
yyy.abc();
namespace vijay
class yyy
Console.WriteLine("abc");
Compiler Error
a.cs(6,1): error CS0246: The type or namespace name 'yyy' could not be found (are you missing
Now we get an error for yyy and not for Console as the yyy class belongs to the vijay namespace
and not the global namespace. Because of the using keyword, C# adds the namespace System to
yyy yielding System.yyy.abc and realizes that System does not contain a class called yyy. Hence
the error.
a.cs
using System;
using vijay;
class zzz {
static void Main()
yyy.abc();
namespace vijay
class yyy
Output
abc
The error vanishes as C# first tries System.yyy.abc gets an error, then tries vijay.yyy.abc and is
successful. Thus by having two using's we do not have to write the namespaces vijay or System
ever again.
a.cs
using System;
using mukhi;
using vijay;
namespace mukhi
class zzz
static void Main()
yyy.abc();
abc();
zzz.abc();
zzz.abc();
}
namespace vijay
class yyy
Output
abc
abc in zzz
abc in zzz
abc in zzz
We can have as many using's as we like and the compiler will try each one in turn. If none of
them match we will receive an error. In this case it will try 3 times with System, mukhi and vijay
and if none match, you will get an error.
a.cs
using System.Console;
class zzz
static void Main()
{
WriteLine("abc in zzz ");
Compiler Error
a.cs(1,7): error CS0138: A using namespace directive can only be applied to namespaces;
'System.Console' is a class not a namespace
After the word using you can only write the name of a namespace. System.Console is a
namespace class combination which is not allowed.
Building Hierarchy
In C# you organize classes using namespaces. Now let's discover the extent we can go to as far
as organizing classes.
a.cs
class zzz
static void Main()
mukhi.vijay.yyy.abc();
namespace mukhi
namespace vijay
class yyy {

{
Output
abc
In this program we have a namespace within a namespace i.e. within the namespace mukhi we
have another namespace vijay. Thus namespaces are 'hierarchical'. If you want to access the
function abc in yyy you have to specify it in the form- namespace.classname.functionname. So,
the qualified name is now mukhi.vijay.yyy.abc(); Once the function is called, WriteLine will
display 'abc'.
In order to differentiate between the various names separated by dots, always read backwards.
Reading backwards, the first is the function name then the class name and the names thereafter
will all be namespaces.
Alternatively, you can directly specify the namespace as mukhi.vijay, as we have done below.
This program generates the same output as previously, it prints abc.
a.cs
class zzz
static void Main()
mukhi.vijay.yyy.abc();
namespace mukhi.vijay
{
class yyy
Output
abc
Here we have a single namespace by the name mukhi.vijay. The name mukhi.vijay is actually a
shortcut for defining a namespace named mukhi that contains a namespace named vijay. In this
program, we have only two namespaces. But you can expand it further to include a number of
namespaces depending upon the level of hierarchy required by your program.
We can liken this to an organization. Let's consider mukhi to be the name of the company. Within
that you have a sub-company or a division called vijay, which creates it own classes. As such the
level of hierarchy can be expanded.
Before you understand the next program let's address a simple question. Why do you use classes?
Classes are used because they offer a large number of functions. You don't use classes because of
the variables that you can create within them; you use classes for the functions that they provide.
Remember, you call a function using the form -namespace.classname.functionname.
File Operations
a.cs
class zzz
static void Main()

{
File.Copy("c:\\csharp\\a.txt","c:\\csharp\\b.txt",true);
Compiler Error
a.cs(5,1): error CS0246: The type or namespace name 'File' could not be found (are you missing
Our next program will enlighten you on something most sought after - The art of Copying. Ah!
Finally something of interest!
This program introduces the 'Copy' function. It allows you to duplicate a file. File is a class and it
has a function called Copy, which is static.
The first parameter 'a.txt' is the source file i.e. the file, which we want to duplicate. The second
parameter 'b.txt' is the destination file i.e. the file that we want to copy to. Note that you must
specify the entire path for the file name. The last parameter 'true' implies that if the file exists
then it will be overwritten. If the file does not exist it will be created and contents of the source
file will be copied onto it.
And just when you thought you had mastered the art of copying the program returns with an
error message. The error says C# does not know what File.Copy is. The problem is that the name
of the namespace is System.IO. So you have to specify the namespace too.
Add the namespace and execute the program.
a.cs
class zzz
static void Main()
System.IO.File.Copy("c:\\csharp\\a.txt","c:\\csharp\\b.txt",true);
}
The program does not generate any compilation errors. Create a file called a.txt with some text
before you run this program. Execute this program and then open the file 'b.txt'. Finally, the task
has been accomplished! You now have the contents of a.txt copied into b.txt.
Our next program introduces another function called 'Delete'.
a.cs
class zzz
static void Main()
System.IO.File.Delete("c:\\csharp\\a.txt");
The above program takes the name of a file as the parameter. This function will remove the file
specified from disk. Give the dir command at the command prompt and you will find that the file
has been deleted.
Every language will offer you millions of such functions like copy and delete. These functions
were always available, but C# has gone one step further and made these functions a part of a
Class. They are now part of a Namespace. Hence it becomes easier to categorize functions. It is
but a question of detail whether you should or should not categorize them.
3
Constructors and Destructors
New
Let's consider the following program.
a.cs
class zzz
static void Main()
yyy.abc();
class yyy
public void abc() {
}
Compiler Error
a.cs(5,1) : error CS0120: An object reference is required for the nonstatic field, method or
property 'yyy.abc()'
This program contains one class called yyy which has a function called abc. In Main() we are
using the syntax yyy.abc() to call the abc function as we did earlier. Within the abc function we
have the code for the function abc that will print the string "abc". On compiling this program you
will get an error as incomprehensible as ever!
But how is it that when we ran this program earlier we didn't get an error? If you are still
bewildered, wake up and smell the coffee! Didn't you notice we removed the word 'static' while
saying public void abc(). Hence we get an error.
In our earlier programs when we wrote the function abc we had written the word static which is
missing now.
No, we are not going to tell you to add the word static and execute the program. We are not that
predictable! On the contrary, we shall do something quite different and interesting. Keeping that
in mind let's consider the next program.
a.cs
class zzz
static void Main()
yyy a;
a.abc();
class yyy
public void abc()
{
Compiler Error
a.cs(6,1): error CS0165: Use of unassigned local variable 'a'
Before we look into this program let's get our basics clear. We have often used the statement 'int
i' meaning that i was a variable that looked like an int. When we used the statement 'string s', it
meant that s was a variable that looked like string. Similarly, in this program we are saying yyy
a. This implies that 'a' looks like yyy. What is yyy? It is the name of a class. Here we do not call
'a' a variable, we call it an object. An object and a variable can be used interchangeably.
Earlier, whenever we wanted to call a member from a class we would say yyy.abc(); i.e. class
name dot function name. But in our current program we are saying a.abc(); We are using the
same dot, but now it gives an error saying - 'Use of unassigned local variable'. Note that the word
member is analogous with the word function.
But things still don't seem any clearer. So, let's go a step further and add another statement
a=new yyy(); Match your code with the one below.
a.cs
class zzz
static void Main()
yyy a;
a=new yyy();
a.abc();
class yyy
{
public void abc()
Output
abc
The word or keyword new must be followed by the name of a class; You cannot substitute it with
anything else, it must be a class. In our case, we have given the statement as new yyy(). yyy is
the name of an existing class. But why have round brackets after the class name? The '(' and ')'
brackets are part of the syntax. And you very well know by now that you can't argue with syntax.
Thus it is at this point i.e. after saying new, that the object 'a' that looks like yyy is created. We
could have also called the object 'a' an instance of the class yyy. Since the class yyy has only one
function it will allocate memory for THAT one function ONLY. Now we have an object 'a' that
looks like class yyy. Once the object is created, it can be used to access the function from class
yyy. Hence, now if we say a.abc() we will not get an error.
Thus an object is nothing but an instance or an occurrence of a class. Therefore, 'a' is an instance
of the class yyy. This is how you can instantiate an object.
In order to create an object you must use the keyword 'new'. Our next program will help you gain
a better understanding of this concept.
a.cs
class zzz
static void Main()
int i;
i=new int();
}
At first we have int i, meaning i looks like int. Then we have i=new int(); Executing this program
will not generate any errors. But so far whenever we used int i we never created the object i
using new int(). This is because C# does this internally for us. It saves us the trouble of doing so.
Then why doesn't C# do so for all the other objects that we create? This is because C# recognizes
only two types of classes.
The first type is one that the C# compiler knows of in advance. int, long, bool, and string are
classes that fall into this category. These are predefined classes. But we call them data types
because in C and C++ they were called data types and C# has a legacy of C and C++. So
technically, when we say int i it does i=new int(); internally.
The second type of classes that C# recognizes are the ones that we create i.e. user-defined
classes. For user-defined classes we have to create objects ourselves. Thus anything other than
the basic data-types must be explicitly created.
So when we say 'yyy a' we are not creating the object at this point. We are only declaring the
object to be of type yyy. It is only when we use the word 'new' that the object is created and
memory is allocated for the same. Therefore, when we have our own classes, that's the time we
use new. Without new you cannot create an object.
Static
You are certainly going to benefit by the patience you have shown so far. To find out how, let's
follow the next program.
a.cs
class zzz
static void Main()
yyy a;
a=new yyy();
a.abc();
yyy.pqr();
}
class yyy
public void abc()
public static void pqr()
System.Console.WriteLine("pqr");
Output
abc
pqr
In this program we have two functions abc and pqr. It is of significance to note that the function
pqr has the word static whereas abc does not. If you want to access the static function pqr you
say yyy.pqr() and to access the non static function abc you say a.abc(); You can't do the reverse
i.e. you cant say a.pqr() and yyy.abc().
a.cs
class zzz
static void Main()
{
yyy a;
a=new yyy();
yyy.abc();
a.pqr();
class yyy
public void abc()
System.Console.WriteLine("pqr");
Compiler Error
a.cs(7,1): error CS0120: An object reference is required for the nonstatic field, method, or
property 'yyy.abc()'
a.cs(8,1): error CS0176: Static member 'yyy.pqr()' cannot be accessed with an instance reference;
qualify it with a type name instead
The word 'static' implies 'free'. Static signifies that you can access a member or a function
without creating an object. At last you are enjoying the fruits of patience!
Observe that the function Main in zzz is static. This is because we are not creating any object that
looks like zzz. The crux is that if you don't want to use 'new' and yet use the function then you
must make the function static.
In both cases a dot is used to reference the function. The only difference is that a static member
belongs to the class and as such we don't need to create an object to access it. On the other hand,
a non-static member, that is the default, can be accessed only via an object of the class. Thus
WriteLine is a static function in Console as we did not create an object that looks like Console to
access it.
a.cs
class zzz
static void Main()
System.Console.WriteLine(yyy.i);
class yyy
public int i = 10;
Compiler Error
a.cs(5,26): error CS0120: An object reference is required for the nonstatic field, method, or
property 'yyy.i'
Why did we get an error? Think for thinking is the hardest work there is, which is probably the
reason why so few engage in it. If you still haven't got it, let us enlighten you. The same rules for
static apply to functions as well as variables. Hence we get the above error.
a.cs
class zzz
{
static void Main()
yyy a = new yyy();
yyy b = new yyy();
a.j = 11;
System.Console.WriteLine(a.j);
System.Console.WriteLine(b.j);
yyy.i = 30;
class yyy
public static int i = 10;
public int j = 10;
Output
11
10
30
A static variable belongs to the class. Hence if we create a static variable i, no matter how many
objects we create that look like yyy, there will be one and only one value of i as there is only one
variable i created in memory. Thus we access a static variable by prefacing with the name of the
class and not name of object. If the variable is non-static like j then we have to use the syntax as
explained earlier i.e. name of object dot name of variable. Thus each time we create an object
that looks like yyy we are creating a new/another copy of the variable j in memory. We now have
two j's in memory one for a and another for b. Thus j is called an instance variable unlike i.
When we change the variable j of a to 11, the j of b remain at 10.
Thus functions are created in memory only once, irrespective of the word static. If a class has no
instance or non static variables then it makes no sense to create multiple instances of the object
as there will be no way of distinguishing between the copies created.
Constructors
a.cs
class zzz
public static void Main()
yyy a;
System.Console.WriteLine("Main");
a=new yyy();
class yyy
public yyy()
System.Console.WriteLine("yyy");
Output
Main
yyy
In the above program we have a class called yyy. We also have a function called yyy which
happens to be having the same name as the name of the class. We have a friend named Bunty.
Coincidentally, the name of his pet dog is also Bunty! Similarly, it is absolutely legal to have a
function by the same name as that of the class. In this case first we see Main and then we see yyy
displayed on the screen which means that the function yyy() gets called automatically. Note, we
have not called the function yyy explicitly.
This happens to be a special function and it is called a 'constructor'.
Initially we are saying yyy a. By doing so we are specifying that 'a' looks like yyy. We are not
creating an object that looks like yyy. The next statement has System.Console.WriteLine, which
will print 'Main'. Thereafter, using new we are creating an object a. It is at this point that C# calls
the constructor i.e. it calls the function yyy(). Now you will see 'yyy' displayed. This goes to
prove that as soon as an object of a class is created, C# automatically calls the constructor. A
constructor gets called at the time of birth or creation of the object. It has to have the same name
as the name of the class.
a.cs
class zzz
yyy a;
System.Console.WriteLine("Main");
a=new yyy();
a.yyy();
class yyy
{
public yyy()
System.Console.WriteLine("yyy");
Compiler Error
a.cs(8,1): error CS0117: 'yyy' does not contain a definition for 'yyy'
Here, we are calling the function yyy using the appropriate syntax i.e. by saying a.yyy(). Now,
run the compiler. Baffled by the error? The error says 'yyy' does not contain a definition for
'yyy'. The class yyy does contain a function called yyy which got called in the previous example.
Has C# developed amnesia all of a sudden? What went wrong? Well, you cannot call this
function using a.yyy() or yyy.yyy() The catch is that when you have a function with the same
name as that of the class you cannot call it at all. It gets called automatically. C# does not give
anyone the authority to call such a function. It calls this function automatically only at birth.
Seems abnormal doesn't it!
But what is the purpose of having constructors?
A constructor can be used in cases where every time an object gets created and you want some
code to be automatically executed. The code that you want executed must be put in the
constructor. That code could be anything, it could check for hard disk space, it could create a file
or it could connect to the net and bring a file over. What that code will do shall vary from person
to person.
To understand how and when the constructor gets called, let's take into consideration our next
example. Now remove the word 'public' in front of yyy() as we have done below.
a.cs
class zzz
yyy a;
System.Console.WriteLine("hi");
a=new yyy();
class yyy
yyy()
System.Console.WriteLine("yyy const");
Compiler Error
a.cs(7,3): error CS0122: 'yyy.yyy()' is inaccessible due to its protection level.
Obviously, you will get an error. This is because without the word public the function is private
property. And when you trespass on private property you have to face the consequences. In our
case we are faced with an error. By making the function public every one can use it, it is now
becomes public property! If the constructor is private then nobody can create an object that looks
like yyy.
Do you think constructors can return values? Let's try it out and find out for ourselves.
a.cs
class zzz
yyy a;
a=new yyy();
class yyy
public int yyy()
Compiler Error
a.cs(12,12): error CS0542: 'yyy': member names cannot be the same as their enclosing type
Executing the above program generates an error. It says that member i.e yyy cannot be the same
as the enclosing type i.e class yyy. Now, that is an error that you certainly didn't expect.
Let us analyze why we got this error.
Here we are saying public int yyy implying that the function yyy() is returning an int. yyy() is a
constructor and is called automatically at the time an object is created. If a constructor is to
return a value then to whom should it return the value to? Since it is called automatically, there is
nothing that can accept the return value. Thus constructors cannot return values. Also when a
constructor gets called, an object is in the act of being created. It has not yet been created. The
keyword new first allocates memory for the functions and the variables. After this it calls the
constructor. When the constructor finishes, then we say that the object has been created. Thus the
constructor has no one to return values to.
Now that we know constructors don't return values let's return void instead.
a.cs
class zzz
{
yyy a;
a=new yyy();
class yyy
public void yyy()
Compiler Error
a.cs(12,13): error CS0542: 'yyy': member names cannot be the same as their enclosing type
Though we are returning void, we get the same error. This is because C# is very sure of what it
says. When you borrow from other people you do so on the pretext that you will return it. It's a
different story that you never do! You rarely mean what you say. But when C# says that
constructors cannot return values it means 'constructors cannot return values', not even 'void'.
Remember, there is nothing that can accept the return values. Hence even void cannot be
accepted. When a function returns a void we mean that it will return no value at all. For a
constructor, the word return makes no sense at all.
Constructors with parameters
Just as we pass parameters to other functions, you can also pass parameters to constructors.
a.cs
class zzz
yyy a;
a=new yyy("no");
class yyy
public yyy()
Compiler Error
a.cs(7,3): error CS1501: No overload for method 'yyy' takes '1' arguments
You are already aware of the fact that parameters are passed to functions while calling them.
Similarly, we will pass a parameter to the constructor yyy while creating the object a; because it
is at this point that the constructor gets called.
Hence we are saying a=new yyy("no"). But on compiling this program you get an error. Here,
the constructor is being called with a string 'no' as a parameter. But there is no variable in the
constructor yyy to store the value 'no'. Add 'string s' in the constructor yyy and watch the error
disappear.
a.cs
class zzz
yyy a;
a=new yyy("no");
class yyy
public yyy(string s)
Output
hi
no
At first WriteLine will display 'hi'. Then we have a constructor yyy that takes a string 'no' as a
parameter and accepts it in a variable s. Thus the moment the constructor yyy is called 'no' will
be displayed. This is because the constructor yyy contains code that will print the value stored in
the variable s. This is how constructors with parameters are called.
So far we created only one instance of the class yyy. In the following program we are creating
two instances of the class yyy, 'a' and 'b'.
a.cs
class zzz
yyy a,b;
a=new yyy("no");
b=new yyy();
class yyy
Compiler Error
a.cs(8,3): error CS1501: No overload for method 'yyy' takes '0' arguments
While creating the object 'a' the constructor yyy is being passed a parameter 'hi'. In case of the
object 'b' the constructor will be called without any parameters. But in our program we have code
only for the constructor with parameters. Try executing this program and you will get an error
saying that method yyy takes 0 arguments. This is because we do not have code for the
constructor without parameters.
Let's understand the reason behind the error.
In our earlier programs, we did not specify a constructor. A relevant question here would be -
how did the objects get created then, without the constructor being called? C# is a Good
Samaritan, at that time it inserted a free constructor. It does so internally. On its own it inserts a
constructor without any parameters, without any code into the class.
It looks like this-
yyy()
Point to ponder - in the above program, when we didn't create a constructor without parameters
why didn't we get one free? Remember we said C# is a Good Samaritan? And Good Samaritans
help the needy. On seeing that we already have a constructor with parameters, C# looks the other
way i.e., it takes the free one away. However, it is only when you have no constructor at all that
C# melts its heart and gives you one free. Remember, even if it finds that you have even one
constructor it will take away the free one. On the assumption that if you can provide one
constructor, then with a little effort you can work towards providing the others too!
Now the only way to get rid of the error is to add the constructor yourself.
a.cs
class zzz
yyy a,b;
a=new yyy("no");
b=new yyy();
class yyy
public yyy()
System.Console.WriteLine("bad");
Output
hi
no
bad
Here, initially, the two objects 'a' and 'b' are declared. In the next statement we have WriteLine,
which will display 'hi'. We are then creating the object a. At this point the constructor with a
string as a parameter is called. It will now display the value stored in the variable s which is 'no'.
Thereafter, the object b is created. At this point the constructor without the parameters will be
called. This constructor contains the WriteLine statement, which will print 'bad'. Here, we have
as many constructors as we are calling and hence we do not get any errors.
So, essentially, a constructor is a special function that gets called when an object is created. It
does not return any values, not even void. As far as parameters go it behaves like a normal
function. If no constructors are specified you get one free, otherwise, you need as many
constructors as you are calling. Hence in the above case we cannot create an object as new
yyy(100) as we do not have a constructor that accepts one int as a parameter.
Destructors
a.cs
public class zzz
aa a = new aa();
public class aa
public aa()
System.Console.WriteLine("Constructor ");
~aa()
System.Console.WriteLine("Destructor");
Output
Constructor
Destructor
A destructor is a function with the same name as the name of a class but starting with the
character ~. A constructor gets called at birth whereas a destructor gets called at death. In C#
unlike other languages we do not know when an object dies as unlike James Bond, we do not
have a license to kill. Thus even though the object a dies at the end of main, the destructor may
not get called. Thus, in C# we cannot decide when the destructor gets called. This decision to call
the destructor is made by a program within C# called the garbage collector.
The concept first gained currency with the advent of Java. In Java and C# we cannot remove our
objects from memory. Thus it is for the garbage collector to decide when to call the destructor.
The programming world was replete with errors mainly because programmers use new to
allocate memory and then forget to deallocate it. This gave rise to a concept called memory
leaks. On the flip side of the coin, programmers deallocated the memory, forgot about it and then
accessed the object again. This generates an error occurring at random and difficult to pin down.
a.cs
public class zzz
aa a = new aa();
public class aa
public aa()
System.Console.WriteLine("Constructor");
public ~aa()
{
Compiler Error
a.cs(14,9): error CS0106: The modifier 'public' is not valid for this item
A destructor cannot have any modifiers like public preceding it.
a.cs
public class zzz
aa a = new aa();
public class aa
public aa()
~aa(int i)
{
Compiler Error
a.cs(14,5): error CS1026: ) expected
a.cs(14,10): error CS1002: ; expected
a.cs(16,25): error CS1519: Invalid token '(' in class, struct, or interface member declaration
a.cs(18,1): error CS1022: Type or namespace definition, or end-of-file expected
Constructors come in plenty with different numbers of arguments being passed to them.
However, in the case of destructors, one size fits all, i.e., they come in only one size, with no
parameters. Here we created a destructor with an int as a parameter thereby confusing the C#
compiler completely.
C# lacks true synchronous or deterministic destructors i.e. destructors being called at a certain
point in time. You cannot have your life depend on when a destructor would be called. The
common grouse against C# is that unlike C++ it does not support true destructors.
a.cs
public class zzz
aa a = new aa();
public class aa
public aa()
{
~aa()
protected override void Finalize()
Compiler Error
a.cs(18,25): error CS0111: Class 'aa' already defines a member called 'Finalize' with the same
parameter types
We tried to create a function called Finalize. The compiler comes back and tells us that we
already have a function called Finalize. This is weird as we have only one Finalize function. The
reason for this error is that the compiler converts our destructor from ~aa to Finalize.
Arrays
All programming languages embrace the concept of arrays. An array is nothing but more of one
entity i.e., a multiple of the same type. Simply put, when we have five books, we don't just say
we have five books. Instead we say we have an array of five books. So, whenever you want to
store multiple values of variables you store them in an array.
a.cs
class zzz

{
int[] a;
a= new int[3];
a[0]= 1; a[1]= 10; a[2]= 20;
System.Console.WriteLine(a[0]);
a[0]++;
int i;
i=1;
System.Console.WriteLine(a[i]);
i=2;
Output
10
20
Here 'a' is an array of ints. You declare arrays with a set of [] brackets. At this point it is not
known how large the array will be. For that we have a=new int[3]; after new we have int
meaning we want to create a variable of type int. We are putting 3 in the square brackets meaning
we want to store 3 ints. This will create three ints a[0], a[1] and a[2]. They are then initialized to
the values 1,10 and 20 respectively. To initialize an array variable we use the name, i.e. in this
case a and follow it with the open and close [] brackets. Inside them we put the array number.
The first variable is called a[0] , the second a[1] and so on. C# like most computer programming
languages likes to start counting from 0 and not 1. Therefore, the last variable is a[2] and not
a[3].
Since an array is many of the same type, they all have the same name. In our earlier example,
even if we have many books, all the books will be called books. However, to refer to them
individually you can say book1, book2, book3 etc.
WriteLine will display the value stored in a[0] which is 1. a[0]++ will increment the value stored
in a[0] by one. WriteLine will now display 2.
Thereafter, the variable i is declared as an int. It is then initialized to 1. Within the WriteLine
function we have a[i]. It is not specifically stated which variable, instead we have said a[i]. There
is no variable called a[i], but i has a value 1, so it is read as a[1]. Hence the value stored at a[1],
which is 10, is displayed. The next WriteLine will display the value stored in a[2] as i is
reinitialized to 2.
Doing this makes our program more generic. We haven't specifically stated which variable, we
are letting a variable called i decide the name of the variable.
The next example demonstrates how arrays can be used within loops.
a.cs
class zzz
int[] a;
a= new int[3];
int i;
for( i=0; i<=2; i++)
a[i]= i*10;
for( i=0; i<=2; i++)
}
}
Output
10
20
The advantage of using arrays is that you can decide the name of the variable later and they can
also be used in loops.
Here 'a' is an array of ints and i is a variable of type int. The array size is 3 i.e. it can store three
ints. The first for loop is used to initialize the individual array items. Within the for loop, i is
initialized to 0. The condition i<=2 indicates that the loop will execute thrice. So, when the
control enters the for loop, for the first time i is 0. Looking at the right hand side of the
expression, i*10 will now read as 0*10, which is 0. Hence, a[i] which is read as a[0] will be
initialized to 0. i++ increments the value of i to 1. The second time a[i] will be read as a[1] which
will be initialized to 10. Thereafter, a[i] will be read as a[2] and initialized to 20 as i is now 2.
Now i will be 3, so the condition evaluates to false and the loop terminates.
The second for loop displays the values stored in the array. This is similar to the above loop.
Here we are displaying the values of the individual array items. As the for loop executes,
WriteLine will read a[i] as a[0], a[1] and a[2] in each case. As such, WriteLine displays 0,10,20.
So, starting from the beginning and going upto the end, all the values stored in the array are
displayed.
Arrays can also be used in a foreach statement. This is exemplified in the following program.
a.cs
class zzz
int[] a;
a= new int[3];
a[0]= 1; a[1]= 10; a[2]= 20;

foreach ( int i in a)
System.Console.WriteLine(i);
Output
10
20
The foreach statement lists the elements of the array. It executes a statement for each element of
the array or collection. 'a' is an array of type int that can store three items. a[0], a[1] and a[2] are
the elements or items of the array. They have been initialized to 1, 10 and 20 respectively. In the
foreach statement we have ( int i in a ).
i is a variable of type int and a is the array created earlier. The first element of the array 'a' is a[0]
and it holds the value 1. The foreach statement picks up this value and stores it in i. Since i now
holds the value 1, WriteLine displays 1. The second element is a[1]. It picks up its value, which
is 10 and stores it in i. Thus i now holds the value 10. WriteLine will now display 10. This goes
on for all the elements of the array. Our array 'a' comprises three elements. Hence the foreach
will execute the WriteLine statement for each of them and display their values 1,10 and 20. The
variable i is only available in the foreach. The foreach makes it easier for us to run through all
the members of any array.
Parameters Revisited with Out and Ref
Variables are the cornerstone of programming languages. In a way, they are like items contained
in a bag. You can put an item in a bag, remove it therefrom, or replace it with another. Our next
few programs shall be explained along these lines.
a.cs
class zzz
{
int i=100;
yyy a;
a=new yyy();
a.abc(i);
class yyy
public void abc(int i)
i=10;
Output
100
100
'a' is an object that looks yyy. The variable 'i' is initialized to a value 100. Then the object 'a' that
looks like yyy is created. We are now calling the function abc with one parameter 'i'. Within the
abc function we are printing the value of i. When we call the function abc from Main, i had a
value 100. So the variable i in abc also has a value 100. Thus WriteLine will display the value
100. We are now assigning i a new value 10. But the i that changes is the parameter i in abc, and
not the i of Main in zzz. It's like having two similar bags, where you change the contents of only
one. So the WriteLine in Main will again print 100.
Thus the variable i within the abc function is temporary. It exists only within the '{' and '}' braces
of the function. Therefore, this 'i' is local to the function. Its value is not available in Main. It's
like your memory, temporary. It exists as long as you are reading this book. Once the book is
over everything is forgotten! Thus please do not call the variable i in abc as i because it will
confuse everyone. Thus i in abc has nothing to do with the i in Main. Ergo, changing i in abc will
have no effect on the i in Main.
But a situation could arise wherein you would like the function abc to change the value of i. In
this context you are saying, I am giving a variable to a function abc, use it, but I would also like
the function abc to change it. And once its value is changed in the function, it i.e. the changed
value should be available in Main. Let's see how we can handle a situation like that.
a.cs
class zzz
yyy a;
int i=100;
a=new yyy();
a.abc(i);
class yyy
public void abc( out int i)
i=10;
}
}
Compiler Error
a.cs(8,1): error CS1502: The best overloaded method match for 'yyy.abc(out int)' has some
invalid arguments.
a.cs(8,7): error CS1503: Argument '1':cannot convert from 'int' to 'out int'.
This program is exactly like the previous one. The only change is that we added the word 'out' in
the function abc along with the parameter i. We get an error on compiling this program. You
realize, we are saying a.abc(i) in Main, but in the function we are saying abc(out int i). 'out' is the
key to solving our previous problem. 'out' means whatever changes you will make in abc, they
will be visible outside the function also.
Note that it doesn't matter what you call the variable in the function abc, the original will change.
So, instead of saying abc(out int i) you could have used another variable. In that case, if you said
abc(out int p) it would be absolutely legal. To do away with the error you must specify 'out' while
calling the function as well.
Now we have rewritten the program with the above change.
a.cs
class zzz
yyy a;
int i=100;
a=new yyy();
a.abc(out i);
}
class yyy {
public void abc( out int i) {
i=10;
Output
10
In this program, we now have 'out' in both cases: in the function call and the function itself. So
by saying a.abc( out i) you are implying that you are allowing the function abc to change the
value of i. Then in the function definition we also have the word 'out', so it knows i is going to
change and hence i now changes in the original. Therefore, WriteLine will displays the new
value 10.
We are now using the word 'ref' instead of 'out'. Let us see the effects of doing so.
a.cs
class zzz
yyy a;
int i=100;
a=new yyy();
a.abc(ref i);
}
}
class yyy
public void abc( ref int j)
j=10;
Output
10
This program executes smoothly and gives the same output as previously. It displays the value
10. So in that sense 'ref' is like 'out'. In either case the original value of 'i' changes. Thus, if you
are calling the function with 'ref' then state 'ref' in the function also. If you are calling the
function with 'out' then give 'out' in the function also.
Game for some experimentation? Let's try to execute the above program without initializing the
variable i.
a.cs
class zzz
yyy a;
int i;
a=new yyy();
a.abc(ref i);
class yyy
public void abc(ref int j)
j=10;
Compiler Error
a.cs(8,11): error CS0165: Use of unassigned local variable 'i'
Here we are saying int i. Note that we are not initializing i. We are using 'ref' which gives us an
error. The error says 'use of possibly unassigned local variable i'. Here we didn't initialize i and
yet we are trying to use it; hence we get an error.
Now, let's look at the next example. Here we have the same program only now we are using 'out'
instead of ref.
a.cs
class zzz
yyy a;
int i;
a=new yyy();
a.abc(out i);
class yyy
public void abc(out int j)
j=10;
Output
10
In this program we haven't initialized i either but this time we don't get any error. This goes to
show that when using 'ref' the variable must be initialized and only then can you change its
value. In case of 'out' you don't have to initialize the variable to change its value.
But why have this differentiation? This is because in case of 'ref' you can read the value of the
variable as well as write to it. Therefore, if one has to read the value of the variable, it must be
initialized before hand. But it is your discretion whether you want to change the value, read it or
do both.
But in case of 'out' you can only write i.e., you can only change the value of the variable, you
cannot read it. So, in case of 'out' since it does not read the variable it doesn't matter even if it is
not initialized.
This is further exemplified with the help of the next few programs. In the following program we
have initialized i. Note here we are using 'out'.
a.cs
class zzz
{
yyy a;
int i=10;
a=new yyy();
a.abc(out i);
class yyy
public void abc( out int j)
System.Console.WriteLine(j);
j=10;
Compiler Error
a.cs(16,26):error CS0165: Use of unassigned local variable 'j'
Within the function abc we are first printing the value of i using the WriteLine statement. That
means we are trying to read the value of i which is passed to the variable j in the function abc.
But with 'out' one cannot read values hence we get an error. Now if you try the same program
with 'ref' instead of 'out' you will not get any errors. This is because with 'ref' you can read the
values as well as well as change them.
However do note that all 'out' parameters must be initialized or else you will get an error form
the compiler as follows.
a.cs
class zzz
yyy a;
int i=10;
a=new yyy();
a.abc(out i);
class yyy
public void abc( out int j)
Compiler Error
a.cs(14,13): error CS0177: The out parameter 'j' must be assigned to before control leaves the
current method
So where can we use 'out'? We can use 'out' if we want the function to make some calculations
and fill up the variable.
a.cs
class zzz
yyy a;
int i=10;
a=new yyy();
a.abc( out i );
class yyy
public void abc( out int i )
i= 20 * 20;
Output
400
In this program we are using 'out'. We are multiplying 20 by 20 and storing the result 400 in i.
Thereby the value of i is changed and WriteLine will now print 400.
Our next example will make things as clear as daylight.

a.cs
class zzz
yyy a;
int i=10;
int k=20;
int m;
a=new yyy();
m=a.abc( out i, out k );
System.Console.WriteLine(k);
System.Console.WriteLine(m);
class yyy
public int abc( out int x, out int y)
int j;
x=30;y=10;
j=x * y;
return j;
Output
30
10
300
After specifying that a looks like yyy, the two variables i and k are initialized to the values 10
and 20 respectively. Then the object a is created. The third variable m is of type int and is used to
store the return value of the function abc. By using 'out', the function abc is called with two
parameters, i and k. The abc function has the variables x and y. Within the function another
variable j is declared of type int. The variables x and y are assigned new values 30 and 10
respectively. Their values are multiplied and stored in j, i.e. 300. The next statement return j will
yield the value of j, which is stored in m. Now WriteLine will display the value of i as 30. This is
because with the abc function we filled up i with the value 30. Similarly, the next WriteLine
statement will print the value of k, which is 10. Then we print the value of m, which is 300.
In a nutshell-
In case of both 'ref' and 'out' the original changes.
A point to note is that when we say 'ref' it means we will initialize the variable. The abc function
expects the variable to be initialized so that the function can use the value of the variable. When
the variable changes the change is reflected outside. So, whenever you say 'ref' the variable has
to be initialized, otherwise an error occurs. The function will assume that the variable is
initialized because it expects to read the value. You may choose to read the value or change it or
do both.
But when you say 'out' it implies that we are not going to initialize the variable, that the abc
function is not going to use the value, it is only going to change the value. When there is an 'out',
abc can use the variable even if it is not initialized. This is because you cannot read the value in
case of an 'out' variable; the function can only change the value. In other words, it has to change
the value of the variable to avoid any errors.
4
Components and Database Handling
Exception Handling
Failing to prepare is preparing to fail. Ergo, one is constantly planning and preparing for the
future. We often set a path for ourselves and try to follow it steadily. But then life intervenes.
Uncertainties in life result in unforeseen situations. These are like exceptions in the normal
course that we set for ourselves. Similarly, when you write programs, unforeseen problems may
arise during its normal path of execution.
These unforeseen problems are nothing but an euphemism for errors. Just as in life, in the
programming world, these errors can be further classified into Fatal errors and Non-Fatal errors.
A Fatal error is an error that brings the program to a grinding halt. A Non-Fatal error is an error
that allows your program to run but with limited capacity. This can be exemplified by the
following.
Let's assume you have a card that is not of a high resolution. Accordingly, your browser displays
your page in a lower resolution. Now, technically, that is an error but it is not a Fatal one.
However, if you didn't have a graphics card at all then it would be a Fatal error. Thus, we may
also call an unforeseen problem or error an Exception. In other words, therefore, the word
Exception is used almost synonymously with the word Error.
Earlier, the problem was that we never centralized error handling. Let's assume you have to open
three files. Each time you open a file you have to check whether an error occurred or not. So you
have to conduct that check for every file. Since there are three files, it would mean repeating the
same error check thrice. That is surely a waste of time. Or you could be calling two functions and
checking for the same error in both the functions. One reason that programmers don't write error-
handling routines is that they get tired of the mundane task. It is the same thing repeated over and
over again.
Let's consider constructors. Before the constructor gets called, the object has not yet been
created. So you ask the constructor to create an object, to allocate memory and create a file.
Now, if it can't do so, how will the constructor return to tell you that an error occurred! Today
constructors carry a lot of code within them and if you haven't forgotten, constructors cannot
return values.
Because of the various reasons discussed above, we don't talk about errors any more; we handle
exceptions. Bearing this in mind let's understand the next program.
a.cs
class zzz
yyy a;
a=new yyy();
a.abc();
class yyy
public void abc()
throw new System.Exception();
Compiler Warning
Output
Unhandled Exception: System.Exception: Exception of type System.Exception was thrown

at yyy.abc()
at zzz.Main()
Here, a.abc calls the function abc in class yyy. System.Console.WriteLine is used to display
'Bye'. It is of significance to note that when you run this program the System.Console.WriteLine
does not get called. Hence the word 'Bye' is not displayed. Within the abc function we have a line
that says throw new System.Exception(); The word new indicates that we are creating an object.
We are creating an object that looks like System.Exception. 'throw' is a reserved word, that
means it is recognized by C#. Exception is a class in the System namespace. In other words, we
are identifying an exception, creating an object of it, and throwing it. Then we have a WriteLine
statement for printing 'abc'. Note that neither 'Bye' nor 'abc' gets displayed. A Message Box may
appear for debugging the applicaition. Since we are still at the learning stage, we click on the No
button.
The warning says that when you use the 'throw' keyword in your code, no lines of code get called
after that. Since the function abc is throwing an exception no code after the throw in abc will get
executed. The throw acts like the return statement. Everything comes to a stand still! And we get
an error at runtime and not at the time of running the compiler; indicating where the exception
occurred. Also no code gets called after function abc gets called as it throws an exception.
Explicitly declaring exceptions tells the compiler that a particular problem might occur. When
the problem does occur, an exception is thrown; the next step being to catch the exception. Let's
see how we can accomplish this. In our program, the function abc throws an exception. We will
now catch the exception.
a.cs
class zzz
yyy a;
a=new yyy();
try
a.abc();
catch (System.Exception e)
System.Console.WriteLine("In Exception"+ e.ToString());
System.Console.WriteLine("After Exception");
class yyy {
public void abc()
Output
In ExceptionSystem.Exception: Exception of type System.Exception was thrown.
at yyy.abc()
at zzz.Main()
After Exception
Catching exceptions is done within 'try-catch' blocks. Therefore, the code for abc is included
within a 'try-catch' block. a.abc - the function that throws the exception - is included within the
try-catch block . The abc function throws an exception by using the keyword throw. There is no
other way of throwing an exception. At this point all code is skipped in function abc as well as
the in the try block and the control moves to the catch block. As such, neither 'abc' nor 'bye' gets
displayed.
Within the catch we have a parameter 'e' that looks like System.Exception. The object e has a
method called ToString. ToString is a very handy function. It tells you where exactly the
exception occurred and in which function, function within function. So,
System.Console.Writeline will display the string 'In Exception' along with the exception.
After the code contained in the catch block is executed, the remaining code after the end of the
try - catch block will be executed. Hence, WriteLine will display 'After Exception'. That means
the program will not come to a stand still, it resumes execution after the catch and not after the
function which threw the exception. If you give a return statement immediately after the catch
block, as we have given in the next program, the program will stop execution there itself. Hence,
in this case, 'After Exception' will not be displayed as shown below.
a.cs
class zzz
yyy a;
a=new yyy();
try
a.abc();
catch (System.Exception e)
System.Console.WriteLine("In Exception"+ e.ToString());
return;
}
System.Console.WriteLine("After Exception");
class yyy
public void abc()
Output
In ExceptionSystem.Exception: Exception of type System.Exception was thrown.
at yyy.abc()
at zzz.Main()
Each time that abc gets called an exception is thrown. But you may not want that to happen.
Hence, exception handling is normally included in an if statement and if an error condition takes
place.
A 'try-catch' block can include a number of functions and whenever an exception occurs for any
one of them, we will catch it. By doing so we are synchronizing all the code to handle errors at
one place. Constructors can also throw exceptions.
Building Components
a.cs
public class zzz {

public void abc() {
System.Console.WriteLine("zzz abc");
The above program consists of a simple class zzz with one public function. The class has also
been tagged with the modifier public that makes it accessible to everyone. When we run the
command csc a.cs, we are asking the C# compiler to create an executable file for us even though
we did not explicitly ask it to. An executable file will always be created by the C# compiler
unless you override it by stating an option to the C# compiler. Let us start with the /t option.
csc /t:library a.cs
You could use /t or /target. This option specifies what type of output file the compiler should
create for you. If you do not specify a /t option on the command line, C# by default writes /t:exe
for you thereby creating an executable file. The long form of /t is /target and depending upon the
time of day, choose the appropriate one. Not all options have a long and a short form like /t does.
The : after the option is mandatory. Then we write the type of executable output file we want.
Library means a dll. When we run the dir command we see a file named a.dll in the current sub
directory. A file with a .dll or a .exe extension are called Windows PE files. This is the default
file format that Windows uses to create executable files. There is a minor difference between the
internal structures of a dll and a exe file. Which is that a dll cannot be executed like an exe
program can. By convention dlls' are used to store code even though an exe could have also be
used. What we have done is created a component.
What if we wanted to change the name of the output file. By default it is the name of our
program. Then we must use the /out option as follows.
csc /t:library /out:bbb.dll a.cs
This will create a file bbb.dll instead of a.dll as earlier. Whether we use the /out option or not, C#
does it for us. If the C# program was called a.cs, then C# wrote /out:a.exe on the command line
for us. We can use the /out option to change the name of the output file. /out does not have a
short form /o.
Remember C# uses defaults for command line options to make life easier for us.
Note that we have created a component in a file bbb.dll
a.cs
class yyy
{
zzz a;
Compiler error
a.cs(5,1): error CS0246: The type or namespace name 'zzz' could not be found (are you missing a
using directive or an assembly reference?)
The only reason we create a component is to allow other programs to call code from it. In the
above program, we are saying that a looks like a class zzz. The C# compiler is telling us in a
vague way that it does not know that zzz is a class. Though we know zzz is a class as we just
created it and it is in a file called bbb.dll, C# is not aware of the same.
a.cs
class yyy {
zzz a;
>csc a.cs /r:bbb.dll
Compiler Warning
a.cs(5,5): warning CS0168: The variable 'a' is declared but never used
The /r or reference option tells the C# compiler to look at bbb.dll; in this case for the code of
classes it is not aware of. In our case the error disappears as the file bbb.dll contains the code for
the class bbb.dll. Thus in future, if the C# compiler ever gives you the above error, do not panic.
All that you need to do is specify which dll contains the code for the classes. The help available
along with C#, tells you every class and the dll that contains the code of the class.
a.cs
class yyy
zzz a = new zzz();
a.abc();
Output
zzz abc
We have successfully called the function abc in class zzz. The code of the class zzz resides in
bbb.dll.
a.cs
namespace mukhi
public class zzz
public void abc()
System.Console.WriteLine("zzz abc");
}
}
>csc /t:library /out:bbb.dll a.cs
The same class zzz is now enclosed in a namespace mukhi and the component recreated.
a.cs
class yyy
zzz a = new zzz();
a.abc();
csc a.cs /r:bbb.dll
Compiler Error
a.cs(5,1): error CS0246: The type or namespace name 'zzz' could not be found (are you missing a
a.cs(6,1): error CS0246: The type or namespace name 'a' could not be found (are you missing a
The error results as the name of the class is not zzz but mukhi.zzz.
a.cs
using mukhi;
class yyy {

{
zzz a = new zzz();
a.abc();
Output
zzz abc
All's well that ends well.
Databases
Databases are centralized stores of data. In a database, information from several files (also
known as tables) is accessed, coordinated and operated upon as if in a single file. Thus, the
database organizes data independently from the programs that access it. Large volumes of data
are stored in a database.
Computer programs have little meaning when written in isolation. Therefore, it is of importance
to have our programs work with databases. Databases work under the control of a database
management system. SQL Server is an RDBMS; it is one such database management system.
Before we can write programs that communicate with databases we need to have a database. One
of the simplest databases to use is Microsoft Access. As a large number of people use it, we have
based our examples on it. However you could use any RDBMS like Oracle, SQL Server as you
wish.
First and foremost, before we can access a database and perform various operations, we need to
connect to the database. Assuming you want to speak to your friend over the phone, you dial
your friend's phone number. Its only when you connect to your friends phone that the both of you
can speak to each other. Similarly, if we want to use a database we first have to connect to it and
only then can we speak to it.
a.cs
class zzz

{
System.Data.OleDb.OleDbConnection s;
}}
Compiler warning
a.cs(5,35): warning CS0168: The variable 's' is declared but never used
Let's see how we can connect to a database.
a.cs
class zzz
try
s = new System.Data.OleDb.OleDbConnection();
System.Console.WriteLine("hell");
catch(System.Exception e)
System.Console.WriteLine(e.ToString());
}
Output
hell
Within the try block we have an object s that looks like System.Data.OleDb.OleDbConnection.
You are already aware that System is a namespace, but what about Data and OleDb? Well,
System.Data.OleDb is the name of the namespace. We can liken this to an earlier example where
we created a namespace mukhi.vijay. Hierarchy in a namespace can go to absurd lengths! The
help on C# states that System.Data.OleDb is the name of a namespace and OleDbConnection is a
class within that namespace. By saying s = System.Data.OleDb.OleDbConnection(); we are
creating the object s. When you run this program all that we see is the word hell, which means
that the constructor threw no Exception. If it did then the catch block would have been executed.
a.cs
class zzz
try
s = new System.Data.OleDb.OleDbConnection();
s.Open();
}
}
Output
System.InvalidOperationException: The ConnectionString property has not been initialized.
at System.Data.OleDb.OleDbConnection.Open()
at zzz.Main()
The class OleDbConnection has a function called Open which opens or connects to our database.
When we run the above the above program, the Open function throws an exception. Now, at this
point you must catch the Exception. The ToString within the catch block displays the Exception
message. The error says that the ConnectionString property has not been initialized.
The reason an exception occurred is that we did not provide certain mandatory information
whilst creating the object. We did not indicate the location of the database server that we want to
connect to or the database. It's like picking up the phone and not dialing a number. How in the
world do you expect to connect then!
We will now provide the constructor with some basic information.
a.cs
class zzz
try
s = new System.Data.OleDb.OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;
Data Source=c:\\zzz.mdb;");
s.Open();
}
Output
System.Data.OleDb.OleDbException: Could not find file 'c:\zzz.mdb'. at

System.Data.OleDb.OleDbConnection.ProcessResults(Int32 hr)
at System.Data.OleDb.OleDbConnection.InitializeProvider()
at System.Data.OleDb.OleDbConnection.Open()
at zzz.Main()
We first specify the database provider as Provider=Microsoft.Jet.OLEDB.4.0, which stands for

MS-Access and then the path as Data Source=c:\\zzz.mdb separated by semicolon.
When you run the program, an OleDbException is thrown, which says could not find file
'c:\zzz.mdb'. This is because we have not created an MSAccess DataBase called zzz.mdb.
An mdb file stores data from multiple tables. In this file zzz.mdb, create one table abc with 2
fields f1 and f2 , both of type text. Add two records to this database. The first record will contain
1,a1 and the second record will be 2,a2.
Re run the program which now displays hell unlike before where we generated an Exception.
Output
hell
s.Open opens a connection to the database. The 'Provider' and 'Data Source' given in the
constructor identify the database.
As we have given the constructor all the mandatory information, s.Open() will open a connection
with the Access database. The program executes smoothly and once the connection is established
WriteLine displays 'hell'.
Now that we have established a connection with the database, let's see how we can communicate
with it. More specifically, let's see how we can execute an SQL command.
a.cs
using System.Data.OleDb;
class zzz
try
OleDbConnection s;
s = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;
Data Source=c:\\zzz.mdb");
s.Open();
OleDbCommand c;
c=new OleDbCommand("Create Table a1 ( vno integer , name char(10))",s);
c.ExecuteNonQuery();
}
Output
hell
Employing using, we do not have to preface every class with the namespace
System.Data.OleDb. The purpose of this program is to execute an SQL statement. SQL is a short
form for Structured Query Language. It is not a computer programming language like C# but
rather a language like English. SQL understands certain words like Create, which create a table
for us in our database. SQL has nothing to do with Oracle or Access, it works with all the
RDBMSs of the world.
Create Table a1 (vno integer, name char(10))
The above SQL statement means that a table called a1 will be created in our database. It will
have 2 fields vno and name. Vno will store numbers and name will store characters subject to a
maximum of 10.
A class in any programming language is made up of a collection of variables and functions.

These put together do something for us like solving a particular problem or accomplishing a
certain task. We live in a world of specialization. Just like it is difficult to come across one
human being who is a PHD in Nuclear Science as well as Sociology, classes too are written to
focus on one particular task only.
Thus we need one class to handle our connection to a database and another class which
understands SQL. We first create an object that looks like an OleDbConnection, which
understands how to connect to a database using a string attributes 'Provider' and 'Data Source',
which it passes as a parameter to the constructor. Then we create an object c which looks like
OleDbCommand as this class understands SQL. The constructor gets called with 2 parameters,
the SQL statement and also the connection object. Thus the object c now comprises the necessary
information regarding the command we want to execute and the connection. Now,
c.ExecuteNonQuery() will actually execute the SQL statement. ExecuteNonQuery() is a function
within the OleDbCommand class that enables us to execute any SQL command. You will now
see the word 'hell' displayed on your screen.
But did the table get created? Let's find out by starting Access and then choosing the database
zzz. Here we will see the table a1 with 2 fields vno and name but with no data at all. We created
our table alright, but it is empty as it has no data in it! So let's start inserting data/records into the
table. Before doing so, Quit out of Access
a.cs
class zzz
try
OleDbConnection s;
s.Open();
OleDbCommand c;
c=new OleDbCommand("insert into a1 values(1,'hi')",s);
}}
Output
hell
The only difference between this program and the previous one is that this one uses the Insert
SQL command. Earlier, we created a table zzz, now we are inserting records in zzz. To the
constructor of OleDbCommand we are giving two things - the insert command "insert into a1
values(1,'hi')" and the connection. Insert into and values are part of the SQL syntax. A1 is the
name of the table in which a fresh record will be added. After values, we write the data separated
by commas. The first field will contain 1 and the second hi. As the second field has the data type
of character, it has to be enclosed in single quotes. c.ExecuteNonQuery as usual executes the
SQL command and as no exception gets thrown ,the word 'hell' gets displayed..
Let's cross check to see if the data has been inserted into zzz by running Access. Aha! It displays
the record that you just inserted in the following format-
vno name
1 hi
Now it follows that if we can insert a record then we should be able to remove it too. The
following program uses the delete command to remove all the records from the table zzz.
a.cs
class zzz
try
OleDbConnection s;
s.Open();
OleDbCommand c;
c=new OleDbCommand("delete from a1",s);

catch(System.Exception e) {
Output
hell
Now c.ExecuteNonQuery will execute the delete command. This command deletes all the data
from the table. In Access we will see an empty table. This proves that the delete command was
successful!
Apart from inserting and deleting data another operation that is commonly performed is updating
data. However, you must have data in your table to update it. Our table is empty right now, so
let's execute the insert program once again. You will now have one record in your table zzz. After
inserting a record, change the sql insert command to an update command. This is shown below.
c= new OleDbCommand("update a1 set vno=3,name='bad' where vno=1",s);
Here, we are giving an update statement and our connection to the object is 'c'. The update
statement will change the vno and name to the values specified. It will do so for any record that
has vno=1. We have only one record in our table and it meets this criteria. Now, go back to
Access , you will find that the record has been updated as follows-
vno name
3 bad
a.cs
class zzz
{
try
OleDbConnection s;
s = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=c:\\zzz.mdb");
s.Open();
OleDbCommand c;
c=new OleDbCommand("delete from a11",s);
Output
System.Data.OleDb.OleDbException: The Microsoft Jet database engine cannot find the input
table or query 'a11'. Make sure it exists and that its name is spelled correctly.
at System.Data.OleDb.OleDbCommand.ExecuteCommand
TextErrorHandling(Int32 hr)
at System.Data.OleDb.OleDbCommand.ExecuteCommand
TextForSingleResult(tagDBPARAMS dbParams, Object& executeResult)
at System.Data.OleDb.OleDbCommand.
ExecuteCommandText(Object& executeResult)
ExecuteCommand(CommandBehavior behavior, Object& executeResult)
ExecuteReaderInternal(CommandBehavior behavior, String method)
at System.Data.OleDb.OleDbCommand.ExecuteNonQuery()
at zzz.Main()
Don't worry, we have simulated this error on purpose. The table a11 does not exist in our
database. Thus an exception got thrown by ExecuteCommandText and not ExecuteNonQuery as
seen above. What it means is that ExecuteNonQuery calls Execute which calls ExecuteCommand
which finally calls ExecuteCommandText. Also the word hell does not get displayed because of
the exception thrown.
We will now execute a simple select statement.
a.cs
class zzz
try
OleDbConnection s;
s.Open();
OleDbCommand c;
c=new OleDbCommand("select * from abc",s);
OleDbDataReader r;
r = c.ExecuteReader();
Output
hell
We have executed different SQL commands through our earlier programs. We will now try and
execute an SQL select statement. In order to do so, we have given the following select statement
to the constructor along with the connection- 'Select * from abc'. Abc is a table in the database
called zzz . Remember, c looks like OleDbCommand. 'Select' is part of the SQL syntax like
insert , update . 'from' is also a reserved word . 'abc' is the name of the table created earlier in
Access and populated by data keyed in by us. The '*' means all fields in the table. We could have
also replaced the * with a comma separating list of field names that we were interested in.
As OleDbConnection has an Open function, OleDbCommand has a ExecuteReader function.

This function returns an object that looks like OleDbDataReader.
The function ExecuteReader will create an object that looks like OleDbDataReader and initialize
r to it. No exception was thrown, which meant no errors from our side.
What we need to do now is retrieve data from the abc table. The abc table may have ten fields
and twenty records. So we use what is called a 'dataset'. In other words, how do we access data
contained in multiple rows and multiple columns through our program? For example, when we
run the select statement it gives us the data in rows and columns. How can we achieve this
through our program? To do that we now need a third object which looks like OleDbDataReader.
We can almost feel your dismay - Oh no! Another object! Well, there is a very good reason why
you need to have three different objects. Firstly, you need an object that understands a
connection. Then you need another object that understands an SQL statement. This is because
somebody has to execute that statement. You now need a third object that will let you
read/retrieve data. That is why we have 'r' an object that looks like OleDbDataReader. Thereafter,
we have c.ExecuteReader. Earlier we used a function call ExecuteNonQuery. This is because in
case of an insert, update or delete we didn't want any data to be retrieved, we didn't want an
answer back!!
As a recap, we are using r to store the value return by ExecuteReader. That means r will be filled
up by ExecuteReader. On executing this program only 'hell' is displayed.
Now that we have the filled up r, let's see how we can display the data.
a.cs
class zzz
try
OleDbConnection s;
s.Open();
OleDbCommand c;
OleDbDataReader r;
System.Console.WriteLine("{0},{1}",r.GetValue(0),r.GetValue(1));
Output
System.InvalidOperationException: No data exists for the row/column.
at System.Data.OleDb.OleDbDataReader.DoValueCheck(Int32 ordinal)
at System.Data.OleDb.OleDbDataReader.GetValue(Int32 ordinal)
at zzz.Main()
Run this program. Expect the unexpected....an error! The error says 'No data exists for the
row/column' But didn't the function Execute fill up r? It did, but it did not position the record
pointer on the first record. A record pointer is an abstract concept. To start with it appears just
before the first record. The function GetValue will return the value of the fields depending upon
where the record pointer is. At the start it is just before the first record. So r can be also looked at
as an array that contains all the fields. We get an error because we need to read the data into our
array first. In order to read data into the fields we must give r.Read. Without r.Read, the records
will not be read into the array, so also the record pointer will not be moved forward to the first
record.
Now that we know the reason why the error occurred let's rectify it by doing the needful. Let's
add r.Read() to our program.
a.cs
class zzz
try
OleDbConnection s;
s.Open();
OleDbCommand c;
OleDbDataReader r;
System.Console.WriteLine(r.Read());
}
}
Output
True
1,a1
Now that we have added r.Read() the program executes as advertised. r.Read() returns true.
Thereafter, the GetValue() function which needs the field number as a parameter retrieves the
data associated with the first and second column. Remember in C# we start counting from zero
and hence zero as a parameter to GetValue will retrieve the value of field one in the table. The
datatype of the first field is numeric and of the second character. However, the function GetValue
does not seem to care.
Read returns true if more data is available to read and false if it is at the last record. Also read
positions the record pointer to the next record.
a.cs
class zzz
try
OleDbConnection s;
s.Open();
OleDbCommand c;
OleDbDataReader r;
while (r.Read())
Output
1,a1
2,a2
(A display of only the first two fields of all the records in the table. )
But now we want to display all the data in the fields. So we are using Read in a loop.
while(r.Read()). r.Read() returns true as long as it can read data. The while loop continues till the
condition is true. We are using our trusted function WriteLine to display the data of the first and
second field. Thus the moment r.Read() cannot read more data it returns false and the while loop
terminates. Now all the data in the two fields is displayed and as such we have a long list of data
displayed. To verify further, add some more fields and records to abc.
Just as we mind our manners in daily life we must do so in programming too. It is a good
practice to shut the door when leaving a room. Similarly, in programs we must close what ever
we opened.
a.cs
class zzz
try
OleDbConnection s;
s.Open();
OleDbCommand c;
OleDbDataReader r;
while (r.Read())
r.Close();
s.Close();
}
Output
1,a1
2,a2
We will mind our manners and give r.Close() and s.Close. Note that it is not mandatory to do so.
First we are closing r and then we are closing s i.e. the connection that we opened.
a.cs
class zzz
try
OleDbConnection s;
s.Open();
OleDbCommand c;
OleDbDataReader r;
System.Console.WriteLine(r.FieldCount);
for ( int i = 0 ; i < r.FieldCount ; i++)
System.Console.WriteLine(r.GetName(i));
Output
f1
f2
An OleDbDataReader has a useful function called FieldCount which tells you how many fields
the SQL statement contained. In our case abc has two fields. We have one more function
GetName which will tell us the name of the function in the table given the field number. Thus
r.GetName(1) will give us the name of the 2nd field. In the for statement, the variable i starts at
zero. The condition becomes false when the value of i is one less than r.FieldCount which in this
case is 2 i.e. i will take values of 0 and 1. The reason being i starts from zero as GetName
understands zero as the first field. Thus we can now print all the column names using the for.
Now lets print the entire table irrespective of the number of columns or the number of rows.
a.cs
class zzz

{
try
OleDbConnection s;
s.Open();
OleDbCommand c;
OleDbDataReader r;
while ( r.Read() )
System.Console.Write(r.GetValue(i)+" ");
System.Console.WriteLine();
}
}
Output
1 a1
2 a2
You can modify abc to add more fields and fill in more records. Execute the program and see the
change in output. Whenever we do not know better, we use a for or a while i.e. a looping
construct. However we do not know two things. One, the numbers of rows in the table and two
the number of columns. The first while takes care of the number of rows and the for, the variable
number of columns. Thus the above program will work for any number of columns and rows in
the table. All that we do is change the select statement. The difference between Write and
WriteLine is that Write does not add an enter at the end like WriteLine does. Also + is used to
join two strings together. We are adding a space at the end of every field as a separator.
5
Web Enabling Data
We now have to our credit, programs that enable execution of a general purpose select statement
as well as those that update, insert and delete commands. These were all C# programs which
were compiled into executable files.
Let's assume you want to display the contents of the customer table. Our program will very well
serve this purpose. Alternatively, the program can be made to accept user input and depending
upon the table name that the user typed in, the program can display contents of that table. You
can easily do so with the help of a function called GetLine in Console. GetLine will cause the
program to wait at the console for the user input followed by the 'Enter' key.
This situation comes with its share of problems though. The problem is that if there are five
people who are going to use this program then you need to give them five copies of the program.
If there are five thousand such users then you have to copy this on to five thousand different
machines. Simply not possible. Wait a minute! Did you get a sudden brainwave? The perfect
solution would be to 'put it on a network'!! But don't forget that there are many networking
standards available. Some may have Novell, some may have Windows 2000, and others may
have the Macintosh or even Linux/Unix. So what do we do now? You will have to make sure that
the same program works under Linux as well as it does under a Mac or any other standard. Apart
from this you would have the headache of having to train people to use the program.
The only solution to this problem is Web enabling data. This is the new standard of writing code.
You need to access your data using Internet Technologies. It's only then that we can eliminate the
loopholes that exist within the already available standards.
No matter which operating system you install, along with it you get access to a browser. When
you use the Internet you use a browser, a.k.a. an user agent, that enables you to view web pages
and enables data transfer over the Internet.
Since we do have a browser, can't we do a simple thing? Let the user type the name of our
machine and get a form. Within the form he can key in the table name and once he does that he
will get the details of that table. Which means you will now have to execute your code on a
program called the WebServer. This is what is meant by Web Enabling Data.
But before we leapfrog into the world of Web Enabling Data, let's acquaint ourselves with the
basic language that the browser understands. It is called HTML.
HTML
Amongst browsers, the usual suspects are Netscape Navigator and Internet Explorer. What
happens when you view a web page using such a browser? Technically speaking, you connect to
a web server and a file comes over onto your computer, which is generally an HTML file.
HTML is the acronym for Hyper Text Markup Language. It is a document-formatting language.
HTML is basically a stream of characters without any intelligent functionalities like the for and if
statements. Hence it cannot be considered an equivalent of a programming language. HTML, as
simple as it is, allows any bumpkin to be an ace at it!
Assuming you have a Web Browser, let's write our first HTML program. You can use any editor
like word to type your program in. The only thing that you must bear in mind is that the file must
be saved with the extension .htm or .html. Create the file in your root directory. In our case, we
will save in c: and since we are using the dos editor we shall begin by saying edit a.html
C:>edit a.html
Type the code as we have done below.
a.html
Hi
Bye
Output
Hi Bye
Note that the text must be on two separate lines. Once you have saved your file run your browser.
In the browser you will see a white text box known as the address bar. Click there and type
c:/a.html, in our case we have saved the file in the root of the C drive.
As of now we are picking up this html file from our hard disk. But when you are on the Net you
are accessing a file from some other machine on the net. In that case, you give the address of that
machine. For instance, if you want to connect to the Microsoft site, you will type
www.microsoft.com. Apart from that there is no difference in trying this on the Net or off the
Net.
When the browser sees an html file, it reads it line by line. Hence, in the browser window you
will see Hi Bye displayed. Wow! You have just written your first html program!
But didn't we write Hi and Bye on two separate lines? The browser, dumb as it is doesn't seem to
understand this. Looks like the browser, by default, ignores enters! So, how can we make the
browser understand? We can do so with the help of 'tags'.
HTML is based on 'tags', which instruct the browser how to display a piece of text or an
image/picture. A tag begins with '<' and ends with '>'.
So let's add a tag.
a.html
Hi <br>
Bye
Output
Hi
Bye
Going by the definition of a tag you will realize that br is a tag. It is enclosed within the angular
brackets. <br> means next line. Save the file. Now when you view this file in the browser you
will find that Hi and Bye are displayed on two separate lines.
Hence, HTML is nothing but a collection of tags. You just need to know which tag satisfies what
purpose.
a.html
<b> Hi </b> <br>
Bye
Output
Hi
Bye
In this program, the tag b means bold. But here we also have </b>, which is a closing tag. This
indicates that we are closing the <b> tag. Whatever is enclosed between the two will be made
bold. Hence only Hi will be bold. HTML tags are romantic, most of them always travel in pairs -
called an opening tag and a closing tag. But some tags like <br> like to play the field for they
prefer to remain single.
Using the <i> tag we will display Hi in italics.

a.html
<i> Hi </i> <br>
Bye
Output
Hi
Bye
It is all very mechanical! <i> means italics and hence Hi is displayed in italics. Had you included
bye within <i> and </i> then bye would be in italics too! That's all the understanding that is
required to learn HTML!
Now we have included another tag <h1>
a.html
<i> Hi </i> <br>
<b> Bye </b> <br>
<h1> You are Welcome again! <h1>
Output
Hi
Bye
You are Welcome again!
Since Hi is included in <i> </i> it will be displayed in italics. Bye is displayed in bold due to the
<b> tag. <hi> means heading1, it makes the text bigger. Thus, 'You are Welcome again!' is
displayed in a bigger font.
a.html
<html>
<body>
<i> Hi </i> <br>

<b> Bye </b> <br>
</body>
</html>
Output
Hi
Bye
You are Welcome again!
This program outputs the same result as the above. The only difference is that now it is a well-
formed HTML program. Every HTML file must begin with the <html> and end with </html>
tag. Whatever text is to be displayed within the browser must be enclosed within the <body> and
</body> tag. This is the way an HTML program must be written. Hope the purists have forgiven
us now!
Let's make our page attractive by adding a picture to it. Copy any gif file to your root directory
and name it aa.gif. In our case, we copied it to c:
a.html
<html>
<body>
<i> Hi </i> <br>
<b> Bye </b> <br>
<img src="aa.gif">
</body>
</html>
img is the image tag, it is used to display pictures. Along with this tag you have to specify the
name of the image file. Following the word 'img' is the word 'src' and after the '=' sign you
specify your filename. i.e. aa.gif. You can give the name of any picture file. But follow this
syntax! Another thing to note is that you can have the file name included in single quotes or
double quotes or you may exclude them totally. Thus viewing this file in the browser will now
display the image you specified along with the text. In HTML parlance, src is called an attribute.
An attribute describes / qualifies a tag.
<a href=a.html> Hi </a>
<a href=b.html> Bye </a>
You will see two hyperlinks in your browser window. The names of the html files will not be
displayed but the words Hi and Bye will be underlined. And if you click on hi and bye the
respective html files will be displayed instead.
Then there are tables in HTML
a.html
<html>
<table border=10>
<tr>
<td>hi</td><td>100</td>
</tr>
<tr>
<td>1000</td><td>bye</td>
</tr>
</table>
</html>
The table tag has one attribute, border, that specifies how the lines or borders between columns
looks like. The table tag encompasses two tags . tr stands for a table row and td for a table
columns. We have two tr's , hence we have two rows and each tr encloses two td's one for each
column.
Similarly, you can keep adding more and more tags depending on how you want your page to be
displayed. Any book on HTML will list all the available tags. Our aim is not to learn html here
but to use C# on the Net. Since knowing this much will suffice our forthcoming needs, let's get
back on track!
Using C# on the Net
Now that you are familiar with the rudimentary elements of HTML, let's see how we can apply
our recently acquired knowledge in conjunction with C# on the Net.
First and foremost you need a Web Server. Hence you will now need to install Apache. You can
download Apache from http://www.apache.org and then run the installer program. Among the
Apache directories, there are two sub-directories that are of importance to us, namely, cgi-bin
and htdocs.
The cgi-bin sub-directory is used for storing executable files.
In order to change to the cgi-bin sub-directory follow the path as given below.
C:\progra~1\apache~1\apache\cgi-bin
And to change to the htdocs sub-directory give the following path.
C:\progra~1\apache~1\apache\htdocs
The htdocs sub-directory is used for storing html files.
To install the Apache Web Server all that you need to do is download the install program on your
hard disk. Run the executable program which will install apache in the apache group directory of
program files. Change to C:\progra~1\apache~1\apache directory and then run the web server as
follows.
C:\progra~1\apache~1\apache >apache
If you get an error about some server name, cd to the conf sub directory , edit a file called
httpd.conf , change a line starting with #ServerName to ServerName localhost and all should be
well after that.
Now that you have the Apache server running, activate your web browser. Type the address
127.0.0.1 in the address bar and press enter. Every machine on the internet is known by a
number. We call this number an IP address. IP stands for the Internet Protocol. Every machine
that has the Internet software running is also known by the number 127.0.0.1 or localhost. In case
a file called index.html exists, the browser will display it. This is because it is located in htdocs
and is the file that gets picked up by default when you give your machine address and you have
Apache running.
Change to the htdocs sub-directory and create an html file a.html to display a form.
a.html
<html>
<form>
<input type=submit value=Search>
<form>
</html>
The <form> tag is used to specify that we are creating a form. <input type=submit is the syntax
for creating a button. Value =Search means that 'Search' is the word that will appear on the
button. Had we said Value = Vijay, you would see the 'vijay' on the button.
Save the file as a.html in the htdocs subdirectory. Go to the browser window and type
http://127.0.0.1/a.html in the address bar and press enter. You will now see a button with the
name Search on it. But clicking on this button doesn't serve any purpose as of now.
Let's alter the program such that when the user clicks on the Search button our C# program
should execute.
So first we will write our C# program.
C:\csharp>edit a.cs
Now type the following code.
a.cs
class zzz
System.Console.WriteLine("hi<b>bye");
Output
hi<b>bye
This is a simple program that should display hi and bye. Save the program as a.cs. On compiling
the program an executable file 'a' is created. If you run the program as we have been doing, you
will see the output as given above. But remember, what we just told you about executables?
When you are using Apache you must save all executables in the cgi-bin sub-directory as a
security precaution. Hence you must copy a.exe to cgi-bin by giving the following command.
C:\csharp>copy a.exe c:\progra~1\apache~1\apache\cgi-bin
Now we will alter our HTML program. Within the form tag include action=http://127.0.0.1/cgi-
bin/a.exe This indicates the action to be performed when the button is clicked. Since we want our
program a.exe to run, we have given its path.
a.html
<html>
<form action=http://127.0.0.1/cgi-bin/a.exe>
<form>
</html>
Now that we have everything ready, let's get on with the show! Activate your browser and type
http://127.0.0.1/a.html in the address bar. You see the button labeled Search. Now click on this
button. To your horror you see an error! The browser window displays an Internal Server Error.
Note the url in the address bar- http://127.0.0.1/cgi-bin/a.exe?
Now make the changes as we have done below.
a.cs
class zzz
System.Console.WriteLine("Content-Type:text/html\n");
}
}
Output in Browser
hibye
Save your file, compile it and again copy it to cgi-bin once again. Now when you run your
program from the browser, the error vanishes! And you will see hibye displayed. That means it is
mandatory to give Content-Type. It tells the browser that what is being sent across is a text file.
Also the content is qualified as html and not pure text. It is also called a header. Because we are
saying html, the bye is displayed in bold. So we created a file and the file goes over i.e. what
ever is in Console.WriteLine goes over.
Now remove html and instead write plain. Let's see what happens. After making the necessary
changes and compiling the program copy it again to cgi-bin.
a.cs
class zzz
System.Console.WriteLine("Content-Type:text/plain\n");
Output in Browser
hi<b>bye
Now run your program from the browser. You will notice that bye is not displayed in bold. Also
note that now the tags are displayed as normal text. They show no formatting effects. This is
because instead of the word html we are now saying plain. That means the browser will now
display everything as plain text.
Thus the Content-Type: header is used to indicate to the browser that we are sending text
followed by HTML. Thus if we want our program to execute on the web it is mandatory that we
include this header in our program as the web server does not know what is the file type it is
sending over.
Now that we have all the ingredients for the final show, let's get on with it. We will now add the
header to our general-purpose select program. We will do this so that we can display the contents
of a table on the web. Thus the only change that we have made to the program is to add the
following line:
a.cs
class zzz
try
OleDbConnection s;
s.Open();
OleDbCommand c;
OleDbDataReader r;
while ( r.Read() )
{
System.Console.WriteLine(“<br>”);
We have also added System.Console.WriteLine("<br>"); so that each record is displayed on a

new line. The browser will see <br> and understand it as an html tag. This is because in the
header we have specified text/html. As such you will see each record on a new line.
Now save the file and compile it. Copy the file a.exe to the cgi-bin sub-directory. Activate the
browser window and type http://127.0.0.1/a.html in the address bar. Now click on the search
button. Accolades! You have successfully run your C# program from the browser. You will now
see all the contents of the abc table. Why the abc table? Because that's the table you specified in
your program.
Thus, whenever the user clicks on the button in the browser he is calling a program on the server.
The server could be a trillion miles away!! However, even now everything is not hunky dory.
The major problem being that this entire approach is inflexible.
Earlier, we told you we need this type of programming because we didn't want to copy the
programs on each machine. But the problem with the Web Server is that if it contains ten html
files then we can give the user only those ten html files. So we are only giving him ten views.
However, what we really need to do is that we need to pass data from us to his machine.
For example, let's assume we have a database that has names of people. We should have a form
in which the user can write the name of a person. When he clicks on 'ok' that name should get
added to the database. In effect, we are adding one person’s data to the database. Similarly, we
should be able to delete a person from the database too. And finally we can have a table-display
program wherein the user will provide the table name. When he clicks on ok, the contents of that
table will be displayed. Thus you can now think of generating flexible programs. You probably
felt limited earlier as you could display contents of only that table whose name you had provided
within the program.
Environmental Variables
Before we get down to making our programs flexible we need to understand as to how we can
deal with Environmental Variables in C#. An Environmental Variable is a word that the operating
system understands.
a.cs
class zzz
public static void Main(){
string s;
s=System.Environment.GetEnvironmentVariable("PATH");
Output
Content-Type:text/html
C:\JDK1.2.2\BIN; C:\WINDOWS\MICROSOFT.NET\FRAMEWORK\V1.0.2204\;
C:\WINDOWS; C:\WINDOWS\COMMAND; C:\BORLANDC\BIN; C:\WINDOWS;
C:\WINDOWS\COMMAND; C:\PROGRAM FILES\MTS
Displays the value of environmental variable called PATH. An environmental variable is a word,
which stores a value. When you give the command set xyz=bye at the command prompt, xyz
becomes an environmental variable, which stores the value bye. All operating systems allow you
to create environmental variables . The environmental variable PATH stores a list of directories
that the operating system searches for to find executables files. Run it off the web server or by
itself.
a.cs
class zzz
System.Collections.IDictionary i;
i=System.Environment.GetEnvironmentVariables ();
System.Collections.IDictionaryEnumerator d;
d=i.GetEnumerator();
System.Console.WriteLine(i.Count + "<br>");
while (d.MoveNext())
System.Console.WriteLine("{0}={1}<br>",d.Key,d.Value);
There can be 100's of environmental variables and we would like a list of all of them. The class
Environment in the System namespace has a function GetEnvironmentVariables which returns an
object that looks like IDictionary. This IDictionary object has a function called GetEnumerator
which returns an object that looks like IDictionaryEnumerator. You have to learn all this by rote,
there is no other option available. We are then displaying how many environmental variables
there are by printing a member Count in IDictionary. Then we need to activate each variable by
calling MoveNext which returns true if there are more environmental variables in the list. An
environmental variable is represented by a key-value pair, which is also variable in the
IDictionaryEnumerator class. Thus we can display all the environmental variables starting with a
count of how many there are.
If you check the list of environmental variables in your browser, you will see one called
QUERY_STRING , but it will have no value.
Now run as http://127.0.0.1/cgi-bin/a.exe?aa=ho and see the variable QUERY_STRING have a
value aa=ho.
a.html
<html>
<form action=http://127.0.0.1/cgi-bin/a.exe>
<input type=text name=aa>
<form>
</html>
Run the file in the browser. And you will now see a text box which is internally called aa. This is
because of the tag input type=text. Type ho in the text box and click on search. The URL will
now change to http://127.0.0.1/cgi-bin/a.exe?aa=ho and the variable QUERY_STRING will have
the value aa=ho.
a.html
<html>
<form action= http://127.0.0.1/cgi-bin/a.exe >
<input type=text name=aa>
<input type=text name=bb>
<form>
</html>
Now we will see two text boxes in which we will type in ho and no. Click on Search and the url
will change to http://127.0.0.1/cgi-bin/a.exe?aa=ho&bb=no and the variable QUERY_STRING
will have the value aa=ho&bb=no.
CGI Programming
Let us now understand what goes on once again. What we have been trying to explain to you is
called CGI programming where CGI stands for Common Gateway Interface. Everyone refers to
by its acronym rather than its expanded full form. CGI is a means by which a client i.e. a browser
can send some information to the web server.
Now typically what happens when we land up at a search engine? Well, we want to send the web
server i.e. yahoo the words that we want it to search the internet for. At times we are asked to fill
up a form on the web asking for some personal details. The information we key in is sent across
to the web server. Lets start with the above HTML file that makes CGI happen. We have two
input tags which have an attribute type=text. Thus we see two text boxes on our screen. We will
type in them hi and bye respectively. The third input tag has a type=submit and another attribute
value=search. This makes it into a button with the word search written on it.
Now, when we click on search after typing in data in the text boxes, the browser knows that you
have clicked on a button of type submit. So, it will now look for a tag form , and when it finds it ,
it will read the attribute action. Whatever is the value of action, it will write it in the address bar.
In the address bar we write a URL or Uniform Resource Locator or the address of a computer on
the net. In our specific case, our browser's address bar will contain http://127.0.0.1/cgi-bin/a.exe.
The browser does not stop here. It then adds a ? to the end of the above URL . Now it looks at
every text box that we have in the form. The first one has been given a name aa and we type hi in
it. So our URL now changes to http://127.0.0.1/cgi-bin/a.exe?aa=hi.
It's not over yet as we have one more text box to finish with. This one is called bb and has bye in
it. Thus our URL now reads http://127.0.0.1/cgi-bin/a.exe?aa=hi&bb=bye. The & is used to
separate different parameters. aa and bb are also called parameters. This url is sent across to the
web server. The web server is just another name for a file server. It can only send files across. In
this case we are asking it to run a program called a.exe from the cgi-bin sub directory. Before the
web server runs a.exe, it creates one environmental variable called QUERY_STRING and
initializes it to whatever follows the ? i.e. in this case aa=hi&bb=bye. The web server now runs
a.exe. What a.exe actually does is none of its concern. All that is wants from a.exe is a html file
which the web server sends back to the browser.
The web server also needs at least one header Content-Type which tells it the type of file being
sent across. Normally a.exe would read the environmental variable QUERY_STRING, extract
the parameters, then read a database, extract some values from it and finally create an HTML file
which it would hand over to the web server. All in all, this is how the magic of the internet is
bought about.
Now, let's learn some more C#.
a.cs
class zzz

string s ;
string [] e;
char[] c ;
s = "hi=bye&no=bad" ;
c = new char[2];
c[0] = '&';
c[1] = '=';
e = s.Split(c);
foreach ( string t in e)
System.Console.WriteLine(t);
Output
hi
bye
no
bad
s is a string which has been initialized to hi=bye&no=bad which looks similar to what
QUERY_STRING as explained earlier looks like. C is an array of chars which has two members
initialized to & and = respectively. The string class has a member Split, which will split a string
as per the delimiters provided as the first parameters in an array of chars. Thus the split function
will take the string s and split it whenever it sees a & or a = . In this case it will result in 4
strings. Split returns an array of strings which we are storing in an array e and using foreach to
display the array.
Now lets us create a simple form based web application which will accept a table name and then
display the entire table for us.
The html file a.html as usual will be copied to the htdocs sub-directory.
a.html
<html>
<b> Enter Table Name </b>
<input type=text name=aa> <p>
<input type=submit value="Show Table">
<form>
</html>
We will run as:
http://127.0.0.1/a.html
Our C# program freshly compiled and copied to the cgi-bin subdirectory would now read as:
a.cs
class zzz
try
string t;
t=System.Environment.GetEnvironmentVariable("QUERY_STRING");
string [] u;
char [] v = new char[1];

v[0] = '=';
u = t.Split(v);
string w;
w = "select * from " + u[1];
OleDbConnection s;
s.Open();
OleDbCommand c;
c=new OleDbCommand(w,s);
OleDbDataReader r;
while ( r.Read() )
System.Console.WriteLine("<br>");
}
At our web form we are asked to write the name of the table. Then click on the button Show
Table. The web browser now writes the following URL in the address bar after we wrote abc as
the name of our table. http://127.0.0.1/cgi-bin/a.exe?aa=abc. The Apache Web Server now runs
a.exe. a.exe is nearly similar to what we wrote earlier with some minor modifications. t contains
the value of the environmental variable QUERY_STRING . v is an array of chars with one
member which is our delimiter '='. Split will return an array of strings in u , in our case aa and
abc which will be stored in u[0] and u[1]. Earlier we hard-coded the SQL Select statement. Here
w starts with the constant string 'Select * from ' and the name of the table is got from u[1] which
in turn gets its value from the environmental variable QUERY_STRING. Write the name of any
table that exists in the database in the text box and see how you have been able to web enable
your data on the net.
Lets use the table tags to make our data look more appealing in the browser.
a.cs
class zzz
try
string t;
string [] u;
v[0] = '=';
u = t.Split(v);
string w;
OleDbConnection s;
s.Open();
OleDbCommand c;
OleDbDataReader r;
System.Console.WriteLine("<table border=10>");
while ( r.Read() )
System.Console.WriteLine("<tr>");
for ( int i = 0 ; i < r.FieldCount ; i++) {
System.Console.Write("<td>" + r.GetValue(i) + "</td>");
System.Console.WriteLine("</tr>");
System.Console.WriteLine("</table>");
}
The output looks great. We have made very small additions to our program, mostly cosmetic. We
start with the table tag with a border. The while gets called once for every record and in this
while we start and end with a row tag tr and /tr. The for gets called for every field and here we
enclose the field value with a tag td and /td. At the end of the while we end with the /table tag.
The only problem is that we have not displayed the field names at all. Let the next program do
so.
a.cs
class zzz
try
string t;
string [] u;
v[0] = '=';
u = t.Split(v);
string w;
OleDbConnection s;
s.Open();
OleDbCommand c;
OleDbDataReader r;
System.Console.WriteLine("<table border=10>");
System.Console.WriteLine("<td>" + r.GetName(i) + "</td>");
while ( r.Read() )
for ( int i = 0 ; i < r.FieldCount ; i++) {
System.Console.Write("<td>" + r.GetValue(i) + "</td>");
}
System.Console.WriteLine("</table>");
All that we did was to copy the for loop which generated the field names from an earlier
program. We put a tr and a /tr around the for loop and the names of fields are tagged with td.
Great looking output.
a.cs
class zzz
string t;
Output
aa=select+*+from+abc
In the original a.html instead of writing a simple table name we wrote ‘select * from abc’ instead.
When we displayed the environment variable QUERY_STRING we learn that the spaces are
replaced with a + sign. The rules of creating a URL specify that a space is a forbidden character
and all spaces that we write are replaced by a +. Thus we have to convert the + back into spaces.
a.cs
class zzz
string t,s;
s = t.Replace('+',' ');
System.Console.WriteLine(s + "<br>");
Output
aa=select * from abc
aa=select+*+from+abc
The string class has a method called replace which replaces every occurrence of the first
parameter i.e. + with the second i.e. a space. Thus s is t but with the plus sign replaced by a
space.
Lets us know write an insert statement which will ask the user to key in his first and last name
and then add it into a table. We create a table 'bbb' in our database with two fields f1 and f2 both
character type. Our html file also now changes to.
a.html
<html>
<b> Enter Users First Name </b>
<b> Enter Users Last Name </b>
<input type=text name=bb> <p>
<input type=submit value="Add">
<form>
</html>
a.cs
class zzz
try
OleDbConnection s;
s.Open();
OleDbCommand c;
string t;
string [] u;
v[0] = '=';
v[1] = '&';
u = t.Split(v);
string f1,f2,f3;
f1 = u[1].Replace('+',' ');
f2 = u[3].Replace('+',' ');
f3 = "insert into bbb values('" + f1 + "','" + f2 + "')";
System.Console.WriteLine(f3);
c=new OleDbCommand(f3,s);
Output
insert into bbb values('vijay ram','mukhi')

URL in Address Bar.
http://127.0.0.1/cgi-bin/a.exe?aa=vijay+ram&bb=mukhi
The first change is that our array of chars is now two members large and the second delimiter is
the '&'. Thus our QUERY_STRING will break into 4 strings aa , vijay+ram , bb and mukhi in
u[0] to u[3]. We replace the + with the ' ' in both strings and dynamically generate the insert
statement. It looks confusing but is not, Once again f1 and f2 contain the dynamic data but
because they are strings we need them to be separated by a single inverted comma. Thus the
complication in concatenating strings. The browser displays the SQL statement that will be
executed, but in real life we would display a success or error message.
Data Search Program
Now let us write a search engine or more precisely, a general purpose data retrieval engine. For
which we have to first create a simple database that will contain the following fields :
Keyword - that will store what the page contains,
url - the address of the page,
name - to be displayed instead of the url
and finally the text that will be displayed explaining the page.
create table ss ( keyword char(10), url char(100), name char(100), descrip char(100));
We will also add the following records.
insert into ss values ( 'java', 'a.html', 'java site', 'great java site');
insert into ss values ( 'c', 'b.html', 'c site', 'great c site');
insert into ss values ( 'basic', 'c.html', 'basic site', 'great basic site');
insert into ss values ( 'cobol', 'd.html', 'cobol site', 'great cobol site');
Create the following html files in the htdocs subdirectory
search.html
<html>
<b> Enter keyword </b>

<input type=submit value="Search">
<form>
</html>
a.html
The file is for java
b.html
The file is for C
c.html
The file is for Basic
d.html
The file is for Cobol
The C# program will be as follows
a.cs
class zzz
try
string t;
string [] u;
v[0] = '=';
u = t.Split(v);
string w;
w = "select * from ss where keyword='" + u[1] + "'";
OleDbConnection s;
s.Open();
OleDbCommand c;
OleDbDataReader r;
while ( r.Read() )
System.Console.WriteLine("<a href=/{0}> {1} </a> {2}

<br>",r.GetValue(1),r.GetValue(2),r.GetValue(3));
}
}
Open up the browser and enter the url 'http://127.0.0.1/search.html'
All that this program does is use the concept of a hyperlink to build a search engine and extract
data from a database. We assume we have a database of a trillion records that map the internet
telling us the keywords that each url stands for. The user keys in the name of a language and we
use the select statement to fetch the records meeting the condition, format it and then send the
html file across.
We can use the same concept to fill up a list box. The html tags for list box are as follows
<select name = aa>
<option> blue </option>
<option> red</option>
<option> orange </option>
</select>
In a real life situation, the colours will be retrieved from a database and the HTML file generated
by a CGI program.
6
Miscellaneous
Multiple files
A C# program can be spread over multiple files. So far all our code has been written in one large
file. Lets us create 2 .cs files a.cs and b.cs as follows
a.cs
class zzz
yyy a = new yyy();
a.abc();
b.cs
public class yyy
public void abc()
}
Earlier our code did not spawn multiple files. C# does not care whether the code is in one file or
spread over multiple files. We have only to make a small change while we compile the program.
Running Csc a.cs b.cs will create a.exe
Output
Hi
These files are called source files and it is a good idea to give them a file extension of .cs. If you
rename b.cs to b.xxx as we did and rerun csc as
>csc a.cs b.xxx
This will create a.exe as usual. File extensions matter to the programmer not to the compiler.
Ascii and Unicode
a.cs
class zzz
System.Console.WriteLine((char)65);
Output
A
B
Computers in a way are pretty dumb. They do not understand letters of the alphabet. All that they
can store in memory are numbers. But then, how does a computer understand or display
alphabets? The WriteLine function displays 65 as 65, but the output is A. In the () brackets we
have placed a data type called char. We call a ( ) a cast. It means, for the moment convert
whatever follows into a char. Thus the number 65 gets converted into a char which is displayed
as a 'A'. The 66 gets displayed as a 'B'. Someone, somewhere in the world invented a rule which
specified that the number 65 represents a capital A, etc. This rule is given a name and is called
ASCII. All that ASCII says is that the numbers form 0 to 255 can also represent small and capital
letters, punctuation etc. Whenever you write A, rest assured somewhere in memory, a 65 was
stored. A file on disk can also contain numbers form 0 to 255 only and the same rule as spelt
above apply.
a.cs
class zzz
char i = 'a';
System.Console.WriteLine((char)i);
Output
C# offers us the data type char to represent ASCII values naturally.
a.cs
class zzz
{
int i;
for ( i=0; i<=255; i++)
System.Console.Write(i + " " + (char)i + " ");
The above program displays the entire Ascii table. The problem with Ascii is that it is sufficient
for a language like English, which does not have to many symbols to represent. However, when
it comes to visual languages like Japanese, they have more symbols to represent than English.
Ascii can represent a max of 256 unique symbols. The industry thus invented Unicode which
uses 2 bytes for every character unlike Ascii's one. All the languages of the world can be
represented by Unicode. C# understands Unicode and thus the char data type store characters
internally as Unicode and not Ascii.
The present Unicode standard is 3.0.
a.cs
class zzz
int int;
Compiler Error
a.cs(5,5): error CS1041: Identifier expected, 'int' is a keyword
a.cs(5,8): error CS1001: Identifier expected

Words like int, char, if etc are reserved by C# and we are not allowed to use them as function
names, class names, variable names etc. However, if you insist on doing so, then you have to
preface the name with a @ sign like below.
a.cs
class zzz
int @int;
Compiler Warning
a.cs(5,5): warning CS0168: The variable 'int' is declared but never used
The warning does not name the variable @int but int.
a.cs
class zzz
int @int;
@int = 10;
System.Console.WriteLine(@int);
}
Output
10
We have millions of names to choose for a variable, then why insist on an int. There will be
times when another language declares a name as a reserved name and in those cases we would
use the @ sign. It is advisable not to use the @ sign very often.
When we run the C# compiler on our program, it does 2 things. One, it reads our code and
converts it into things/tokens it understands. This is called a Lexical analysis. Then it does a
Syntactic analysis which gives us an executable output.
Comments
Comments are a form of documentation. They are lines of code written for our benefit (the
community of programmers) and not for C#'s. In spite of this, programmers in general are lazy in
writing comments. Comments are ignored by the compiler.
a.cs
// hi this is comment
class zzz
public static void Main() // allowed here
/*
A comment over
two lines
*/
A regular comment starts with a /* and ends with a */. They can be spread over multiple lines
and can be placed anywhere in your code. Any line beginning with a // is a one line comment and
as the name suggests, cannot span multiple lines. A single line comment does not have to be at
the beginning of a line.
Escape Sequences and Strings
a.cs
class zzz
System.Console.WriteLine("hi \nBye\tNo");
System.Console.WriteLine("\\");
Output
hi
Bye No
An escape sequence is anything that starts with a \. A \n means start printing from a new line and
a \t means a tab. Two backslashes convert into a single backslash.
a.cs
class zzz
System.Console.WriteLine(@"hi \nBye\tNo");
}
Output
hi \nBye\tNo
A string is anything in double quotes. A verbatim string starts with a @ sign and all the escape
sequences are ignored by the C# compiler and displayed verbatim.
a.cs
class zzz
System.Console.WriteLine("hi
bye");
Compiler Error
a.cs(5,26): error CS1010: Newline in constant
a.cs(6,6): error CS1010: Newline in constant
A string cannot spawn multiple lines.
a.cs
class zzz
System.Console.WriteLine(@"hi
bye");
}
Output
hi
bye
Placing an @ in front of the string lets it spawn multiple lines and the spaces shown in the
output. If you want the \ to lose its special meaning in a string, preface that string with a @ sign.
a.cs
class zzz
string a = "bye";
string b = "bye";
System.Console.WriteLine(a == b);
Output
True
The above example displays true, even though the two strings may be stored in different areas of
memory. The two strings contain the same characters and hence are similar.
The Preprocessor
Before the C# compiler can start, a small part of it called the pre-processor first activates itself. It
is called the preprocessor as the same concept existed in the programming language 'C'. All that
the preprocessor does is that it looks at those lines beginning with a # symbol.
a.cs
#define vijay
class zzz
The first preprocessor directive we are learning is called define. This lets us create a
word/variable or even better, an identifier called vijay. The identifier vijay has no value other
than true.
a.cs
class zzz
#define vijay
Compiler Error
a.cs(5,2): error CS1032: Cannot define/undefine preprocessor symbols after first token in file
We cannot use the #define, after valid C# code has been written. They have to come at the
beginning of the file.
a.cs
#define vijay
class zzz
#if vijay
System.Console.WriteLine("1");
#endif
Output
As a #define creates a variable, its value can be checked by the if or more precisely the #if which
works in the same way as the if of C# does. Thus the #if is true and all code up to the #endif gets
added to the code.
a.cs
class zzz
#if vijay
#else
#endif
}
Output
The same rules as before for an else. Here as we have not created an identifier called vijay, it gets
a value of false and therefore the #if is false. Imagine a preprocessor identifier as a boolean
variable.
Why use a preprocessor variable instead of a normal one?
Run the C# compiler as follows on the above program and observe the change in output.
csc /D:vijay a.cs
Output
The output displays 1 as the /D compiler option lets you create identifiers at the time of
compiling the program. This cannot be done with a normal variable. We can add/subtract lots of
code form our program, at the time of compilation.
a.cs
#undef vijay
class zzz
#if vijay
#else
#endif
Output
As we are allowed to create an identifier vijay by the define, the undef does the reverse. It sets it
to false which is the default in any case. As the value of vijay is false, the else gets activated.
However we run the above as csc /D:vijay a.cs, we are first creating an identifier vijay at the
command line prompt, then undefining it at the first line in the program and the output will show
2 as before. You cannot use the define or undefine after real code.
a.cs
#define vijay
#undef vijay
#undef vijay
class zzz
#if vijay
#endif
People are allowed to nag you as many times as they like. Repetition has been part of human
history since ancient times. You are allowed to undef as many times as you like even though it
makes no logical sense.
a.cs
#define vijay
#define mukhi
class zzz
#if vijay
#if mukhi
#endif
#endif
Output
You can have as many #if's within #if's. We call them nested if's. If the #if is true, then the text up
to the #endif is included.
a.cs
#define vijay
class zzz
{
#if vijay
#else
int int;
#endif
We get no error at all in spite of the fact that we are not allowed to create a variable called int. Is
C# sleeping at the wheel? It is not as the preprocessor realized that the identifier vijay is true, it
removed all the code from the #else to the #endif. C# did not flag an error at all, as it was not
allowed to see the offending code by the preprocessor.
a.cs
class zzz
#if vijay
#else
int int;
#endif
Compiler Error
a.cs(8,5): error CS1041: Identifier expected, 'int' is a keyword

a.cs(8,8): error CS1001: Identifier expected
Now we see the error as the identifier vijay is false. Remember what the C# compiler sees is
what the preprocessor allows it to. You write code and what the compiler sees may be very very
different.
a.cs
#warning We have a code red
class zzz
Compiler Warning
a.cs(1,10): warning CS1030: #warning: 'We have a code red'
Whenever we want a warning message to be displayed at the time of compiling our code we use
#warning.
a.cs
class zzz
Compiler Warning
a.cs(3,10): warning CS1030: #warning: 'We have a code red'
Unlike the #define, the #warning can be used anywhere in our program. It enables us to add to
the messages of the compiler. Also the line number changes from 1 to 3 telling us where the
warning occurred.
a.cs
class zzz
#error We have a code red
Compiler Error
a.cs(3,8): error CS1029: #error: 'We have a code red'
Wherever we have warnings, errors cannot be far behind. The difference is that an error unlike a
warning, stops everything in its tracks and does not let the compiler proceed ahead. No exe file is
created. Normally an error or warning would be placed in an if statement as follows.
a.cs
#define vijay
#define mukhi
class zzz
#if vijay && mukhi
#error We have a code red
#endif
Compiler Error
a.cs(6,8): error CS1029: #error: 'We have a code red'
The && means and. The if is true if both sides of the && is true. They are in this case. Remove
one of the above #defines and the if will be false.
a.cs
#line 100 "vijay"
class zzz
Compiler Warning
vijay(102,10): warning CS1030: #warning: 'We have a code red'
The line directive does two things. One it changes the line number from 1 which is what is
should be at the beginning to 100. Thus the warning appears on line 102 now and not 2. Also the
file name changes from a.cs to vijay. You have total control over the line number and file name
displayed.
a.cs
#line 100 "vijay"

class zzz
int int;
#line 200 "mukhi"
char char;
Compiler Error
vijay(104,5): error CS1041: Identifier expected, 'int' is a keyword
vijay(104,8): error CS1001: Identifier expected
mukhi(200,6): error CS1041: Identifier expected, 'char' is a keyword
mukhi(200,10): error CS1001: Identifier expected
Line does not only work with the #error or #warning. It affects also the compiler's error line
number and file name. You are allowed to have as many #lines as you prefer.
7
Function Overloading and Inheritance
Its not what you get but what you give that makes you a richer person. Unfortunately, this little
gem is understood only be a few and giving remains largely a one way street.
This chapter explains function overloading, the params parameter and inheritance. We start with
function overloading.
Function Overloading
a.cs
class zzz
yyy a = new yyy();
a.abc(10);
a.abc("bye");
a.abc("no",100);
class yyy

{
System.Console.WriteLine("abc" + i);
public void abc(string i)
System.Console.WriteLine("abc" + i);
public void abc(string i,int j)
System.Console.WriteLine("abc" + i + j);
Output
abc10
abcbye
abcno100
The class yyy has three functions, all of them having the same name abc. The distinction
between them is in the data types of the parameters. They are all different. In C# we are allowed
to have functions with the same name, but having different data types parameters. The advantage
is that we call the function by the same name as by passing different parameters, a different
function gets called. This feature is called function overloading. All is fine only if the parameter
types to the function are different. We do not have to remember a large number of functions by
name.
The only reason why function overloading works is that C# does not know a function by name,
but by its signature. A signature denotes the full name of the function. Thus the name of a
function or its signature is the original function name plus the number and data types of its
individual parameters.
a.cs
class zzz
public void abc()
public int abc()
Compiler Error
a.cs(6,12): error CS0111: Class 'zzz' already defines a member called 'abc' with the same
parameter types
Here we have two functions abc which differ only in the values they return. As return values do
not count in the function signature and the function names are similar, hence the error.
a.cs
class zzz
static void abc(int i)

{
public void abc(string p)
Compiler error
a.cs(6,14): error CS0111: Class 'zzz' already defines a member called 'abc' with the same
parameter types
We have 2 abc's, that accept an int and differ only in the addition of a modifier static. They have
the same signature as modifiers like static are not considered as part of the function signature.
Also, in the next program, we have two abc's with different access modifiers which differ in the
parameters, hence signature/name changes causing an error.
a.cs
class zzz
void abc(int i)
void abc( out int i)
i = 10;
}
void abc( ref int i)
Compiler Error
Microsoft (R) Visual C# Compiler Version 7.00.9254 [CLR version v1.0.2914]
Copyright (C) Microsoft Corp 2000-2001. All rights reserved.
a.cs(10,6): error CS0663: 'abc' cannot define overloaded methods which differ only on ref and
out
a.cs(6,6): (Location of symbol related to previous error)
The signature consists of not only the parameter data types, but also the kind of parameters i.e.
out ref etc. As function abc takes an int with different modifiers i.e. out etc, the signature on each
is different. The signature of a method consists of its name and number and types of its formal
parameters. The return type of a function is not part of the signature. No two functions can have
the same signature and also non-members cannot have the same name as members.
A function/method can be called by four different types of parameters. These are pass by value,
reference, output and finally parameter arrays. The parameter modifier is not part of the function
signature. Lets now understand what parameter arrays are all about.
Params Parameter
A method declaration creates a separate declaration space. This means that anything created in a
method is lost at the end of the method.
a.cs
public class zzz

{
public void abc(int i,string i) {}
public void pqr(int i)
string i;
Compiler Error
a.cs(3,23): error CS0100: The parameter name 'i' is a duplicate
a.cs(6,8): error CS0136: A local variable named 'i' cannot be declared in this scope because it
would give a different meaning to 'i', which is already used in a 'parent or current' scope to
denote something else
Parameter names have to be unique. Also, we cannot have a parameter and a variable created in a
function block with the same name.
In pass by value, the value of the variable is passed. In the case of ref and out, the address of the
reference is passed.
a.cs
public class zzz
string s = "hi";
{
zzz z = new zzz();
z.pqr();
void pqr()
abc(ref s,ref s);
void abc(ref string a, ref string b) {
a="no";
b = "yes";
s = "maybe";
Output
hi
no
yes
maybe
You are allowed to pass the same ref parameter as many times as you desire. In the function abc
the string s has a value of hi. Then by changing the string b to no, we are actually changing the
string s to no as s is passed by reference. Variables a and s refer to the same string in memory.
Changing one changes the other. Again changing b also changes s as they refer to the same
string. Thus variables a, b and s refer to the same string in memory.
a.cs
public class zzz
zzz z = new zzz();
z.pqr();
void pqr()
abc(2,"hi","bye","no");
abc(20,"hi");
abc(2);
void abc(int i , params string [] b)
foreach ( string s in b)
System.Console.WriteLine(s + " " + i);
Output
hi 2
bye 2
no 2
hi 20
We will encounter a situation where we would like to pass a variable number of arguments to a
function. This is not possible as of now as C# is extremely finicky about the number and type of
data we pass to a function. If we pass a string where an int is expected, C# starts screaming like a
baby. If we want to pass a variable number of arguments to a function, we have to use a keyword
params. This keyword can only be applied to the last parameter. Therefore the variable number
of arguments can only come at the end. In the case of function abc, the first parameter has to be
an int, the rest of them can be from zero to an infinite number of strings.
a.cs
public class zzz
void abc(int i , params string [] b , int j)
Compiler Error
a.cs(6,18): error CS0231: A params or __arglist parameter must be the last parameter in a formal
parameter list
The params keyword in this version has to be at the end only as stated above.
a.cs
public class zzz

{
zzz z = new zzz();
z.pqr();
void pqr()
abc(2,3,4);
abc(20,1);
abc(2);
void abc(int i , params int [] b)
foreach ( int s in b)
System.Console.WriteLine(s + " " + i); } }
Output
32
42
1 20
C# is smart enough if the penultimate parameter and the params have the same data type. The
first int is stored in the variable i, the rest are made part of the array b.
a.cs
public class zzz

{
void abc(int i , params string [][] b)
void abc(int i , params string [,] b)
Compiler Error
a.cs(6,6): error CS0225: The params parameter must be a single dimensional array
The data type of the params parameter must be, as the error message states, a single dimensional
array. Thus [][] is allowed but not [,]. You are also not allowed to combine the params keyword
with ref or out.
a.cs
public class zzz
zzz z = new zzz();
z.pqr();
void pqr()
string [] s = {"hi","bye","no"};
abc(2,s);
foreach ( string s in b)
System.Console.WriteLine(s + " " + i);
Output
hi 2
bye 2
no 2
You are allowed to pass an array of strings instead of individual strings as parameters. Here s is
an array of strings which has been initialized using the short form. Internally when we call the
function abc, C# converts the array of strings into individual strings.
a.cs
public class zzz
zzz z = new zzz();
z.pqr();
void pqr()
{
string [] s1 = {"hi","bye"};
abc(2,s1,"hell");
Compiler Error
a.cs(11,1): error CS1502: The best overloaded method match for 'zzz.abc(int, params string[])'
has some invalid arguments
a.cs(11,7): error CS1503: Argument '2': cannot convert from 'string[]' to 'string'
Mixing and matching is not allowed in C#. What we assumed C# would do is to add the last
string hell to the array of strings s1 or convert s1 to individual strings and then add the string hell
to it. Perfectly logical we thought. Only if wishes were horses…
Internally before calling the function abc, it collects all the individual parameters and converts it
into one big array for the params statement.
a.cs
public class zzz
zzz z = new zzz();
z.pqr();
}
void pqr()
int [] a = {1,2,3};
abc(2,a);
b[1] = 100;
Output
100
The output produced is proof of concept. The array member a[1] has an initial value of 2 and in
the function abc we change it to 100. The original changes, this means that the array is given to
the function abc.
a.cs
public class zzz
zzz z = new zzz();
z.pqr();
}
void pqr()
int a = 10;
abc(2,100,a,20);
System.Console.WriteLine(a);
b[1] = 100;
Output
10
In this case C# creates an array containing 100 10 and 20. We are changing the second member
to 100 which has nothing to do with the variable a. As abc has no knowledge of a, how on earth
can abc change the value of the int a? Thus it stays the same.
a.cs
public class zzz
zzz z = new zzz();
z.pqr();
}
void pqr()
abc(2);
abc(2,3);
abc(2,3,5,6);
void abc(int i, int j)
System.Console.WriteLine("two ints "+ i + " " + j);
void abc(params int [] a)
System.Console.WriteLine("params a");
Output
params a
two ints 2 3
params a
Here we are discussing function overloading. C# is extremely bright though partial. It does not
like the params statement and treats it like a stepchild. When we call abc with one int, C# can
only call the abc that takes a params as a parameter as it matches one int. An array can contain
one member. The fun starts with the abc that is being called with two ints. Here we have a
dilemma. C# can call the params abc or the abc with two ints. As mentioned earlier, C# treats the
params as a second class citizen and therefore chooses the abc with two ints. When there are
more than two ints like in the third invocation, C# has no choice but to grudgingly choose the
abc with the params. C# chooses the params as a last resort before flagging an error.
a.cs
using System;
class zzz
static void ff(params object[] b) {
foreach (object o in b) {
Console.Write(o.GetType().FullName + " ");
Console.WriteLine();
static void Main() {
object[] a = {1, "Hello", 123.456};
object o = a;
ff(a);
ff((object)a);
ff(o);
ff((object[])o);
Output
System.Int32 System.String System.Double
System.Object[]
System.Object[]
System.Int32 System.String System.Double
In the first case we are passing the function ff an array of object that looks like object. We will
tell you a little later that all classes are derived from object. The function ff receives an array of
objects b. In the foreach we know that the object class has a function GetType that returns an
object that looks like Type, which in turn has a function called FullName which returns the name
of the type. We see three different types displayed. In the second invocation of ff we are casting a
to an object. There is no conversion available from converting an object to an object array i.e.
object []. Therefore a one element object [] is created. It's the same case in the third invocation
and the last explicitly casts to an object array.
a.cs
using System;
class zzz
static void ff(params object[] b) {
Console.WriteLine(b.GetType().FullName);
Console.WriteLine(b.Length);
Console.WriteLine(b[0]);
static void Main() {
object[] a = {1, "Hello", 123.456};
ff((object)a);
Output
System.Object[]
System.Object[]
Inheritance
a.cs
class zzz
xxx a = new xxx();
a.abc();
class yyy
public int i = 10;
public void abc()
System.Console.WriteLine("yyy abc");
public void pqr()
System.Console.WriteLine("yyy pqr");
class xxx
{
Compiler Error
a.cs(6,1): error CS0117: 'xxx' does not contain a definition for 'abc'
The class yyy contains 2 functions and one instance variable. The class xxx contains no code and
no variables at all. An empty class does not denote any error as we are able to instantiate an
object that looks like xxx. The error comes about because the class xxx has no function called
abc. However the class yyy has a function abc. Would it not be great if we were allowed to use
all the code in the class yyy from xxx. Easier said than done, we guess!
a.cs
class zzz
xxx a = new xxx();
a.abc();
class yyy
public int i = 10;
public void abc()
}
public void pqr()
class xxx : yyy
Output
yyy abc
The error disappears and the abc in yyy gets executed. If after the name of the class you write :
yyy i.e. the name of another class, a lot happens at once. xxx is now said to have been derived
from yyy. What that means is all the code we wrote in yyy can now be used in xxx. It is if we
actually wrote all the code that is contained in yyy in xxx. If we had created an object that looks
like yyy, everything that the object could do, now an object that looks like xxx can also do. But
we have not written a line of code in xxx. We are made to believe that xxx has one variable i and
two functions abc and pqr as yyy contains these two functions. Here we are teaching you the
concepts of inheritance where yyy will now be called the base class, xxx the derived class.
a.cs
class zzz
xxx a = new xxx();
a.abc();
}
class yyy
public int i = 10;
public void abc()
public void pqr()
class xxx : yyy
public void abc()
System.Console.WriteLine("xxx abc");
Compiler Warning
a.cs(23,13): warning CS0108: The keyword new is required on 'xxx.abc()' because it hides
inherited member 'yyy.abc()'
Output
xxx abc
Nothing in the world stops class xxx from creating a function abc i.e. one with the same name as
in the base class . C# simply gives us a warning. When we run a.abc(), C# first checks whether
the class xxx (as a looks like xxx) has a function called abc. If it does not, then it will check in
the base class. Earlier abc was only available in the base class and hence got executed. Here as it
is already there in xxx, it gets called from xxx and not yyy. Remember the derived classes get a
first shot at execution, then the base class. The reason being, the base class may have a number
of functions and for various reasons you may not be satisfied with what they do. You should have
the right to have your copy of the function to be called. In other words the derived classes
functions override the ones in the base class.
a.cs
class zzz
xxx a = new xxx();
a.abc();
class yyy
public int i = 10;
public void abc()
public void pqr()
{
class xxx : yyy
public void abc()
base.abc();
Output
xxx abc
yyy abc
What if you want the best of both worlds? You may want to call the base classes abc first and
then yours or vice versa. To accomplish this, C# gives you a reserved word, something free
called base. The word base can be used in any derived class. It means call the function off the
base class. Simple. Thus base.abc will call the function abc from yyy the base class of xxx.
a.cs
class zzz
xxx a = new xxx();
a.abc();
}
class yyy
public int i = 10;
public void abc()
public void pqr()
class xxx : yyy
public void abc()
base.pqr();
Output
xxx abc
yyy pqr
There is only one small change made to the program and that is base.abc is replaced by base.pqr.
In this case the function pqr from the class yyy gets called. Base is very general purpose. It lets
you access members of the base class from the derived class. You cannot use base in yyy as yyy
is not derived from any class. Thus base can only be used in derived classes.
a.cs
class zzz
yyy a = new yyy();
a.xyz();
class yyy
public void abc()
class xxx : yyy
public void xyz()

{
Compiler Error
a.cs(6,1): error CS0117: 'yyy' does not contain a definition for 'xyz'
In this case, xxx is derived from yyy and not vice versa. Thus xxx can use all the members of
yyy. Inheritance does not work backwards. Whatever members xxx comprises do not permeate
upwards to yyy. Class xxx may now have a function xyz but it cannot give it to class yyy and
thus an error occurs.
A class inherits everything from its base class except the constructors and destructors. If a class c
is derived from class b, which in turn has been derived from class a, class c inherits all the
members declared in class b and also class a. This concept is called transitive. A derived class
can inherit all the members of the base class but cannot subtract or remove members off that base
class. A derived class can hide members of the base class by creating functions by the same
name. The original member in the base class remains unchanged and unaffected by whatever is
happening in the derived class. It remains unchanged in the base class, it is simply not visible in
the derived class.
A class member can either be a static member belonging to the class or an instance member
belonging to the instance i.e. accessible through the object and not the class. The default is non-
static.
A class is also called a data structure. It consists of data members like constants, fields and
events and function members like methods, properties, indexers, operators, constructors, static
constructors and destructors. A class within a class is called a nested class. Thus we can place 11
different types of entities in a class. Function members are the only members of a class that
contain executable code. A class creation creates a new declaration space.
All classes derive from object . Object is the mother of all classes.
a.cs
public class zzz : object
{
}
If you do not derive from any class, then the C# compiler automatically adds :object to your class
definition. Object, the only class to have this feature is not derived from any class. It is the
ultimate base class of all classes in the C# hierarchy.
class aa
class bb : aa
Class aa is the base class of bb . The documentation however calls aa the direct base class of bb.
Thus the base classes of bb are aa and object.
a.cs
public class zzz
class aa : System.Delegate
class bb : System.Enum
{
}
class cc : System.Array
class dd : System.ValueType
Compiler Error
a.cs(7,7): error CS0644: 'aa' cannot inherit from special class 'System.Delegate'
a.cs(10,7): error CS0644: 'bb' cannot inherit from special class 'System.Enum'
a.cs(13,7): error CS0644: 'cc' cannot inherit from special class 'System.Array'
a.cs(16,7): error CS0644: 'dd' cannot inherit from special class 'System.ValueType'
You cannot derive a class from the above 4 classes as they are special.
a.cs
public class zzz
class aa
}
class bb
class cc : aa, bb
Compiler Error
a.cs(9,16): error CS0527: 'bb' : type in interface list is not an interface
A class can only be derived from one more class . You are not permitted to derive from two or
more classes i.e. multiple inheritance is not supported. Thus every class has one and only one
base class.
a.cs
public class zzz
class aa : bb
class bb : cc
}
class cc : aa
Compiler Error
a.cs(13,7): error CS0146: Circular base class definition between 'cc' and 'aa'
class aa is derived from bb. Class bb in turn is derived from cc and cc is derived from aa. This
results in a circular definition. class aa is derived from bb and cc, as bb is derived from cc. As cc
is also derived from aa class, bb also derives from this class which is aa. Thus aa is derived from
aa which is a logical impossibility.
Equating Objects
a.cs
class zzz
yyy a = new yyy();
xxx b = new xxx();
a = b;
b = a;
class yyy
public int i=10;
}
class xxx {
public int j=10;
Compiler Error
a.cs(7,5): error CS0029: Cannot implicitly convert type 'xxx' to 'yyy'
a.cs(8,5): error CS0029: Cannot implicitly convert type 'yyy' to 'xxx'
C# has a very simple rule. It does not like you to equate different objects to each other. Thus an
object that looks like yyy cannot be equated to one that looks like xxx and vice versa. Thus the
error. Another example - you cannot take an int and equate it to a string . C# is extremely strict
when it comes to dealing with different data types.
a.cs
class zzz
yyy a = new yyy();
xxx b = new xxx();
a = b;
b = a;
class yyy
public int i=10;
}
class xxx : yyy
public int j=10;
Compiler Error
a.cs(8,5): error CS0029: Cannot implicitly convert type 'yyy' to 'xxx'
There is however one way out. On account of this way, one of the errors disappeared. The only
time we are allowed to equate dissimilar data types is when we derive from them. Lets explain
this in detail.
When we create an instance of yyy by saying new, we are creating two objects at one go, one
that looks like yyy and the other that looks like object. All classes in C# are finally derived from
object. As xxx is derived from yyy, when we say new xxx, we are creating 3 objects, one that
looks like yyy, one that looks like xxx and finally object.
Thus when we write a = b, b looks like xxx, yyy and object and as a looks like yyy, there is a
match at yyy. Consequence? No error. Even though a and b have the same values, using a we can
only access the members of yyy, even though had we used b we could access xxx also. We have
devalued the potency of a . The error arises at b = a, because the class yyy is less/smaller than the
class xxx . The class xxx has yyy and more. We cannot have a larger class on the right and a
smaller class on the left. a only represents a yyy whereas b expects a xxx which is a xxx and yyy.
The basic rule is that we can only equate dissimilar objects if they are derived from each other.
You can equate an object of a base class to a derived class but not vice versa.
a.cs
class zzz
yyy a = new yyy();
xxx b = new xxx();
a = b;
b = (xxx) a;
class yyy
public int i=10;
class xxx : yyy
public int j=10;
Though we broke a C# rule on equating objects, we did not get an error because of the cast . A ()
is called a cast. Within the brackets we put the name of a class. A cast is the great leveler. When
we write b = a, C# expects the right hand side of the equal to to be a b i.e. a xxx . Instead it finds
a i.e. a yyy . So by applying a cast, we are for the moment converting the yyy object into an xxx.
This strategy satisfies the rules of C# on only equating similar objects. Remember it is only for
the duration of the line that a becomes a xxx and not a yyy.
a.cs
class zzz
yyy a = new yyy();
xxx b = new xxx();
a = (yyy) b;
b = (xxx) a;
}
class yyy
public int i=10;
class xxx
public int j=10;
Compiler Error
a.cs(7,6): error CS0030: Cannot convert type 'xxx' to 'yyy'
a.cs(8,6): error CS0030: Cannot convert type 'yyy' to 'xxx'
Unfortunately casting works only if one of the two classes is derived from the other. You cannot
cast any two objects to each other.
a.cs
class zzz
int i = 10;
char j = 'A';
i = j;
j = i;
}
Compiler Error
a.cs(8,5): error CS0029: Cannot implicitly convert type 'int' to 'char'
We are allowed to convert a char into a int as i = j but not the other way round as j = i.
8
Modifiers
Access Modifiers
Public, Private, Protected and Internal
Whenever a class is created by us we want to have the ability to decide who can access certain
members of the class. In other words, we would like to restrict access to the members of the
class. The basic rule is that members of a class can freely access each other. There is no way one
can prevent a function of a particular class from executing another function in the same class. By
default though, the same class is allowed complete access but no one else is granted access to the
members of the class. The default access modifier is private.
a.cs
class zzz
yyy.pqr();
class yyy
static void abc()
{
System.Console.WriteLine(“yyy abc”);
System.Console.WriteLine(“yyy pqr”);
abc();
Output
yyy pqr
yyy abc
Pqr is public and hence anyone is allowed to execute it. abc has no access modifier which makes
it private, which is anyway the default. The private modifier has no effect on members of the
same class and hence pqr is allowed to call abc. This concept is called member access.
a.cs
class zzz
yyy.abc();
class yyy
{
static void abc()
abc(); } }
Compiler Error
a.cs(5,1): error CS0122: ‘yyy.abc()’ is inaccessible due to its protection level
abc is private an no one but members of yyy can access it.
a.cs
class zzz
yyy.abc();
class yyy
protected static void abc()
{
abc();
}}
Compiler Error
We have now introduced one more access modifier, protected, which also does not let you access
a class from outside. However pqr is allowed to access abc as access modifiers do not effect the
same class as mentioned earlier.
a.cs
class zzz
xxx.aaa();
class yyy
static void abc()
{
protected static void xyz()
System.Console.WriteLine(“yyy xyz”);
class xxx : yyy
public static void aaa()
abc();
pqr();
xyz();
Compiler Error
We are now dealing with derived classes. When we flag a function with the modifier, protected,
we are informing C# that only derived classes can access the function. Nobody else can. Thus in
function aaa we can call xyz as it is flagged protected, but it cannot be called from anywhere else
including Main. The function abc is private and can be called only from the class yyy. Comment
out abc(); in aaa and csc will show you no errors.
To sum up, we have learnt three concepts. Private means only the same class has access, public
means everyone has access and protected lies in between where only derived classes have access.
All functions for example reside in a class. The accessibility of that function is decided by the
class in which it resides as well as the modifiers on the function. If we are allowed access to a
member, we say that the member is accessible, else inaccessible.
b.cs
internal class yyy
csc /t:library b.cs
This command will produce a library b.dll with one class yyy.
a.cs
class zzz
yyy a;
>csc a.cs /r:b.dll
Compiler Error
a.cs(5,1): error CS0122: ‘yyy’ is inaccessible due to its protection level

We get the above error as the modifier internal means that we can only access yyy from b.dll and
not from any other file or program. Never create a component and flag the class internal as no
one would be able to use it. Internal means access limited to this program only.
Also writing csc a.cs b.cs would not give us any error.
a.cs
public namespace vijay
class zzz
Compiler Error
a.cs(1,8): error CS1518: Expected class, delegate, enum, interface, or struct
Namespaces by default can have no accessibility modifiers at all. They are public by default and
we cannot add any other access modifier including public again.
a.cs
private class zzz
Compiler Error
a.cs(1,1): error CS1527: Namespace elements cannot be explicitly declared as private or

protected
A class can only be public or internal. It cannot be marked as protected or private. The default is
internal.
b.cs
class yyy
csc b.cs /t:library
Compiler Error
fatal error CS2022: Options ‘/out’ and ‘/target’ must appear before source file names
Mistake, done on purpose. At times we will forget to tell you that some compiler options like /t
and /out must appear before the names of the source files.
>csc /t:library b.cs
a.cs
class zzz
yyy a;
>csc a.cs /r:b.dll
Compiler Error
a.cs(5,1): error CS0122: ‘yyy’ is inaccessible due to its protection level
Thus if we want other programs/files to access classes created by us, we must not forget that by
default they are marked as internal as explained earlier.
Members of a class can have all the modifiers described above and default to private.
a.cs
class zzz
public private void abc()
Compiler Error
a.cs(6,8): error CS0107: More than one protection modifier
You are not allowed more than one access modifier most of the time. The exceptions, we will
soon take care off. Predefined types like int, object have no accessibility restrictions. They can be
used anywhere and everywhere.
b.cs
class yyy
public void abc()
csc /t:library b.cs

a.cs
class zzz
yyy a = new yyy();
a.abc();
Compiler Error
a.cs(5,1): error CS0122: 'yyy' is inaccessible due to its protection level
a.cs(6,1): error CS0246: The type or namespace name 'a' could not be found (are you missing a
As the class yyy has not been specified by an access modifier, it is by default internal. Even
though abc is public, the type enclosing it i.e. yyy is internal and hence no member of yyy can be
accessed from outside b.cs. Thus the access modifiers of the class and the members is important.
b.cs
public class yyy
void abc()
>csc /t:library b.cs
a.cs
class zzz
yyy a = new yyy();
a.abc();
Compiler Error
Here yyy is accessible as the modifier is public but the function abc is private and hence cannot
be accessed by anyone but the class.
From now on we will only display a.cs and b.cs as the command line executions of the compiler
will remain the same. a.cs remains the same for this program.
b.cs
public class yyy
internal void abc()
Compiler Error
Internal means no one from outside the dll can access the function.
a.cs
class zzz
ppp a = new ppp();
a.aaa();
b.cs
public class yyy
protected internal void abc()
public class xxx : yyy
void pqr()
abc();
public class ppp

{
public void aaa()
yyy a = new yyy();
a.abc();
No error occurs as protected internal means two things. It is either derived classes or classes in
the same file that can access abc. Therefore derived class xxx can use it as well as class ppp.
What we are trying to get at here is that the containing type decides first the accessibility and
then the member modifiers also comes in. Making the class internal and then the members public
will in no way allow classes in others files access it.
a.cs
class zzz
class yyy
protected int x;
void abc( yyy a , xxx b)
a.x = 1;
b.x = 2;
class xxx : yyy
void pqr( yyy a , xxx b)
a.x = 1;
b.x = 2;
}}
Compiler Error
a.cs(20,1): error CS1540: Cannot access protected member ‘yyy.x’ via a qualifier of type ‘yyy’;
the qualifier must be of type ‘xxx’ (or derived from it)
Class yyy contains a protected member x. To the same class no modifiers make sense. However
as x is protected, in the derived class function pqr, we cannot access it through yyy as a.x gives
us an error. However b which looks like xxx does not give an error. To check this out, comment
out the line a.x=1 in pqr(). This means that we can access the protected members not from an
object of the base class, but from the derived class objects only. This is in spite of the fact that x
is a member of yyy, the base class. Even so, we still cannot access it. Also we cannot access x
from the function Main.
a.cs
class zzz
}
class yyy
public class xxx : yyy
Compiler Error
a.cs(10,14): error CS0060: Inconsistent accessibility: base class ‘yyy’ is less accessible than class
‘xxx’
Between internal and public, public allows greater access to its members. The class yyy is by
default internal and xxx which derives from yyy is explicitly made public. We get an error as the
derived class yyy has to have an access modifier which allows greater access than the base class
access modifier. Here internal is more restrictive than public.
a.cs
class zzz
public class yyy
class xxx : yyy
{
}
If we reverse the modifiers, i.e. we make yyy public and xxx the derived class internal we get no
error. The base class allows more accessibility than the derived class.
a.cs
class zzz
class yyy
public class xxx
public yyy f()
return new yyy();
Compiler Error
a.cs(12,12): error CS0050: Inconsistent accessibility: return type ‘yyy’ is less accessible than
method ‘xxx.f()’
The accessibility of yyy is internal which is more restrictive than public. The accessibility of
function f is public which is more than that of the type yyy. The error occurred as return values
must have greater accessibility than that of the method, which is not true in this case.
a.cs
class zzz
class yyy
public class xxx
public yyy a;
Compiler Error
a.cs(12,12): error CS0052: Inconsistent accessibility: field type ‘yyy’ is less accessible than field
‘xxx.a’
Rules are rules – they remain the same everywhere. The class yyy or data type yyy is internal. a,
an object/field is public which makes it more accessible than yyy which is internal. Hence the
error.
a.cs
class zzz
{
class yyy
public class xxx
yyy a;
Now we get no error as a has been made private which gives it a lower accessibility than yyy
which is internal. Logic is that whatever you create must be more accessible than what you
create from.
Sealed Classes
Sealed is another modifier that applies to classes. aaa is a sealed class. No class can derive from
aaa. In another words aaa cannot act as a base class for any class.
a.cs
public class zzz
sealed class aaa

{
class bbb : aaa
Compiler Error
a.cs(10,7): error CS0509: ‘bbb’ : cannot inherit from sealed class ‘aaa’
a.cs
public class zzz
aaa a = new aaa();
System.Console.WriteLine(a.i);
a.abc();
sealed class aaa
public int i = 9;
public void abc()
System.Console.WriteLine(“hi”);
}
Output
hi
The only difference between a sealed class and a non-sealed class is that a sealed class cannot be
derived from. Otherwise there is no difference at all. It can contain the same variables, functions
etc as a normal class does . A sealed class lets us create classes which no one can derive from.
Thus the code in such classes cannot be overridden. Also as the compiler knows this, certain run
time optimizations can be performed on a sealed class
Constants
a.cs
public class zzz
const int i = 10;
public static void Main() {
Output
10
A constant or const variable behaves as a variable. We give it an initial value and can use it
wherever we can use a variable.
a.cs
public class zzz
{
const int i = 10;
i++;
i = 30;
Compiler Error
a.cs(6,1): error CS0131: The left-hand side of an assignment must be a variable, property or
indexer
a.cs(8,1): error CS0131: The left-hand side of an assignment must be a variable, property or
indexer
Unlike a variable, we are not allowed to change the value of a const. The change is an
assignment statement.
a.cs
public class zzz
const int i ;
i = 30;
}
Compiler Error
a.cs(3,13): error CS0145: A const field requires a value to be provided
We have to initialize the const variable at the time of creation. We are not allowed to initialize it
later in our program.
a.cs
public class zzz
const int i = j + 4;
const int j = k - 1;
const int k = 3;
System.Console.WriteLine(“{0} {1} {2}”,i,j,k);
Output
623
A constant can depend upon another constant. C# is smart enough to realize that to calculate the
value of const i, it first needs to know the value of j. j’s value depends upon another const k,
whose value is 3. Thus C# first evaluates k to 3 then j becomes 2 i.e. k -1 and finally i takes on
the value of j i.e. 2 + 4 resulting in 6.
Like classes const’s cannot be circular i.e., they cannot depend upon each other.
a.cs
public class zzz
{
const int i = j + 4;
const int j = k - 1;
const int k = i;
System.Console.WriteLine(“{0} {1} {2}”,i,j,k);
Compiler Error
a.cs(3,11): error CS0110: The evaluation of the constant value for ‘zzz.i’ involves a circular
definition
The value of the const i depends upon j which in turn depends upon k, which is equal to i. This
becomes a circular definition. A const is a variable whose value cannot be changed but whose
initial value is compile time determined.
a.cs
public class zzz
public const aa a = new aa();
public class aa
}
Compiler Error
a.cs(3,17): error CS0133: The expression being assigned to ‘zzz.a’ must be constant
a.cs
public class zzz
public const aa a = null;
public class aa
The error vanishes as we are now initializing a to an object which has a value that can be
determined at compile time. We cannot ever change the value of a, so it will always be null.
Normally we do not have consts as a reference type as they have value only at runtime.
As mentioned earlier we can only initialize a const to a compile time value i.e. a value available
to the compiler while it is executing. new unfortunately gets executed at runtime and therefore
has no value at compile time. This gives us an error.
a.cs
class zzz
yyy y = new yyy();

System.Console.WriteLine(y.i);
class yyy {
public const int i = 3;
Compiler Error
a.cs(6,26): error CS0176: Static member 'yyy.i' cannot be accessed with an instance reference;
qualify it with a type name instead
A constant is static by default and we cannot use the instance reference i.e. a name to reference a
const. A const has to be static as no one is allowed to make any changes to a const.
a.cs
class zzz
class yyy
public static const int i = 3;
Compiler Error
a.cs(9,25): error CS0504: The constant ‘yyy.i’ cannot be marked static

C# does not want us to repeat the obvious over and over again. Just like humans, programming
language too have their own quirks. Some other time, perhaps, C# may permit us to write a static
before an entity that is already static by default.
a.cs
class zzz
System.Console.WriteLine(yyy.i + “ “ + xxx.i);
class yyy
public const int i = 3;
class xxx : yyy
public const int i = 30; }
Compiler Warning
a.cs(14,18): warning CS0108: The keyword new is required on ‘xxx.i’ because it hides inherited
member ‘yyy.i’
Output
3 30
We can create a const with the same name as another const in the base class. The const of the
class xxx i will hide the const i in class yyy for the class xxx only.
Fields
A field to start with is another word for a variable in a class. There are a large number of generic
rules that apply to all members of a class and we will not tire you by repeating them ad nauseam.
A variable can never have an uninitialized value in C#.
a.cs
public class zzz
static int i;
static bool j;
System.Console.WriteLine(zzz.i + “ “ + zzz.j );
}}
Output
0 False
Static variables are initialized when the class is loaded first. An int is given an initial value of
zero and a bool False.
a.cs
public class zzz
int i;
bool j;
{
zzz a = new zzz();
System.Console.WriteLine(a.i + “ “ + a.j );
}}
Output
0 False
An instance variable is initialized at the time of creation. The keyword new will create an
instance of the zzz. It will allocate memory for each of the non static variables and then initialize
each of them to their default values.
a.cs
public class zzz
static int i = j + 10;
static int j = i + 1;
System.Console.WriteLine(zzz.i + “ “ + zzz.j );
Output
10 11
Outputs make a lot of sense if you understand them in plain simple English. C# always initializes
static fields to their initial value after creating them . Variables i and j are thus given a default of
zero. Then C# realizes that these variables need to be assigned some values. It does not read all
the lines, only one at a time. It will now read the first line and as the variable j has a value of 0, i
will get a value of 10. Then at the next line, j is the value of i plus 1. The variable i has a value of
10 and j now becomes 11. As it does not see both lines at the same time, it does not notice the
circularity of the above definition. In short, though the above example works, it is frowned upon
by the powers to be at C#.
a.cs
public class zzz
int i = j + 10;
int j = i + 1;
Compiler Error
a.cs(3,9): error CS0236: A field initializer cannot reference the nonstatic field, method, or
property ‘zzz.j’
a.cs(4,9): error CS0236: A field initializer cannot reference the nonstatic field, method, or
property ‘zzz.i’
It does not work for instance variables as the rules of an instance variable are different than that
of static. The field initializer of an instance variable has to be determined at the time of creation
of the object. The variable j does not have a value at this point in time. It cannot refer to variables
of the same instance at the time of creation. Thus we can refer to no instance members to
initialize an instance member. Textual order means first come first served.
Readonly Fields
Fields can be also tagged with the modifier readonly.
a.cs
public class zzz
public static readonly int i = 10;

{
Output
10
No errors at all. However, remember if we use a non static variable in a static function we will
get an error.
a.cs
public class zzz
public static readonly int i = 10;
i = 20;
Compiler Error
a.cs(6,1): error CS0198: A static readonly field cannot be assigned to (except in a static
constructor or a variable initializer)
You cannot change the value of a readonly field after its being given an initial value.
a.cs
public class zzz {

public static readonly int i ;
Unlike a const, a readonly field does not have to be initialized at the time of creation.
a.cs
public class zzz
public static readonly int i ;
static zzz()
i = 20;
System.Console.WriteLine(“In Const”);
Output
In Const
20
A static readonly field can be initialized in a static constructor also. This is the major difference
between a const and a readonly field.
a.cs
public class zzz
public readonly aa a = new aa();
public class aa
The same example which gave an error with const does not give an error with readonly. To sum
up a readonly is a more generic const and it makes our programs more readable as we refer to a
name and not a number. Is 100 more intuitive or priceofcopper easier to understand? The
compiler would for reasons of efficiency convert all const’s and readonly variables to the actual
values.
a.cs
public class zzz
public class aa
{
public int readonly i = 10;
Compiler Error
a.cs(9,12): error CS1585: Member modifier ‘readonly’ must precede the member type and name
a.cs(9,23): error CS1519: Invalid token ‘=’ in class, struct, or interface member declaration
Wherever you can place multiple modifiers, remind yourself that there are rules that decide the
order of modifiers, which comes first. Here the readonly modifier precedes the data type int.
Once again, no great cosmic law responsible, just a rule that must be remembered.
a.cs
public class zzz
public class aa {
public readonly int i = 10;
void abc(ref int z)
void pqr()
abc(ref i);
}
}
Compiler Error
a.cs(13,9): error CS0192: A readonly field cannot be passed ref or out (except in a constructor)
A readonly field cannot be changed by anyone except a constructor. The function abc expects a
ref parameter which if you have forgotten allows you to change the value of the original. Thus
C# does not permit a readonly as a parameter to a function that accepts a ref or a out parameters.
9
Virtual Functions - new and
override
Every breath you take,
And every move you make
Every bond you break, every step you take
I’ll be watching you
-Every Breath You Take,Sting
New and Override Methods
a.cs
class zzz
yyy a = new yyy();
xxx b = new xxx();
yyy c = new xxx();
a.abc();a.pqr();a.xyz();
b.abc();b.pqr();b.xyz();
c.abc();c.pqr();c.xyz();
class yyy
public void abc()
public void pqr()
public void xyz()
class xxx : yyy
public void abc()
{
System.Console.WriteLine(“xxx abc”);
public void pqr()
System.Console.WriteLine(“xxx pqr”);
public void xyz()
System.Console.WriteLine(“xxx xyz”);
Compiler Warning
a.cs(30,13): warning CS0108: The keyword new is required on 'xxx.abc()' because it hides
inherited member 'yyy.abc()'
a.cs(34,13): warning CS0108: The keyword new is required on 'xxx.pqr()' because it hides
inherited member 'yyy.pqr()'
a.cs(38,13): warning CS0108: The keyword new is required on 'xxx.xyz()' because it hides
inherited member 'yyy.xyz()'
Output
yyy abc
yyy pqr
yyy xyz
xxx abc
xxx pqr
xxx xyz
yyy abc
yyy pqr
yyy xyz
Class xxx derives from class yyy. That makes xxx the derived class and yyy the base class. The
class xxx comprises yyy and more. Thus can we not conclude, albeit in broken English that an
object that looks like xxx is bigger than one that looks like yyy. In C#, you can equate a smaller
object to a bigger object as stated earlier.
Lets take the case of object a. It looks like yyy and initialized by creating an object that also
looks like yyy. When we call the functions abc and pqr and xyz through the object a obviously it
will call them from yyy.
Object b looks like xxx, the derived class. It is initialized to an object that looks like xxx. When
we call abc, pqr and xyz through b, it calls abc, pqr and xyz from xxx.
Object c again looks like yyy but it is now initialized to an object that looks like xxx which does
not give an error as explained earlier. However there is no change at all in the output and the
behavior is identical to that of object a. Hence initializing it to an object that looks like yyy or
xxx does not seem to matter.
a.cs
class zzz
yyy a = new yyy();
xxx b = new xxx();
yyy c = new xxx();
}
}
class yyy
public void abc()
public void pqr()
public void xyz()
class xxx : yyy
public override void abc()
public new void pqr()

{
public void xyz()
Compiler Error
a.cs(30,22): error CS0506: ‘xxx.abc()’ : cannot override inherited member ‘yyy.abc()’ because it
is not marked virtual, abstract, or override
We get an error because we have added two new modifiers, new and override to the functions.
The error says to add the modifier virtual to the functions in the base class.
a.cs
class zzz
yyy a = new yyy();
xxx b = new xxx();
yyy c = new xxx();
}
class yyy
public virtual void abc()
public virtual void pqr()
public virtual void xyz()
class xxx : yyy
}
public void xyz()
Output
yyy abc
yyy pqr
yyy xyz
xxx abc
xxx pqr
xxx xyz
xxx abc
yyy pqr
yyy xyz
There is a single subtle change in the workings of the objects c only and not a and b. Adding the
virtual modifier has made all the difference. The difference is in the object c. c looks like the
base class yyy but is initialized to an object that looks like the derived class xxx. C# remembers
this fact. When we execute c.abc(), C# remembers that object c was initialized by a xxx object
and hence it first goes to class xxx. Here the function has a modifier override which in English
means, forget about the data type of c which is yyy, call abc from xxx as it overrides the abc of
the base class. The override modifier is needed as the derived class functions will get first
priority and be called. We mean to override the abc of the base class. We are telling C# that this
abc is similar to the abc of the base class.
New has the exactly the opposite meaning. The function pqr has the new modifier. C.pqr() calls
pqr from yyy and not xxx. New means that the function pqr is a new function and it has
absolutely nothing to do with the pqr in the base class. It may have the same name pqr as in the
base class, but that is only a coincidence. As c looks like yyy, the pqr of yyy gets called even
though there is a pqr in xxx. When we do not write any modifier, then it is assumed that we
wrote new. Thus every time we write a function, C# assumes it has nothing to do with the base
class. These modifiers can only be used if the function in the base class is a virtual function. To
us virtual means that the base class is granting us permission to call the function from the derived
class and not the base class. We have however one caveat, we have to add the modifier override
if our derived class function has to be called.
a.cs
class zzz
yyy a = new xxx();
yyy b = new vvv();
xxx c = new vvv();
class yyy
public void abc()

{
class xxx : yyy
public override void xyz()

{
class vvv : xxx
System.Console.WriteLine(“vvv abc”);
public void xyz()
System.Console.WriteLine(“vvv xyz”);
Output
yyy abc
yyy pqr
xxx xyz
yyy abc
yyy pqr
xxx xyz
vvv abc
xxx pqr
xxx xyz
Pretty long example. To reiterate, we are allowed to initialize a base object to a derived object.
The other way around will generate an error. This leads to an object of a base class being
initialized to an object of the derived class. The question that now springs to mind is, which
function will get called. The one from the base class or the derived class. If the base class object
declared the function virtual and the derived class used the modifier override, the derived class
function will get called. Otherwise the base class function will get executed. Thus for virtual
functions, the data type created is decided at run time. All functions not tagged with virtual are
non virtual, and the function to be called is decided at compile time, depending upon the static
data type of the object. If the object is initialized to the same data type, none of the above apply.
Whenever we have a mismatch, we need rules to resolve the mismatch. Thus we can land up
with a situation where an object to a base class can call a function in the derived class.
The object a looks like yyy but is initialized to the derived class xxx. a.abc(), first looks into the
class yyy. Here it checks whether the function abc is virtual. The answer is an emphatic no and
hence everything stops and the function abc gets called from class yyy. a.pqr does the same
thing, but the function now is virtual in class yyy. Thus C# looks at the class yyy, the one it was
initialized to. Here pqr is flagged with the modifier new. This means that pqr is a new function
which has nothing to do with the one in the base class. They only accidentally share the same
name. Thus as there is no function called pqr (as it is a new pqr) in the derived class, the one
from base class gets called. In the case of a.xyz(), the same steps are followed again, but in the
class yyy, we meet the modifier override, which overrides the function in the base class. We are
telling C# to call this function in class xxx and not the one in the base class yyy.
The object b which also looks like class yyy, is now initialized with an object that looks like vvv
and not xxx like before. As abc is non virtual it gets called from yyy. In the case of function pqr,
C# now looks into class vvv. Here it sees no function pqr and hence now looks into class xxx.
Thus the above rules repeat and it gets called from class yyy. In the case of b.xyz, in class vvv, it
is marked new by default and hence this function has nothing to do with the one in class yyy.
Hence the one from vvv does not get called but the one from class yyy where it specifies
override.
public override void xyz()
System.Console.WriteLine(“vvv xyz”);
If we change xyz in class vvv to the above, i.e. we change new to override, the xyz of vvv will
get called.
The last object c looks like xxx but is now initialized to an object that looks like the derived class
vvv. c.abc(), first looks into class xxx where it is marked as virtual. Remember abc is non virtual
in class yyy but virtual in xxx. From now on, the function abc is virtual in vvv also but not in
class yyy. Virtual is like water, it flows downwards not upwards. As abc is virtual, we now look
into class vvv. Here it is marked override and hence abc gets called from class vvv. In the case of
pqr, pqr is marked virtual in class yyy and new in xxx, but as there is no function pqr in vvv,
none of the modifiers matter at all. Thus it gets called from class xxx. Lastly for function xyz, in
class vvv it is marked new. Hence it has no connection with the xyz in class xxx and thus
function xyz gets called from xxx and not yyy.
a.cs
class zzz
class yyy
public virtual void pqr() {}
class xxx : yyy
public new void pqr() {}
class vvv : xxx
public override void pqr() { }

}
Compiler Error
a.cs(17,22): error CS0506: ‘vvv.pqr()’ : cannot override inherited member ‘xxx.pqr()’ because it
is not marked virtual, abstract, or override
We get an error as the function pqr in class xxx is marked new. This means that it hides the pqr of
class yyy. Form the viewpoint of class vvv, xxx does not supply a function called pqr. The pqr in
class xxx has nothing to do with the pqr in yyy. This means that the function pqr of xxx does not
inherit the virtual modifier from the function pqr of class yyy. This is what the compiler is
complaining about. As the function pqr in xxx has no virtual modifier, in vvv we cannot use the
modifier override. You can, however, use the modifier new and remove the warning.
a.cs
class zzz
yyy a = new vvv();
a.pqr();
xxx b = new vvv();
b.pqr();
class yyy
}
class xxx : yyy
public virtual new void pqr()
class vvv : xxx
public override void pqr()
System.Console.WriteLine(“vvv pqr”);
Output
yyy pqr
vvv pqr
and if we remove the override modifier from pqr in vvv we get
public void pqr()
}
Output
yyy pqr
xxx pqr
That’s the problem with virtual functions. We call them the cause of migraine. The answers are
always different from what you expect. Object a looks like a yyy but is initialized to the derived
class vvv. As pqr is virtual, C# now looks into class vvv. However before looking into the class,
it realizes that in class xxx, pqr is new. This cuts of all connection with the pqr in yyy. Thus the
word new is preceded with virtual, otherwise the override modifier would give us an error in
class vvv. As pqr in class xxx is new function, having nothing to do with the class yyy, class vvv
inherits a new which also has nothing to do with the class yyy. The pqr in class vvv is related to
the pqr of class xxx and not of class yyy. Thus the pqr of class yyy gets called.
In the second case object b looks like class xxx now but is initialized to an object of class vvv.
C# first looks at class xxx. Here pqr is new and virtual, which makes it a unique function pqr.
Unfortunately, the pqr in vvv has the override modifier which sees to it that the pqr of vvv hides
the pqr of xxx. This calls the pqr of vvv instead. If we remove the override modifier from pqr in
class vvv, the default is new, that cuts off the umbilical cord from the pqr of xxx. Thus, as it is, a
new function, the pqr of xxx gets called.
A virtual function cannot be marked by the modifiers static, abstract or override. A non virtual
function is said to be invariant. This means that the same function gets called always, irrespective
of whether one exists in the base class or derived class. In a virtual function the run-time type of
the instance decides on which function to be called and not the compile-time type as is in the
case of non virtual functions. For a virtual function there exists a most derived implementation
which gets always gets called.
a.cs
class zzz
yyy a = new vvv();
xxx b = new vvv();
www c = new vvv();

vvv d = new vvv();
a.pqr();b.pqr();c.pqr();d.pqr();
class yyy
class xxx : yyy
class www : xxx
public virtual new void pqr()
System.Console.WriteLine(“www pqr”);
}
class vvv : www
Output
xxx pqr
xxx pqr
vvv pqr
vvv pqr
One last explanation of virtual with a slightly more complex example involving 4 classes.
The first line in Output, xxx pqr, is the result of the statement a.pqr();. We have the function pqr
as virtual in class yyy. Hence, when using new, we now proceed to class xxx and not vvv as
explained earlier. Here, pqr has an override and C# knows that class www inherits this function
pqr. In class www, as it is marked as new, C# will now backtrack and not proceed further to class
vvv. Hence the function pqr gets called from class xxx as shown in the output.
}
If we change the function pqr in class www to override, then C# will proceed to class vvv and
call the pqr of class vvv as it overrides the pqr of www. Remove the override from pqr in class
vvv and the function will get called from class www as the default is new.
For object b, everything remains the same as object a, because it overrides the pqr of class yyy.
Restoring back the defaults, lets look at the third line. Object c looks like www. In class www,
pqr is a new and hence it has nothing to do with the earlier pqr functions. In class vvv, we are
overriding the pqr of class www and hence the pqr of vvv gets called. Remove the override and
then it will get called from class www. The object d thankfully follows none of the above rules as
the left and the right of the equal to sign are the same data types.
An override method is a method that has the override modifier included on it. This introduces a
new implementation of a method. You cannot use the modifiers new, static or virtual along with
override. However abstract is permitted.
a.cs
class zzz
yyy a = new xxx();
a.pqr();
yyy b = new www();
b.pqr();
class yyy
{
class xxx : yyy
base.pqr();
class www : xxx
base.pqr();
Output
yyy pqr
xxx pqr
yyy pqr
xxx pqr
www pqr
Using the keyword base, we can access the base class functions. Here whether pqr is virtual or
not, it is treated as non virtual by the keyword base. Thus the base class pqr will always be
called. The object a knows that pqr is virtual. When it goes to yyy, it sees base.abc and hence it
calls the pqr of yyy. In the second case, it first goes to class vvv, here it calls the base.abc, i.e. the
function pqr of class xxx, which in turn calls function pqr in class yyy.
a.cs
class zzz
yyy a = new xxx();
a.pqr();
class yyy
class xxx : yyy
{
((yyy)this).pqr();
Output
Unhandled Exception: StackOverflowException.
No amount of casting will stop the infinite loop. Thus even though this is being cast to a yyy, it
will always call pqr from xxx and not yyy. Hence you see no output
a.cs
class zzz
yyy a = new www();
xxx b = new www();
a.pqr();a.xyz();
b.pqr();b.xyz();
class yyy

{
class xxx : yyy
private new void pqr()
public new void xyz()
class www : xxx
{
public void xyz()
System.Console.WriteLine(“www xyz”);
Output
www pqr
yyy xyz
www pqr
xxx xyz
More virtual functions, more complications in life. Let us embark on a thousand mile journey
with a single step.
When we have a statement a.pqr, C# starts at the class yyy as usual, sees virtual, then goes to
class xxx. Here pqr is private and hence its scope is limited to class xxx. The modifier new is
thus ignored. C# now goes to class www where the pqr overrides the pqr of class yyy and thus
we see www pqr. If we remove the override modifier from function pqr in class www, as it is a
new function, it will now be called from class yyy. a.xyz calls pqr from yyy due to the
explanation given many times before i.e. they are all news.
b.pqr knows that pqr in class xxx is private. The scope of this pqr does not extend to class www,
the derived class. As the pqr in class www overrides the pqr of class xxx, the one from class
www gets called as it overrides the one from the base class yyy. If you change the override to
new, then the pqr in www is a new one and has nothing to do with the one from yyy. This calls
pqr from the base class yyy.
b.xyz calls it from class xxx. This has already been explained at least a trillion times earlier.
Abstract Classes
a.cs
public class zzz

{
new aaa();
abstract class aaa {
Compiler Error
a.cs(5,1): error CS0144: Cannot create an instance of the abstract class or interface ‘aaa’
The keyword abstract can be written before a class. It is called a class modifier. An abstract class
cannot be instantiated by the keyword new. We cannot create an object that looks like aaa. Thus
we cannot use the class and for all practical purposes the class is useless to us.
a.cs
public class zzz
new aaa();
abstract class aaa
public int i;
public void abc()
The error remains the same. Since we have used the modifier abstract in front of the class we
cannot use new. Had we removed the modifier abstract, all would be fine. This program is to
show that an abstract class can contain variables and functions.
a.cs
public class zzz
new bbb();
abstract class aaa
public int i;
public void abc()
class bbb : aaa
{
}
We can derive a class bbb from an abstractc class aaa. Thus creating an object that looks like bbb
does not give us any error. We cannot yet use aaa directly.
a.cs
public class zzz
new bbb();
abstract class aaa
public void pqr();
public int i;
public void abc()
class bbb : aaa
Compiler Error
a.cs(10,13): error CS0501: ‘aaa.pqr()’ must declare a body because it is not marked abstract or
extern
In a abstract class we have added a function prototype. An extern or abstract function implies
that the actual definition or code is created somewhere else. A function prototype in a abstract
class must also be declared abstract as per the rules of C#.
a.cs
public class zzz
new bbb();
abstract class aaa
abstract public void pqr();
public int i;
public void abc()
class bbb : aaa
Compiler Error
a.cs(16,7): error CS0534: ‘bbb’ does not implement inherited abstract member ‘aaa.pqr()’
After declaring pqr abstract in aaa, we get another error. We are not allowed to create objects that
look like bbb because it is derived from aaa, an abstract class which has one abstract function.
We have to implement this abstract function pqr in bbb .
a.cs
public class zzz
new bbb();
abstract class aaa
public int i;
public void abc()
class bbb : aaa
public void pqr()
{
}
Compiler Warning
a.cs(18,13): warning CS0114: ‘bbb.pqr()’ hides inherited member ‘aaa.pqr()’. To make the
current method override that implementation, add the override keyword. Otherwise add the new
keyword.
Compiler Error
a.cs(16,7): error CS0534: ‘bbb’ does not implement inherited abstract member ‘aaa.pqr()’
Now we are really lost. The error clearly says that both classes aaa and bbb have a similar
function called pqr. Whenever a class (bbb) derives from another class (aaa) and they both have a
function with the same name, an error results. The only way out is for the derived class bbb to
explicitly add a keyword override to the function definition. This tells the compiler that we know
that the base class has a function of the same name and we want the pqr of bbb to be called, not
aaa’s . It is more of a caution exercised by the compiler so that you do not inadvertently override
functions of the base class. C# has a large number of such cautions that make you think.
a.cs
public class zzz
new bbb();
abstract class aaa
public int i;
public void abc()
class bbb : aaa
The warning vanishes after using the keyword override.
a.cs
public class zzz
new bbb();
abstract class aaa
public int i;
public void abc()
class bbb : aaa
public override int pqr()
Compiler Error
a.cs(18,21): error CS0508: ‘bbb.pqr()’: cannot change return type when overriding inherited
member ‘aaa.pqr()’
When you are overriding an abstract function from a derived class, you cannot change the
parameters passed to it or the return type. If the abstract class has 5 functions, the class derived
from it should also implement the same 5 functions without changing return type and/or
parameters passed to it.
a.cs
public class zzz
new bbb();
}
abstract class aaa
abstract public void pqr1();
abstract public void pqr2();
public int i;
public void abc()
class bbb : aaa
Compiler Error
a.cs(18,7): error CS0534: ‘bbb’ does not implement inherited abstract member ‘aaa.pqr1()’
a.cs(18,7): error CS0534: ‘bbb’ does not implement inherited abstract member ‘aaa.pqr2()’
The error goes away if we implement functions pqr1 and pqr2 in bbb.
An abstract class implies that the class is incomplete and cannot be directly used. It can only be
used as a base class for other classes to derive from. Hence we get a error if we use new on an
abstract class. If we do not initialize a variable in an abstract class, it will have a value of 0 which
is what the compiler kept warning us about. We can initialize i to any value we want. The
variables have the same use and meaning in an abstract class like any other class. Whenever a
class is incomplete i.e. we do not have the code for certain functions, we make those functions
abstract and the class abstract . This enables us to compile the class without errors. Other classes
can then derive from our incomplete class but they have to implement the abstract i.e. our
incomplete functions. Abstract thus enables us to write code for part of the class and allows the
others to complete the rest of the code.
a.cs
public class zzz
class aaa
public int i = 20;
public void abc()
Compiler Error
a.cs(9,22): error CS0513: ‘aaa.pqr()’ is abstract but it is contained in nonabstract class ‘aaa’
If a class has even one abstract function, then the class has to be declared abstract. An abstract
method cannot also use the modifiers static or virtual.
Only in the abstract class can we have one abstract function. Anyone who implements from an
abstract class has to write the code for its function. By default the modifier new gets added,
which makes it a new/different function.
a.cs
class zzz
abstract class yyy
public abstract void abc();
class xxx : yyy
base.abc();
Compiler Error
a.cs(15,1): error CS0205: Cannot call an abstract base method: ‘yyy.abc()’
Like the Sting number, C# is always watching every step you take and every move you make.
Like a hawk. You cannot call the function abc from the base class as it does not carry any code
along with it and has been declared abstract. Common sense prevails and C# does not allow you
to call a function that has no code.
a.cs
class zzz
yyy a = new www();
xxx b = new www();
a.abc();b.abc();
class yyy
abstract class xxx : yyy
public abstract new void abc();
class www : xxx

{
System.Console.WriteLine(“www abc”);
Output
yyy abc
www abc
a.abc() will first peek into the class yyy. Here it finds function abc tagged as virtual. How many
times have we repeated the above lines? Countless times. C# will then toddle over to class xxx.
Here it finds to its dismay that the function abc is abstract i.e. there is no code for abc and also
that it is a new function, thus severing all links with the base class. Activity stops and all hell
breaks loose and the function abc from yyy gets executed. In the case of b.abc(), as the function
is new, the links to the base class are broken, we have no choice but to call the function from
www as it says override. We cannot replace the modifier new with the keyword override for
function abc in abstract class xxx .
Compiler Error
a.cs(21,7): error CS0534: ‘www’ does not implement inherited abstract member ‘xxx.abc()’
If we replace the override keyword with new in class www, we will get an error as there is no
code for the function abc. Remember the abc of yyy has nothing to do at all with that of xxx and
www.
Virtual functions run slower than non virtual functions and it is obvious that an abstract class
cannot be sealed.
a.cs
public class zzz
}
}
sealed abstract class aaa
public abstract void abc();
Compiler Error
a.cs(7,23): error CS0502: 'aaa' cannot be both abstract and sealed

10
Properties and Indexers
Properties
Properties are a natural extension to fields. Very few programming languages support the notion
of a property. Unlike a variable, a property is not stored in a memory location. It is made up of
functions. Thus even though a property and a field share the same syntax a property has the
advantage that code gets called. When we initialize a variable, no code in our class gets called.
We are not able to execute any code for a variable access or initialization at all. In the case of a
property, we can execute tons of code. This is one singular reason for the popularity of a product
like Visual Basic - the use of properties. One simple example is setting the value of a variable. If
it is through a variable, we have no control over the value used. If the same access is through a
property, the programmer has no inkling of whether it is a property or a variable, we can build
range checks to make sure that the variable does not cross certain bounds.
Lets start by creating a simple property. A property is a member of a class. It behaves like a
variable for the user.
a.cs
public class zzz
public class aa
public int ff {
}
Compiler Error
a.cs(9,12): error CS0548: ‘aa.ff’ : property or indexer must have at least one accessor
We have tried to create a property called ff which is of type int. We get an error because a
property is used either on the left or the right of an equal to sign. If we had created a variable ff,
we would like to write a statement as gg = ff + 9. Here ff should return some value which is of
the data type int.
a.cs
public class zzz
aa a = new aa();
int gg = a.ff + 9;
System.Console.WriteLine(gg);
public class aa
public int ff {
get
System.Console.WriteLine(“in get”);
return 12;
Output
in get
21
A property should have at least one accessor, in our case, a get as we want to read the value of
the property. Thus a.ff calls the get accessor which returns an int, in this case 12. If we did not
have access to the code of the class aa, we would have assumed ff to have been a variable.
a.cs
public class zzz
aa a = new aa();
a.ff = 19;
System.Console.WriteLine(a.ff);
public class aa
public int ff {
get
{
return 12;
set
System.Console.WriteLine(value);
Output
19
in get
12
A variable can also be used on the left-hand side of the equalto sign. In this case we are writing
or changing the value of the variable. We are passing it some value. If it is a property, ff in our
case, a.ff = 19 will call the accessor set. The set accessor has a free variable available in it called
value. It gets created automatically, we do not create this variable. In our case, this has the value
19, which we are displaying in WriteLine. Then to display the value of the property ff, the get
needs to be called again. The get always returns the same answer as the set does not store the
value of the variable anywhere. To resolve this issue, we do the following.
a.cs
public class zzz
{
aa a = new aa();
a.ff = 19;
public class aa
int f1;
public int ff {
get
return f1;
set
System.Console.WriteLine(“in set “ + value);
f1 = value;
Output
in set 19
in get
19
To implement a property in real life, we create a public variable which will hold the value of the
property. This variable f1 will have the same data type as the property i.e. an int in our case. In
the get, we return f1 and in the set we initialize f1 to value. This is the simplest case possible.
The reason we use a property and not a variable is because if we change the value of a
variable/field, then code in our class is not aware of the change. Also we have no control over
what values the variable will contain. The user can change them to whatever he/she likes and we
cannot implement range checks on the variable. Also the user may want to associate some action
with the changes in the value of the variable. Using a property, reading or writing to the variable
also can be monitored.
a.cs
public class zzz
aa a = new aa();
a.ff = 19;
public class aa
int f1;
public int ff {
get
{
return f1;
Compiler Error
a.cs(6,1): error CS0200: Property or indexer ‘aa.ff’ cannot be assigned to — it is read only
You are allowed to declare a property readonly by omitting the set accessor. No one is now
allowed to change the value of the property. It now behaves as a const or readonly field.
a.cs
public class zzz
aa a = new aa();
a.ff = 19;
public class aa
int f1;
public int ff {
set
{
System.Console.WriteLine(“in set “ + value);
f1 = value;
Output
in set 19
Theoretically, you can have a property which is write only i.e. only with a set accessor. With set,
you can change the value of ff but it is of limited use because you can never access the value of
ff. A property differs from a field by ending with {}.
a.cs
public class zzz
public class aa
public int ff {
set
}
public int ff {
get
Compiler Error
a.cs(12,12): error CS0102: The class ‘aa’ already contains a definition for ‘ff’
You cannot create a property in 2 separate bits and pieces. It has to be in one whole. This is part
of the syntax. The above creates two properties, both called ff, the first one being write only, the
second, read only. The compiler tells you that you cannot create two properties by the same
name.
a.cs
public class zzz
public class aa
private int ff;
public int ff {
get {
}
set {
Compiler Error
a.cs(10,12): error CS0102: The class ‘aa’ already contains a definition for ‘ff’
You obviously cannot have a property and variable with the same name. The compiler would not
know whether to invoke the property or the field. They both are stored in the same namespace.
a.cs
class zzz
yyy.i = 20;
class yyy
public static int i
get {
System.Console.WriteLine(“get”);
return 10;
}
set {
System.Console.WriteLine(“set “ + value);
Output
set 20
get
10
The rules of static apply to properties also. Like variable we access them using the class and not
the instance. Everything that we have learned about static in the past applies to properties also.
a.cs
class zzz
yyy a = new yyy();
a.i = 100;
abstract class xxx
{
public abstract int i
get ;
set ;
class yyy : xxx
public override int i {
get
System.Console.WriteLine(“get”);
return 10;
set
System.Console.WriteLine(“set “ + value);
Output
set 100
get
10
The abstract property i in class xxx carries no code at all. The get and set accessors are simply
represented by a semicolon. In the derived class, we must implement both the get and the set
accessors. If we do not use the override keyword, it is new. We hope you have finally understood
new and override.
a.cs
class zzz
abstract class xxx
public abstract int i
get ;
class yyy : xxx
public override int i {
get
}
set
Compiler Error
a.cs(20,1): error CS0546: ‘yyy.i.set’: cannot override because ‘xxx.i’ does not have an
overridable set accessor
In class xxx, the abstract property has only a get accessor. In the derived class we are
implementing both the get and the set. The original never ever had a set. This is unacceptable to
the compiler. Thus we have no choice but to implement only the accessors that are present in the
original. A get accessor can be viewed as a method which returns a value but accepts no
parameters.
a.cs
class yyy
public void i {
Compiler Error
a.cs(3,13): error CS0547: ‘i’ : property or indexer cannot have void type
It makes no sense for an accessor to have a void type as a variable cannot be of type void. Void
literally means ‘I do not know the type’ or no type at all.
a.cs
class yyy
{
public int i {
set
return 10;
Compiler Error
a.cs(6,2): error CS0127: Since ‘yyy.i.set’ returns void, a return keyword must not be followed by
an object expression
A set accessor can be viewed as function which returns void but accepts one parameter which
stands for the value of the property. Thus a set cannot return a value. If we remove the 10, we
will not get an error.
a.cs
class zzz
public int i {
set
value = 20;
}
}
The reserved variable value in the set can be changed at will. Though, understanding why anyone
would want to do such dumb stuff is beyond us.
a.cs
class zzz
public int i {
set
int value;
Compiler Error
a.cs(9,6): error CS0136: A local variable named ‘value’ cannot be declared in this scope because
it would give a different meaning to ‘value’, which is already used in a ‘parent or current’ scope
to denote something else
We cannot however create a variable value as it will clash with the variable value which is
already present by default in the set.
a.cs
class zzz
{
yyy a = new yyy();
a.i = 10;
xxx b = new xxx();
((yyy)b).i = 20;
b.i = 10;
class yyy
public int i {
set {
class xxx : yyy
public int i {
get {
return 10;
}}
Compiler Error
a.cs(9,1): error CS0200: Property or indexer ‘xxx.i’ cannot be assigned to — it is read only
In the class yyy, the property i has only the set accessor. In the class xxx which derives from yyy,
we have implemented only the get accessor. The property i in class xxx hides the i of yyy. They
do not add up. What we are trying to say is that both these properties are independent of each
other. What we had thought C# would have done is, taken the set from one class and added it to
the second. However, that does not make sense. It treats them independently. If we want to use
the property of the class yyy, then we need to explicitly cast it as we have done for b. Thus the
property i of class yyy gets hidden but can be accessed.
A property is not necessarily slower than a variable. A variable access normally initializes some
memory, whereas a property executes a method. This is not necessarily slower as at times, C#
will rewrite your property methods to memory accesses. This is called inlining of code. Except
for minor differences, all that we mentioned about virtual, abstract and new apply also to a
property. The difference is, if the original property has a get and a set, the derived class will only
implement a set or a get.
Indexers
An indexer lets us access members of a class as if it were an array.
a.cs
public class zzz
yyy a = new yyy();
a[1] = 10;
public class yyy {
Compiler Error
a.cs(6,1): error CS0021: Cannot apply indexing with [] to an expression of type ‘yyy’
We have created an object a that looks like yyy. The object a, in no sense of the word is an array.
We are assuming that a is an array and we’ve used the array syntax a[], hence it gives us an error.
a.cs
public class zzz
yyy a = new yyy();
a[1] = 10;
public class yyy
public int this[int i]
set {
System.Console.WriteLine(“in get “ + value + “ “ + i);
Output
in get 10 1
We’ve added a few lines to have the array notation work with an object that looks like yyy. To
implement indexers, we need to create a special property called this. This is a reserved word. As
of now, we have a parameter i (an int) in the square brackets. When we did properties earlier,we
learnt that a set gets called whenever we want to initialize or set a variable. Within the set
accessor we have a special variable called value which stores the value passed to the set, in this
case 10. The variable i will hold the value 1 as the array parameter is 1.
This is how we implement arrays when there are none.
a.cs
public class zzz
yyy a = new yyy();
public class yyy
public int this[int i]
set
get
{
System.Console.WriteLine(“in set “ + i);
return 23;
Output
in set 1
23
The rules binding properties are applicabe to indexers too. When you want to read the value of
a[1], the get gets called. The major difference between properties and indexers is that when you
implement the code for indexers you have to understand that the get and set get called with a
variable which is the array parameter value. The code will have to understand array simulation.
a.cs
public class zzz
yyy a = new yyy();
a[“hi”] = 30;
System.Console.WriteLine(a[“hi”]);
public class yyy
public int z;
public int this[string i]
set
z = value;
get
System.Console.WriteLine(“in set “ + i);
return z;
Output
In get 30 hi
In set hi
30
The this property has a return value, in this case, an int. Also the [] brackets can contain data
types other than an int. In this case a string. The string i has a value hi as that is what we passed
in the array brackets. You can have two this’s in your class. You have to decide what data type to
use in the array brackets. An indexer is very useful when you have a database object and you
want to access the data in the fields using a notation [“fieldname”]
Indexers follow the same concepts of virtual, new, override etc.
a.cs
class zzz
yyy a = new yyy();
a[1] = 10;
a[“one”] = 10;
a[“hi”,2] = 30;
class yyy
public int this [ int i]
set
System.Console.WriteLine(“one int “+ i + “ “ + value);
public int this [ string i]
set
{
System.Console.WriteLine(“one string “+ i + “ “ + value);
public int this [ string i, int j]
set
System.Console.WriteLine(“one string and int “+ i + “ “ + j + “ “ + value);
Output
one int 1 10
one string one 10
one string and int hi 2 30
The signature of an indexer is the number and types of formal parameters. The return value and
the names of the parameters do not contribute to the indexers signature. Thus we have
overloaded the indexers to take an int, string or a string int combination. Each time a different
function gets called. The point to understand is that all the indexers have to return the same data
type, in our case int. The same rules that apply to function overloading apply here also. Functions
cannot differ only by return values. We are sure that for indexers in the next version, C#
should/must make an exception.
A property is identified by its name, an indexer by its signature. There is no concept of property
overloading in C#.
a.cs
class zzz
{
class yyy
public static int this [ int i]
set
Compiler Error
a.cs(9,19): error CS0106: The modifier ‘static’ is not valid for this item
A property can be both an instance member which is the default or static. An indexer
unfortunately can only be an instance member and not static. God alone knows why this
discrimination against indexers. Once again no rational reason for the above error. Obviously
you cannot create a variable with the same name as that of the parameter passed in the indexer.
a.cs
class zzz
xxx a = new xxx();

a[2] = 20;
class yyy
public virtual int this [ int i]
get
System.Console.WriteLine(“yyy get “ + i);
return 20;
set
System.Console.WriteLine(“yyy set “ + value + “ “ + i);
class xxx : yyy
public override int this [ int i]
{
get
int p = base[i];
System.Console.WriteLine(“xxx get “ + i + “ “ + p);
return 200;
set
System.Console.WriteLine(“xxx set “ + value + “ “ + i);
base[i] = value;
Output
xxx set 20 2
yyy set 20 2
yyy get 2
xxx get 2 20
200
The above example deals with calling the indexers of the base class. At times when we are
overriding code in the derived class, we would like to call the original indexer in the base class
first. The first rule that we have to adhere to is that the indexer in the base class must be declared
virtual. In the derived class, we are now declaring it with the modifier override. Same rules as
above. In the set accessor, we have to call the original as base[i], where i is the index to the
indexer. Also we need to pass it the value to initialize itself. This is stored in the variable value.
This a[2] in Main gets replaced by base[2] in the set. In get the reverse takes place. Here we need
to place base[i] on the right of the equalto sign, the original get will return a value, in this case
20, which we are storing in a variable p. What we do with p as well as the value from the get is
our business.
a.cs
class yyy
public int this [ byte i , string j]
get
return 10;
set
int get_Item(byte i,string j)
return 20
void set_Item(byte i,string j , int value)
Compiler Error
a.cs(5,1): error CS0111: Class ‘yyy’ already defines a member called ‘get_Item’ with the same
parameter types
a.cs(9,1): error CS0111: Class ‘yyy’ already defines a member called ‘set_Item’ with the same
parameter types
Like a property, an indexer also gets a name change. If people can get their bodies pierced then
why cannot a indexer get converted to a series of functions starting with get? For a get, the
parameters are the same as we pass to an indexer. It has a return value and the type of the
indexer. Also the set has one more added parameter and that is the free variable value.
11
Interfaces and Structures
Constructors Revisited
A constructor is used to initialize the instance of a class as explained earlier.
a.cs
public class zzz
System.Console.WriteLine("in main");
bb a = new bb();
bb b = new bb(10);
public class aa
public aa()
System.Console.WriteLine("in const aa");
}
public aa(int i)
System.Console.WriteLine("in const aa" + i);
public class bb : aa
public bb()
System.Console.WriteLine("in const bb");
public bb(int i)
System.Console.WriteLine("in const bb" + i);
Output
in main
in const aa
in const bb
in const aa
in const bb10
Class aa is the base class. It consists of two constructors. One that takes no parameters and the
other that takes an int as a parameter. Class bb is derived from class aa, i.e. aa is the base class,
bb the derived class. When we create an object like bb, the compiler does not execute the code
for the constructor but instead asks the constructor which constructor of the base class to execute
first. As we haven't stated this, by default, the constructor with no parameters get executed.
Remember it is the base class constructor which gets executed first and the derived class
constructor specifies which base class constructor to call first. In the second case, even though
we are calling the constructor with a parameter, the constructor with no parameters in the base
class gets called and not the one with one int as a parameter.
a.cs
public class zzz
bb a = new bb();
bb b = new bb(10);
public class aa
public aa()
public aa(int i)

}
public bb() : base()
public bb(int i) : base(i)
System.Console.WriteLine("in const bb" + i);
Output
in main
in const aa
in const bb
in const aa10
in const bb10
If we do not specify which constructor of the base class to call, C# by default calls the
constructor with no parameters. Which means that C# rewrites our code . When we write bb(), it
gets rewritten as bb() : base(). Base is a reserved word. It means call the constructor of the base
class with no parameters. For the second constructor, bb(int i), the line gets rewritten to bb(int i) :
base(). We now want to call the constructor with one int and hence we write bb(int i) : base(i).
That is why the constructor with one int gets called. We have the option to decide which
constructor of the base class we would like to call.
a.cs
public class zzz
bb a = new bb();
public class aa
public aa()
public aa(int i)
public bb() : this(20)

{
public bb(int i) : base(i)
System.Console.WriteLine("in const bb" + i); } }
Output
in main
in const aa20
in const bb20
in const bb
A constructor gets called at the time of creation of the object. At the line, new bb(), the compiler
asks the constructor of bb as to which constructor of the base class aa to call. Here he was told
that the answer lies with this(20). this, like base, is a reserved word. It means call a constructor of
the same class and not the base class. Therefore the compiler now asks the one constructor of the
derived class bb which constructor of the base class to call. bb(int i) : base(i) tells the compiler to
execute the one int constructor of aa. This is the first constructor that gets called. Then the one
int constructor of bb gets called and finally the one who started it all, the no parameter
constructor of bb. Thus, two derived class constructors get called instead of one.
a.cs
public class zzz
aa a = new aa();
}
}
public class aa
private aa()
Compiler Error
a.cs(6,8): error CS0122: 'aa.aa()' is inaccessible due to its protection level
When you create a constructor which is private, you cannot create an object that looks like aa.
Thus aa should only contain static members.
a.cs
public class zzz
public class aa
private aa()
}
Compiler Error
a.cs(13,14): error CS0122: 'aa.aa()' is inaccessible due to its protection level
Nor can any class derive from aa. Thus no one can instantiate an object that looks like aa or
derive from it as the constructor has been made private.
a.cs
public class zzz
System.Console.WriteLine(aa.i);
public class aa
private aa()
static public int i = 20;
Output
20
You can however use all the static variables in aa
a.cs
public class zzz
class yyy
public yyy()
class xxx : yyy
public int i;
xxx() : base( this.i)
Compiler Error
a.cs(16,15): error CS0027: Keyword this is not available in the current context
Base is called a constructor initializer. When base gets called, the instance or the object has not
yet been created. Ergo, this is not available here as this refers to the current object. In the
constructor, however, this can be freely used.
The values of variables in a class are initialized to their default values as per their data types
before the constructor gets called. Thus, in the constructor they have their default values as
shown below.
a.cs
public class zzz
yyy a = new yyy();
class yyy
public int i;
public bool j;
public yyy()
System.Console.WriteLine(i+" " + j);
Output
0 False
Here as before, the first line of code in the constructor gets executed.
a.cs
public class zzz
xxx a = new xxx();
class yyy
public int i = 10;
public yyy(int j)
i = j;
class xxx : yyy
public xxx() : base(100)
System.Console.WriteLine(base.i);
}
Output
10
100
Calling the base class constructor is like inserting all the code of the one int constructor i.e.
yyy(int j), in the constructor of class xxx. We are also allowed to access members of the base
class after the constructor gets called. Also, first the variable i gets initialized to 10 or the default
value of int. Then we change it to 100 and in the constructor of xxx, we will see a value of 100.
a.cs
public class zzz
xxx a = new xxx();
class yyy
public yyy()
abc();
{
}
class xxx : yyy
public int x = 10;
public xxx()
System.Console.WriteLine(x);
x = 100;
Output
10
10
100
We have already confessed a million times in the past that we have copied ideas from anyone and
everyone, specially from the documentation. In this specific case, we wanted to demonstrate that
first the variables are initialized. Thus in class xxx, the int x is initialized to 10. Then the base
class constructor of yyy gets called. The value of x in class yyy should be 10. But what guarantee
can we give you as we are not able to print the value of x in an object of a class derived from the
base class. Very simple. We call a virtual function abc from class yyy and override it in class xxx.
The abc of class xxx prints the value of x as they belong to the same class and the output is 10.
Viola and thank you Mr. Documentation for the above thought and many more such ideas. Once
all code in the yyy constructor is executed, the first line in xxx constructor will get executed
which will print the value of x as 10. x is then initialized to 100, hence we see 100 as the new
value of x, displayed on the screen.
a.cs
public class zzz
static zzz()
System.Console.WriteLine("zzz");
System.Console.WriteLine("main");
new aa();
public class aa
public aa()
System.Console.WriteLine("aa");
static aa()
{
System.Console.WriteLine("static aa");
Output
zzz
main
static aa
aa
and if we comment new aa() then the resulting output reads as follows.
Output
zzz
main
A static constructor gets called before any other constructors.
a.cs
public class zzz
static zzz()
System.Console.WriteLine("zzz");
{
System.Console.WriteLine("main");
aa.a();
public class aa
public aa()
System.Console.WriteLine("aa");
public static void a()
static aa()
System.Console.WriteLine("static aa");
Output
zzz
main
static aa
If you try to access any static member of a class or whenever you instantiate an object, the static
constructor gets called. A constructor is not inherited by the derived class.
A class is loaded in memory before any instance of the class is created or its static members
accessed. A class can only be loaded once and that too before its derived class is loaded. The
static constructor is called at the time of loading the class. Like other constructors, a static
constructor cannot be explicitly called.
a.cs
public class zzz
xxx.pqr();
yyy.abc();
class yyy {
static yyy()
System.Console.WriteLine("static yyy");
System.Console.WriteLine("abc yyy");
class xxx {
static xxx()
{
System.Console.WriteLine("static xxx");
System.Console.WriteLine("pqr xxx");
Output
static xxx
pqr xxx
static yyy
abc yyy
Do not believe the above results as if you run them on your machine, your mileage may wary.
This is because C# does mandate the order of loading of classes and thus the order of execution
of the static constructors. On your machine if the yyy constructor gets executed first, do not
panic. Blame it on your destiny.
a.cs
public class zzz
yyy.abc();
xxx.pqr();
}
}
class xxx
static xxx()
System.Console.WriteLine("static xxx");
System.Console.WriteLine("pqr xxx");
class yyy : xxx
static yyy()
System.Console.WriteLine("static yyy");
System.Console.WriteLine("abc yyy");
}
Output
static yyy
abc yyy
static xxx
pqr xxx
We have made only one small change in the above program. We have derived the class yyy from
xxx. Since the functions in each class are marked static, the program behaves in the same manner
as before.The above order of calls remains the same. If an object of the type is created, then the
output will change. The reason being that before the object of type yyy is created, xxx must be
loaded. Hence the constructors will be called first.
a.cs
public class zzz
public static int x = yyy.y + 2;
static zzz()
System.Console.WriteLine("static zzz " + zzz.x + " " + yyy.y);
x = 500;
yyy.y = 600;
System.Console.WriteLine("main "+ zzz.x + " " + yyy.y);
}
}
class yyy
static yyy()
System.Console.WriteLine("static yyy " + zzz.x + " " + yyy.y);
y = 10;
zzz.x = 200;
public static int y = zzz.x + 3; }
Output
static yyy 0 3
static yyy 200 10
static zzz 12 10
static zzz 500 600
main 500 600
Difficult code to understand and follow. C# first tries to load class zzz in memory as it contains
the function Main. Unfortunately it realizes that it has to first initialize the variable x before
calling the static constructor of zzz. It first initializes x to 0. Now note that this initialization of x
to zero is extremely significant for our understanding. To get the new value of x, C# now needs
the value of the variable y from the class yyy. Before it can call the static constructor of yyy it
must initialize the variable y. It makes sure that y's value is first set to zero. It then computes the
value of zzz.x which is zero as stated above. We are yet left hanging in class zzz at the line x = .
As zzz.x is zero, the value of y is 0 + 3 i.e. 3. This completes the initialization of all the variables
in the class. All this happens first. Thus the static constructor of class yyy shows the value of the
variable x as 0 and that of variable y as 3.
But hold on, the fun is yet to begin. In the static constructor, we now initialize y to 10 and the x
of zzz to 200. The next WriteLine confirms that our initializations actually were carried out.
Then we go back to class zzz. Here we come back to the initialization of the static variable x. As
yyy.y is now 10 since we changed it in the static constructor of yyy, the value of x is 10 + 2 i.e.
12. This overrides the value of x which we changed to 200 in the static constructor yyy. Now C#
calls the static constructor of zzz as it has finished all the variable initializations. Thus the first
WriteLine displays 12 and 10. We are now changing both x and y and they display the same
values in the constructor and in Main.
a.cs
public class zzz
public static int x = yyy.y + 2;
static zzz()
x = 500;
yyy.y = 600;
class yyy
static yyy()
y = 10;
zzz.x = 200;
public static int y = zzz.x + 3;
System.Console.WriteLine("main "+ zzz.x + " " + yyy.y);
Output
static zzz 2 0
static zzz 500 600
static yyy 500 503
static yyy 200 10
main 200 10
The above program adds a small twist. It bowls what in cricket parlance is called a googly. We
simply bring Main from the class zzz to the class yyy. Now C# as usual first starts at the class
containing Main which now happens to be yyy and not zzz. Here it has to first initialize all the
variables in class yyy. We have only one. It starts by setting y to zero and runs to the class zzz to
fetch the value of x. x now become 0 + 2 i.e. 2. Then in the static constructor, we are displaying
the relevant values of x and y. In the static constructor of class zzz, we are changing x and y to
500 and 600 respectively and displaying the values. When we move back to class yyy, however,
y gets a new value of 503 as x is 500. y loses its value of 600 that was initialized in zzz, hence
you see 500 and 503. The rest remains the same as explained in the earlier example.
Interfaces
An interface is simply a collection of function prototypes. Like we derive a class from another,
so also we could derive from an interface.
a.cs
class zzz
{
interface ddd
void a1();
void a2();
class yyy : ddd
Compiler Error
a.cs(12,7): error CS0535: 'yyy' does not implement interface member 'ddd.a1()'
a.cs(12,7): error CS0535: 'yyy' does not implement interface member 'ddd.a2()'
We have just created an interface called ddd by using a new keyword interface in place of a class.
Our interface ddd has two function prototypes, a1 and a2. We can derive from our interface ddd
like we derived from a class. The difference is that an interface has no code, only function
prototypes. Whenever we derive from an interface, we have to implement the code or body of the
function. A class gives you lots of free code, an interface does not. The error is generated as we
have not given the code for a1 and a2 in yyy
a.cs
class zzz

{
yyy a = new yyy();
a.a1();
ddd d = new yyy();
d.a2();
interface ddd
void a1();
void a2();
class yyy : ddd
public void a1()
System.Console.WriteLine("yyy a1");
public void a2() {
System.Console.WriteLine("yyy a2");
Output
yyy a1
yyy a2
We get no errors because we have now implemented the code of a1 and a2. Looks wise we do no
know whether ddd is a class or an interface as the syntax at the time of derivation is the same. d
is an object that looks like an interface which is syntactically correct. d can be equated to a yyy
as a yyy is a yyy + a ddd. We can, by only using d, call members of a ddd.
a.cs
class zzz
aaa a ;
a = new aaa();
interface aaa
Compiler Error
a.cs(6,5): error CS0144: Cannot create an instance of the abstract class or interface 'aaa'
Even though an interface aaa is empty, we cannot write the keyword new in front of it. An
interface contains no code and thus cannot be instantiated. However we are allowed to declare
objects that look like an interface. Therefore, in this case, the line aaa a, does not flag an error.
a.cs
class zzz
{
interface aaa
void a1()
Compiler Error
a.cs(9,6): error CS0531: 'aaa.a1()': interface members cannot have a definition
Reiterating, an interface can only contain function prototypes, no code at all. The functions
cannot have a definition.
a.cs
class zzz
class xxx
}
class vvv
class yyy : xxx,vvv
Compiler Error
a.cs(13,17): error CS0527: 'vvv' : type in interface list is not an interface
C# does not support multiple inheritance. We can derive from a single class only at one point in
time.
a.cs
class zzz
yyy a = new yyy();
ddd d = new yyy();
d.a1(); d.a2();
a.a1();
a.a2();
interface ddd
{
void a1();
void a2();
class yyy : ddd
public void ddd.a1()
System.Console.WriteLine("a1");
public void a2()
Compiler Error
You are not allowed to use the modifier public for a function which has qualified its name with
that of the interface.
a.cs
class zzz
}
}
interface aaa
public void a1();
Compiler Error
Interface members are public by default. The access modifiers are not allowed here. All the other
access modifier rules remain the same as that from classes. The rules in classes stated that the
base class must be at least as accessible as the derived class. Replace the word class with
interface and you will not be sorry.
a.cs
class zzz
yyy a = new yyy();
ddd d = new yyy();
d.a1(); d.a2();
a.a1();
a.a2();
interface ddd
{
void a1();
void a2();
class yyy : ddd
void ddd.a1()
public void a2()
Compiler Error
a.cs(8,1): error CS0117: 'yyy' does not contain a definition for 'a1'
The reason we get an error is because we created the function a1 in yyy as ddd.a1 and not a1. By
doing this, we were telling C# that only objects that look like ddd are allowed access to a1. Even
an object that looks like yyy is not allowed to access a1. Comment out line number 8 i.e. a.a1
and all works fine as follows
Output
a1
a2
a2
a.cs
class zzz
yyy a = new yyy();
ddd d = new yyy();
eee e = new yyy();
a.a1(); a.a2();
d.a1();
e.a2();
interface ddd
void a1();
interface eee
void a2();
class yyy : ddd , eee
public void a1()

{
public void a2()
Output
a1
a2
a1
a2
Here we are doing something that just cannot be done with classes. We are deriving from two
interfaces ddd and eee at the same time. Each has one function prototype a1 and a2 respectively.
Using a which looks like yyy we can call both a1 and a2 but with d that looks like ddd we can
only call a1. Similarly, with e only a2 can be called.
a.cs
class zzz
yyy a = new yyy();
ddd d = new yyy();
eee e = new yyy();

a.a1();
d.a1();
e.a1();
interface ddd
void a1();
interface eee
void a1();
public void a1()
Output
a1
a1
a1
The two interfaces share the same function name a1. We do not get an error but yet things do not
seem right. Both d and e call the same a1 and there is only one implementation of the function
a1. We would like to have two a1's but we cannot have the same function defined twice in a
class.
a.cs
class zzz
ddd d = new yyy();
eee e = new yyy();
d.a1();
e.a1();
interface ddd
void a1();
interface eee
void a1();

{
void ddd.a1()
System.Console.WriteLine("ddd a1");
void eee.a1()
System.Console.WriteLine("eee a1");
Output
ddd a1
eee a1
We did what we had explained earlier. We prefaced the name of the function with the name of
the interface. Then we removed the modifier public and the object a which looked like yyy. Now
each interface has its own copy of a1 to be called. ddd.a1 is called the explicit interface member
name.
a.cs
class zzz
yyy a = new yyy();
a.a1();
}
}
interface ddd
void a1();
interface eee
void a1();
void ddd.a1()
System.Console.WriteLine("ddd a1");
void eee.a1()
System.Console.WriteLine("eee a1");
Compiler Error
a.cs(6,1): error CS0117: 'yyy' does not contain a definition for 'a1'
The reason we removed a was that once we have an explicit interface member, we cannot access
it through the class, it is done only through the interface. This make a lot of sense as there are
two functions of the same name, and C# does not know which one it should call. By prefacing
the functions with the names of the interface, we are making them part of the interface and not
the class. In a sense they are private to the class. As there is no function by the name of a1 in
class yyy, we see the above error.
a.cs
class zzz
interface ddd
void a1();
interface eee
void a1();
class yyy : ddd
void ddd.a1()
void eee.a1()
{
Compiler Error
a.cs(21,6): error CS0540: 'yyy.eee.a1()': containing class does not implement interface 'eee'
We get an error as class yyy is derived only from interface ddd. Thus we cannot use eee.a1() as
interface eee is not a base interface for class yyy.
a.cs
class zzz
interface ddd
void a1();
class yyy : ddd
void ddd.a1()
}
class xxx : yyy
void ddd.a1()
Compiler Error
a.cs(19,6): error CS0540: 'xxx.ddd.a1()': containing class does not implement interface 'ddd'
The key concept earlier was that we could only use the name of an interface explicitly if it was
categorically stated as a base class. Anything indirect would not do. Here class yyy is derived
from interface ddd and thus we can use the form ddd.a1. However even though class xxx is
derived from class yyy and thus also from interface ddd, we are not allowed to write ddd.a1 as
interface ddd is not explicitly stated in the derivation list of class xxx.
An interface defines a contract and can only contain four entities viz methods, properties, events
and indexers. An interface thus cannot contain constants, fields, operators, constructors,
destructors, static constructors, or types. Also an interface cannot contain static members of any
kind. The modifiers abstract, public, protected, internal, private, virtual, override are disallowed
as they make no sense in this context.
a.cs
class zzz
public delegate void d1();
public interface aaa

{
void a1(string s);
int a2
get; set ;
event d1 ddd;
string this[int i]
get; set;
}}
The above example demonstrates the four entities an interface can contain. Anything else will
flag an error.
a.cs
class zzz
ccc c = new ccc();
aaa a = c;
bbb b = c;
c.a1();c.a2();
a.a1();
b.a1();b.a2();
}
interface aaa
void a1();
interface bbb : aaa
void a2();
class ccc : bbb
public void a1()
public void a2()
Output
a1
a2
a1
a1
a2
An interface can also, like a class, inherit from one or more interfaces. In this case bbb as an
interface, can inherit from aaa. The class ccc inherits from interface bbb and and thus interface
aaa has to implement functions a1 and a2. The object c not only looks like a ccc but also looks
like an aaa and bbb. Thus equating them does not give an error. The reverse, however, is not true.
It will obviously flag an error. However a can only access functions from the interface it belongs
to, in this case a1 and b can access a1 and a2. b cannot access members from class ccc even
though a, b, and c have the same values. Whenever an interface derives from another it is called
an explicit base interface. Like classes, circular definitions are not permitted. In fact nowhere in
the C# programming language are we permitted to have circular definitions.
An interface also creates a new type and as in classes, methods must have their own unique
signatures. Properties and methods cannot have similar names.
a.cs
class zzz
interface aaa
void a1();
interface bbb : aaa
{
void a1();
Compiler Warning
a.cs(13,6): warning CS0108: The keyword new is required on 'bbb.a1()' because it hides
inherited member 'aaa.a1()'
Like classes if interfaces derive from each other, there is a possibility that they may contain the
same function signatures. Thus we get a warning which can be removed by adding the keyword
new as follows.
interface bbb : aaa
new void a1();
The point to be stressed here is that the keyword new really does not do much, other than remove
the warning. This is because the implementation of the interface is done in the class. There, we
will have only one implementation of function a1 and not two, one for aaa and the other for bbb.
At one level, from the point of view of the class which derives from interface bbb, it will see
only one function in it, not two. All that we are doing is hiding the base interface member.
a.cs
class zzz
void abc(ccc c)
c.aa(1);
((bbb)c).aa(1);
((aaa)c).aa(1);
c.aa = 2;
((aaa)c).aa = 3;
((bbb)c).aa = 3;
interface aaa
int aa
get; set;
interface bbb
void aa(int i);
interface ccc : aaa , bbb
Compiler Error
a.cs(8,1): error CS0229: Ambiguity between 'aaa.aa' and 'bbb.aa(int)'
a.cs(10,10): error CS0118: 'aaa.aa' denotes a 'property' where a 'method' was expected
a.cs(11,1): error CS0229: Ambiguity between 'aaa.aa' and 'bbb.aa(int)'
a.cs(13,10): error CS0654: Method 'bbb.aa(int)' referenced without parentheses
Interface aaa has only one member, a property called aa, whereas interface bbb has one function
called aa. The interface ccc does not give us an error in spite of the fact that we have a property
and a function with the same name. In the function abc, we are passing c, an object that looks
like ccc. The line c.aa(1) gives us an error as we have a property and a function called aa. C# gets
confused whether it is the property or the function we are referring to. In our humble opinion, we
could only be referring to the function as per the syntax, but you don't argue with a compiler.
In the second case c.aa = 2 also flags an error due to the name confusion. In this case also, we
could only be referring to a property. The only way out is to cast. The second cast in each case
gives an error as the syntax for calling a function and property is different. Normally, to cast, we
need to give two sets of brackets.
A cast incurs no run time costs i.e., it does not slow down the program. All that a cast does in the
above case is lowers the pointer from a ccc to aaa or bbb at compile time. In an earlier example,
we spoke of functions from two interfaces having similar names. The same rules stated there
apply here also.
a.cs
class zzz
void abc(ccc c)
c.aa(1);
c.aa((byte)1);
((aaa)c).aa(1);
((bbb)c).aa(1);
}
}
interface aaa
void aa(byte i);
interface bbb
void aa(short i);
interface ccc : aaa , bbb
Compiler Error
a.cs(8,1): error CS0121: The call is ambiguous between the following methods or properties:
'bbb.aa(short)' and 'aaa.aa(byte)'
a.cs(9,1): error CS0121: The call is ambiguous between the following methods or properties:
'bbb.aa(short)' and 'aaa.aa(byte)'
We have a similar problem again. c.aa(1) does not know which function aa to call. C# could
convert the 1 an int, either to a short or a byte. Thus the ambiguity. Even if we cast the 1 to a
byte, for some reason, C# yet gives us an error. The only way out is like what we did earlier,
explicitly cast your way out of trouble. When we cast, we are restricting ourselves to only one
method and thus no ambiguity.
a.cs
class zzz

{
interface aaa
void aa();
interface bbb : aaa
new void aa();
interface ccc : aaa
void cc();
interface ddd : bbb , ccc
class eee : ddd
Compiler Error
a.cs(22,7): error CS0535: 'eee' does not implement interface member 'bbb.aa()'
a.cs(22,7): error CS0535: 'eee' does not implement interface member 'ccc.cc()'
a.cs(22,7): error CS0535: 'eee' does not implement interface member 'aaa.aa()'
The interface aaa has one function aa. The interface bbb is derived from aaa and also has one
function called aa. The keyword new informs the C# compiler that, it has hidden or has nothing
to do with the function aa in interface aaa. Remember in interfaces, we cannot write any code.
The interface ccc also derives from aaa but does not have a function called aa. Then we are
creating another interface ddd which derives from both bbb and ccc. The class eee is then derived
from interface ddd. We get three errors as we have to implement three functions in class eee.
The interface ccc brings in two functions. One cc and the other aa from interface aa. The
interface bbb has only one function, aa which is different from the aa which is present in
interface aaa, thanks to the keyword new which is optional.
a.cs
class zzz
aaa a = new eee();
a.aa();
bbb b = new eee();
b.aa();
ccc c = new eee();
c.aa();
ddd d = new eee();
d.aa();
eee e = new eee();
//e.aa();
((aaa)d).aa();
((bbb)d).aa();
((ccc)d).aa();
((ddd)d).aa();
interface aaa
void aa();
interface bbb : aaa
new void aa();
interface ccc : aaa
void cc();
interface ddd : bbb , ccc
class eee : ddd
void aaa.aa()
{
12
Operator Overloading
Let’s explain what operator overloading is all about with an example of a class that represents a
date. Would it not be great if we could subtract two date objects and be returned an int
representing the number of days elapsing between the two dates. We would like to use the good
old subtraction operator – like we do when subtracting numbers. Also we would like the >
operator to compare two date objects and tell us which one is larger. The + operator could add a
number to a date resulting in a new date object.
Thus, operator overloading lets us redefine the existing operators so that they work with
classes/objects we create like yyy. We have not yet instructed C# on how to use the trusty old +
operator with two yyy objects. Though C# knows how to use the + to add two numbers, it does
not know how to add two yyy’s.
a.cs
public class zzz
yyy a = new yyy(10);
yyy b = new yyy(5);
yyy c;
c=a+b;
}
public class yyy
public int i;
public yyy( int j)
i = j;
Compiler Error
a.cs(8,5): error CS0019: Operator ‘+’ cannot be applied to operands of type ‘yyy’ and ‘yyy’
We have created a simple class yyy which has one instance variable i which will distinguish
different instances of yyy from each other. The constructor with an int as a parameter initializes i.
We have tried to add two objects that look like yyy which does not go down well with C# and it
objects to it.
a.cs
public class zzz
yyy b = new yyy(5);
yyy c;
c=a+b;
}
public class yyy
public int i;
public yyy( int j)
i = j;
public yyy operator + ( yyy x , yyy y)
Compiler Error
a.cs(18,12): error CS0558: User-defined operators ‘yyy.operator +(yyy, yyy)’ must be declared
static and public
Error messages can be at times helpful. Our operator + is public but not static. C# demands that
all operator overloads be static.
a.cs
public class zzz
yyy b = new yyy(5);

yyy c;
c=a+b;
System.Console.WriteLine(c.i);
public class yyy
public int i;
public yyy( int j) {
i = j;
public static yyy operator + ( yyy x , yyy y)
System.Console.WriteLine(“operator + “ + x.i + “ “ + y.i);
yyy z = new yyy(x.i+y.i);
return z;
Output
operator + 10 5
15
The word operator as the name of a function, is legal and the only way to overload operators. We
follow this word with the operator we want to overload and then the parameters we will call the
operator with. + is a binary operator and will need two yyy’s, one on its left and the other on its
right. Then at beginning, we give the return value of the operator. In our case we want a + to add
two yyy’s and return a third yyy whose i will be the sum of the individual i’s. Thus a+b will call
the operator + with x being equal to a and y to b. Thus x.i will have a value 10 and y.i, 5. We are
creating a new object z and in the constructor passing 15 i.e. 10 + 5. Thus the i of z will be 15
which is being returned. a + b will now be replaced by the object whose i has a value 15 and c
will be equal to this object. Thus c.i will be equal to 15.
a.cs
public class zzz
yyy b = new yyy(5);
yyy c;
c=a+b;
System.Console.WriteLine(c.i);
public class yyy
public int i;
public yyy( int j)
i = j;
public static yyy operator = ( yyy x , yyy y)

{
return z;
Compiler Error
a.cs(19,28): error CS1020: Overloadable binary operator expected
The error message is telling us that we cannot overload the assignment operator =. Every class
gets a free assignment operator which does a bitwise copy of the variables of the object from the
left to the right.
a.cs
public class zzz
yyy b = new yyy(5);
yyy c = new yyy(2);
yyy d;
d=a+b+c;
System.Console.WriteLine(d.i);
public class yyy
public int i;
public yyy( int j)
i = j;
return z;
Output
Operator + 10 5
Operator + 15 2
17
The only change is d = a + b + c. C# gets easily confused with complex statements so it does not
read all of it. It sees two operators on the same line. In this case, the same plus. An internal rule
tells it to read the plus left to right i.e. it will only see a + b. It will call the operator + with x.i as
10 and y.i as 5 because a’s i is 10 and b’s i is 5. This will create a temporary object like yyy
whose i is 15, lets call it zz. The object z is very different from zz. C# then evaluates zz + c. Thus
x.i will display 15 and y.i will have the value of c.i i.e. 2. To support multiple invocations of the
operator on a single line, the code does not change.
a.cs
public class zzz
yyy b = new yyy(5);
int d = a + b ;
System.Console.WriteLine(d);
public class yyy
public int i;
public yyy( int j)
i = j;
public static int operator + ( yyy x , yyy y)

return x.i + y.i;
Output
operator + 10 5
15
C# does not and will never understand what addition of two yyy’s is all about. It is in your hands
to decide what the code accomplishes. You decide whether the overloaded + returns a yyy or an
int object. The class yyy is your creation not C#’s. Hence you decide what addition means in the
context of a yyy class. In this case, we are returning an int unlike earlier where we returned a
yyy.
a.cs
public class zzz
yyy b = new yyy(5);
int d = a + b ;
System.Console.WriteLine(d);
public class yyy
public int i;
public yyy( int j)
i = j;
public static int operator + ( yyy x , yyy y)
return x.i + y.i;
return z;
Compiler Error
a.cs(23,19): error CS0111: Class ‘yyy’ already defines a member called ‘ op_Addition ‘ with the
same parameter types
You cannot have two operator + overloads which only differ in return types. Also the error
messages change the name of the operator from + to op_Addition. When we overloaded
functions, the return type was not considered part of the function signature. The same applies for
operators.
a.cs
public class zzz

{
yyy b = new yyy(5);
yyy d = a + b + 20;
public class yyy
public int i;
public yyy( int j)
i = j;
return z;
}
Compiler Error
a.cs(7,9): error CS0019: Operator ‘+’ cannot be applied to operands of type ‘yyy’ and ‘int’
C# is now telling you that you can add two yyy’s but cannot do the same, i.e. add a yyy and an
int as we have not told C# how to do so.
a.cs
public class zzz
yyy b = new yyy(5);
yyy d = a + b + 20;
public class yyy
public int i;
public yyy( int j)
i = j;
{
return z;
public static yyy operator + ( yyy x , int y)
System.Console.WriteLine(“operator + “ + x.i + “ “ + y);
yyy z = new yyy(x.i+y);
return z;
Output
Operator + 10 5
Operator + 15 20
35
Life is fun in the fast lane. As we could have a large number of functions with the same name but
differing number of parameters, ditto for operators. a + b as usual calls the first operator +. This
as usual creates a temp object, say zz and now C# reads the line as zz + 20. This matches the
second operator + which now gets called. You can have over a million plus operators with
differing parameters if you desire.
a.cs
public class zzz
{
yyy b = new yyy(5);
if ( a > b )
System.Console.WriteLine(“true”);
else
System.Console.WriteLine(“false”);
public class yyy
public int i;
public yyy( int j)
i = j;
public static bool operator > ( yyy x , yyy y)
System.Console.WriteLine(“operator < “ + x.i + “ “ + y.i);
return x.i > y.i;
Compiler Error
a.cs(20,20): error CS0216: The operator ‘yyy.operator >(yyy, yyy)’ requires a matching operator
‘<‘ to also be defined
C# is a romantic at heart and loves pairs. We tried to overload the > operator and C# tells us that
we have to also overload the < operator. It makes sense as a user would want to know whether a
yyy is greater than or less than another yyy.
a.cs
public class zzz
yyy b = new yyy(5);
if ( a > b )
System.Console.WriteLine(“true”);
else
System.Console.WriteLine(“false”);
public class yyy
public int i;
public yyy( int j)
i = j;
public static bool operator > ( yyy x , yyy y)

{
System.Console.WriteLine(“operator > “ + x.i + “ “ + y.i);
return x.i > y.i;
public static bool operator < ( yyy x , yyy y)
System.Console.WriteLine(“operator < “ + x.i + “ “ + y.i);
return x.i < y.i;
Output
operator > 10 5
true
The operator < returns a bool as we would like to use it as part of an if or a while. In this case we
are using it as part of an if and nothing stops us from using the < overloaded for ints and yyy’s to
return a bool. What code you write in an operator is entirely your decision. The < operator looks
like the + and can take different parameters. To overload the !=, you also have to overload the
==.
a.cs
public class zzz
System.Console.WriteLine(a.ToString());
public class yyy
public int i;
public yyy( int j)
i = j;
Output
yyy
yyy
In the first WriteLine function to be called, we are passing the object a whereas the first
parameter to WriteLine should be a string. Also we do not get an error and we see yyy displayed.
A longtime back we told you that all classes finally derive from object. The class object has a
function ToString. Thus calling the ToString function off a produces the same output as the above
line. We have not created the ToString function. So either we got a free ToString implementation
from C# like we get a free Constructor or the ToString function of object in some way
determines the name of our class and returns it as a string.
a.cs
public class zzz
{
public class yyy
public int i;
public yyy( int j)
i = j;
public string ToString()
System.Console.WriteLine(“ToString”);
return “mukhi”;
Compiler Warning
a.cs(17,15): warning CS0114: ‘yyy.ToString()’ hides inherited member ‘object.ToString()’. To

make the current method override that implementation, add the override keyword. Otherwise add
the new keyword.
It is the same warning if a function exists in the base class.
Output
yyy
ToString
mukhi
WriteLine displays yyy and a.ToString displays mukhi. Which means that they call different
ToString functions. The WriteLine(a) calls the ToString of object whereas the second WriteLine
calls it of yyy. If we want to override a function in the base class, we have to specifically do so
by using the modifier override. If we do not, the default is to call the base class ToString. All this
has been explained earlier, in any case.
a.cs
public class zzz
public class yyy
public int i;
public yyy( int j)
i = j;
}
public override string ToString()
return “mukhi”;
Output
ToString
mukhi
ToString
mukhi
Now both the System.Console.WriteLine calls the ToString function of yyy. We would like to
convert a yyy into a string or an int for example. These type conversions are a major part of
operator overloading.
a.cs
public class zzz
}
public class yyy
public int i;
public yyy( int j)
i = j;
public static implicit operator string(yyy y)
System.Console.WriteLine(“operator string”);
return “string “ + y.i;
return “mukhi”;
Output
operator string
string 10
In spite of having a function ToString, it does not get called unlike earlier. After the keyword
operator we have the name of a data type i.e. string. This function is called whenever we want to
convert our object into a string. The parameter y stands for the object to be converted. In this
function we can write whatever code we want to but we must return a string. In our case we
return the text string concatenated with the current value of i.
Once again, the WriteLine function requires a string class. We are offering a yyy class. C#
checks whether there is an operator string which is available to convert a yyy into a string. As
there is one, it gets called. The word implicit means that we are indirectly implying that it should
be called. Lets explain this with another example.
a.cs
public class zzz
string s;
s = a;
public class yyy
public int i;
public yyy( int j)
i = j;
public static explicit operator string(yyy y)

{
return “mukhi”;
Compiler Error
a.cs(7,5): error CS0029: Cannot implicitly convert type ‘yyy’ to ‘string’
We have changed the word implicit which means imply. It also means giving a hint with the
word explicit which means specify. Had we not changed implicit with explicit, we would have
got no error and C# would have called the operator to convert a into a string and initialize s to it.
a.cs
public class zzz
string s;
s = (string)a;
}
public class yyy
public int i;
public yyy( int j)
i = j;
return “mukhi”;
Output
operator string
string 10
The () is called a cast and it takes any data type within brackets. We are explicitly asking for a
conversion to a string and unlike earlier we are not being implicit but explicit.
a.cs
public class zzz
string s;
s = (string)a;
public class yyy
public int i;
public yyy( int j)
i = j;
return “mukhi”;
Output
operator string
string 10
ToString
mukhi
The explicit will get called only when we cast and as we do not have an implicit modifier, the
ToString gets called. We get no error if we do not have an implicit modifier.
a.cs
public class zzz
string s;
s = (string)a;
public class yyy
public int i;
public yyy( int j)
i = j;
public static implicit operator string(yyy y)
return “mukhi”;
Compiler Error
a.cs(24,15): error CS0557: Duplicate user-defined conversion in class ‘yyy’
We cannot have both the implicit and explicit modifier as two separate functions. Thus you have
to decide which one you would want to implement.
a.cs
public class zzz
yyy a ;
a = 10;
public class yyy
public int i;
public yyy( int j)
i = j;

{
return “mukhi”;
Output
a.cs(7,5): error CS0029: Cannot implicitly convert type ‘int’ to ‘yyy’
One more error. Here we are trying to equate a yyy to an int but unlike earlier, we have not
created an object like yyy by saying new. We would need someone to create the yyy object and
initialize it to 10, an int.
a.cs
public class zzz
yyy a ;
a = 10;
public class yyy
public int i;
public yyy( int j)

{
i = j;
static public implicit operator yyy(int v)
System.Console.WriteLine(“operator yyy int “ + v);
yyy z = new yyy(v);
return z;
return “mukhi”;
Output
operator yyy int 10
10
A constructor has the same name as the name of the class. Thus operator yyy may double up as a
constructor. When we write a = 10, C# calls this constructor and passes the parameter v a value,
10. Operator yyy has now to create an object that looks like yyy and return it. Thus it does not
act like a constructor in the sense that a constructor is responsible for creating the object. In
other words, writing a = 10, creates a new object that looks like yyy and initializes it to 10. It is
different from what we did earlier as previously the operator did not have to create an object that
looks like yyy. In this case it has to.
a.cs
public class zzz
yyy a ;
a = “Hi”;
public class yyy
public int i;
public yyy( int j)
i = j;
static public implicit operator yyy(int v)
System.Console.WriteLine(“operator yyy int “ + v);
yyy z = new yyy(v);
return z;
static public implicit operator yyy(string v)

{
System.Console.WriteLine(“operator yyy string “ + v);
yyy z = new yyy(100);
return z;
return “mukhi”;
Output
operator yyy string Hi
100
We can have as many operator yyy functions as we like, provided we follow the rules of function
overloading. Thus we have two of them, one that takes a string, another that takes an int. In this
case as we are writing a = “hi”, the second operator that accepts a string get called. They all have
to return an object that looks like yyy.
a = (short) 10;
Had we written the above line, we will not get any errors. We assumed we will get an error as we
do not have an operator yyy which takes a short as a parameter. C# is highly intelligent. It first
checks whether we have an operator yyy that matches what we wrote. In no case, there is a
match. It will then check whether there is any other way it can prevent an error from being
signaled. C# realizes that there is an operator yyy which accepts an int. Thus it converts a short
to an int and then calls the operator yyy with the int parameter.
13
Collection Objects
Earlier we used an array in a foreach. If the array had three members, the foreach got executed
three times and each time the variable i had a different value. The concept described below is
called a collection class. It is a class that returns a value each time till the values run out, thus
making it easier for us to iterate through the array.
a.cs
public class zzz
yyy f = new yyy();
foreach (string i in f)
class yyy
}
Compiler Error
a.cs(6,1): error CS1579: foreach statement cannot operate on variables of type ‘yyy’ because
‘yyy’ does not contain a definition for ‘GetEnumerator’, or it is inaccessible
To use yyy in a foreach as a collection class, foreach requires a function GetEnumerator.
a.cs
public class zzz
yyy f = new yyy();
class yyy
public int GetEnumerator()
Compiler Error
a.cs(6,1): error CS1579: foreach statement cannot operate on variables of type 'yyy' because 'int'
does not contain a definition for 'MoveNext', or it is inaccessible
a.cs(13,12): error CS0161: 'yyy.GetEnumerator()': not all code paths return a value
Foreach obviously tries to execute the function called GetEnumerator. This function should not
return an int but something else as the error suggests.
a.cs
using System.Collections;
public class zzz
yyy f = new yyy();
class yyy
public IEnumerator GetEnumerator()
return new xxx();
class xxx : IEnumerator
{
}
Compiler Error
a.cs(19,7): error CS0535: ‘xxx’ does not implement interface member

‘System.Collections.IEnumerator.MoveNext()’

‘System.Collections.IEnumerator.Reset()’

‘System.Collections.IEnumerator.Current’
IEnumerator is an interface which has three functions MoveNext, Reset and Current and xxx has
to implement all of them to remove the compiler errors.
a.cs
public class zzz
yyy f = new yyy();
class yyy
{
return new xxx();
public bool MoveNext()
System.Console.WriteLine(“MoveNext”);
return true;
public void Reset()
System.Console.WriteLine(“Reset”);
public object Current
get
System.Console.WriteLine(“Current”);
return “hi”;
}
}
Run the program and you will notice that the output does not stop. It goes on forever.
IEnumerator is an interface which belongs to the namespace System.Collections. foreach first

calls the function GetEnumerator from yyy. It expects this function to return an object like
IEnumerator. It then calls the function MoveNext from this returned object. If MoveNext returns
true it knows that there is some data to be read and it calls the property Current to access this
data. From Current the get accessor gets called which always returns “hi” in our case. Then
MoveNext gets called and if it returns false, we quit out of the foreach statement. As MoveNext
always returns true, we go into an indefinite loop.
a.cs
public class zzz
yyy f = new yyy();
class yyy

{
return new xxx();
public string [] a = new string[3] {“hi” , “bye” ,”no”};
public int i = -1;
i++;
System.Console.WriteLine(“MoveNext” + i);
if ( i == 3)
return false;
else
return true;
public void Reset()
{
get
System.Console.WriteLine(“Current “ + a[i]);
return a[i];
Output
MoveNext0
Current hi
hi
MoveNext1
Current bye
bye
MoveNext2
Current no
no
MoveNext3
We have created an array a which has 3 members and initialized them respectively to hi, bye and
no by giving the strings in {} immediately after the new. Each time MoveNext gets called the
variable i is increased by 1. If the value of i is 3, we have no more strings to return and thus we
return false, else we return true. The variable i keeps track of how many times the function
MoveNext is being called. As MoveNext returns true, Current gets called which returns a string
from the array using i as the offset. Thus we can iterate through the entire array depending upon
the length.
a.cs
public class zzz
yyy f = new yyy(“This is Great”);
class yyy
string t;
public yyy(string t1)
t = t1;
return new xxx(t);
}
}
public string [] a;
public xxx(string t3)
char [] b = new char[1];
b[0] = ‘ ‘;
a = t3.Split(b);
public int i = -1;
i++;
System.Console.WriteLine(“MoveNext “ + i);
if ( i == a.Length)
return false;
else
return true;
public void Reset()
}
get
System.Console.WriteLine(“Current “ + a[i]);
return a[i];
Output
MoveNext 0
Current This
This
MoveNext 1
Current is
is
MoveNext 2
Current Great
Great
MoveNext 3
Pretty big program. At the time of creating a yyy object we are passing a string to the constructor.
Thus the yyy constructor gets called first. The constructor stores this string in variable t. The
foreach statement calls GetEnumerator which now creates a xxx object passing it the string
through t. The constructor of xxx now gets called. Every string class has a member function
called Split. Split will break up a string on certain characters which we call delimiters. In this
case, we want our string to be broken up whenever we encounter a space. The Split function
requires an array of chars which it can use as a delimiter. The reason it requires an array is
because we may have more than one char that we would like to break the string on. Like earlier,
the array a now contains the array of strings. The last change is the condition in the if statement.
Earlier we used a constant number, now we use a member, Length, of an array which stores the
length of the array or the number of members. Thus the class yyy can now be used as a collection
class which enumerates the individual words in the string. The function Reset for some reason
never ever gets called.
14
Attributes, The Reflection API And Conditionals
Attributes
a.cs
class zzz
[vijay]
class yyy
{
}
Compiler Error
a.cs(7,2): error CS0246: The type or namespace name 'vijay' could not be found (are you missing
Anything in a square bracket is called an attribute. We tried to create an attribute called vijay,
which C#, for some reason, does not seem to recognize.
a.cs
class zzz
class vijay : System.Attribute
[vijay]
class yyy
All that we have done is created a class vijay that has been derived from the class
System.Attribute and the error simply disappears. Thus an attribute is simply a class that derives
from System.Attribute. To understand attributes lets take an example with structures.
a.cs
class zzz
{
yyy a = new yyy();
a.i = 65536+512+3;
System.Console.WriteLine(a.i + " " + a.j + " " + a.k);
struct yyy {
public int i;
public short j;
public byte k;
Output
66051 0 0
A simple revision once again. We have created a structure a, that looks like yyy and initialized
only one member i. Hence we see the warnings. The other members j and k get a default value of
zero.
a.cs
using System;
class zzz
unsafe public static void Main()
{
Console.WriteLine(sizeof(byte) + " " + sizeof(short) + " " + sizeof(int) + " " + sizeof(long));
>csc a.cs
Compiler Error
a.cs(4,27): error CS0227: Unsafe code may only appear if compiling with /unsafe
The error here says that you have to use the /unsafe option while compiling any unsafe code.
>csc a.cs /unsafe
Output
1248
We shall explain the modifier unsafe in the next chapter. Sizeof tells us how much memory C#
allocates for a data type. A byte is allocated one memory location, short 2, int 4 and a long 8.
a.cs
using System.Runtime.InteropServices;
class zzz
yyy a = new yyy();
a.i = 65536+512+3;
System.Console.WriteLine(a.i + “ “ + a.j + “ “ + a.k);
[StructLayout(LayoutKind.Explicit)]
struct yyy
[FieldOffset(0)] public int i;
[FieldOffset(0)] public short j;
[FieldOffset(0)] public byte k;
Output
66051 515 3
We are using an attribute StructLayout that belongs to the namespace

System.Runtime.InteropServices. In the earlier program, we had used an attribute called vijay.
Thus, StructLayout is a class derived from Attribute. We are passing a parameter
LayoutKind.Explicit to it. The output now differs dramatically.
Every variable is stored in memory. FieldOffset indicates the starting position of the variable
within the memory location. Offset of 0 will position i, j, and k, all three variables at the same
memory address of a. Explicit requires FieldOffset to be mentioned as we are explicitly laying
the order for the variables held in the strucuture.LayoutKind.Sequential and LayoutKind.Auto
gives different memory locations to each of the variable.
We will explain the reasons a little later in the coming chapter ‘Unsafe Code’. We have seen how
important attributes are so lets delve deeper into them.
a.cs
class zzz
class vijayAttribute : System.Attribute

{
[vijay]
class yyy
[vijayAttribute]
class yyy1
We are allowed a little leeway in the name of the attribute. By convention, the attribute class
should end with the word Attribute and when we use the attribute, the name attribute is optional.
a.cs
class zzz
[vijay("hi")]
class yyy
{
Compiler Error
a.cs(10,2): error CS1501: No overload for method 'vijay' takes '1' arguments
We had used the attribute StructLayout earlier where we passed a parameter. When we do the
same thing with our attribute vijay, we get the above error.
a.cs
class zzz
public vijay(string s)
[vijay("hi")]
class yyy
}
We forgot to add a constructor that accepts a string as a parameter. If we had passed a number to
our attribute vijay, we would have to create a constructor that accepts an int. Thus if we pass 2
parameters to vijay, we need the appropriate constructor.
a.cs
class zzz
public vijay(string s ,int i)
[vijay("hi",10,mukhi = 200)]
class yyy
Compiler Error
a.cs(13,16): error CS0103: The name 'mukhi' does not exist in the class or namespace 'vijay'
What we tried to do is, take a word called mukhi and initialize it to 200. C# comes back and tells
us that it does not know what mukhi is.
a.cs
class zzz
public int mukhi;
[vijay("hi",10,mukhi = 200)]
class yyy
mukhi, now, is called a named parameter. It can also be termed as a property.
a.cs
class zzz
{
}
public int mukhi;
public string sonal
get
return "ss";
set
[vijay("hi",10, mukhi = 200, sonal = "bye")]
class yyy
{
}
A named parameter is a non-static field or a non-readonly property. A positional parameter is

what we pass on to a constructor. We have 2 positional parameters as our constructor has two
parameters and mukhi and sonal are our named parameters. The named parameters come after
the positional ones. The positional parameter's order is important, but the named parameters can
be in any order. If we don't follow this rule we will get an error as follows.
Compiler Error
a.cs(19,22): error CS1016: Named attribute argument expected
When we place the attribute before a function, the error disappears.
a.cs
using System;
class zzz
[AttributeUsage(AttributeTargets.Class)]
public int mukhi;

public string sonal
get { return "ss"; }
set { ; }
class yyy
[vijay("hi",10, sonal = "bye",mukhi = 200 )]
public void abc() {}
Compiler Error
a.cs(24,2): error CS0592: Attribute 'vijay' is not valid on this declaration type. It is valid on 'class'
declarations only.
AttributeUsage is one more attribute class derived from Attribute. It gives us the option to decide
where the user can use the Attribute. The parameter in this case is class and hence we can use it
only in front of a class and not in front of a method. The default is anywhere.
The Reflection API
Reflection or Introspection is when you look within to find out about your true self. In the same
way we need a method by means of which, our program can find out all about a class. We need
to know how many methods, properties etc while our program is executing or running. This
distinction is important and we could always read the documentation if we wanted to know more
about the functionality of a class. But, C# gives us a large number of functions that tell us the
innards of a class. These functions put together have to be used in a certain way. The functions
have to be called in a certain order and the parameters to them have to conform to certain data
types. This concept is called an API or a Application Program Interface. In short, an API is how a
programmer uses functions to get a desired result.
a.cs
using System;
class zzz
Type m;
m = typeof(int);
System.Console.WriteLine(m.Name + " " + m.FullName);
m = typeof(System.Int32);
m = typeof(yyy);
class yyy
Output
Int32 System.Int32
Int32 System.Int32
yyy yyy
Typeof is a keyword. It needs a class name as a parameter. In the first case, we are specifying a
class called int. typeof returns an object that looks like Type. This class has two members Name,
which gives the name of the class and FullName which is the name preceded with the name of
the Namespace. When we use int as the name of the class, the member Name does not display int
but Int32; we mentioned earlier int is an alias for a structure Int32 in the System namespace. This
is what FullName tells us. We thus have visible proof that int is an alias for a structure. yyy is
class belonging to no namespace and hence the Name and FullName members are similar.
a.cs
using System;
using System.Reflection;
class zzz
Type m = typeof(yyy);
MemberInfo [] n;
n = m.GetMembers();
Console.WriteLine(n.Length);
foreach ( MemberInfo a in n)
Console.WriteLine(a.Name);
class yyy {
private int pqr( int i ) { return 0;}
protected string xyz (string g , int p) {return "";}
}
Output
GetHashCode
Equals
ToString
abc
GetType
.ctor
We are now displaying the members of a class yyy. The class Type has a function called
GetMembers that returns an array of type MemberInfo. Every array has a field called Length that
returns the size of the array. In our specific case it is 6. We then use a foreach to run through each
member of the MemberInfo array and are displaying the name of each function using the field
Name from the class MemberInfo.
a.cs
using System;
class zzz
Type m = typeof(yyy);
MemberInfo [] n;
n = m.GetMembers();
Console.WriteLine(n.Length);
foreach ( MemberInfo a in n)
{
Console.WriteLine((MemberInfo)a + " " + a.DeclaringType);
class yyy {
public int i;
public int pqr( int i ) { return 0;}
public string xyz (string g , int p) {return "";}
Output
Int32 i yyy
Int32 GetHashCode() System.Object
Boolean Equals(System.Object) System.Object
System.String ToString() System.Object
Void abc() yyy
Int32 pqr(Int32) yyy
System.String xyz(System.String, Int32) yyy
System.Type GetType() System.Object
Void .ctor() yyy
The first concept you need to be clear with is that we can inspect only details of public members
and protected or private like pqr and xyz. Also variables are part of the members of a class. The
MemberInfo object has a ToString function that displays the entire function in all its glory
including parameters and their data types. The names of the parameter variables are however not
being displayed. The DeclaringType member returns the class name that the member belongs to.
Thus we can differentiate which class created the function.
Let us now display the attributes used on a class.
a.cs
using System;
class zzz
Type m;
m = typeof(yyy);
System.Console.WriteLine(m.Name);
foreach(object a in m.GetCustomAttributes (true))
Console.WriteLine(a);
[AttributeUsage(AttributeTargets.All)]
string s1,s2;int i1;
public int mukhi;

return s1+" " + s2+" " + i1 + " " + mukhi;
s1=s;i1=i;
public string sonal
get { return s2; }
set { s2 = value; }
[vijay("hi1",10, sonal = "bye1",mukhi = 200 )]
class yyy
public int i;
Output
yyy
hi1 bye1 10 200
GetCustomAttributes takes a boolean as parameter and returns an array of objects. The ToString
function of the attribute class gets called which will decide what string the attribute stands for.
a.cs
using System;
class zzz
Type m;
m = typeof(yyy);
foreach(MethodInfo a in m.GetMethods())
object [] b = a.GetCustomAttributes(true);
foreach(Attribute c in b)
Console.WriteLine(c);
}
}
public int mukhi;
return s1+" " + s2+" " + i1 + " " + mukhi;
s1=s;i1=i;
public string sonal
get { return s2; }
set { s2 = value; }
class yyy
{
public void pqr() {}
Output
yyy
hi2 bye2 100 2000
hi3 bye3 1000 2
The object m looks like Type. As explained earlier, we are calling a function called GetMethods
which returns an array of MethodInfo's. a loops through each one. We have two methods and the
foreach gets executed twice. Once for abc and then for pqr. The GetCustomAttributes also exists
in a MethodInfo class that returns an array of objects representing our attributes. We iterate
through each, displaying what the ToString function returns. As we have only one attribute per
function, the second for each gets executed only once.
a.cs
using System;
class zzz
Type m;
m = typeof(yyy);
if ( c is vijay )
public int mukhi;
return s1+" " + s2+" " + i1 + " " + mukhi;
s1=s;i1=i;
}
public string sonal
get { return s2; }
set { s2 = value; }
class yyy
There is no change at all in the output. A function can be decorated with as many attributes as
you like. We would like to filter out certain attributes.
a.cs
using System;
class zzz

{
Type m;
m = typeof(yyy);
if ( c is vijay )
return "vijay";
class vijay1 : System.Attribute

{
return "vijay";
class yyy
[vijay()]
[vijay()]
[vijay1()]
Output
yyy
vijay
vijay
We have two attribute classes vijay and vijay1. The function pqr has been decorated with 2
attributes whereas abc with only one. However we do not see vijay1 in the output as the 'c is
vijay' makes the if statement true only for the attribute vijay and not vijay1. For the function pqr
GetCustomAttributes returns an array of size two, but the if statement is true only for one of
them, the one with the attribute name vijay. This is because of the 'is'.
a.cs
using System;
class zzz
yyy a = new yyy();
if ( a is yyy)
Console.WriteLine("a yyy");
xxx b = new yyy();
if ( b is xxx)
Console.WriteLine("b xxx");
if ( b is yyy)
Console.WriteLine("b yyy");
int d = 10;
if ( d is yyy)
Console.WriteLine("b yyy");
class xxx
class yyy : xxx
}
Output
a yyy
b xxx
b yyy
We would like to know the data type of an object at runtime. C# offers you a keyword 'is' that
lets you check the data type of an object. a looks like yyy and 'is' results in true. B looks like xxx
but is initialized to a new yyy. Thus it doubles up for a yyy and a xxx resulting in the next two
is's returning true. D is an int and not a yyy, so the last 'is' is false.
Attributes Revisited
Positional parameters are a must whereas names parameters are optional. Attribute parameters
can be a bool, byte, char, short, int, long, float and double. These are the simple types that C#
supports. Other data types are string, enums, objects arrays etc.
Attribute usage has a position parameter which specifies the elements where the attribute can be
used. The default is All. It also has one named parameter called AllowMultiple.
a.cs
using System;
class zzz
{
class yyy
[vijay("hi")][vijay("hi1")]
Compiler Error
a.cs(18,15): error CS0579: Duplicate 'vijay' attribute
By default we cannot use the same attribute twice on any entity.
a.cs
using System;
class zzz
[AttributeUsage(AttributeTargets.All,AllowMultiple=true)]

{
class yyy
[vijay("hi")][vijay("hi1")]
[vijay("hi2") , vijay("hi3")]
We get no error as by default the AllowMultiple named parameter has a value of false. If we set
its value to true, we are allowed to use multiple attributes on any entity. The above two forms are
similar and either one can be used. Attribute permits us to set declarative information for various
program entities for use by someone else at run time.
Conditionals
a.cs
using System.Diagnostics;
using System;
class zzz
yyy a = new yyy();
a.abc();
}
class yyy
[Conditional("vijay")]
public void abc()
When we run the above program we get no output at all. In other words the function abc does not
get called at all. This is inspite of writing a.abc().
a.cs
#define vijay
using System.Diagnostics;
using System;
class zzz
yyy a = new yyy();
a.abc();
}
class yyy
[Conditional("vijay")]
public void abc()
Output
abc
Any line beginning with a # is read by the C# pre-processor, a program that starts before the C#
compiler starts. It has words like #define which creates a variable or word called vijay. In a
programming language, a variable has to have a value, but in the preprocessor scheme of things,
it may/maynot have a value. However if we do not give it a value, like in this case, the variable is
only set to have been defined or created. Anything in [] brackets is an Attribute class. Earlier we
had not created a variable vijay and hence the entire code of abc was left out of the executable
file. Not only that, but all calls to function abc were eliminated from our code. All of this by
defining or not defining a variable vijay. This is what we passed as the attribute to Conditional.
We can create functions that are omitted during compilation depending upon a preprocessing
symbol.
When we write code, we add a lot of code for debugging purposes. This code is to help the
programmer debug code. After a function works, it is error free, we do not require any of this
debugging code. One way to eliminate this debugging code is by making the functions
conditional. The resulting code is called a 'Retail build' and the debugging version, obviously a
'Debug build'. A Retail build is much smaller in size and obviously much faster. The #define has
to be at the start of code.
Another way of achieving the same result is by eliminating the #define from the code and
creating a preprocessor symbol as an option to the compiler.
>csc a.cs /d:vijay
The compiler option is /d and the colon is part of the syntax. Following the colon is the name of
the preprocessor symbol. In this case, it is vijay. We’ve discussed preprocessors in one of the
earlier chapters.
a.cs
using System;
class zzz
yyy a = new yyy();
a.abc();
class yyy
[Obsolete]
public void abc()
Compiler Error
a.cs(7,1): warning CS0612: 'yyy.abc()' is obsolete
Output
abc
Many a times we create functions in a class which we would not want the user to use, as these
functions were useful years ago, but are now obsolete. The only way to warn the user that some
time in the future we will no longer support these functions is by marking them with the attribute
Obsolete. We see the warning as displayed above but the program runs as normal.
15
Unsafe code
Today, the programming language C is the most widely used because of only one reason and that
is the use of pointers. In this chapter, we will explain what pointers are all about and how they
can be used in the world of C#.
a.cs
class zzz
yyy a = new yyy();
a.abc();
class yyy
public void abc()

{
int *i;
Compiler Error
a.cs(13,6): error CS0214: Pointers may only be used in an unsafe context
All simple variables like int, byte, short store numbers. When we create a variable in C#, we are
allowed to put a multiplication/asterisk sign '*' in front of the variable. These variables are called
Pointers. We get an error as C# considers pointers to be unsafe and hence we need special
permission to use pointers.
a.cs
class zzz
yyy a = new yyy();
a.abc();
class yyy
unsafe public void abc()
int *i;
}
}
Compiler Error
a.cs(11,20): error CS0227: Unsafe code may only appear if compiling with /unsafe
As seen in the previous chapter, the unsafe option must be tagged while compiling the program.
Give the command as csc a.cs /unsafe and the error now disappears.
a.cs
class zzz
yyy a = new yyy();
a.abc();
unsafe class yyy
public void abc()
int *i;
The C# documentation very clearly states that the modifier can be used along with the class
keyword, By using the modifier unsafe, we are asking C# to let us use pointers as we are unable
to write code without the use of pointers.
a.cs
using System;
class zzz
yyy a = new yyy();
a.abc();
class yyy
Console.WriteLine(sizeof(byte *) + " " + sizeof(short *) + " " + sizeof(int *) + " " + sizeof(long
*));
Console.WriteLine(sizeof(byte **) + " " + sizeof(short **) + " " + sizeof(int **) + " " +
sizeof(long **));
Output
4444
4444
Some time back, we had used the sizeof keyword, to determine how much memory C# allocates
for our variables. When we ask for the sizeof an pointer variable, we always get 4, irrespective of
whether the data type is a short or int or whatever, including another pointer.
a.cs
using System;
class zzz {
yyy a = new yyy();
a.abc();
class yyy {
unsafe public void abc() {
int *i;
int j=1;
i = &j;
Console.WriteLine((int)i);
*i = 10;
Console.WriteLine(j);
Output
1243472
10
We have created a variable j that has been initialized to one. We have also created a variable i,
with a multiplication sign at the time of creation. By doing this C# allocated four memory
locations to store i. What is most important is that a pointer variable is just like any another
variable. It simply stores numbers. The single big difference is that a pointer variable value is
interpreted as a computer memory location. If both i and j were being initialized to 1, then j is the
number 1 as we know it, whereas i stand for computer memory location 1. Pointers can only be
initialized to a computer memory location. Whenever we place an ampersand(&) in front of a
variable, we are asking C# to tell us about the memory allocated for the variable. Every time C#
creates a variable, it stores it somewhere in memory. We are at times interested in knowing where
in memory the variable was allocated. A & in front of j will tell us the memory location where j
starts in memory. As it is a computer memory location or address we can store it in i. C#
allocated 4 memory location for j and the start of these 4 are being stored in a pointer.
We would like to display the value of the pointer. The WriteLine function does not have an
overload to display a pointer and we have to cast it to an int. As we get 1243472 displayed, it
could only mean that the variable j begins here and is spread over memory locations 1243473,
1243474 and 1243475.
We can only place the multiplication sign in front of a variable defined to be a pointer. If i is not
a pointer, *i will return an error. C# here asks a simple question. What is the value of the variable
i? . The answer is 1243472. C# will now go to memory location 1243472 to 1243475 and place
the value 10 there. As the value of j is determined by what is present from memory locations
1243472 to 1243475, the value of j changes from 1 to 10.
a.cs
using System;
class zzz
yyy a = new yyy();
a.abc();
class yyy
int *i;
int j=1, k = 1;
i = &j;
*i = 10;
Console.WriteLine(j);
i = &k;
*i = 100;
Console.WriteLine(k + " " + j);
Output
1243468
10
1243464
100 10
Whenever we create a pointer variable, int *i, we are not stating explicitly which int i will be
pointing to. Thus it can point to one int today, another int tomorrow. This is what gives pointers
their flexibility. It can point to any int it wants to in memory. We are first initializing i to point to
j, then we are changing the value of j to 10 through the pointer. Then i points to k in memory, and
then k's value is indirectly being changed to 100 through the pointer. The first WriteLine tells us
that the variable j begins at memory location 1243468. From here the next 4 have been reserved
for the variable j. Memory for k has been allocated at 1243464. Thus, physically, k starts first in
memory from 1243464 to 67 and j from 1243468 onwards.
a.cs
using System;
class zzz
yyy a = new yyy();
a.abc();
}
class yyy
int *i;
int j=1;
i = &j;
Console.WriteLine((int)i + " " + (int) &i);
Output
1243464 1243468
Lets not forget that pointers are also variables and C# allocates memory for i. An & in front of
any variable tells us where it starts in memory. Thus i starts from memory location 1243468
onwards.
a.cs
using System;
class zzz
yyy a = new yyy();

a.abc();
class yyy
long *i;
long j=1, k = 1;
i = &j;
i = &k;
Output
1243460
1243468
The sizeof a long is 8 bytes and the addresses printed differ by 8 bytes.
a.cs
using System;
class zzz
{
yyy a = new yyy();
a.abc();
class yyy {
unsafe public void abc(){
byte *i;
byte j=1, k = 1;
i = &j;
i = &k;
Output
1243468
1243472
The only change here is that j and k are not longs but bytes. Why are we learning all about
pointers is a question you should ask yourself. The C# documentation says very clearly that a
byte occupies one memory location. The sizeof byte will also return one. In the above output,
however, the memory locations differ by 4. The reason being that on the Pentium Processor, if
we want one memory location, we will receive a minimum of 4. That's why, the Pentium is said
to be a 32-bit processor. It will give you memory in chunks of 4. From this knowledge, using a
byte instead of a int does not conserve memory or speed up your program. The above
explanation cannot be comprehended without the knowledge of pointers.
a.cs
using System;
class zzz
yyy a = new yyy();
a.abc();
class yyy
byte *i;
i = 0;
Compiler Error
a.cs(15,5): error CS0029: Cannot implicitly convert type 'int' to 'byte*'
C# is a strongly typed language and we are not allowed to convert a zero which is an int to a byte
*, the data type of i. The only way out is to use a cast.
a.cs
using System;
class zzz
yyy a = new yyy();
a.abc();
class yyy
byte *i;char *j;int *k;long *l;
i = (byte *)0; j = (char *)0; k = (int *)0 ; l = (long *)0;
Console.WriteLine((int)i + " " + (int) j + " " + (int) k + " " + (int)l);
i++;j++;k++;l++;
i++;j++;k++;l++;
Output
0000
1248
2 4 8 16
A pointer to any data type is allocated four memory locations at the time of creation. This
enables pointers to store values that range from 0 to 4 billion. The question that comes to your
mind, is what is the difference between a pointer to an int from a pointer to a long. We have
created four variables i, j, k, l. Each is a pointer to a different data type. We have also initialized
each variable to 0 and displayed their values using the WriteLine function. We have then
incremented each of them by 1. To our surprise the pointer to an int k, increases by 4 and not by
1. The char pointer increases by 2 and long by 8. To make sure that is not a isolated phenomena,
we increment them again. Same answer once again. They do not increase by one but by the size
of the data type they point to. The sizeof a long is 8 and thus a pointer to a long increases by 8
and not 1.
When we initialized l to zero, we were telling C# that a long begins at memory location 0. This
long will occupy the next 8 memory locations, form 0 to 7. Thus when we write l++, we are
telling C# to take us to the next long in memory, which has to begins now at 8. The first
difference between pointers to different data types is that the amount the pointer value increases
is dependent upon what it is pointing to.
a.cs
using System;
class zzz
yyy a = new yyy();
a.abc();
class yyy
{
unsafe public void pqr(int x , int y , int z)
int *p1; int *p2; int *p3;
p1 = &x; p2 = &y ; p3 = &z;
Console.WriteLine((int) p1 + " " + (int) p2 + " " + (int) p3);
*p1 = 20;
*p2 = 30;
int *i ; int *j ; int *k;
int l=1,m=2,n=3;
i=&l; j=&m; k=&n;
Console.WriteLine((int) i + " " + (int) j + " " + (int) k);
pqr(l,m,n);
Console.WriteLine(l + " " + m + " " + n); }}
Output
1243460 1243456 1243452
1243424 1243436 1243432
123
We have created a variable i of type int in memory. It begins at memory location 1243460.
Similarly m and n start at 56 and 52 respectively. We are then calling a function pqr and passing
three parameters to it. These are being stored at memory locations 1243424, 36 and 32
respectively. When we write *p1, we are going to memory location 1243424 and writing 20
there. This will change the value of x from 1 to 20. As variable l begins at 1243460, its value
remains unchanged. The area of memory where x, y and z start is called the stack. Stack memory
is used to pass parameters to functions.
a.cs
using System;
class zzz
yyy a = new yyy();
a.abc();
class yyy
p1 = &x; p2 = &y ; p3 = &z;
unsafe public void xyz(int x , int y , int z)
p1 = &x; p2 = &y ; p3 = &z;

int l=1,m=2,n=3;
i=&l; j=&m; k=&n;
pqr(l,m,n);
xyz(l,m,n);
Output
1243460 1243456 1243452
1243424 1243436 1243432
1243424 1243436 1243432
Now you will begin to comprehend the importance of pointers. Its is an understanding of
pointers that will give you a better insight into understanding the innards of a programming
language. The last two WriteLines display the same answer as the stack memory gets reused for
every function call. The stack is an area of memory that will store parameters and variables
created in a function. Let us assume that the stack begins at memory location 100. The
parameters are first pushed onto the stack and then all the local variables are created later, but
below the parameters. Remember that the stack grows down in memory. When the function is
over, the stack is moved back to 100, and the next function that gets called, reuses the same
memory from 100. Thus anything created in a function has a lifetime of the open and close
braces as the next function uses the same memory and the earlier values get overwritten.
a.cs
using System;
class zzz
yyy a = new yyy();
a.abc();
class yyy
unsafe public void xyz()
int i=0,j=0,k=0;
p1 = &i; p2 = &j ; p3 = &k;
unsafe public void aaa()
int x=0,y=0,z=0;
p1 = &x; p2 = &y ; p3 = &z;

}
unsafe public void pqr()
int i=0,j=0,k=0;
p1 = &i; p2 = &j ; p3 = &k;
pqr();
xyz();
aaa();
Output
1243460 1243464 1243468
1243460 1243464 1243468
1243460 1243464 1243468
The above program proves a number of points. C# reuses the same memory for passing
parameters and creating variables in functions. The variable names are not important as they get
created on the stack, at the same place in memory.
a.cs
using System;
class zzz
yyy a = new yyy();
a.abc();
class yyy
p1 = &x; p2 = &y ; p3 = &z;
p3++;p3++;p3++;p3++;p3++;p3++;
Console.WriteLine((int) p3);
*p3=20;
p3++;
Console.WriteLine((int) p3);
*p3=200;
}
int l=1,m=2,n=3;
i=&l; j=&m; k=&n;
pqr(l,m,n);
Console.WriteLine(l + " " + m + " " + n);
Output
1243460 1243456 1243452
1243424 1243436 1243432
1243452
1243456
1 200 20
Pointers are really unsafe. There is a simple rule in C# which says that variables created in one
function abc, cannot be changed by another function pqr. The variables m and n begin at memory
locations 1243456 1243452 respectively. If there was some way, I could write to these memory
locations, I would be changing the values of m and n respectively. The pointer p3 stores, where
the parameter z is stored in memory i.e. 1243432. If we can increment this pointer 6 times, 6 will
actually be 24 due to pointer arithmetic, the value of p will now be 1243452 which is the address
of n in memory. Thus from one function, I can change the value of another variable. In this case
we are doing it on purpose but if I called a function, where a pointer went haywire, my variables
change and nobody knows why the program stops working. Thus pointers are like a sharp knife,
it can save a life in the hands of a doctor but in the wrong hands it can also kill.
a.cs
using System;
class zzz
yyy a = new yyy();
a.abc();
class yyy
p1 = &x; p2 = &y ; p3 = &z;
int q = 1;
while ( q <= 12 )
p1++;
Console.WriteLine((int) p1 + " " + *p1);
q++;
}
int l=1,m=2,n=3;
i=&l; j=&m; k=&n;
pqr(l,m,n);
Console.WriteLine(l + " " + m + " " + n);
Output
1243460 1243456 1243452
1243424 1243436 1243432
1243428 47645012
1243432 3
1243436 2
1243440 0
1243444 1243508
1243448 1243544
1243452 3
1243456 2
1243460 1
1243464 1243452
1243468 1243460
1243472 1243484
123
Would it not be a great idea to be able to display whatever is there on the stack. Between
variables there are some gaps and the above program is displaying the contents of the stack. The
variable q makes the loop go on 12 times and each time we increment p1 by 4. P1 is pointing to x
the first parameter on the stack. Would it not aid understanding if Microsoft explained what all it
pushes on the stack. One of the most common hacking exploits on the net is called a stack
overflow.
a.cs
using System;
class zzz
yyy a = new yyy();
a.abc();
public class yyy
unsafe public void pqr( int *a)
Console.WriteLine("{0} {1} {2}",a[0],a[1],a[2]);

{
int [] a = new int[3];
a[0] = 10; a[1] = 2; a[2] = 30;
pqr(a);
Compiler Error
a.cs(20,1): error CS1502: The best overloaded method match for 'yyy.pqr(int*)' has some invalid
arguments
a.cs(20,5): error CS1503: Argument '1': cannot convert from 'int[]' to 'int*'
We were trying to pass an array as a parameter to a function. Unfortunately C# has some other
views.
a.cs
using System;
class zzz
yyy a = new yyy();
a.abc();
public class yyy
{
a[0] = 10; a[1] = 2; a[2] = 30;
fixed ( int *i = a) pqr(i);
Output
10 2 30
The keyword fixed removed the error. An array in memory can be moved around by C#. We
would like C# to keep it fixed in memory. The keyword fixed guarantees that C# will not move it
around in RAM for the duration of the program. The only reason C# moves objects in memory is
to speed up execution of the program. The keyword fixed as part of syntax wants the () .Within
them you can create a variable in our case i which we initialize to a C# object, an array a. The
scope or lifetime of this array is in the next statement i.e. the invocation of function pqr. In case
you have more lines you can use the {}. Even though a now is a pointer to an int, the notation
a[0] refers to the first member. The name of an array tells us where the array starts in memory.
a.cs
using System;
class zzz
{
yyy a = new yyy();
a.abc();
public class yyy
a[0] = 100 ; a[1] = 40; *(a+2) = 33;
a[0] = 10; a[1] = 2; a[2] = 30;
Output
10 2 30
100 40 33
Changing anything through a pointer changes the original. Whenever we write a[1]= , we are
changing the first member of the original array. a[1] is only a notation, it actually get converted
to *(a+1). Thus we are changing the original members of the array. Also the array grows upward
in memory.
a.cs
using System;
class zzz
yyy a = new yyy();
a.abc();
public class yyy
for ( int i = 0 ; i<= 2000; i++)
*(a+i) = i*10;
a[0] = 10; a[1] = 2; a[2] = 30;

Please do not run the above program as the error would be unpredictable. The reason being that
we are writing beyond the bounds of the array. The array a created in the function abc has only
12 memory locations allocated for it. We are writing the next 2000 * 4, 8000 memory locations.
The error on your machine will be very different form another machine. This unpredictability is
why pointer errors are hard to catch, and your boss would thus not like you to use a pointer while
programming.
a.cs
using System;
class zzz
yyy a = new yyy();
a.abc();
struct aaa
public int i,j;
class yyy
{
aaa *a;aaa b;
b = new aaa();
a = (aaa *)b;
Compiler Error
a.cs(20,10): error CS0030: Cannot convert type 'aaa' to 'aaa*'
aaa is a structure with two members i and j. new aaa() allocates memory for i and j. new aaa()
and b are of the same data type ie aaa. When we try to equate a and b, C# canot convert a pointer
to a struct/class to the object itself. Remember new returns not a pointer to an object but the
object itself.
a.cs
using System;
class zzz
yyy a = new yyy();
a.abc();
struct aaa
{
public int i,j;
class yyy
aaa *a;aaa b;
b = new aaa();
a = &b;
int *x;
x = &(a->i);
int *y;
y = &(a->j);
Console.WriteLine((int) a + " " + (int)x + " " + (int) y);
Output
1243468 1243468 1243472
We need to take the address of where b begins in memory by using the & and equate that to a.
The address of an object like aaa is of the data type aaa *. As a now is a pointer to a structure, we
have to use a different syntax to display the members of the structure. The new way is to use the
-> operator. Thus a->i refers to the member i of the structure that looks like aaa. The variable x
now stores the address of where the first member i begins in memory. Obviously the address of
the first member i and the address of the structure will be the same and the second member will
be stored 4 later.
a.cs
using System;
class zzz
yyy a = new yyy();
a.abc();
struct aaa
public int i,j;
class yyy
aaa *a;aaa b;
b = new aaa();
a = &b;
Console.WriteLine((int) a);
b = new aaa();
a = &b;
Console.WriteLine((int) a);
Output
1243468
1243468
We have one object b that we have initialized twice with new. Each time we get the same
memory location as the address of b in memory will remain the same.
Unions
a.cs
class zzz
yyy a = new yyy();
a.i = 65536+512+3;
int *i1;short *j1;byte *k1;
i1 = &a.i; j1 = &a.j ; k1 = &a.k;
System.Console.WriteLine((int)i1 + " " + (int) j1 + " " + (int) k1);
System.Console.WriteLine(sizeof(yyy));
}
struct yyy
[FieldOffset(0)] public int i;
[FieldOffset(0)] public short j;
[FieldOffset(0)] public byte k;
Output
66051 515 3
1243476 1243476 1243476
Let us understand what a union is all about. We are printing the addresses of i, j and k and lo and
behold they are all the same. In a union all the members begin at the same place and that is why
their addresses were similar. If we understand pointers, understanding unions then becomes a
piece of cake as we can visually see the addresses.
a.cs
class zzz

{
yyy a = new yyy();
a.i = 65536+512+3;
int *i1;short *j1;byte *k1;
i1 = &a.i; j1 = &a.j ; k1 = &a.k;
System.Console.WriteLine((int)i1 + " " + (int) j1 + " " + (int) k1);
System.Console.WriteLine(sizeof(yyy));
struct yyy
[FieldOffset(0)]
public int i;
[FieldOffset(0)]
public short j;
[FieldOffset(10)]
public byte k;
Output
66051 515 0
1243468 1243468 1243478

11
a.cs
using System;
class zzz
yyy a = new yyy();
a.abc();
class yyy
short i = 512+3;
byte *j;
j = (byte *)&i;
Console.WriteLine((int)j + " " + i );
*j = 1;
Console.WriteLine(i);
j++;
Console.WriteLine((int)j);
*j=1;
j++;
*j=10;
Output
1243468 515
513
1243469
257
1243470
257
j is a pointer to a byte. From the output, we can see that i begins at 1243468. i is of data type
short which means it takes 2 bytes. j now contains the the address value of i i.e. 1243468. The
first line proves it. The statement *j=1 will change the bottom byte value to 1.j++ will then
increment the address value by 1, hence *j=1 will now change the top byte to 1. The last j++ has
no effect because the scope of short is only 2 btes. Hence we see no change in the value of i.
Here, in place of the data type short, we have given an int.
a.cs
using System;
class zzz {
yyy a = new yyy();
a.abc();
class yyy {
int i = 512+3;
byte *j;
j = (byte *)&i;
Console.WriteLine((int)j + " " + i );
*j = 1;
j++;
*j=1;
j++;
*j=10;
Output
1243468 515
513
1243469
257
1243470
655617
The last j++ in the series will touch the third byte, there by replacing the 1 to 10. Hence the
output changes dramatically.

Csharp Basics

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Csharp Basics

Încărcat de

Drepturi de autor:

Formate disponibile

Authors

Sandeep Shanbhag (sandy.shanbhag@vsnl.com) is a Chartered Accountant by profession, a

Sonal Mukhi (svmukhi@yahoo.com) is a freelance programmer having a widespread exposure

Who should read this book?

inspiration through the process of writing this book.

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

Once done, type the command as follows:

static void Main()

static void Main()

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

static void Main()

static void Main()

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

static void Main()

static void Main()

static void Main()

static void abc()

static void Main()

static void abc()

static void pqr()

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

static void Main()

static void abc()

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

static void pqr()

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

static void Main()

The program below is simply an extension of the above.

static void Main()

static void Main()

Our next program will demonstrate how this can be done.

static void Main()

static void Main()

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

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);

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

static void Main()

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

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

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

static void Main()

bool ii; int jj;

Executing the above program gives the following errors:

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'

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

static void Main()

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

static void Main()

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

Let's understand the rationale behind it.

The following program will make this concept clearer.

static void Main()

static void Main()

static void Main()

static void Main()

Our next program explains the for loop.