1

Anna University B.E. (Computer Science)

---------------------------------------------------------------------------------
CS6001 C# and .NET Framework (Elective I)
VI-Sem-CSE 2013-Regulations
--------------------------------------------------------------------------------------------
Question Bank
UNIT-I
1) Define a) Problem Domain b) Solution Domain
Solving a problem involves conversion of problem domain or problem space to Solution domain. The
problem domain is a sector or sectors to which the problem belongs. It is an area of interest having clearly
defined boundaries. It forms an autonomous body describing high level features.
The Solution domain is the subject matter that is of concern to the computer system and the implementor
of the system. It describes the features in a manner which can be understood by the computer.
The problem domain refers to the scope of the problem being addressed by the software system. While
solving a problem using a computer ,its solution is in the form of a program.

2) Define in brief Object Oriented Principles.

OOP is based on three key principles: encapsulation, inheritance, and polymorphism. Encapsulation binds
together code and data, inheritance is the mechanism by which one class can inherit the functionality of
another, and polymorphism lets you define one interface that describes a general set of actions. These attributes
work together in a powerful way that enables the construction of reliable, reusable, and extensible programs.

3) Define a)Abstraction b)Encapsulation

a) The essential features of an entity is known as abstraction. A feature may be either an attribute
reflecting a property(or state or data) or an operation reflecting a method( or a behavior or function).
Abstraction defines necessary and sufficient description rather than implementation. An inteterface is an
abstraction and is the separation of an interface and its implementation is an example of abstraction.
b) From the user’s point of view ,a number of features are packaged in a capsule to form an entity.
This entity offers a number of services in the form of interfaces by hiding the implementation detail.
The adcantages of encapsulation are a) Information hiding b) Implementation independence

4) Differentiate an interface from its implementation.

Slno Interface Implementation

1 It is user’s view point. (What It is supplier’s view point.
part) (How part)
2 It is used to interact with the It describes how the delegated
outside world responsibility is carried out.
3 User is permitted to access the Functions or methods are
interfaces only permitted to access the data.
4 It It provides the restriction of
encapsulates the knowledge access data by the user.
about the object.

5) Define a) Class b) Object

A group of objects sharing common structure and behavior is called a class. A class is a template
for creating objects.
An object is an instance of a class. An object has identity,state and behavior.
2

A C# program is basically a collection of classes. A class is defined by a set of declaration statements and
methods containing instructions known as executable statements.

6) Differentiate an Object and a Class.

A class is a template for creating an object. An object is an instance of a class. An object has
memory and reference.
The class is C#'s basic unit of program functionality. However, it is more than that. It is also C#'s
foundation for object-oriented programming (OOP)

7) What are the advantages of OOP?

 Code reuse
 Seamless transition from different phases of s/w development
 Modularity

8) What are the applications of C# ?

1) console applications
2) Winows applications
3) Developing windows controls
4) Developing ASP.NET projects
5) Creating Web Controls
6) Providing web services
7) Developiong .NET component library

9) What is .NET Framework?

.NET represents an advanced new generation of software that will drive the Next Generation Internet.
Its purpose is to make information available any time, any place, and on any device.
Quick Definition
.NET is an initiative to integrate all Microsoft products with the “Next Generation” web.

.NET is a software framework that includes everything requiered for developing software for web services. It
integrates presentation technologies,component technologies,and data technologies on a single platform so as to
enable users to develop internet applications as easily as thyey do on desktop systems.
In brief .NET platform provides a new environment for creating and running robust,scalable and distributed
applications over the web.
It consists of three distinct technologies

a)Common Language Runtime

b) Framework base classes
c) User and program Interfaces(ASP.NET and Winforms)
3

10) State the Charateristics of C#.

a) Simple – C# simplifies C++ by eliminating irksome operations such as →,:: and pointers
b) Consistent – C# supports unified type system
c) Modern – Automatic garbage Collection
Modern approach to debugging
Rich intrinsic model for error handling
Decimal data type for financial applications
Robust security model
d) Object Oriented
Supports encapsulation,Inheritance, and Polymorphism
In C#,every thing is an object. There is no global functions,variables and constants
e) Type Safe – promotes robust programs
Following are some type safe measures :
i. All dynamically allocated objects and arrays are initialized to zero
ii. Use of uninitialized variables produces an error message by the compiler
iii. Access to arrays are range checked and warned if it goes out-of bounds
iv. C# does not permit unsafe casts
v. C# enforces overflow checking in arithmetic operations
vi. Reference paramets that are passed are type-safe
vii. C# supports automatic garbage collection
f) C# is versionable – Making new versions of software modules work with existing applications is
known as versioning. C# provides support for versioning with the help of new and override keywords.
Using versioning,a programmer can guarantee that his new class library will maintain binary
compatibility with the existing client applications.
g) Compatible - C# enforces the .NET common Language specifications and therefore allows inter-
operation with other .NET languages. C# provides support for transparent acces to COM and OLE
automation
4

h) Interoperability – C# provides support for using COM objects

11) Write the compilation and execution commands of a C# source program.

Overview of a C# Program
Hello, world
The canonical “Hello, world” program can be written in C# as follows:
using System;
class Hello
{
static void Main()
{
Console.WriteLine(“Hello, world”);
}
}
C# is a case-sensitive language: Incorrect case prevents the code from compiling successfully.
Those experienced in programming with Java, C, or C++ will immediately see similarities. Like Java, C#
inherits its basic syntax from C and C++. Syntactic punctuation (such as semicolons and curly braces), features
(such as case sensitivity), and keywords (such as class, public, and void) are familiar to programmers
experienced in these languages. Beginners and programmers from other languages will quickly find these
constructs intuitive.
Compiling and Running the Application
The default file extension for C# programs is .cs, as in hello.cs. Such a program can be compiled with the
command line directive
csc hello.cs
Which produces an executable program named hello.exe. The output of the program is: Hello, world

