Chapter 3

C# Language Fundamentals

1
OBJECTIVES
Basic C# Class
Constructors
Basic Input and Output
Value Types and Reference Types
Iteration Statements
Control Flow Statements
Static Methods and Parameter passing Methods
Arrays, Strings, and String Manipulations
Enumerations and Structures
2
Anatomy of a simple c# program
// Hello.cs
using System;
class HelloClass
{
public static int Main(string[ ] args)
{
Console.WriteLine("Hello World");
return 0;
}
}

3
Anatomy of a simple c# program
Contain Main() method
Public members accessible from other types
Static members scoped at class level ( not object
level)
(string[] args) command line arguments
Console class
Console.ReadLine()
C# not support to create global functions & global
points of data
4
 Variations of Main() method
// Hello1.cs // Hello2.cs
using System; using System;
class HelloClass class HelloClass
{ {
public static void Main()
public static void Main(string[ ] args)
{
{
// .
// . }
} }
}

5
Variations of Main() method
// Hello2.cs
using System;
class HelloClass
{
public static int Main()
{
// .
}
}

Main() method based on 2 questions

Do you need to process any user-specified command-line parameters?
Do you want to return a value to the systen when Main() has completed.

6
Command Line Parameters
// clp.cs
using System;
class HelloClass
{
public static int Main(string[ ] args)
{
Console.WriteLine("Command Line parameters");
for (int x = 0; x < args.Length; x++) // foreach (string s in args)
Console.WriteLine("Args: {0}", args[x]);
return 0;
}
}

7
Command Line Parameters
Length is the property of Syatem.Array [ C# arrays actually alias the
System.Array type]
foreach statement can be used in place of for statement
// when using foreach no need to check the size of the array
public static int Main(string[ ] args)
{

foreach (string s in args)
Console.WriteLine("Args: {0}", s);
..
}
}

