Chapter 3

C# Language Fundamentals

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 using System; class HelloClass { public static void Main(string[ ] args) { // . } } // Hello2.cs using System; class HelloClass { public static void Main() { // . } }

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 SystemDirectory returns 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; c1.SayHi(); HelloClass c1 = new HelloClass(); 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
sbyte
byte short ushort int uint long ulong char float

System Type
System.SByte
System.Byte System.Int16 System.UInt16 System.Int32 System.UInt32 System.UInt64 System.UInt64 System.Char System.Single

Range
-128 to 127
0 to 255 -32768 to 32767 0 to 65535 -2,147,438,648 to +2,147,438,647 0 to 4,294,967,295 -9,223,372,036,854,775,808 to +9,.. 0 to 18,446,744,073,709,551,615 U10000 to U1FFFF 1.510-45 to 3.41038

double bool
decimal string object

System.Double System.Boolean
System.Decimal System.String System.Object

5.010-324 to 1.710308 true or false

100 to 1028 Limited by system memory Anything at all

Hierarchy of System Types

Object Type String Array Exception Delegate ValueType (derived one is struct type and not class) Boolean Byte Char UInt16 UInt32 UInt64 Void DateTime Guid TimeSpan Single
13

Decimal
Double Int16 Int32 Int64

MulticastDelegate

SByte

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() { } private void MyMethod() { } protected void MyMethod() { } internal void MyMethod() { }

Accessible anywhere Accessible only from the class where defined Accessible from its own class and its descendent 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() Title WindowsHeight, WindowsTop, WindowsLeft Windows Width clears the buffer & display area sets the title control the dimensions of the console in relation to the 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. 2. 3. 4. 5. 6. 7. C or c D or d E or e F or f G or g N or n X or x Currency ($) Decimal Exponential Fixed point General Numerical Hexadecimal
Example // Format.cs using System; class Format { public static void Main (string [ ] args) { Console.WriteLine("C Format: {0:c}", 9999); Console.WriteLine("D Format: {0:d}", 9999); Console.WriteLine("E Format: {0:e}", 9999); Console.WriteLine("F Format: {0:f}", 9999); Console.WriteLine("G Format: {0:g}", 9999); Console.WriteLine("N Format: {0:n}", 9999); Console.WriteLine("X Format: {0:x}", 9999); } }

C Format: $9,999.00 D Format: 9999 E Format: 9.999000e+003 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) { // Error no break case "India": case "USA": default: } { // Correct case "India": HiIndia(); break; case "USA": HiUSA(); break; 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 { public static void Main(string[ ] args) { MyClass.MyMethod(); } }

If MyMethod() is not declared as static, then MyClass obj = new MyClass(); obj.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; public int y; } 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

Program Entry Point

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); 52 Now, item2 is a copy of item1

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 53 the garbage collector is called finalization.

Parameter Passing Methods

Value out Value parameter 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 Program a, b r
out

Called Program x, y 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
Reference Variables
Shape rect = new Shape();

Objects 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:
Creating r1 Assign r1 to r2 Changing all vaues of r2
r1.rectInfo.infoString: This is new info r2.rectInfo.infoString: This is new info r1.bottom: 100 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(); PersonByValue(geetha); geetha.PrintPerson();

Passing By Value........... Geetha is 25 years old Geetha is 60 years old

// 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 Where is this type allocated? How is a variable represented? Value Type Reference type Allocated on the stack. On the heap Value type variables are local copies Reference type variables are pointing to the memory occupied by the allocated instance. Can derive from any other type, as long as that type is not 78 sealed

What is the base type? Must derive from System.ValueType.

Can this type function as a base to other types? What is the default parameter passing behavior? Can I define constructors for this type?

No. Value types are always sealed and cannot be extended. Variables are passed by value.

Yes. If the type is not sealed, it may function as a base to other types. Variables are passed by reference

When do variables of this type die?

Yes, but the default Yes constructor is reserved (i.e., custom constructors must all have arguments). When they fall out of When the managed 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 numerals

Example - 1 enum Colors
{ Red, Green, Blue // 0 // 1 // 2

The internal type used for enumeration is System.Int32 Valid types: byte, sbyte, short, ushort, int, uint, long, ulong Eg: enum pos:byte { off, on}
Using Enumerations Colors c; c = Colors.Blue; Console.WriteLine(c); // Blue

Example - 2 enum Colors

{
Red = 10, Green, Blue // 10 // 11 // 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

Format() Converts a value of an enumerated type to its string equivalent according to the specified format Retrieves the name for the constant in the enumeration Returns the type of enumeration
(Colors))); // System.Int32

GetName()