12) Explain the structure of a C# program with an example.

Structure of a Simple C# Program
The following diagram illstrates a simple C# program and explains its components one by one. This will
introduce a range of topics, from the structure of a C# program to the method of producing program
output to the screen.
Let’s start by looking at a simple C# program. The complete program source is shown as below. When
the code is compiled and executed, it displays the string “Hi there!” in a window on the screen.
5

Line Description
Number
Line 1 Tells the compiler that this program uses types from the System namespace.
Line 3 Declares a new namespace, called Simple.
• The new namespace starts at the open curly brace on line 4 and extends through the
matching curly brace on line 12.
• Any types declared within this section are members of the namespace.
Line 5 Declares a new class type, called Program.
• Any members declared between the matching curly braces on lines 6 and 11 are
members that make up this class.
Line 7 Declares a method called Main as a member of class Program.
•In this program, Main is the only member of the Program class.
• Main is a special function used by the compiler as the starting point of the program.
Line 9 Contains only a single, simple statement; this line constitutes the body of Main.
• Simple statements are terminated by a semicolon.
• This statement uses a class called Console, in namespace System, to print out the
message to a window on the screen.
•Without the using statement in line 1, the compiler wouldn’t have known where to
look for class Console.

 To compile the program, you can use Visual Studio or the command-line compiler. To use the
command-line compiler, in its simplest form, use the following command:

csc SimpleProgram.cs

13) What are tokens? What are the tokens supported in C# Language?
The smallest, non execuatable ,textual elements in a program are refered to as tokens. The compiler recognizes
them by building up expressions and statements.
In simple sterms,a C# program is a collection of tokens. C# includes the following five types of tokens :

 Keywords
 Identifiers
 Literals
 Operators
 Punctuators
6

Keywords are essential part of language definition. They implement specific features of the language. They
are reserved,and cannot be used as identifiers except when they are prefacedby the @ character.
Few C# keywords are :

bool float namespace static

byte for new string
char foreach private this
catch finally override throw

Identifiers are programmer-designed tokens. They are used for naming

classes,methods,variables,labels,namespaces,interfaces etc.
The rules for defining identifiers are :
a) They have alphabets,digits and underscore characters.
b) They must not begin with a digit.

Literals are value constants assigned to variables (or results or expressions) in a program.
The Literal types are :

Numeric Literals Boolean Character Literals

Literals
Integer literals Real Literals  True Single String
 false character
An integer literal refers to a sequence Numbers '5' “Hello
of digits. containing 'X' World”
Decimal Integers fractional parts
123
-321 Eg
0 215.95
Hexadecimal Integers -0.75
0X2
0X9F A real literal can
be expressed in
exponential or
scientific
notation.
0.65e4
18E3
-1.2E-1

The format is
mantissa e
exponent

Operators are symbols used in expressions to describe operations involving one or more operands.
Punctuators are symbols used in grouping and seperating code. They define the shape and function of a
program.
Some Punctuators supported in C# are
7

 Parentheses ()  Colon :
 Braces { }  Comma ,
 Brackets [ ]  Period .
 Semicolon ;

14) What are Escape Sequences? Enumerate differenct Esc Sequences.

Escape sequences are special backslash character constants that are used in output methods. For example '\n'
stands for a newline character.
The following tables lists the common Escape Sequences used in C#.
Literal constant Meaning
'\a' alert
'\b' Back space
'\f' Form feed
'\n' New line
'\r' Carriage return
'\t' Horizontal tab
'\v' Vertical tab
'\'' Single quote
'\''' Double quote
'\\' Back slash
'\o' null

15) What the data types supported in C#?

16) Explain the difference between a Value type and reference type. Illustrate with some examples
Value types:

* Value types can be created at compile time.

* Stored in stack memory.
* Garbage collector can't access the stack
* value types holds the data directly
* No default values will be stored in value types
* Examples for value types: Predefined datatypes,structures,enums
8

Reference types:

* Reference types can be created at run time.

* Stored in heap memory
* Garbage collector can access heap
* Reference types holds the data indiredtly
* Reference types holds default value
* Examples for reference types: Classes,objects,Arrays,Indexers,Interfaces

17) How literals are classified in C#?

What is a Numeric Literal?

A numeric literal is a fixed number that may be assigned to a variable or used in calculations. Literals
are sometimes known as constants. However, this should be avoided as there are other types of
constant in C#. Here are some examples of literals being assigned to variables:
int facesOnADie = 6; // 6 is a literal
int lessThanZero = -1; // -1 is a literal
int zeroValue = 0; // 0 is a literal
double piApprox = 3.142; // 3.142 is a literal

Boolean Literals
Two literal values are permitted for the Boolean data type. These are false and true. No other values are
valid.
bool grassIsGreen = true;
bool cowsGoBaa = false;

String literals

C# supports two forms of string literals: regular string literals and verbatim string literals.

A regular string literal consists of zero or more characters enclosed in double quotes, as in "hello", and
may include both simple escape sequences (such as \t for the tab character) and hexadecimal and
Unicode escape sequences.

A verbatim string literal consists of an @ character followed by a double-quote character, zero or more
characters, and a closing double-quote character. A simple example is @"hello". In a verbatim string
literal, the characters between the delimiters are interpreted verbatim, the only exception being a quote-
escape-sequence. In particular, simple escape sequences and hexadecimal and Unicode escape
sequences are not processed in verbatim string literals. A verbatim string literal may span multiple lines.

