OBJECT ORIENTED PROGRAMMING WITH C#

C# ClassesClasses are used to accomplish:Modularity: Separating the functionality of a program into independent, interchangeable modules,

such that each contains everything necessary to execute only one aspect of the desired functionality.

Blueprints(a design plan) for generating objects or instances : Per instance data and method signatures (Method name, number of parameters,

parameter type and order of parameters)

Classes support: Data encapsulation - private data and implementation.Inheritance - code reusePolymorphism - The ability for classes to provide different implementations of methods that are called by the same name

Encapsulation Encapsulation refers to language’s ability to hide unnecessary implementation

details from the object user (Wrapping up of data). For example, assume you are using a class named DatabaseReader that has two

methods named Open() and Close():

// DatabaseReader encapsulates the details of database manipulation.DatabaseReader dbObj = new DatabaseReader();dbObj.Open(@"C:\Employees.mdf");// Do something with database...dbObj.Close();

DatabaseReader class has encapsulated the inner details of locating, loading, manipulating, and closing the data file.

Inheritance Inheritance is the language’s ability to allow you to build new class definitions based

on existing class definitions. Inheritance allows us to extend the behavior of a base (or parent) class by enabling a

subclass to inherit core functionality (also called a derived class or child class) Inheritance can be classified to 5 types.

1. Single Inheritance2. Multi-Level Inheritance3. Hierarchical Inheritance4. Hybrid Inheritance5. Multiple Inheritance

10

Single Inheritance

Multi-level Inheritance

Hierarchical Inheritance

Hybrid InheritanceAny combination of single, hierarchical and multi-level inheritances is called as hybrid inheritance.

Multiple InheritanceWhen a derived class is created from more than one base class then that inheritance is called as multiple inheritance. But multiple inheritance is not supported by .net using classes and can be done using interfaces.

11

Example program for Multiple Inheritance:

using System;//Example Program for Multiple Inheritancenamespace ProgramCall { interface Icar { int WheelsCount(); } interface IPlane { String CanFly(); }

class SuperCar : Icar, IPlane { //Multiple Inheritance public int WheelsCount() { return 4; } public String CanFly() { return "true"; } }

class Program{ static void Main(string[] args) { SuperCar mysupercar = new SuperCar(); Console.WriteLine("My Super Car has " + mysupercar.WheelsCount() + " Wheels and can fly is " + mysupercar.CanFly()); Console.ReadLine(); } } }

Output: My Super Car has 4 Wheels and can fly is true.

Polymorphism Polymorphism means having more than one form Overloading and overriding are used to implement polymorphism Polymorphism is classified into 2 types:

1. Compile time polymorphism (aka, early binding or static binding)2. Runtime polymorphism (aka, late binding or dynamic binding)

Compile time polymorphismThe polymorphism in which compiler identifies which polymorphic form it has to execute at compile time itself is called as compile time polymorphism.Examples of early binding are overloaded methods, overloaded operatorsNote: Overloading allows creating several methods with the same name which differ in parameters.

Runtime polymorphism The polymorphism in which compiler identifies which polymorphic form to execute at runtime but not at compile time is called as runtime polymorphismExample of late binding is overridden methods that are called using base class object.Note: Overriding allows a subclass or child class to provide a specific implementation of a method that is already provided by one of its superclasses or parent classes

CastingCast, in the context of C#, is a method by which a value is converted from one data type to another. Cast is an explicit conversion by which the compiler is informed about the conversion and the resulting possibility of data loss.In C#, you can perform the following kinds of conversions:

Implicit conversions Explicit Conversions User-defined conversions Conversions with helper classes

12

Implicit Conversionint num = 2147483647;long bigNum = num;