GetUnderlyingType() Console.WriteLine(Enum.GetUnderlyingType(typeof GetValues() IsDefined() Gives an array of values of the constants in enumeration To check whether a constant exists in enum
if (Enum.IsDefined(typeof(Colors), "Blue") .

Converts string/value to enum object

Parse()

Colors CarColor = (Colors)Enum.Parse(typeof(Colors), "Red");

86

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()
GetType() ToString() Finalize() MemberwiseClone()

Returns an integer that identifies a specific object instance

Returns System.Type [ describes current item] Returns string representation of a given object Protected method, used for object removal (garbage collection) Returns a new object, i. e. member-wise copy of the current object
90

Example
// ObjTest.cs using System; class ObjTest { public static void Main (string [ ] args) { ObjTest c1 = new ObjTest(); ToString: namespacename.ObjTest GetHashCode: 1 GetType: System.Object Same Instance

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() { object[] objArray = new object[4]; objArray[2] = "hello"; objArray[3] = 123; objArray[4] = 123.4; objArray[5] = null; for (int i = 0; i < objArray.Length; ++i) { string s = objArray[i] as string; Console.Write("{0}:", i); if (s != null) Console.WriteLine("'" + s + "'"); else Console.WriteLine("not a string"); } } }

Output: 0:'hello 1:not a string

2:not a string
3: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 Length Contains() Format() Insert() Remove() Replace() Substring() ToUpper() ToLower() Meaning Returns length of the current string Determine if the current string object contains a specific string Format a string literal (i.e. numerals to other string) Contains newly inserted data Character removed or replaced Returns a string that represents a substring Create a copy of string in upper or lower case
106

Strings
For string comparisons, use

Compare, CompareOrdinal, CompareTo(), Equals, EndsWith, and StartsWith Use IndexOf, IndexOfAny, LastIndexOf, and LastIndexOfAny Copy and CopyTo Substring and Split

To obtain the index of the substring, use

To copy a string a substring, use To create one or more strings, use To change the case, use
ToLower and ToUpper
Insert, Replace, Remove, PadLeft, PadRight, Trim, TrimEnd, and TrimStart

To modify all or part of the string, use

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 ); Example: s = s.ToLower();

108

ToLower() - Returns a copy of this String in lowercase

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

\ \ \\ \a \n
]r \t

Single quote Double quote Insert backslash Beep New Line

Carriage return Horizontal tab

Eg:String s3 Hello \t there \t again; Console.WriteLine(s3); Or Console.WriteLine(C:\\myapp\ \bin\\debug);

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( ) Clear( ) CopyTo( ) GetEnumerator( ) GetLength( ) Length GetLowerBound( ) GetUpperBound( ) GetValue( ) SetValue( ) Reverse( ) Sort( ) Finds a given item Sets range of elements to 0/null Copy source to Destination array Returns the IEnumerator interface To determine no. of elements Length is a read-only property To determine lower and upper bound Retrieves or sets the value of an array cell, given its index Reverses the contents of one-dimensional array 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; namespace MyShapes { class Square { } } // Circle.cs using System; namespace MyShapes { class Circle { } } // Heagon.cs using System; namespace MyShapes { class Hexagon { } }
All the three classes Square, Circle, and Hexagon are put in the namespace

MyShapes using System; using MyShapes; namespace MyApplication { class ShapeDemo { .. Square sq = new Square(); Circle Ci = new Circle(); Heagone he = new Heagon(); . } } defined in MyShapes namespace

Resolving Name clashes in namespaces

using My3DShapes; { public class Square { } public class Circle { } public class Hexagon { } } using System; using MyShapes; usingMy3DShapes; .. // Error! Square Sq = new Square(); .

The class Square is define in both the namespaces (MyShapes and My3DShpaes) To resolve this name clash, use
My3DShapes. Square Sq = new My3DShapes.Square();

Qualify the name of the class with the appropriate namespace The default namespace given in VS IDE is the name of the project

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 that contains exisiting My3DShapes namespace, update the previous codes as follows: Usinf System; namespaceNest { Namespace My3DShapes; { class Square { } class Circle { } class Hexagon { } }} Or Using System; Namespace Nest.My3DShapes { 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() { object[] objArray = new object[4]; objArray[2] = "hello"; objArray[3] = 123; objArray[4] = 123.4; objArray[5] = null; for (int i = 0; i < objArray.Length; ++i) { string s = objArray[i] as string; Console.Write("{0}:", i); if (s != null) Console.WriteLine("'" + s + "'"); else Console.WriteLine("not a string"); } } }

Output: 0:'hello 1:not a string

2:not a string
3: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 { public int sampleMember; public void SampleMethod() {} static void Main() { Type t = typeof(SampleClass); // Alternatively, you could use // SampleClass obj = new SampleClass(); // Type t = obj.GetType(); Console.WriteLine("Methods:"); MethodInfo[] methodInfo = t.GetMethods(); foreach (MethodInfo mInfo in methodInfo) Console.WriteLine(mInfo.ToString()); Console.WriteLine("Members:"); MemberInfo[] memberInfo = t.GetMembers(); foreach (MemberInfo mInfo in memberInfo) Console.WriteLine(mInfo.ToString()); } }
Output: Methods: Void SampleMethod() System.Type GetType() System.String ToString() Members: Void SampleMethod() System.Type GetType() System.String ToString() Int32 sampleMember

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
// ValRef.cs // This is a Reference type because it is a class

InnerRef valWithRef = new InnerRef("Initial Value"); valWithRef.structData = 666; valWithRef

structData = 666 refType

class TheRefType { public string x; public TheRefType(string s) { x = s; } }

// This a Value type because it is a structure type

struct InnerRef { public TheRefType refType; public int structData;

"I am NEW" "Initial Value"

x=

// ref type // value type

valWithRef2
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"; String s2 = "A"; int x = String.CompareOrdinal(s1, s2); int y = String.Compare(s1, s2); Console.WriteLine("Ordinal"); if (x == 0) Console.WriteLine("a = A"); else if (x > 0) Console.WriteLine("a > A"); else Console.WriteLine("a < A"); Console.WriteLine("Compare"); if (y == 0) Console.WriteLine("a = A"); else if (y > 0) Console.WriteLine("a > A"); else Console.WriteLine("a < A"); Ouput: Ordinal a>A Compare 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