The example

string a = "hello, world"; // hello, world

string b = @"hello, world"; // hello, world
string c = "hello \t world"; // hello world
string d = @"hello \t world"; // hello \t world
string e = "Joe said \"Hello\" to me"; // Joe said "Hello" to me
string f = @"Joe said ""Hello"" to me"; // Joe said "Hello" to me
string g = "\\\\server\\share\\file.txt"; // \\server\share\file.txt
string h = @"\\server\share\file.txt"; // \\server\share\file.txt
9

string i = "one\r\ntwo\r\nthree";
string j = @"one
two
three";

shows a variety of string literals. The last string literal, j, is a verbatim string literal that spans multiple
lines. The characters between the quotation marks, including white space such as new line characters,
are preserved verbatim.

18) Enumerate list of operators available in C# and classify them according to their functionality.

C# Operators
C# provides a large set of operators, which are symbols that specify which operations to perform in an
expression. Operations on integral types such as ==, !=, <, >, <=, >=, binary +, binary -, ^, &, |, ~, ++, --,
andsizeof() are generally allowed on enumerations. In addition, many operators can be overloaded by the user,
thus changing their meaning when applied to a user-defined type.

The following table lists the C# operators grouped in order of precedence. Operators within each group have
equal precedence.

Operator Operators
++x
category
--x
Primary x.y
(T)x
f(x)
true
a[x]
false
x++
&
x--
sizeof
new
typeof Multiplicative *

checked /

unchecked %

-> Additive +

Unary + -

- Shift <<
! >>
~ Relational and <
10

type testing
> +=
<= -=
>= *=
is /=
as %=

Equality == &=

!= |=
^=
Logical AND &
<<=
Logical XOR ^
>>=
Logical OR | ??
Conditional &&
AND

Conditional OR ||

Conditional ?:

Assignment =
Arithmetic Overflow

The arithmetic operators (+, -, *, /) can produce results that are outside the range of possible values for the
numeric type involved. You should refer to the section on a particular operator for details, but in general:

 Integer arithmetic overflow either throws an OverflowException or discards the most significant bits of
the result. Integer division by zero always throws a DivideByZeroException.
 Floating-point arithmetic overflow or division by zero never throws an exception, because floating-point
types are based on IEEE 754 and so have provisions for representing infinity and NaN (Not a Number).
 Decimal arithmetic overflow always throws an OverflowException. Decimal division by zero always
throws a DivideByZeroException.

When integer overflow occurs, what happens depends on the execution context, which can be checked or
unchecked. In a checked context, an OverflowException is thrown. In an unchecked context, the most
significant bits of the result are discarded and execution continues. Thus, C# gives you the choice of handling or
ignoring overflow.

In addition to the arithmetic operators, integral-type to integral-type casts can cause overflow, for example,
casting a long to an int, and are subject to checked or unchecked execution. However, bitwise operators and
shift operators never cause overflow.
11

19) Explain with example declaration of primitive data types in C#.

What is Data Type?

The type of data that a variable contains is called Data Type (type). A Data Type is a classification of things
that share similar type of qualities or characteristics or behavior.

C# is strongly typed language so every variable and object must have a type.

There are two types of data type in C#

1. primitive types (or) predefined

Ex: byte, short, int, float, double, long ,char, bool, DateTime, string, object etc..

2. non-primitive types (or) User Defined

Ex: class , struct , enum , interface, delegate, array.

In C#, based on what a variable contains there is two types of built-in data type

Value types

A variable holds actual values then that type of data types are value types. These value types are stored in
“stack” memory and these value types are fixed in size. If you assign a value of a variable to another
variable it will create two copies.

Ex: byte, short, int, float, double, long ,char, bool, DateTime.

 Primitive data types are value types except string, object.

 Object type is superior to all types. It can store any type or any size of data. It helps in
inheritance process.
 Struct, enum are value types.

Reference types

A variable holds a reference to the value, then that type of data types are reference types. These reference
types are stored in “heap” memory and these types are not fixed in size. They are maintained in system
managed heap but it also uses stack to store reference of the heap. Two primitive types (string and object)
and non-primitive data types (class, interface & delegate) are examples of reference type.

Ex: class, interface, delegate, string, object and array

Let us learn couple of data types and its uses with example

Date and Time

Date time is one of the most commonly used data type in C#, here i am going to explain some of properties
about it also.
12

Ex:

DateTime currenttime = DateTime.Now;//display’s current date time.

Output:

int days = DateTime.DaysInMonth(2011, 7);// it displays “31”.

Output:

20) Define the syntax of a “Class” in C#.