Explicit Conversionsclass Test{ static void Main() { double x = 1234.7; int a; // Cast double to int. a = (int)x; System.Console.WriteLine(a); }}// Output: 1234

Exception Handling An exception is a problem that arises during the execution of a program. A C# exception is a response to an exceptional circumstance that arises while a

program is running, such as an attempt to divide by zero C# exception handling is built upon four keywords: try, catch, finally and throw.

try: A try block identifies a block of code for which particular exceptions will be activated. It's followed by one or more catch blocks.

catch: A program catches an exception with an exception handler at the place in a program where you want to handle the problem.

finally: The finally block is used to execute a given set of statements, whether an exception is thrown or not thrown. For example, if you open a file, it must be closed whether an exception is raised or not.

throw: A program throws an exception when a problem shows up. This is done using a throw keyword.

try{ // statements causing exception}catch( ExceptionName e1 ){ // error handling code}catch( ExceptionName e2 ){ // error handling code}catch( ExceptionName eN ){ // error handling code}finally{ // statements to be executed}

13

Garbage CollectorIn the common language runtime (CLR), the garbage collector serves as an automatic memory manager. It provides the following benefits:

Enables you to develop your application without having to free memory.

Allocates objects on the managed heap efficiently.

Reclaims objects that are no longer being used, clears their memory, and keeps the memory available for future allocations. Managed objects automatically get clean content to start with, so their constructors do not have to initialize every data field.

Provides memory safety by making sure that an object cannot use the content of another object.

Note: Heap is the portion of memory where dynamically allocated memory resides

14

Interfaces and CollectionsEnumerator

Iterators in the .NET Framework are called "enumerators" and represented by the IEnumerator interface.

An enumerator helps you enumerate (iterate) over a collection of items. IEnumerator provides a MoveNext() method, which advances to the next element

and indicates whether the end of the collection has been reached. A Current property, to obtain the value of the element currently being pointed at. Otional Reset() method, to rewind the enumerator back to its initial position. The enumerator initially points to a special value before the first element, so a call to

MoveNext() is required to begin iterating. Enumerators are typically obtained by calling the GetEnumerator() method of an

object implementing the IEnumerable interface. Container classes typically implement this interface.

Note: A container class is a class that is used to hold objects in memory or external storage

using System;using System.Collections;class car : IEnumerable{ private car[] carr; public string name; public car(string s) { name = s; } public car() { carr = new car[3]; carr[0] = new car("Benz"); carr[1] = new car("Audi"); carr[2] = new car("BMW"); } public IEnumerator GetEnumerator() //to get Enumerator { return carr.GetEnumerator(); }}class enumInterface{ public static void Main(string[] args) { car o = new car(); foreach (car c in o) { Console.WriteLine(c.name); } }}Output:

15

Cloneable Objects Objects in C# and in the CLR live on the heap and are accessed through references.

You’re not actually making a copy of the object when you assign one object variable to another, as in the following code.

Object obj = new Object();Object objCopy = obj;

After this code executes, objCopy doesn’t refer to a copy of obj; rather, you now have two references to the same Object instance

Sometimes it makes sense to be able to make a copy of an object. For that purpose, the Standard Library defines the ICloneable interface. When your object implements this interface, it is saying that it supports the ability to have copies of itself made. In other words, it claims that it can be used as a prototype to create new instances of objects.

Let’s have a look at the ICloneable interface:public interface ICloneable{ object Clone();}

The interface only defines one method, Clone(), that returns an object reference. That object reference is intended to be the copy.The documentation for the interface doesn’t indicate whether the copy returned should be a deep copy or a shallow copy. The documentation leaves it open for the class designer to decide.Shallow Copy: A shallow copy of an object creates a copy of the object whose contained object references refer to the same objects as the prototype’s references.

Note: Prototype-based programming is a style of object-oriented programming in which behaviour reuse (known as inheritance) is performed via a process of cloning existing objects that serve as prototypes

16

Deep Copy: Deep copy creates a copy of the prototype where all of the contained objects are copied as well. In a deep copy, the object containment tree is traversed all the way down to the bottom and copies of each of those objects are made. Therefore, the result of a deep copy shares no underlying objects with the prototype.

//Implementing Shallow clone using icloneable interfaceusing System;public class one{ public int a;}public class two : ICloneable{ public int b; public one o = new one(); public two(int a1, int b1) { o.a = a1; b = b1; } public void show() { Console.WriteLine(o.a + " " + b); } public Object Clone() { return (this.MemberwiseClone()); }}class tth{ public static void Main(string[] args) { two t1 = new two(1, 2); two t2 = (two)t1.Clone(); t1.show(); t2.show(); t1.o.a = 5; t1.b = 5; t1.show(); t2.show(); }}Output:

17

Comparable objectsThe IComparable interface specifies a behavior that allows an object to be sorted based on some specified key.

Aim: Implementing icomparable interfaceusing System;class combo : IComparable{ public int id; public string name; public combo(string name1, int x) { name = name1; id = x; } public int CompareTo(object o) { combo temp = (combo)o; if (this.id > temp.id) return (1); if (this.id < temp.id) return (-1); else return (0); }}class icomparable{ public static void Main(string[] args) { combo[] c = new combo[3]; c[0] = new combo("Aan", 123); c[1] = new combo("Bob", 14); c[2] = new combo("Cop", 1); Array.Sort(c); foreach (combo m in c) Console.WriteLine(m.name + "\t" + m.id); }}

Output:

18

Collections We use an array when the number of elements that need to be inserted into the array is

known at compile time and it remains fixed throughout the execution of the program. We can use a collection when we do not know how many elements we will need to store. So basically a collection can grow in size dynamically. The data structure used to implement the collection depends on the collection type.

A list is generally faster than an array if you must insert items at the beginning or in the middle of the collection

public class TestCollections { public static void TestList() {List<string> sandwich = new List<string>( ); sandwich.Add("bacon"); sandwich.Add("tomato");

sandwich.Insert(1, "lettuce"); foreach (string ingredient in sandwich) { System.Console.WriteLine(ingredient); } }

Output: bacon lettuce tomato

Notice that unlike the Array class, items can be inserted into the middle of the list.

19

IndexesAn indexer allows an object to be indexed like an array. When we define an indexer for a class, this class behaves like a virtual array. We can then access the instance of this class using the array access operator ([ ]).

A one dimensional indexer has the following syntax:

element-type this[int index] { // The get accessor. get { // return the value specified by index }

// The set accessor. set { // set the value specified by index }}

20

Overloading Operatorsoperator overloading is a specific case of polymorphism, where different operators have different implementations depending on their arguments

Unary operator overloading: using System;namespace program1{ class uniaryop { public int a, b; public uniaryop(int a1, int b1){ a = a1; b = b1; } public void disp() { Console.WriteLine(a); Console.WriteLine(b); }

public static uniaryop operator -(uniaryop ob) { ob.a = -ob.a; ob.b = -ob.b; return ob; } } class unaryoperator { public static void Main(string[] args){ uniaryop u = new uniaryop(-10, -10); u.disp(); uniaryop u1 = -u; u1.disp(); Console.ReadKey(); } } }

Output:-10-101010

21

Binary Operator Overloadingusing System;using System.Collections.Generic;using System.Linq;using System.Text;

namespace binaryop{ class binop { public int real, im; public binop() { } public binop(int r, int i) { real = r; im = i; } public void disp() { Console.WriteLine(real + "+i" + im); } public static binop operator +(binop ob1, binop ob2) { binop b = new binop(); b.real = ob1.real + ob2.real; b.im = ob1.im + ob2.im; return b; } } class binaryoperator { public static void Main(string[] args) { binop b1 = new binop(15, 5); b1.disp(); binop b2 = new binop(2, 12); b2.disp(); binop b3 = b1 + b2; b3.disp(); } }

}

22

Delegates C# delegates are similar to pointers to functions, in C or C++. A delegate is a

reference type variable that holds the reference to a method. The reference can be changed at runtime.

Delegates are especially used for implementing events and the call-back methods. All delegates are implicitly derived from the System.Delegate class.

Syntax for delegate declaration is:delegate <return type> <delegate-name> <parameter list>

public delegate double Delegate_Prod(int a,int b);class Class1{ static double fn_Prodvalues(int val1,int val2) { return val1*val2; } static void Main(string[] args) { //Creating the Delegate Instance Delegate_Prod delObj = new Delegate_Prod(fn_Prodvalues); //delObj holds reference to Delegate_Prod

Console.Write("Please Enter Values"); int v1 = Int32.Parse(Console.ReadLine()); int v2 = Int32.Parse(Console.ReadLine()); //use a delegate for processing double res = delObj(v1,v2); Console.WriteLine ("Result :"+res); Console.ReadLine(); }}

EventsAn event in C# is a way for a class to provide notifications to clients of that class when some interesting thing happens to an object. The most familiar use for events is in graphical user interfaces; typically, the classes that represent controls in the interface have events that are notified when the user does something to the control (for example, click a button).

Declaring an event “ To declare an event inside a class, first a delegate type for the event must be declared, if none is already declared.

public delegate void ChangedEventHandler(object sender, EventArgs e);

Next, the event itself is declared.

public event ChangedEventHandler Changed;

Invoking an eventif (Changed != null)Changed(this, e);

23

XML DocumentationC# provides a mechanism for developers to document their code using XML. In source code files, lines that begin with /// and that precede a user-defined type such as a class, delegate, or interface; a member such as a field, event, property, or method; or a namespace declaration can be processed as comments and placed in a file.

Code DiscussionXML documentation starts with ///. When you create a new project, the wizards put some starter /// lines in for you. The processing of these comments has some restrictions:

The documentation must be well-formed XML. If the XML is not well-formed, a warning is generated and the documentation file will contain a comment saying that an error was encountered. For more information on well-formed XML, see XML Glossary.

Developers are free to create their own set of tags. There is a recommended set of tags (see the Further Reading section). Some of the recommended tags have special meanings:

The <param> tag is used to describe parameters. If used, the compiler will verify that the parameter exists and that all parameters are described in the documentation. If the verification failed, the compiler issues a warning.

The cref attribute can be attached to any tag to provide a reference to a code element. The compiler will verify that this code element exists. If the verification failed, the compiler issues a warning. The compiler also respects any using statements when looking for a type described in the cref attribute.

The <summary> tag is used by IntelliSense inside Visual Studio to display additional information about a type or member.

24