8
Command Line Parameters
Also access command-line arguments using static
GetCommandLineArgs() method of the System.Environment type
Return value is array of strings
First index identifies - current directory containing the application
itself
Remaining elements- individual command- line arguments
..
// Get arguments using System.Environment
string[] theArgs=Environment.GetCommandLineArgs();
Console.WriteLine(Path of this app is: {0}", theArgs[0]); s);
..
9
The System.Environment class
Obtain number of details regarding the operating system currently
hosting .NET application using various static members.
Some propeties of System.Environment
Property Meaning
Current Directory Display current directory
GetLogicalDrives get drives of the m/c
Version Execute version of the .NET
MachineName name of the current m/c
NewLine gets newline symbol for current environement
ProcessorCount retrns no. of processors on current m/c
SystemDirectoryreturns full path of system directory
UserName returns name of the entity that stated appl

10
Creating Objects
Works almost same as C++
"new" is the de facto standard to create an object
instance
Example ( illegal ) Correct version
HelloClass c1; HelloClass c1 = new HelloClass();
c1.SayHi(); c1.SayHi();
C# object variables are references to the objects in memory
and not the actual objects
Garbage collection is taken care by .NET
11
C# Data Types
C# Alias System Type Range
sbyte System.SByte -128 to 127
byte System.Byte 0 to 255
short System.Int16 -32768 to 32767
ushort System.UInt16 0 to 65535
int System.Int32 -2,147,438,648 to +2,147,438,647
uint System.UInt32 0 to 4,294,967,295
long System.UInt64 -9,223,372,036,854,775,808 to +9,..
ulong System.UInt64 0 to 18,446,744,073,709,551,615
char System.Char U10000 to U1FFFF
float System.Single 1.510-45 to 3.41038
double System.Double 5.010-324 to 1.710308
bool System.Boolean true or false
decimal System.Decimal 100 to 1028
string System.String Limited by system memory
object System.Object Anything at all
Hierarchy of System Types
Object Boolean
UInt16
Byte
Type UInt32
Char
String ValueType UInt64
(derived one Decimal
is Void
Array
struct type Double
and not DateTime
Exception Int16
class)
Guid
Delegate Int32
TimeSpan
Int64
Single
MulticastDelegate SByte
13
Enumerations and Structures
Contd..
All value types permitted to create a system type using the new keyword. It
sets default value to the variable.
Eg: bool b1=new bool(); // b1 = false
bool b2=false;
Integer data type properties
UInt16.MaxValue
UInt16.MinValue
Eg: static void Main(string[] args)
{ System.UInt16 myuint=30000;
Console.WriteLine(Max value:{0}, UInt16.MaxValue);
Console.WriteLine(Max value:{0}, UInt16.MinValue);
}

14
Contd
Double
double.Maxvalue
double.MinValue
double.PositiveInfinity
double.NegativeInfinity
Members of System.Boolean
Valid assignment is true or false. Cant assign values like (-1,0,1)
bool.FalseString
bool.TrueString
Members of System.Char
char.IsDigit('K')
char.IsLetter('a') or char.IsLetter("100", 1)
char.IsWhiteSpace("Hi BIT", 2)
char.IsPunctuation(',')

15
Contd
Parsing values from String data
Parsing technique is used to convert textual data into a numerical
value
Eg: static vaoid Main(string[] args)
{
bool mybool = bool.parse(true);
Console.WriteLine(value of mybool: {0}, mybool);
int myint = int.parse(8);
Console.WriteLine(value of myint: {0}, myint);
..
}

16
Contd
System.DateTime and System.TimeSpan
DateTime type represents specific date & time value
Static void Main()
{..
DateTime dt=new DateTime(2004, 10, 17)
Console.WriteLine(The day of {0} is {1}, dt.Date, dt.DayOfWeek);
dt. = dt.Addmonths(2)
.
}

17
Contd
TimeSpan structure allows to define & transform units of
time using various members.
static void Main(string[] args)
{..
TimeSpan ts=new TimeSpan(4,30,0);
Console.WriteLine(ts);
Console.WriteLine(ts.subtract(new TimeSpan(0,15,0)));
.
}
18
Default Values
The member variables of class types are automatically set
to an appropriate default value.
the rules are simple:
bool types are set to false.
Numeric data is set to 0 (or 0.0 in the case of floating-
point data types).
string types are set to null.
char types are set to '\0'.
Reference types are set to null.
19
Default Values
Public variables/members are automatically get default values
Example
class Default
{
public int x; public object obj;
public static void Main (string [ ] args)
{
Default d = new Default();
// Check the default value
}
}

Local members/variables (within the method) must assign an

initial value before use them.
public static void Main (string [ ] args)
{
int x;
Console.WriteLine(x); // Error
} 20
Variable initialization
C# allows you to assign a types member data to an
initial value at the time of declaration
// This technique is useful when you don't want to accept default values
class Test
{
public int myInt = 9;
public string myStr = "My initial value.";
..
}

21
Defining a constant Data
C# offers the const keyword to define variables with a fixed,
unalterable value.
any attempt to alter it results in a compiler error.
the const keyword cannot be used to qualify parameters or
return values, and is reserved for the creation of local or
instance-level data.
value assigned to a constant variable must be known at
compile time, and therefore a constant member cannot be
assigned to an object reference

22
Example
class ConstData
{
public const string BestNbaTeam = "Timberwolves";
public const double SimplePI = 3.14;
public const bool Truth = true;
public const bool Falsity = !Truth;
}

23
Establishing Member Visibility
Members of a given class or structure must specify their
visibility level.
C# Accessibility Keywords

24
Access Specifiers
public void MyMethod() { } Accessible anywhere
private void MyMethod() { } Accessible only from
the class where defined
protected void MyMethod() { } Accessible from its own
class and its descendent
internal void MyMethod() { } Accessible within the
same Assembly
void MyMethod() { } private by default
protected internal void MyMethod() { }
Access is limited to the current assembly or types derived from
the containing class
25
Establishing Type Visibility
Types (classes, interfaces, structures, enumerations, and
delegates) can also take accessibility modifiers
Only public & internal
public - accessed from other types in the current assembly
as well as external assemblies.
Eg: public class MyClass{}
Internal - used only by the assembly in which it is defined.
Eg: internal class MyHelperClass{}
Types are internal by default in C#.

26
The System.Console class
Console Class encapsulates i/p, o/p & error manipulation for console based
applications
Members of System.Console Console User Interface (CUI)
Member Meaning
BackgroundColor set background/foreground colors for the current o/p
ForegroundColor

Clear() clears the buffer & display area

Title sets the title

WindowsHeight,
WindowsTop,
WindowsLeft control the dimensions of the console in relation to the
Windows Width established buffer
27
BASIC INPUT & OUTPUT
Both i/p & o/p methods are defined under System.Console Class
Write(), WriteLine(), Read(), and ReadLine()
Example (Read and Write a string):
// RW.cs
using System;
class BasicRW
{
public static void Main (string [ ] args)
{
string s;
Console.Write("Enter a string: ");
s = Console.ReadLine();
Console.WriteLine("String: {0}", s);
}
}
28
Formatted output
Achieved by WriteLine()
This method takes a string containing the format & a list of variable
syntax:
Console.WriteLine(Format-string, v1, v2, .);
format-string -> contains both static text & markers
v1, v2, -> variables list
A marker / place holder is an index number in curly brackets, that indicates
which variable of the argument list is to be substituted.
eg: Console.WriteLine(Sum of {0} and {1} is {2}, a, b, c);
Can also specify width
{n, w} n-> index number & w -> width for the value
If w is +ve : value is right justified
-ve : value is left justified
Eg: Console.WriteLine({0,5}\n + {1,5}\n\n{2,5}, a, b, c);
29
Basic IO
// IO.cs
using System;
class BasicIO
{
public static void Main(string[ ] args)
{
int theInt = 20;
float theFloat = 20.2F; // double theFloat = 20.2; is OK
string theStr = "BIT";
Console.WriteLine("Int: {0}", theInt);
Console.WriteLine("Float: {0}", theFloat);
Console.WriteLine("String: {0}", theStr);
// array of objects
object[ ] obj = {"BIT", 20, 20.2};
Console.WriteLine("String: {0}\n Int: {1}\n Float: {2}\n", obj);
}
}
Numeric Formatting
Two methods of numeric format:
Standard format
Custom format

Standard format [string formatting]

It converts numeric type to a specific string representation
It consists numeric format character & optionally a precision specifier.
syntax
{n, fc[p] }
n -> index number
fc -> format character
p -> precission specifier
Eg: Console.WriteLine ( D format :{0:d 9} , 99999);
Also achieved through Sring.Format() method
static void Main ()
{
String fstr;
fstr=String.Format(D Decimal {0:D} is :, 999999);
} 31
 .NET String Formatting
1. C or c Currency ($) Example
2. D or d Decimal // Format.cs
using System;
3. E or e Exponential class Format
4. F or f Fixed point {
5. G or g General public static void Main (string [ ] args)
6. N or n Numerical {
7. X or x Hexadecimal Console.WriteLine("C Format: {0:c}", 9999);
Console.WriteLine("D Format: {0:d}", 9999);
Console.WriteLine("E Format: {0:e}", 9999);
C Format: $9,999.00 Console.WriteLine("F Format: {0:f}", 9999);
Console.WriteLine("G Format: {0:g}", 9999);
D Format: 9999
Console.WriteLine("N Format: {0:n}", 9999);
E Format: 9.999000e+003 Console.WriteLine("X Format: {0:x}", 9999);
F Format: 9999.00 }
G Format: 9999 }
N Format: 9,999.00
X Format: 270f
32
Custom Numeric Format
Zero (0) - ({0:0000}, 123) -> 01234
Pound character (#) ({0:####}, 123) -> 123
Decimal Period(.) ({0: ##.000},12.3456) -> 12.346
Comma (,) - (0:##,###.00},12345.899)-> 12,345.90
Percent(%) ({0:##.000%}, 0.12345) -> 12.345%

33
C# Iteration Constructs
for loop
foreach-in loop
while loop
do-while loop

34
The for Loop
C# for Loop is same as C, C++, Java, etc
Example
for (int i = 0; i < 10; i++)
Console.WriteLine(i);
You can use "goto", "break", "continue", etc like other
languages

35
The foreach/in Loop
using System;
class ForEach
{
public static void Main(string[] args)
{
string[ ] Names = new string [ ] {"Arvind 67", "Geetha 90",
"Madhu 34", "Priya 67"};
int n = 0;
foreach (string s in Names)
{
Console.WriteLine(s);
}
}
}
36
The while and do/while Loop
class WhileTest
{
public static void Main()
{
int n=1;
while(n<=10)
{
if (n%2==0)
{ n++; }
else
{ Console.Write( +n); n++; }
}
}
}
37
Control Statements
if, if-else Statements
Relational operators like ==, !=, <, >, <=, >=, etc are all
allowed in C#
Conditional operators like &&, ||, ! are also allowed in C#
Beware of the difference between int and bool in C#
Example
string s = "a b c";
if (s.Length) Error!
{ . }

38
The switch Statement
Same as C, C++, etc. with some restrictions
Every case should have a break statement to avoid
fall through (this includes default case also)
Example switch(country)
switch(country) { // Correct
{ case "India": HiIndia();
// Error no break break;
case "India": case "USA": HiUSA();
case "USA": break;
default: default: break;
} }
39
goto Statement
goto label;
Explicit fall-through in a switch statement can be
achieved by using goto statement
Example: switch(country)
{
case "India": HiIndia();
goto case "USA";
case "USA": HiUSA();
break;
default: break;
}

40
Static Members
Static members a member that is common to all
objects accessed without using a particular object. i.e. ,
the member belongs to the class rather than the objects
created from the class.
Use keyword static.
static int count;
static int max (int x, int y);
Static variables & static methods are referred as class
variables & class methods

41
Static Members example
using System;
class mathoperation
{
public static float mul(float x, float y)
{ return x*y; }
public static float divide(float x, float y)
{ return x/y; }
}
Class mathapplication
{
public static void Main()
{ float a = mathopertaion.mul(4.0F, 5.0F);
float a = mathopertaion.divide(a, 2.0F);
Console.WriteLine(b= , +b);
}
}
Note: static methods are called using class names. No objects are have been created for use

42
Static Members
Static methods have several restrictions
They can only call other static methods
They can only access static data
They cannot refer this or base in any way

43
Static Methods
What does 'static' method mean?
Methods marked as 'static' may be called from class
level
This means, there is no need to create an instance
of the class (i.e. an object variable) and then call.
This is similar to Console.WriteLine()
public static void Main() why static?
At run time Main() call be invoked without any object
variable of the enclosing class
44
Example
public class MyClass
{
public static void MyMethod()
{}
}
public class StaticMethod
{ If MyMethod() is not declared
as static, then
public static void Main(string[ ] args)
{ MyClass obj = new MyClass();
obj.MyMethod();
MyClass.MyMethod();
}
}

45
Static Classes
Class defined using static keyword
When it is defined static, object users cannot create an instance ( i.e. no use of
new keyword), & it can contain only static members & fields.
static class UtilityClass
{ public static void PrintTime()
{ Console.WriteLine(DateTime.Now.ToShortTimeString()); }
public static void PrintDate()
{ Console.WriteLine(DateTime.Today.ToShortDateString()); }
}
static void Main(string[] args)
{ UtilityClass.PrintDate();
UtilityClass u = new UtilityClass(); // Compiler error!
...
}

46
CONSTRUCTORS
Enables an object to initialize itself when it is created
Same as the class name
C# class automatically provided with free default
constructor
C# also provides additional constructors
They do not specify a return type, not even void.

47
EXAMPLE (Point.cs)
class Point
{
public Point()
{ Console.WriteLine("Default Constructor"); }
public Point(int px, int py)
{ x = px; y = py; }
public int x; Program
public int y; Entry Point
}
class PointApp
{
public static void Main(string[ ] args)
{
Point p1 = new Point(); // default constructor called
Point p2;
p2 = new Point(10, 20); // one arg constructor called
Console.WriteLine("Out: {0}\t{1}", p1.x, p1.y);
Console.WriteLine("Out: {0}\t{1}", p2.x, p2.y);
}
}
Overloaded CONSTRUCTORS
Used when objects are required to perform similar tasks
but using different i/p parameters
Process of polymorphism
Create an overloaded constructor - provide several
different constructor definition with different parameter
lists
Example:

49
Example
using System;
class Room
{
public double length;
public double breadth;
public Room (double x, double y) // constuctor1
{ length =x; breadth = y; }
public Room (double x) // constructor 2
{ length = breadth = x; }
}
50
Static Constructors
Is called before any object of the class is created
Usually used to do any work that needs to be done once
Used to assign initial values to static data members
Declare by static keyword
Eg:
Class abc
{
static abc() // no parameters
{ }
}
No access modifies on static constructors
A class can have only one static constructor

51
Copy Constructors
Copy constructor creates an object by copying variables
C# does not provide a copy constructor, so must provide it ourselves to the class
Eg: Pass an Item object to the Item constructor so that the new Item object has
the same values as the old one
Public Item (Item item)
{ code = item.code;
price = item.price;
}
Copy constructor is invoked by initializing an object of type Item & passing it the
object to be copied
Item item2 = new Item(item1);
Now, item2 is a copy of item1

52
Destructors
It is opposite to a constructor, Is called when object is no more required
Same as class name & preceded by a tilde(~) , No return type
Eg: Class Fun
{
~Fun()
{ .. }
}
Wont have arguments
C# uses a garbage collector, running on a separate thread, to execute all
destructors on exit [so does not support delete keywor
The process of calling a destructor when an object is reclaimed by the
garbage collector is called finalization.
53
Parameter Passing Methods
Value Value parameter
out Output parameter (called member)
used to pass results back from a method
ref Same as pass-by-reference
used to pass parameters into method by
reference
params Variable number of parameters
within a single parameter
54
Parameter Passing by value
If a parameter is not marked with a parameter
modifier, it is assumed to be passed by value
Passing parameters by value
The called method receives a copy of the original
data.

55
Parameter Passing - out
One advantage of out parameter type is that we can return
more than one value from the called program to the caller

Calling Called
Program Program

a, b x, y

r out ans

s.Add(a, b, out r); public void Add(int x, int y, out int ans)

56
The out modifier
using System;
class outclass
{
public static void Fill(out int a, out string, out bool c)
{ a = 9; b = your string; c = true; }
static void Main(string[ ] args)
{
int i; string str; bool b;
Fill(out i, out str, out b);
Console.WriteLine(Int is :{0}, i);
Console.WriteLine(Int is :{0}, str);
Console.WriteLine(Int is :{0}, b);
}
} 57
The ref modifier
Difference b/w out & ref modifier is out parameters do not need
to be initialized before they passed to method but ref needs
initialization
Use ref keyword
Does not create a new storage location, it represents the same
storage location as the actual parameter.

58
The ref modifier
using System;
class Ref
{
public static void Swap(ref int x, ref int y)
{ int temp;
temp = x; x = y; y = temp;
}

static void Main(string[ ] args)

{
int a = 10; int b = 20;
Console.WriteLine("Before Swap => {0} \t {1}", a, b);
Ref.Swap(ref a, ref b);
Console.WriteLine("After Swap => {0} \t {1}", a, b);
} } 59
The params modifier
To achieve variable number of parameters in a
Method declaration
The params parameter must be a single dimensional
array (else you get an error)
You can define any object in the parameter list

60
Example
using System;
class Params
{ public static void DispArrInts(string msg, params int[ ] list)
{
Console.WriteLine(msg);
for (int i = 0; i < list.Length; i++)
Console.WriteLine(list[i]);
}
static void Main(string[ ] args)
{
int[ ] intArray = new int[ ] {1, 2, 3};
DispArrInts("List1", intArray);
DispArrInts("List2", 4, 5, 6, 7); // you can send more elements
DispArrInts("List3", 8,9); // you can send less elements
} } 61
Generic use of params
Instead of using only an integer list for the params parameter,
we can use an object (Refer to ParamsMethod folder)
public class Person
{
private string name;
private byte age;
public Person(string n, byte a)
{
name = n;
age = a;
}
public void PrintPerson()
{ Console.WriteLine("{0} is {1} years old", name, age); }
} 62
pass any object
public static void DisplayObjects(params object[ ] list)
{
for (int i = 0; i < list.Length; i++)
{
if (list[i] is Person)
((Person)list[i]).PrintPerson(); Output:
else John is 45 years old
Instance of System.String
Console.WriteLine(list[i]);
}
Console.WriteLine();
}
Calling Program:
Person p = new Person("John", 45);
DisplayObjects(777, p, "Instance of System.String"); 63
Value and Reference Types
.NET types may be value type or reference type
Primitive types are always value types including
structures & enumerations
These types are allocated on the stack (fixed
length). Outside the scope, these variables will be
popped out.
However, structure are value based types

64
Value Type and Reference Type
Value Type
Value types are used directly by their values
int, float, char, enum, etc. are value types
These types are stored in a Stack based memory
Example: int Age = 42; or int Age = new int(42);

Stack

int 42

65
Example - 1
public void SomeMethod()
{
int i = 30; // i is 30
int j = i; // j is also 30
int j = 99; // still i is 30, changing j will not change i
}

66
Example - 2
struct Foo
{
public int x, y;
}

public void SomeMethod()

{
Foo f1 = new Foo();
// assign values to x and y
Foo f2 = f1;
// Modifying values of f2 members will not change f1 members
.
}
67
Reference Type
These types are allocated in a managed Heap (variable
length)
Objects of these types are indirectly referenced
Garbage collection is handled by .NET
Objects
Reference Variables

Shape rect = new Shape(); Shape

Shape Temprect = rect;

68
Reference Types
Class types are always reference types
These are allocated on the garbage-collected heap
Assignment of reference types will reference the same object
Example:
class Foo
{
public int x, y;
}
Now the statement Foo f2 = f1; has a reference to the object
f1 and any changes made for f2 will change f1

69
Value Types Containing Reference
Types
Assume the following reference(class) type, that maintains an
informational string:

class ShapeInfo
{
public string infoString;
public ShapeInfo(string info)
{ infoString = info; }
}

70
Value Types Containing Reference
Types
The following value type(struct) contain reference type
struct MyRectange
{ public ShapeInfo rectInfo; // MyRectangle structure contains a reference
type member
public int top, left, bottom, right;
public MyRectanle(string info)
{ rectInfo=new ShapeInfo(info);
top=left=10;
bottom=right=100; }
}

71
Value Types Containing Reference
Types
static void Main(string[] args)
{ Console.WriteLine(Creating r1);
MyRectangle r1=new MyRectangle(This is first rect);

Console.WriteLine(Assign r1 to r2);
MyRectangle r2;
r2=r1;

Console.WriteLine(Changing all values of r2);

r2.rectInfo.infoString=This is new info;
r2.bottom=444;
72
Value Types Containing Reference
Types
Console.WriteLine(Values after change);
Console.WriteLine(r1.rectInfo.infoString: {0}, r1.rectInfo.infoString);
Console.WriteLine(r2.rectInfo.infoString:{0},r2.rectinfo.infoString);
Console.WriteLine(r1.bottom: {0}, r1.bottom);
Console.WriteLine(r2.bottom: {0}, r2.bottom);
}

o/p: r1.rectInfo.infoString: This is new info

Creating r1 r2.rectInfo.infoString: This is new info
Assign r1 to r2 r1.bottom: 100
Changing all vaues of r2 r2.bottom: 444

73
Passing Reference Types
By Value
If a reference type is passed by value, the calling program may
change the value of the object's state data, but may not change
the object it is referencing
class person
{
public string fullname;
public int age;
public person (string n, int a)
{ fullname=n; age=a; }

74
Passing Reference Types
By Value
public person() { }
public void printInto()
{ Console.WriteLine({0} is {1} year old, fullname, age);}
}
Public static void PersonbyValue(Person P)
{ p.age=60; //change the age of p?
p=new person(Nikki, 90); // will the caller see this reassinment?
}
Public static void Main(string[] args)
{
75
Passing Reference Types
By Reference
If a class type is passed by reference, the calling program
may change the object's state data as well as the object it is
referencing
public static void PersonByRef(ref Person p)
{
// will change state of p
p.age = 60;
// p will point to a new object
p = new Person("Nikki", 90);
}
76
Calling Program
// Pass by Value
Console.WriteLine("Passing By Value...........");
Person geetha = new Person("Geetha", 25);
geetha.PrintPerson(); Passing By Value...........
Geetha is 25 years old
PersonByValue(geetha); Geetha is 60 years old
geetha.PrintPerson();

// Pass by Reference
Console.WriteLine("Passing By Reference........");
Person r = new Person("Geetha", 25);
r.PrintPerson(); Passing By Reference........
Geetha is 25 years old
PersonByRef(ref r); Nikki is 90 years old
r.PrintPerson();
77
 Difference b/w Value Types &
Reference Types
Questions Value Type Reference type
Where is this type Allocated on the stack. On the heap
allocated?
How is a variable Value type variables Reference type
represented? are local copies variables are pointing
to the memory
occupied by the
allocated instance.
What is the base type? Must derive from Can derive from any
System.ValueType. other type, as long
as that type is not78
sealed
Can this type function No. Value types are Yes. If the type is not
as a base to other always sealed and sealed, it may function
types? cannot be extended. as a base to other
types.
What is the default Variables are passed Variables are passed
parameter passing by value. by reference
behavior?
Can I define Yes, but the default Yes
constructors for this constructor is reserved
type? (i.e., custom
constructors must all
have arguments).
When do variables of When they fall out of When the managed
this type die? the defining scope. heap is garbage
collected. 79
Boxing and UnBoxing
Boxing
Explicitly converting a value type into a corresponding
reference type
Example:
int Age = 42;
object objAge = Age;
No need for any wrapper class like Java
C# automatically boxes variables whenever needed. For
example, when a value type is passed to a method
requiring an object, then boxing is done automatically.
80
UnBoxing
Converting the value in an object reference (held in heap)
into the corresponding value type (stack)
Only unbox the variable that has previously been boxed
Example:
object objAge;
int Age = (int) objAge; // OK
string str = (string) objAge; // Wrong!
The type contained in the box is int and not string!

81
Difference b/w Shallow copy &
Deep copy
Deep Copy
Contents are copied completely
Both value & reference type
are copied completely into the
new variable
Each reference would have their
independent copy to refer it
Contents of the object can be
changed only using the
reference of that particular
object
Cloning is required
Shallow Copy
Contents are not copied completely
Only value type would be copied
completely into the new variable
The reference types would be
pointing to the same object after the
copy
Contents of the object can be
changed using any of reference
pointing the object
Cloning is not required
82
Enumerations in C#
Mapping symbolic names to The internal type used for
numerals enumeration is System.Int32
Example - 1 Valid types: byte, sbyte, short,
enum Colors ushort, int, uint, long, ulong
{ Eg: enum pos:byte
Red, // 0
Green, // 1 { off, on}
Blue // 2
}
Using Enumerations
Example - 2
enum Colors Colors c;
{ c = Colors.Blue;
Red = 10, // 10 Console.WriteLine(c); // Blue
Green, // 11
Blue // 12
}
83
Pgm illustrate use of enum
Using System;
Class area
{
public enum Shspe
{ circle, square }
Public void Sreashape(int x, Shape shape)
{ double area;
switch(shape)
{
case Shape.circle: area=Math.PI*x*x;
Console.WriteLine(circle area = +area); break;
case Shape.squre: area=x*x;
Console.WriteLine(Square area = +area); break;
default: Console.WriteLine(Invalid input); break;
}}}

84
Contd.
Class Enumtest
{
public static void main()
{ area a1 = new area();
a1.areashape(15, area.Shape.circle);
a1.areashape(15, area.Shape.square);
a1.areashape(15, (area.Shape) 1);
a1.areashape(15, (area.Shape) 10);
}
}

85
System.Enum Base Class
Converts a value of an enumerated type to its
Format()
string equivalent according to the specified format
Retrieves the name for the constant in the
GetName()
enumeration
Returns the type of enumeration
GetUnderlyingType() Console.WriteLine(Enum.GetUnderlyingType(typeof
(Colors))); // System.Int32

Gives an array of values of the constants in

GetValues()
enumeration
To check whether a constant exists in enum
IsDefined()
if (Enum.IsDefined(typeof(Colors), "Blue") .
Converts string/value to enum object
Parse() Colors CarColor = (Colors)Enum.Parse(typeof(Colors),
86
"Red");
Example [enumeration]
Array obj = Enum.GetValues(typeof(Colors));
foreach(Colors x in obj)
{
Console.WriteLine(x.ToString());
Console.WriteLine("int = {0}", Enum.Format(typeof(Colors), x, "D"));
}
Output
Red
int = 0
Blue
int = 1
Green
int = 2
87
System.Object
Every C# data type is derived from the base class
called System.Object
The object class defines a common set of members
supported by every type in the .NET universe
class HelloClass // implicitly derive system.object
{ .... }
is same as
class HelloClass : System.Object // explicitly deriving
{ ....}
88
Example
System.object defines a set of instance-level & class-level (static)
members.
Instance level members are declared using virtual keyword
namespace System
can be overridden
{ public class Object by derived class
{ public Object();
public virtual Boolean Equals(Object(obj);
public virtual Int32 GetHashCode();
public Type GetType();
..
}
}
89
Core Members of System.Object
Equals() Returns true only if the items being compared refer
to the exact same item in memory
GetHashCode() Returns an integer that identifies a specific object
instance
GetType() Returns System.Type [ describes current item]
ToString() Returns string representation of a given object

Finalize() Protected method, used for object removal

(garbage collection)
MemberwiseClone() Returns a new object, i. e. member-wise copy of
the current object
90
Example
// ObjTest.cs ToString: namespacename.ObjTest
using System; GetHashCode: 1
class ObjTest GetType: System.Object
{ Same Instance
public static void Main (string [ ] args)
{
ObjTest c1 = new ObjTest();

Console.WriteLine("ToString: {0}", c1.ToString());

Console.WriteLine("GetHashCode: {0}", c1.GetHashCode());
Console.WriteLine("GetType: {0}", c1.GetType().BaseType);

// create second object

ObjTest c2 = c1;
object o = c2;
if (o.Equals(c1) && c2.Equals(o))
Console.WriteLine("Same Instance");
}
} 91
Overriding System.Object Methods
We can redefine the behavior of virtual methods by overiding
Example ToString(), Equals(), etc.
class Person
{
public Person(string fname, string lname, string ssn, byte a)
{
firstName = fname;
lastName = lname;
SSN = ssn;
age = a;
}
public Person() { }
public string firstName, lastName, SSN;
public byte age;
} 92
Overriding ToString()
It provides a way to quickly gain a snapshot of an object current state.
using System.Text;
class Person
{
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat("[FName = {0}", this.firstName);
sb.AppendFormat("LName = {0}", this.lastName);
sb.AppendFormat("SSN = {0}", this.SSN);
sb.AppendFormat("Age = {0}]", this.age);
return sb.ToString();
}

}
93
Overriding Equals()
Equals() returns true if and only if the two objects
being compared reference the same object in
memory
We can override this behavior and design when two
objects have the same value (value-based). That is,
when name, SSN, age of two objects are equal, then
return true else return false.

94
Example
class Person
{
public override bool Equals(object o)
{
Person temp = (Person) o;
if (temp.firstName == this.firstName &&
temp.lastName == this.lastName &&
temp.SSN == this.SSN &&
temp.age == this.age) return true;
else return false;
}

}
Overriding GetHashCode()
When a class override Equals(), it should also override
GetHashCode()
Returns All custom types will be put in a
System.Collections.Hashtable type. The Equals() and
GetHashCode() methods will be called behind the scene to
determine the correct type to return from the container
Generation of hash code can be customized. In our example
we shall use SSN a String member that is expected to be
unique
Example:
public override int GetHashCode()
{ return SSN.GetHashCode(); }
Main() method for all override
functions
static void Main(string [] args)
{ person p3=new person (Anu,Sing, 222-22-2222,28);
person p3=new person (Anu,Sing, 222-22-2222,28);
// should have same hash code & string at this point
CW(Hash code of p3={0}, p3.GetHashCode());
CW (Hash code of p4={0}, p4.GetHashCode());
CW(String of p3={0}, p3.ToString());
CW(String of p4={0}, p4.ToString());
Contd
If (p3.Equals(p4))
CW(p3&p4 same state):
else
CW(p3 &p4 have differ state);
CW(changing the age of p4);
P4.age=40;
CW(String of p3 ={0}, p3.ToString());
CW(String of p4={0}, p4.ToString());
CW(Hashcode of p3={0}, p3.GetHashCode());
CW(Hashcode of p4={0}, p4.GetHashCode());
Contd
If (p3.Equals(p4))
CW(p3&p4 same state):
else
CW(p3 &p4 have differ state);

}
Static members of System.Object
Two static members : object.Equals() &
object.ReferenceEquals()
Used to check for value-based or references based equality
static void Main(string [] args)
{ person p3=new person (Anu,Sing, 222-22-2222,28);
person p4=new person (Anu,Sing, 222-22-2222,28);
CW(Do p3 & p4 have same state: {0}, object.Equals(p3,p4));
//true
CW(Are p3 &p4 are pointing to same object :{0},
object.ReferenceEquals(p3,p4)); //false }
C# Operators
All operators that you have used in C and C++ can
also be used in C#
Example: +, -, *, /, %, ?:, ->, etc
Special operators in C# are : typeof, is and as
The is operator is used to verify at runtime whether an
object is compatible with a given type
The as operator is used to downcast between types
The typeof operator is used to represent runtime type
information of a class (can also use GetType)
101
Example - is
public void DisplayObject(object obj)
{
if (obj is int)
Console.WriteLine("The object is of type integer");
else
Console.WriteLine("It is not int");
}

102
as operator
The as operator is similar to a cast operation;
however, if the conversion is not possible, as returns
null instead of raising an exception
i.e. it is equal to :
expression is type ? (type)expression : (type)null
as operator only performs reference conversions
and boxing conversions.

103
Example - as
class MainClass
{
static void Main()
{ Output:
object[] objArray = new object[4];
objArray[2] = "hello"; 0:'hello
objArray[3] = 123; 1:not a string
objArray[4] = 123.4;
objArray[5] = null; 2:not a string
for (int i = 0; i < objArray.Length; ++i)
{ string s = objArray[i] as string; 3:not a string
Console.Write("{0}:", i);
if (s != null)
Console.WriteLine("'" + s + "'");
else
Console.WriteLine("not a string");
}
}
}
104
Example - typeof
Instance Level
MyClass m = new MyClass();
Console.WriteLine(m.GetType());
Output
Typeof.MyClass

Class Level
Type myType = typeof(MyClass);
Console.WriteLine(myType);
Output
Typeof.MyClass
105
The System.String Data Type
Member Meaning
Length Returns length of the current string
Contains() Determine if the current string object contains a
specific string
Format() Format a string literal (i.e. numerals to other string)
Insert() Contains newly inserted data
Remove() Character removed or replaced
Replace()
Substring() Returns a string that represents a substring
ToUpper() Create a copy of string in upper or lower case
106
ToLower()
Strings
For string comparisons, use
Compare, CompareOrdinal, CompareTo(), Equals, EndsWith, and
StartsWith
To obtain the index of the substring, use
Use IndexOf, IndexOfAny, LastIndexOf, and LastIndexOfAny
To copy a string a substring, use
Copy and CopyTo
To create one or more strings, use
Substring and Split
To change the case, use
ToLower and ToUpper
To modify all or part of the string, use
Insert, Replace, Remove, PadLeft, PadRight, Trim, TrimEnd, and
TrimStart
String Methods
CompareTo() int x = s1.CompareTo(s2); and returns
an int
Remove() Deletes a specified number of characters
from this instance beginning at a specified position.
public string Remove (int startIndex, int count );
Insert() - Inserts a specified instance of String at a
specified index position in this instance.
public string Insert (int startIndex, string value );
ToLower() - Returns a copy of this String in lowercase
Example: s = s.ToLower();
108
Basic string operations
Example: static void Main(string[] args)
{
string s= this is taking short time;
Console.WriteLine(s contains me?:{0},s.contains(me));
Console.WriteLine(s.Replace(., !);
Console.WriteLine(s.Insert(0, Hai));
}
Equality operator (= =) used to compare the value with string
objects.
+ or String.Concat() used to concatenate existing string with
new string.
109
 Escape characters
Character Meaning Eg:String s3 Hello \t
\ Single quote there \t again;
\ Double quote Console.WriteLine(s3);
Or
\\ Insert
backslash Console.WriteLine(C:\\myapp\
\bin\\debug);
\a Beep
\n New Line
]r Carriage return
\t Horizontal tab
110
Verbatim Strings
@ prefixed string literals notation termed as verbatim string
Using verbatim string-
Disable the process of literals escape characters
Console.WriteLine(@C:\myapp\bin\debug);
Preserve white space for strings the flow over
multiple lines
String mystring= @ This is a very
very
long string;
Console.Write(mystring);
Insert a double quote by doubling token
Console.WriteLine(@ this is verbatim string);

111
System.Text.StringBuilder
String variables are inefficient to build a program that makes heavy
use of textual data
Like Java, C# strings are immutable. This means, strings can not
be modified once established
For example, when you send ToUpper() message to a string
object, you are not modifying the underlying buffer of the existing
string object. Instead, you return a fresh copy of the buffer in
uppercase
It is not efficient, sometimes, to work on copies of strings
solution?
Use StringBuilder from System.Text!
System.Text.Stringbuilder provides members like Append, Format,
Insert & Remove
112
Example
using System;
using System.Text;
class MainClass
{ public static void Main()
{ StringBuilder myBuffer = new StringBuilder("Buffer");
Console.WriteLine(Capacity of the string:{0},myBuffer.Capacity);

myBuffer.Append( " is created");

Console.WriteLine(Capacity of the string:{0},
myBuffer.Capacity);
Console.WriteLine(myBuffer); } }
113
Stack Class (StaticMethod folder)
using System;
public class Stack
{
public static void Push(string s)
{
items[++top] = s;
}
public static string Pop()
{
return (items[top--]);
}
public static void Show()
{
for (int i = top; i >= 0; i--)
Console.WriteLine(items[i]);
}
private static string[ ] items = new string[5];
private static int top = -1;
}
Stack Class.
class StaticMethod
{
public static void Main(string[] args)
{
Console.WriteLine("Stack Contents:");
Stack.Push("BIT");
Stack.Push("GAT");
Stack.Show();
Console.WriteLine("Item Popped=> " + Stack.Pop());
Console.WriteLine("Stack Contents:");
Stack.Show();
}
}
Arrays in C#
C# arrays are derived from System.Array base class
Memory for arrays is allocated in heap
Arrays always have a lower bound of zero
Example
Int [ ] counter; // array declaration
string [ ] strArray = new string[10]; // string array
int [ ] intArray = new int [10]; // integer array
Person[ ] Staff = new Person[2]; // object array
strAarray[0] = "BIT"; // assign some value
int [ ] Age = new int[3] {25, 45, 30}; // array initialization
116
Arrays in C#
Assign an array object to another
eg: int [ ] a ={1,2,3};
int [ ] b; b=a;
Array can also hold reference type elements but they
contain only references to the elements & not the
actual values.

117
Arrays as Parameters ( & return
values)
Pass a parameter & receive it as a member return value
Eg: static void PrintArray(int[ ] myInts)
{ for(int i =0; i<myInts.Length;i++)
Console.WriteLine(Item {0} is {1}, i, myInts[i]);
}
static string[ ] GetstringArray( )
{ string [ ] str1={A , B, C};
return str1;
}
static void Main(string[ ] args)
{ int[ ] ages = {20, 22, 23, 0};
PrintArray(ages);
string[ ] str=SetstringArray();
foreach (string s in str)
Console.WriteLine(s);
}
118
 Multidimensional Arrays
Two types of multidimensional array -
Rectangular Array
int[ , ] myMatrix; // declare a rectangular array
int[ , ] myMatrix = new int[2, 2] { { 1, 2 }, { 3, 4 } }; // initialize
Jagged Array
int[ ][ ] myJaggedArr = new int[2][ ]; // 2 rows and variable columns
for (int i=0; i < myJaggedArr.Length; i++)
myJaggedArr[i] = new int[i + 7];
Note that, 1st row will have 7 columns and 2nd row will have 8
columns
119
System.Array Base Class
BinarySearch( ) Finds a given item
Clear( ) Sets range of elements to 0/null
CopyTo( ) Copy source to Destination array
GetEnumerator( ) Returns the IEnumerator interface
GetLength( ) To determine no. of elements
Length Length is a read-only property
GetLowerBound( ) To determine lower and upper bound
GetUpperBound( )
GetValue( ) Retrieves or sets the value of an array cell, given its
SetValue( ) index
Reverse( ) Reverses the contents of one-dimensional array
Sort( ) Sorts a one-dimensional array
Example
Using System;
Class sortReverse
{ public static void Main(string[ ] args)
{ int[ ] x= {30, 10, 80, 90,20};
Console.WriteLine("Array before sorting");
foreach(int i in x)
Console.WriteLine( +i); Console.WriteLine();;
Array.sort(x); Array.Reverse(x);
Console.WriteLine("Array after sorting");
foreach(int i in x)
Console.WriteLine( +i); Console.WriteLine();;
}
} 121
Example
public static int[ ] ReadArray( ) // reads the elements of the array
{
int[ ] arr = new int[5];
for (int i = 0; i < arr.Length; i++)
arr[i] = arr.Length - i;
return arr;
}
public static int[ ] SortArray(int[ ] a)
{
System.Array.Sort(a); // sorts an array
return a;
}
122
Calling Program
public static void Main(string[ ] args)
{
int[ ] intArray;

intArray = ReadArray( ); // read the array elements

Console.WriteLine("Array before sorting");
for (int i = 0; i < intArray.Length; i++)
Console.WriteLine(intArray[i]);

intArray = SortArray(intArray); // sort the elements

Console.WriteLine("Array after sorting");
for (int i = 0; i < intArray.Length; i++)
Console.WriteLine(intArray[i]);
}

123
Structures in C#
Structures can contain constructors (must have
arguments). We can't redefine default constructors
It can implement interfaces
Can have methods in fact, many!
There is no System.Structure class!

124
Example
using System;
struct STUDENT
{ public int RegNo;
public string Name;
public int Marks;
public STUDENT(int r, string n, int m)
{ RegNo = r;
Name = n;
Marks = m; }
}
class MainClass
{ public static void Main()
{ STUDENT Geetha;
Geetha.RegNo = 111;
Geetha.Name = "Geetha";
Geetha.Marks = 77;

STUDENT SomeOne = new STUDENT(222,"Raghu",90);

} }
(Un)Boxing custom structures
To convert a structure variable into an object reference use boxing
Eg: STUDENT s1= new STUDENT( 333, Anu, 80);
object sbox=s1;
Unboxing:
Eg: public static void Main unboxs1(object o)
{ STUDENT temp=(STUDENT) o;
Console.WriteLine(temp.name+ is got Distinction);
}

unboxs1(sbox); // calling logic

126
 Designing Custom Namespaces
System is the .NET's existing namespace
Using the keyword namespace, we can define our own
namespace
Putting all classes in a single namespaces may not be a good
practice
Typical namespace organization for a large project
To use a namespace:
(1) System.Xml.XmlTextReader;
using System.XmlTextReader;

127
Example
Assume that you are developing a collection of graphic
classes: Square, Circle, and Hexagon
To organize these classes and share, two approaches could
be used:
namespace MyShapes;
{
public class Square { }
public class Circle { }
public class Hexagon { }
}

128
Alternate Approach
// Square.cs
using System; All the three classes Square, Circle, and
namespace MyShapes Hexagon are put in the namespace
{ MyShapes
class Square { }
using System;
}
using MyShapes;
// Circle.cs
namespace MyApplication
using System;
{
namespace MyShapes
class ShapeDemo
{
{
class Circle { }
..
}
Square sq = new Square();
// Heagon.cs
Circle Ci = new Circle();
using System;
Heagone he = new Heagon();
namespace MyShapes
.
{
}
class Hexagon { }
}
}
defined in MyShapes namespace
Resolving Name clashes in
namespaces
using My3DShapes; The class Square is define in both
{ the namespaces (MyShapes and
public class Square { } My3DShpaes)
public class Circle { } To resolve this name clash, use
public class Hexagon { }
My3DShapes. Square Sq =
}
new My3DShapes.Square();
using System;
Qualify the name of the class with the
using MyShapes;
appropriate namespace
usingMy3DShapes;
The default namespace given in VS
..
IDE is the name of the project
// Error!
Square Sq = new Square();
.

130
Defining Namespace Aliases
Aliases - An alternative approach to resolve namespace
clashes
using system; using MyShapes; using My3DShapes;
using A=My3DShapes.Hexagon;
Namespace MyaApp
{ class ShapeTester
{ Public static void Main()
{ A.Hexagon h=new A.Hexagon();
A.Circle c = new A.Circle()
A h2=new a(); // creating an object using alias
}}}

131
Neated Namespaces
Eg: to create a higher level namespace Or
that contains exisiting
My3DShapes namespace, update Using System;
the previous codes as follows: Namespace Nest.My3DShapes
Usinf System; {
namespaceNest class Square { }
{ class Circle { }
Namespace My3DShapes; class Hexagon { }
{ }}
class Square { }
class Circle { }
class Hexagon { }
}}

132
 End of
Chapter 3
More on as operator
The as operator is similar to a cast operation;
however, if the conversion is not possible, as returns
null instead of raising an exception
i.e. it is equal to :expression is type ?
(type)expression : (type)null
as operator only performs reference conversions
and boxing conversions.

134
More Example - as
class MainClass
{
static void Main()
{ Output:
object[] objArray = new object[4];
objArray[2] = "hello"; 0:'hello
objArray[3] = 123; 1:not a string
objArray[4] = 123.4;
objArray[5] = null; 2:not a string
for (int i = 0; i < objArray.Length; ++i)
{ string s = objArray[i] as string; 3:not a string
Console.Write("{0}:", i);
if (s != null)
Console.WriteLine("'" + s + "'");
else
Console.WriteLine("not a string");
}
}
}
135
More on typeof operator
Used to obtain the System.Type object for a type.
A typeof expression takes the following form:
System.Type type = typeof(int);
To obtain the run-time type of an expression, use the .NET
Framework method GetType :
int i = 0;
System.Type type = i.GetType();
Types with more than one type parameter must have the
appropriate number of commas in the specification.
The typeof operator cannot be overloaded.
136
More Example - typeof
public class SampleClass Output:
{
Methods:
public int sampleMember;
public void SampleMethod() {} Void SampleMethod()
static void Main() System.Type GetType()
{
Type t = typeof(SampleClass); System.String ToString()
// Alternatively, you could use Members:
// SampleClass obj = new SampleClass();
// Type t = obj.GetType(); Void SampleMethod()
Console.WriteLine("Methods:"); System.Type GetType()
MethodInfo[] methodInfo = t.GetMethods();
System.String ToString()
foreach (MethodInfo mInfo in methodInfo)
Console.WriteLine(mInfo.ToString()); Int32 sampleMember
Console.WriteLine("Members:");
MemberInfo[] memberInfo = t.GetMembers();
foreach (MemberInfo mInfo in memberInfo)
Console.WriteLine(mInfo.ToString());
}
}
137
Value Types containing
Reference Types
When a value type contains other reference type,
assignment results only "reference copy"
You have two independent structures, each one
pointing to the same object in memory "shallow
copy"
For a more deep copy, we must use ICloneable
interface
Example: ValRef.cs

138
Example InnerRef valWithRef = new
// ValRef.cs InnerRef("Initial Value");
// This is a Reference type because it is a class valWithRef.structData = 666;
class TheRefType
{
public string x;
valWithRef
public TheRefType(string s)
{ x = s; } structData = 666
}
refType x=
// This a Value type because it is a structure type
"I am NEW"
"Initial Value"
struct InnerRef
{ valWithRef2
public TheRefType refType; // ref type
public int structData; // value type structData = 777

refType
public InnerRef(string s)
{
refType = new TheRefType(s);
structData = 9; InnerRef valWithRef2 = valWithRef;
} valWithRef2.refType.x = "I am NEW";
}
valWithRef2.structData = 777
System.Text.StringBuilder
String variables are inefficient to build a program that makes heavy use of textual
data
Like Java, C# strings are immutable. This means, strings can not be modified
once established
For example, when you send ToUpper() message to a string object, you are not
modifying the underlying buffer of the existing string object. Instead, you return a
fresh copy of the buffer in uppercase
It is not efficient, sometimes, to work on copies of strings solution?
Use StringBuilder from System.Text!
System.Text.Stringbuilder provides members like Append, Format, Insert & Remove

Note: A String is called immutable because its value cannot be modified once it has been created.
Methods that appear to modify a String actually return a new String containing the
modification. If it is necessary to modify the actual contents of a string-like object, use the
System.Text.StringBuilder class.

140
String Manipulations in C#

A string is a sequential collection of Unicode characters, typically used to

represent text, while a String is a sequential collection of System.Char
objects that represents a string.
If it is necessary to modify the actual contents of a string-like object, use the
System.Text.StringBuilder class.
Members of String perform either an ordinal or linguistic operation on a
String.
ordinal: acts on the numeric value of each Char object.
linguistic: acts on the value of the String taking into account culture-specific casing,
sorting, formatting, and parsing rules.
Sort rules determine the alphabetic order of Unicode characters and how
two strings compare to each other.
For example, the Compare method performs a linguistic comparison while the
CompareOrdinal method performs an ordinal comparison.
Consequently, if the current culture is U.S. English, the Compare method considers
'a' less than 'A' while the CompareOrdinal method considers 'a' greater than 'A'.
141
Meaning of String Methods
String s1 = "a"; Console.WriteLine("Compare");
String s2 = "A"; if (y == 0)
Console.WriteLine("a = A");
int x = String.CompareOrdinal(s1, s2); else if (y > 0)
int y = String.Compare(s1, s2); Console.WriteLine("a > A");
else
Console.WriteLine("Ordinal"); Console.WriteLine("a < A");
if (x == 0)
Console.WriteLine("a = A"); Ouput:
else if (x > 0) Ordinal
Console.WriteLine("a > A"); a>A
else Compare
Console.WriteLine("a < A"); a<A

142
Example - as
Using as, you can convert types without raising an exception
In casting, if the cast fails an InvalidCastException is raised
But in as no exception is raised, instead the reference will be
set to null
static void ChaseACar(Animal anAnimal)
{
Dog d = anAnimal as Dog; // Dog d = (Dog) anAnimal;
if (d != null)
d.ChaseCars();
else
Console.WriteLine("Not a Dog");
}
143