Classes and Structs (C# Programming Guide)

Classes and structs are two of the basic constructs of the common type system in the .NET Framework.
Each is essentially a data structure that encapsulates a set of data and behaviors that belong together as a
logical unit. The data and behaviors are the members of the class or struct, and they include its methods,
properties, and events, and so on, as listed later in this topic.

A class or struct declaration is like a blueprint that is used to create instances or objects at run time. If you
define a class or struct called Person, Person is the name of the type. If you declare and initialize a
variable pof type Person, p is said to be an object or instance of Person. Multiple instances of the
same Person type can be created, and each instance can have different values in its properties and fields.

A class is a reference type. When an object of the class is created, the variable to which the object is
assigned holds only a reference to that memory. When the object reference is assigned to a new variable, the
new variable refers to the original object. Changes made through one variable are reflected in the other
variable because they both refer to the same data.

A struct is a value type. When a struct is created, the variable to which the struct is assigned holds the
struct's actual data. When the struct is assigned to a new variable, it is copied. The new variable and the
original variable therefore contain two separate copies of the same data. Changes made to one copy do not
affect the other copy.

In general, classes are used to model more complex behavior, or data that is intended to be modified after a
class object is created. Structs are best suited for small data structures that contain primarily data that is not
intended to be modified after the struct is created.

For more information, see Classes (C# Programming Guide), Objects (C# Programming Guide), and Structs
(C# Programming Guide).

Example
13

In the following example, MyCustomClass is defined with three members at the top level of
the ProgrammingGuide namespace. An instance (object) of MyCustomClass is created in the Main method
in theProgram class, and the object’s methods and properties are accessed by using dot notation.

C#

namespace ProgrammingGuide
{
// Class definition.
public class MyCustomClass
{
// Class members:
// Property.
public int Number { get; set; }

// Method.
public int Multiply(int num)
{
return num * Number;
}

// Instance Constructor.
public MyCustomClass()
{
Number = 0;
}
}
// Another class definition. This one contains
// the Main method, the entry point for the program.
class Program
{
static void Main(string[] args)
{
// Create an object of type MyCustomClass.
MyCustomClass myClass = new MyCustomClass();

// Set the value of a public property.

myClass.Number = 27;

// Call a public method.

int result = myClass.Multiply(4);
}
}
}

21) Define a) Method b) Method invocation

14

Methods (C# Programming Guide)

A method is a code block that contains a series of statements. A program causes the statements to be

executed by calling the method and specifying any required method arguments. In C#, every executed
instruction is performed in the context of a method. The Main method is the entry point for every C#
application and it is called by the common language runtime (CLR) when the program is started.

Method Signatures

Methods are declared in a class or struct by specifying the access level such as public or private, optional
modifiers such as abstract or sealed, the return value, the name of the method, and any method parameters.
These parts together are the signature of the method.

Method parameters are enclosed in parentheses and are separated by commas. Empty parentheses indicate
that the method requires no parameters. This class contains three methods:

C#

abstract class Motorcycle

{
// Anyone can call this.
public void StartEngine() {/* Method statements here */ }

// Only derived classes can call this.

protected void AddGas(int gallons) { /* Method statements here */ }

// Derived classes can override the base class implementation.

public virtual int Drive(int miles, int speed) { /* Method statements here */ return 1; }

// Derived classes must implement this.

public abstract double GetTopSpeed();
}

Method Access

Calling a method on an object is like accessing a field. After the object name, add a period, the name of the
method, and parentheses. Arguments are listed within the parentheses, and are separated by commas. The
methods of the Motorcycle class can therefore be called as in the following example:

C#
15

class TestMotorcycle : Motorcycle

{

public override double GetTopSpeed()

{
return 108.4;
}

static void Main()

{

TestMotorcycle moto = new TestMotorcycle();

moto.StartEngine();
moto.AddGas(15);
moto.Drive(5, 20);
double speed = moto.GetTopSpeed();
Console.WriteLine("My top speed is {0}", speed);
}
}

Method Parameters vs. Arguments

The method definition specifies the names and types of any parameters that are required. When calling code
calls the method, it provides concrete values called arguments for each parameter. The arguments must be
compatible with the parameter type but the argument name (if any) used in the calling code does not have to
be the same as the parameter named defined in the method. For example:

C#

public void Caller()

{
int numA = 4;
// Call with an int variable.
int productA = Square(numA);

int numB = 32;

// Call with another int variable.
int productB = Square(numB);

// Call with an integer literal.

int productC = Square(12);

// Call with an expression that evaulates to int.

productC = Square(productA * 3);
}

int Square(int i)
16

{
// Store input argument in a local variable.
int input = i;
return input * input;
}

Passing by Reference vs. Passing by Value

By default, when a value type is passed to a method, a copy is passed instead of the object itself. Therefore,
changes to the argument have no effect on the original copy in the calling method. You can pass a value-
type by reference by using the ref keyword. For more information, see Passing Value-Type Parameters (C#
Programming Guide). For a list of built-in value types, see Value Types Table (C# Reference).

When an object of a reference type is passed to a method, a reference to the object is passed. That is, the
method receives not the object itself but an argument that indicates the location of the object. If you change
a member of the object by using this reference, the change is reflected in the argument in the calling
method, even if you pass the object by value.

You create a reference type by using the class keyword, as the following example shows.

C#

public class SampleRefType

{
public int value;
}

Now, if you pass an object that is based on this type to a method, a reference to the object is passed. The
following example passes an object of type SampleRefType to method ModifyObject.

C#

public static void TestRefType()

{
SampleRefType rt = new SampleRefType();
rt.value = 44;
ModifyObject(rt);
Console.WriteLine(rt.value);
}
static void ModifyObject(SampleRefType obj)
{
obj.value = 33;
}

The example does essentially the same thing as the previous example in that it passes an argument by value
to a method. But, because a reference type is used, the result is different. The modification that is made
17

inModifyObject to the value field of the parameter, obj, also changes the value field of the argument, rt, in
the TestRefType method. The TestRefType method displays 33 as the output.

For more information about how to pass reference types by reference and by value, see Passing Reference-
Type Parameters (C# Programming Guide) and Reference Types (C# Reference).

Return Values

Methods can return a value to the caller. If the return type, the type listed before the method name, is
not void, the method can return the value by using the return keyword. A statement with
the return keyword followed by a value that matches the return type will return that value to the method
caller. The return keyword also stops the execution of the method. If the return type is void,
a return statement without a value is still useful to stop the execution of the method. Without
the return keyword, the method will stop executing when it reaches the end of the code block. Methods
with a non-void return type are required to use thereturn keyword to return a value. For example, these two
methods use the return keyword to return integers:

C#

class SimpleMath
{
public int AddTwoNumbers(int number1, int number2)
{
return number1 + number2;
}

public int SquareANumber(int number)

{
return number * number;
}
}

To use a value returned from a method, the calling method can use the method call itself anywhere a value
of the same type would be sufficient. You can also assign the return value to a variable. For example, the
following two code examples accomplish the same goal:

C#

int result = obj.AddTwoNumbers(1, 2);

result = obj.SquareANumber(result);
// The result is 9.
Console.WriteLine(result);

C#

result = obj.SquareANumber(obj.AddTwoNumbers(1, 2));

// The result is 9.
18

Console.WriteLine(result);

Using an local variable, in this case, result, to store a value is optional. It may help the readability of the
code, or it may be necessary if you need to store the original value of the argument for the entire scope of
the method.

22) Differentiate formal and actual parameters

Passing Parameters (C# Programming Guide)

In C#, arguments can be passed to parameters either by value or by reference. Passing by reference enables function
members, methods, properties, indexers, operators, and constructors to change the value of the parameters and have that
change persist in the calling environment. To pass a parameter by reference, use the ref or out keyword. For simplicity,
only the ref keyword is used in the examples in this topic. For more information about the difference between ref and out,
see ref (C# Reference), out (C# Reference), and Passing Arrays Using ref and out (C# Programming Guide).

The following example illustrates the difference between value and reference parameters.

C#

class Program
{
static void Main(string[] args)
{
int arg;

// Passing by value.
// The value of arg in Main is not changed.
arg = 4;
squareVal(arg);
Console.WriteLine(arg);
// Output: 4

// Passing by reference.
// The value of arg in Main is changed.
arg = 4;
squareRef(ref arg);
Console.WriteLine(arg);
// Output: 16
}

static void squareVal(int valParameter)

{
valParameter *= valParameter;
}

// Passing by reference
static void squareRef(ref int refParameter)
{
refParameter *= refParameter;
}
}
19

23) What is a signature of a method?

Method Signatures

Methods are declared in a class or struct by specifying the access level such as public or private, optional modifiers such
as abstract or sealed, the return value, the name of the method, and any method parameters. These parts together are
the signature of the method.

24) Explain with examples the purpose of Constructor/Destructor

Constructors are special methods, used when instantiating a class. A constructor can never return anything,
which is why you don't have to define a return type for it. A normal method is defined like this:

public string Describe()

A constructor can be defined like this:

public Car()

In our example for this chapter, we have a Car class, with a constructor which takes a string as argument. Of
course, a constructor can be overloaded as well, meaning we can have several constructors, with the same name,
but different parameters. Here is an example:

public Car()

public Car(string color)

this.color = color;

A constructor can call another constructor, which can come in handy in several situations. Here is an example:

public Car()

Console.WriteLine("Constructor with no parameters called!");

}
20

public Car(string color) : this()

this.color = color;

Console.WriteLine("Constructor with color parameter called!");

If you run this code, you will see that the constructor with no parameters is called first. This can be used for
instantiating various objects for the class in the default constructor, which can be called from other constructors
from the class. If the constructor you wish to call takes parameters, you can do that as well. Here is a simple
example:

public Car(string color) : this()

this.color = color;

Console.WriteLine("Constructor with color parameter called!");

public Car(string param1, string param2) : this(param1)

If you call the constructor which takes 2 parameters, the first parameter will be used to invoke the
constructor that takes 1 parameter.

Destructors
Since C# is garbage collected, meaing that the framework will free the objects that you no longer use,
there may be times where you need to do some manual cleanup. A destructor, a method called once an
object is disposed, can be used to cleanup resources used by the object. Destructors doesn't look very
much like other methods in C#. Here is an example of a destructor for our Car class:

~Car()

Console.WriteLine("Out..");

Once the object is collected by the garbage collector, this method is called.
21

25) How will you create objects of a class?

