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

Basic C# Class
// Hello.cs using System;

class HelloClass { public static int Main(string[ ] args) { Console.WriteLine("Hello World"); return 0; } }

Basic C# Class - Variations

// Hello1.cs using System; class HelloClass { public static void Main(string[ ] args) { // . } }

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

CONSTRUCTORS
Works almost same as C++ "new" is the de facto standard to create an object instance Example ( illegal ) Correct version

HelloClass c1; HelloClass(); c1.SayHi();

HelloClass c1 = new c1.SayHi();

C# object variables are references to the objects in memory and not

the actual objects Garbage collection is taken care by .NET

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

Console.WriteLine("Out: {0}\t{1}", p1.x, p1.y); Console.WriteLine("Out: {0}\t{1}", p2.x, p2.y);

} }

Default Values

Public variables/members are automatically get default values

class Default { public int x; public object obj; public static void Main (string [ ] args) { Default d = new Default(); // Check the default value } }

Example

Local members/variables must be explicitly initialized

public static void Main (string [ ] args) { int x; Console.WriteLine(x); // Error }

BASIC INPUT & OUTPUT

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

} }

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

.NET String Formatting

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

Value and Reference Types

.NET types may be value type

or reference type Primitive types are always value types including structures These types are allocated on the stack. Outside the scope, these variables will be popped out. However, classes are not value type but reference based

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 }

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 . }

Class 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

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 deeper copy, we

must use ICloneable interface Example: ValRef.cs

Example
// ValRef.cs // This is a Reference type because it is a class

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; // ref type public int structData; // value type public InnerRef(string s) { refType = new TheRefType(s); structData = 9; } }

System.Object

Every C# data type is derived from the base class called System.Object

class HelloClass { .... } is same as class HelloClass : System.Object { ....}

Example
namespace System
{

public class Object

{

public Object(); public virtual Boolean Equals(Object(obj); public virtual Int32 GetHashCode(); public Type GetType();
.. } }

Core Members of

System.Object Create System.Object Methods

// ObjTest.cs using System; class ObjTest { 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"); } }

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

Overriding ToString()

using System.Text;

To format the string returned by System.Object.ToString()

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

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 (valuebased). That is, when name, SSN, age of two objects are equal, then return true else

return false.

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: refer to: Override.cs
public override int GetHashCode()
{ return SSN.GetHashCode(); }

C# Data Types

Hierarchy of System Types Examples

Integers

 UInt16.MaxValue UInt16.MinValue

Double

double.Maxvalue double.MinValue double.PositiveInfinity double.NegativeInfinity

Boolean
bool.FalseString bool.TrueString

Examples

Char

char.IsDigit('K') char.IsLetter('a') or char.IsLetter("100", 1) char.IsWhiteSpace("Hi BIT", 2) char.IsPunctuation(',')

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

Reference Type
These types are allocated in a managed Heap Objects of these types are indirectly referenced Garbage collection is handled by .NET

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.

UnBoxing
Converting the value in an object reference (held in heap) into the corresponding value type (stack) Example:

object objAge; int Age = (int) objAge; // OK string str = (string) objAge; // Wrong!

The type contained in the box is int and not string!

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

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

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) { if (s.IndexOf("6") != -1) n++; } Console.WriteLine("No. of Students scored above 60 = {0}", n); } }

The while and do/while Loop

class FileRead { public static void Main(string[] args) { try

StreamReader strReader = File.OpenText("d:\\in.dat"); string strLine = null; while (strReader.ReadLine( ) != null) { Console.WriteLine(strLine); } strReader.Close(); } catch (FileNotFoundException e) { Console.WriteLine(e.Message); } }

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! { . }

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

goto Statement
goto label; Explicit fall-through in a switch statement can be achieved by using goto statement Example:

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

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

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

Example - typeof

Instance Level Output

Typeof.MyClass

MyClass m = new MyClass(); Console.WriteLine(m.GetType());

Class Level Output

Type myType = typeof(MyClass); Console.WriteLine(myType);

Typeof.MyClass

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

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

Example
public class MyClass { public static void MyMethod() {} } public class StaticMethod { public static void Main(string[ ] args) { MyClass.MyMethod(); } }

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

Parameter Passing Methods

Default Value parameter out Output parameter (called member) ref Same as pass-byreference params Variable number of parameters within a single parameter

Parameter Passing

One advantage of out parameter

type is that we can return more than one value from the called program to the caller

The ref method

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

The params method

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

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 } }

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

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(); else Console.WriteLine(list[i]); } Console.WriteLine(); }

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 (Refer to PassingRefTypes folder) public static void PersonByValue(Person p) { // will change state of p

p.age = 60; // will not change the state of p p = new Person("Nikki", 90);

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); }
// Pass by Value

Calling Program

Console.WriteLine("Passing By Value..........."); Person geetha = new Person("Geetha", 25); geetha.PrintPerson(); PersonByValue(geetha); geetha.PrintPerson(); // Pass by Reference Console.WriteLine("Passing By Reference........"); Person r = new Person("Geetha", 25); r.PrintPerson(); PersonByRef(ref r); r.PrintPerson();

Arrays in C#
C# arrays are derived from System.Array base class Memory for arrays is allocated in heap It works much same as C, C+ +, Java, etc. Example

string [ ] strArray = new

string[10]; // string array int [ ] intArray = new int [10]; // integer array int[2] Age = {34, 70}; // Error, requires new keyword Person[ ] Staff = new Person[2]; // object array strAarray[0] = "BIT"; // assign some value int [ ] Age = new int[3] {25, 45, 30}; // array initialization

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;

Multidimensional Arrays

Rectangular Array

int[ , ] myMatrix; // declare a

rectangular array

int[ , ] myMatrix = new int[2, 2] { { 1, 2 }, { 3, 4 } }; // initialize myMatrix[1,2] = 45; // access a

cell

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

System.Array Base Class

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

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'.

Strings

For string comparisons, use

Compare, CompareOrdinal,

CompareTo(), Equals, EndsWith, and StartsWith

To obtain the index of the substring or unicode, 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

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

More 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.

Insert() - Inserts a specified instance of String at a

public string Remove (int startIndex, int count );

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.ToUpper();

System.Text.StringBuilder
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!
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.

Example
using System; using System.Text; class MainClass { public static void Main() { StringBuilder myBuffer = new StringBuilder("Buffer"); // create the buffer or string builder myBuffer.Append( " is created"); Console.WriteLine(myBuffer); // ToString() converts a StringBuilder to a string string uppercase = myBuffer.ToString().ToUpper(); Console.WriteLine(uppercase); string lowercase = myBuffer.ToString().ToLower(); Console.WriteLine(lowercase); }

Enumerations in C#

Mapping symbolic names to numerals

enum Colors
{ Red, Green, Blue } // 0 // 1 // 2

Example - 1

Example - 2

enum Colors
{ Red = 10, // 10 Green, // 11 Blue // 12 }

The internal type used for enumeration is System.Int32

Colors c; c = Colors.Blue; Console.WriteLine(c); // Blue

Using Enumerations

System.Enum Base Class

Example
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

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!

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

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 tr; (2) using System.Xml;
XmlTextReader tr;

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:

// shapeslib.cs using MyShapes; {

public class Square { } public class Circle { } public class Hexagon { }

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

End of

Chapter 3