Objects (C# Programming Guide)

A class or struct definition is like a blueprint that specifies what the type can do. An object is basically a block of memory
that has been allocated and configured according to the blueprint. A program may create many objects of the same class.
Objects are also called instances, and they can be stored in either a named variable or in an array or collection. Client code
is the code that uses these variables to call the methods and access the public properties of the object. In an object-
oriented language such as C#, a typical program consists of multiple objects interacting dynamically.

Struct Instances vs. Class Instances

Because classes are reference types, a variable of a class object holds a reference to the address of the object on the
managed heap. If a second object of the same type is assigned to the first object, then both variables refer to the object at
that address. This point is discussed in more detail later in this topic.

Instances of classes are created by using the new operator. In the following example, Person is the type
and person1 and person 2 are instances, or objects, of that type.

C#

public class Person

{
public string Name { get; set; }
public int Age { get; set; }
public Person(string name, int age)
{
Name = name;
Age = age;
}
//Other properties, methods, events...
}

class Program
{
static void Main()
{
Person person1 = new Person("Leopold", 6);
Console.WriteLine("person1 Name = {0} Age = {1}", person1.Name, person1.Age);

// Declare new person, assign person1 to it.

Person person2 = person1;

//Change the name of person2, and person1 also changes.

person2.Name = "Molly";
person2.Age = 16;

Console.WriteLine("person2 Name = {0} Age = {1}", person2.Name, person2.Age);

Console.WriteLine("person1 Name = {0} Age = {1}", person1.Name, person1.Age);

// Keep the console open in debug mode.

22

Console.WriteLine("Press any key to exit.");

Console.ReadKey();

}
}
/*
Output:
person1 Name = Leopold Age = 6
person2 Name = Molly Age = 16
person1 Name = Molly Age = 16
*/

Because structs are value types, a variable of a struct object holds a copy of the entire object. Instances of structs can also
be created by using the new operator, but this is not required, as shown in the following example:

C#

public struct Person

{
public string Name;
public int Age;
public Person(string name, int age)
{
Name = name;
Age = age;
}
}

public class Application

{
static void Main()
{
// Create struct instance and initialize by using "new".
// Memory is allocated on thread stack.
Person p1 = new Person("Alex", 9);
Console.WriteLine("p1 Name = {0} Age = {1}", p1.Name, p1.Age);

// Create new struct object. Note that struct can be initialized

// without using "new".
Person p2 = p1;

// Assign values to p2 members.

p2.Name = "Spencer";
p2.Age = 7;
Console.WriteLine("p2 Name = {0} Age = {1}", p2.Name, p2.Age);

// p1 values remain unchanged because p2 is copy.

Console.WriteLine("p1 Name = {0} Age = {1}", p1.Name, p1.Age);

// Keep the console open in debug mode.

Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
}
/*
Output:
23

p1 Name = Alex Age = 9

p2 Name = Spencer Age = 7
p1 Name = Alex Age = 9
*/

The memory for both p1 and p2 is allocated on the thread stack. That memory is reclaimed along with the type or
method in which it is declared. This is one reason why structs are copied on assignment. By contrast, the memory that is
allocated for a class instance is automatically reclaimed (garbage collected) by the common language runtime when all
references to the object have gone out of scope. It is not possible to deterministically destroy a class object like you can in
C++. For more information about garbage collection in the .NET Framework, see Garbage Collection.

26) How will you access the members of a created object?

How to: Initialize Objects by Using an Object Initializer (C# Programming Guide)
Visual Studio 2010

You can use object initializers to initialize type objects in a declarative manner without explicitly invoking a constructor for
the type.

The following examples show how to use object initializers with named objects. The compiler processes object initializers
by first accessing the default instance constructor, and then by processing the member initializations. Therefore, if the
default constructor is declared as private in the class, object initializers that require public access will fail.

Anonymous types must be declared with an object initializer. For more information, see How to: Return Subsets of
Element Properties in a Query (C# Programming Guide).

Example

The following example shows how to initialize a new StudentName type by using object initializers.

C#

public class Program

{
public static void Main()
{

// Declare a StudentName by using the constructor that has two parameters.

StudentName student1 = new StudentName("Craig", "Playstead");

// Make the same declaration by using a collection initializer and sending

// arguments for the first and last names. The default constructor is
// invoked in processing this declaration, not the constructor that has
// two parameters.
StudentName student2 = new StudentName
{
FirstName = "Craig",
LastName = "Playstead",
};
24

// Declare a StudentName by using a collection initializer and sending

// an argument for only the ID property. No corresponding constructor is
// necessary. Only the default constructor is used to process object
// initializers.
StudentName student3 = new StudentName
{
ID = 183
};

// Declare a StudentName by using a collection initializer and sending

// arguments for all three properties. No corresponding constructor is
// defined in the class.
StudentName student4 = new StudentName
{
FirstName = "Craig",
LastName = "Playstead",
ID = 116
};

System.Console.WriteLine(student1.ToString());
System.Console.WriteLine(student2.ToString());
System.Console.WriteLine(student3.ToString());
System.Console.WriteLine(student4.ToString());
}

// Output:
// Craig 0
// Craig 0
// 183
// Craig 116
}

public class StudentName

{
// The default constructor has no parameters. The default constructor
// is invoked in the processing of object initializers.
// You can test this by changing the access modifier from public to
// private. The declarations in Main that use object initializers will
// fail.
public StudentName() { }

// The following constructor has parameters for two of the three

// properties.
public StudentName(string first, string last)
{
FirstName = first;
LastName = last;
}

// Properties.
public string FirstName { get; set; }
public string LastName { get; set; }
public int ID { get; set; }

public override string ToString()

{
return FirstName + " " + ID;
}
}
25

The following example shows how to initialize a collection of StudentName types by using a collection initializer. Note
that a collection initializer is a series of comma-separated object initializers.

C#

List<StudentName> students = new List<StudentName>()

{
new StudentName {FirstName="Craig", LastName="Playstead", ID=116},
new StudentName {FirstName="Shu", LastName="Ito", ID=112},
new StudentName {FirstName="Gretchen", LastName="Rivas", ID=113},
new StudentName {FirstName="Rajesh", LastName="Rotti", ID=114}
};

27) Explain the usage of „this‟ reference.

this
Visual Studio .NET 2003

The this keyword refers to the current instance of the class. Static member functions do not have a this pointer.
The this keyword can be used to access members from within constructors, instance methods, and instance accessors.

The following are common uses of this:

 To qualify members hidden by similar names, for example:

 public Employee(string name, string alias)
 {
 this.name = name;
 this.alias = alias;
 }
 To pass an object as a parameter to other methods, for example:
 CalcTax(this);
 To declare indexers, for example:
 public int this [int param]
 {
 get
 {
 return array[param];
 }
 set
 {
 array[param] = value;
 }
 }

It is an error to refer to this in a static method, static property accessor, or variable initializer of a field declaration.
26

Example

In this example, this is used to qualify the Employee class members, name and alias, which are hidden by similar
names. It is also used to pass an object to the method CalcTax, which belongs to another class.

// keywords_this.cs
// this example
using System;
public class Employee
{
public string name;
public string alias;
public decimal salary = 3000.00m;

// Constructor:
public Employee(string name, string alias)
{
// Use this to qualify the fields, name and alias:
this.name = name;
this.alias = alias;
}

// Printing method:
public void printEmployee()
{
Console.WriteLine("Name: {0}\nAlias: {1}", name, alias);
// Passing the object to the CalcTax method by using this:
Console.WriteLine("Taxes: {0:C}", Tax.CalcTax(this));
}
}
public class Tax
{
public static decimal CalcTax(Employee E)
{
return (0.08m*(E.salary));
}
}

public class MainClass

{
public static void Main()
{
// Create objects:
Employee E1 = new Employee ("John M. Trainer", "jtrainer");

// Display results:
E1.printEmployee();
}
}

Output
Name: John M. Trainer
Alias: jtrainer
Taxes: $240.00
27

28) Explain the structure of a simple C# program.

General Structure of a C# Program

Visual Studio .NET 2003

C# programs can consist of one or more files. Each file can contain one or more namespaces. A namespace can contain
types such as classes, structs, interfaces, enumerations, and delegates, in addition to other namespaces. The following is
the skeleton of a C# program that contains all of these elements.

// A skeleton of a C# program
using System;
namespace MyNamespace1
{
class MyClass1
{
}
struct MyStruct
{
}
interface IMyInterface
{
}
delegate int MyDelegate();
enum MyEnum
{
}
namespace MyNamespace2
{
}
class MyClass2
{
public static void Main(string[] args)
{
}
}
}

29) What are access modifiers? Explain their purpose.

Access Modifiers
Visual Studio .NET 2003

Access modifiers are keywords used to specify the declared accessibility of a member or a type. This section introduces the
four access modifiers:

 public
 protected
 internal
 private

public
Visual Studio .NET 2003
28

The public keyword is an access modifier for types and type members. Public access is the most permissive access level.
There are no restrictions on accessing public members.

For a comparison of public with the other access modifiers, see Accessibility Levels.

Example

In the following example, two classes are declared, MyClass1 and MyClass2. The public members x and y of
the MyClass1 are accessed directly from MyClass2.

// protected_public.cs
// Public access
using System;
class MyClass1
{
public int x;
public int y;
}

class MyClass2
{
public static void Main()
{
MyClass1 mC = new MyClass1();

// Direct access to public members:

mC.x = 10;
mC.y = 15;
Console.WriteLine("x = {0}, y = {1}", mC.x, mC.y);
}
}

Output
x = 10, y = 15

If you change the public access level to private or protected, you will get the error message:

'MyClass1.y' is inaccessible due to its protection level.

private
Visual Studio .NET 2003

The private keyword is a member access modifier. Private access is the least permissive access level. Private members are
accessible only within the body of the class or the struct in which they are declared.

Nested types in the same body can also access those private members.

It is a compile-time error to reference a private member outside the class or the struct in which it is declared.

For a comparison of private with the other access modifiers, see Accessibility Levels.
29

Example

In this example, the Employee class contains a public member, Name, and a private member, Salary. The public member
can be accessed directly, while the private member must be accessed through the public methodAccessSalary().

// private_keyword.cs
using System;
class Employee
{
public string name = "xx";
double salary = 100.00; // private access by default
public double AccessSalary() {
return salary;
}
}

class MainClass
{
public static void Main()
{
Employee e = new Employee();

// Accessing the public field:

string n = e.name;

// Accessing the private field:

double s = e.AccessSalary();
}
}

In the preceding example, if you attempt to access the private members directly by using a statement like this:

double s = e.salary;

you will get the error message:

'Employee.Salary' is inaccessible due to its protection level.

protected
Visual Studio .NET 2003

The protected keyword is a member access modifier. A protected member is accessible from within the class in which it is
declared, and from within any class derived from the class that declared this member.

A protected member of a base class is accessible in a derived class only if the access takes place through the derived class
type. For example, consider the following code segment:

class A
{
protected int x = 123;
}

class B : A
{
30

void F()
{
A a = new A();
B b = new B();
a.x = 10; // Error
b.x = 10; // OK
}
}

The statement a.x =10 generates an error because A is not derived from B.

Struct members cannot be protected because the struct cannot be inherited.

It is an error to reference a protected member from a class, which is not derived from the protected member's class.

For more information on protected members, see 3.5.3 Protected access for instance members.

For a comparison of protected with the other access modifiers, see Accessibility Levels.

Example

In this example, the class MyDerivedC is derived from MyClass; therefore, you can access the protected members of the
base class directly from the derived class.

// protected_keyword.cs
using System;
class MyClass
{
protected int x;
protected int y;
}

class MyDerivedC: MyClass

{
public static void Main()
{
MyDerivedC mC = new MyDerivedC();

// Direct access to protected members:

mC.x = 10;
mC.y = 15;
Console.WriteLine("x = {0}, y = {1}", mC.x, mC.y);
}
}

Output
x = 10, y = 15

If you change the access levels of x and y to private, the compiler will issue the error messages:

'MyClass.y' is inaccessible due to its protection level.

'MyClass.x' is inaccessible due to its protection level.
31

internal
Visual Studio .NET 2003

The internal keyword is an access modifier for types and type members. Internal members are accessible only within files
in the same assembly. For more information on assemblies, see Components and Assemblies.

A common use of internal access is in component-based development because it enables a group of components to
cooperate in a private manner without being exposed to the rest of the application code. For example, a framework for
building graphical user interfaces could provide Control and Form classes that cooperate using members with internal
access. Since these members are internal, they are not exposed to code that is using the framework.

It is an error to reference a member with internal access outside the assembly within which it was defined.

Caution An internal virtual method can be overridden in some languages, such as textual Microsoft intermediate
language (MSIL) using Ilasm.exe, even though it cannot be overridden using C#.

For a comparison of internal with the other access modifiers, see Accessibility Levels.

Example

This example contains two files, Assembly1.cs and Assembly2.cs. The first file contains an internal base
class, BaseClass. In the second file, an attempt to access the member of the base class will produce an error.

File Assembly1.cs:

// Assembly1.cs
// compile with: /target:library
internal class BaseClass
{
public static int IntM = 0;
}

File Assembly2.cs

// Assembly2.cs
// compile with: /reference:Assembly1.dll
// CS0122 expected
class TestAccess
{
public static void Main()
{
BaseClass myBase = new BaseClass(); // error, BaseClass not visible outside assembly
}
}

30) Differentiate static and non-static members of a class.

C# Static Method
 32

Static methods have no instances. They are called with the

type name, not an instance identifier. They are slightly faster
than instance methods because of this. Static methods can be
public or private. They cannot use the this instance
expression.
Static Modifier
Key point:Static methods are called without an instance
reference.
Example

This program defines both static methods and regular instance

methods and calls them both. The static methods use the static
keyword somewhere in the method declaration signature,
usually as the first keyword or the second keyword after
public.

Static methods cannot access non-static class level members

and do not have a 'this' pointer. Instance methods can access
those members, but must be called through an object
instantiation, which causes another step and level of
indirection.
Program that uses instance and static methods [C#]

using System;

class Program
{
static void MethodA()
{
Console.WriteLine("Static method");
}

void MethodB()
33

{
Console.WriteLine("Instance method");
}

static char MethodC()

{
Console.WriteLine("Static method");
return 'C';
}

char MethodD()
{
Console.WriteLine("Instance method");
return 'D';
}

static void Main()

{
//
// Call the two static methods on the Program type.
//
Program.MethodA();
Console.WriteLine(Program.MethodC());
//
// Create a new Program instance and call the two instance methods.
//
Program programInstance = new Program();
programInstance.MethodB();
Console.WriteLine(programInstance.MethodD());
}
}
34

Output

Static method
Static method
C
Instance method
Instance method
D

This program defines five methods, the first four being

MethodA, MethodB, MethodC, and MethodD and the final
one being the Main entry point. The execution engine first
encounters and compiles the Main method. The MethodA
static method is invoked and its internal logic is executed.
ADDITIONAL QUESTIONS

31) Explain the I/O methods available in C#.

32) Explain with an example the usage of ReadLine() and Writeline() methods.

33) Write a program to convert temperature Fahrenheit to Celsius.

34) What is enumeration?

35) How operators are classified based on symbols and names in C#?

36) Write a program to illustrate arithmetic operators.

37) What are relational and equality operators?

38) What are logical operators? What are different types of logical operators?

39) Classify bitwise operators and explain.

40) Write a program to illustrate bitwise operators.

41) Explain ternary operators with a diagram and example.

35

42) Write a C# program to illustrate ternary operation.

43) What is type conversion? Explain with examples.

44) Explain boxing and unboxing.

45) What is associativity related to evaluation of expressions?

46) How statements are classified?

47) What are control flow statements?

48) Explain conditional and unconditional execution of statements.

49) What are selective control constructs?

50) What are iteration statements?

51) Explain with syntax and flowchart a) While loop construct b) Do while loop construct c)for loop
construct

52) Write a C# program to check whether the given year is Leap Year or not.

53) Write a C# program to print the reverse the digits of a number.

54) Write a C# program to calculate the factorial of a non negative number.

55) Write a program in C# to find fibonoci sequence.

56) Write a program in C# to generate the following sequence of numbers :

1
1 2 3
1 2 3 4 5
1 2 3 4 5 6 7
1 2 3 4 5
1 2 3
1

57) Write a C# program to generate Armsrong numbers from 100 to 999.

58) Wrie a C# program to illustrate return statement.

59) Write a program to find the factorial of a non-negative integer using recursion.
60) How exceptions are handled in C# programs?

61) Give examples of predefined Exception classes in C#.

62) Explain the syntax of a) the throw statement b) the try statement c) user defined exceptions
36

63) Write C# program to illustrate exception handling a) for stack over flow b) divide by zero
exception

64) What are checked and unchecked statements? Write a C# program to illustrate this.

65) Write a C# program to generate Pascal triangle :

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1

66) Develop programs to evaluate the following series :

(a)
S = x + x2+ x3+ ……+ xn
(b)
S = 1 + 1/x + 1/x2 + 1/x3+ …………+ 1/xn
(c) S = 1 + x + x2/2! + x3/3!+ ………….+xn/n!

67) Write a C# program to evaluate function

Cos(x) = 1 – x2/2! + x4/4! – x6/6! + …………..

68) Define an array.

69) How array is represented in C#?

70) Explain array declaration and instantiation in C# with an example.

71) Explain declaration and instantiation of a two dimensional array in C#.

72) Write short notes on a) creation of three dimensional arrays b)creation of jagged arrays

73) Write C# programs a) to read and display the array elements b) to read an array and print its
elemts in reverse order.

74) Tabulate the difference between regular and jagged arrays.

75) Write a C# program to reverse a string.

76) Write a C# program to find the largest element in a matrix.

37

77) Write a C# program to create a multiplication table.

78) Write a C# program to illustrate initialization of a jagged array.

79) Write a C# program to perform matrix multiplication

80) Write a C# program to illustrate a two-dimensional jagged array.

81) Write a C# program to find the area under the curve 1/1+x2 using Trapezoidal rule.