c# starter l02-classes and objects

Mohammad Shakermohammadshaker.com

C# Programming Course@ZGTRShaker

2011, 2012, 2013, 2014

C# StarterL02 – Classes, Polymorphism, Versioning, Interfaces, Reference and Value Types

Today’s Agenda

• Classes

• Inheritance

• Polymorphism

• Versioning

• Interfaces

• Reference types VS Value types

Object oriented programming (OOP) is a way of programming where you create chunks of code that match up with real world objects.

Classes

A Class

• Let’s create a Player

• And a Constructor

class Player{

private string name;private int score;private int livesLeft;

}

class Player{

private string name;private int score;private int livesLeft;

public Player(string name){

this.name = name;}

public Player(string name, int startingLives){

this.name = name;livesLeft = startingLives;

}}

Classes and ObjectsWho is Who?

Objects appear only at Runtime

this Keyword

this KeywordWhat is it?

this KeywordA pointer pointing on the object itself at runtime

this Keyword Usage

• Name hiding and clarity

• Passing Player instance at runtime to other object.

• Cloning the Player object (instance at runtime) into another Player object (in

constructor.)

public Player(string name){

this.name = name;}

public Player(string name, int startingLives){

this.name = name;livesLeft = startingLives;

}

Static KeywordWhat is it?

Destructors

Destructor

• Correspond to finalizers in Java.

• Called for an object before it is removed by the garbage collector.

• No public or private.

• Is dangerous (object resurrection) and should be avoided

class Test {

~Test() {

... finalization work ...// automatically calls the destructor of the base class

}}

Inheritance

Constructors and Inheritance

using System;

public class ParentClass{

public ParentClass(){

Console.WriteLine("Parent Constructor.");}

public void print(){

Console.WriteLine("I'm a Parent Class.");}

}

public class ChildClass : ParentClass{

public ChildClass(){

Console.WriteLine("Child Constructor.");}

public static void Main(){

ChildClass child = new ChildClass();

child.print();}

}

Inheritance

using System;

public class ParentClass{

public ParentClass(){

Console.WriteLine("Parent Constructor.");}

public void print(){


}

public class ChildClass : ParentClass{

public ChildClass(){

Console.WriteLine("Child Constructor.");}


ChildClass child = new ChildClass();

child.print();}

}

Parent Constructor.Child Constructor.I'm a Parent Class.

Inheritance

public class Parent{

string parentString;public Parent(){

Console.WriteLine("Parent Constructor.");}public Parent(string myString){

parentString = myString;Console.WriteLine(parentString);

}public void print(){


}

public class Child : Parent{

public Child() : base("From Derived"){

Console.WriteLine("Child Constructor.");}public new void print(){

base.print();Console.WriteLine("I'm a Child Class.");

}public static void Main(){

Child child = new Child();child.print();((Parent)child).print();

}}

Inheritance

public class Parent{

string parentString;public Parent(){

Console.WriteLine("Parent Constructor.");}public Parent(string myString){

parentString = myString;Console.WriteLine(parentString);

}public void print(){


}

public class Child : Parent{

public Child() : base("From Derived"){

Console.WriteLine("Child Constructor.");}public new void print(){

base.print();Console.WriteLine("I'm a Child Class.");

}public static void Main(){

Child child = new Child();child.print();((Parent)child).print();

}}

From DerivedChild Constructor.I'm a Parent Class.I'm a Child Class.I'm a Parent Class.

Inheritance

Polymorphism

public class DrawingObject{

public virtual void Draw(){

Console.WriteLine("I'm just a generic drawing object.");

}}

public class Line : DrawingObject{

public override void Draw(){

Console.WriteLine("I'm a Line.");}

}

public class Circle : DrawingObject{


Console.WriteLine("I'm a Circle.");}

}

public class Square : DrawingObject{


Console.WriteLine("I'm a Square.");}

}

Polymorphism

class Program{

static void Main(string[] args){

DrawingObject[] dObj = new DrawingObject[4];

dObj[0] = new Line();dObj[1] = new Circle();dObj[2] = new Square();dObj[3] = new DrawingObject();

foreach (DrawingObject drawObj in dObj){

drawObj.Draw();}

}}

Polymorphism

class Program{

static void Main(string[] args){

DrawingObject[] dObj = new DrawingObject[4];

dObj[0] = new Line();dObj[1] = new Circle();dObj[2] = new Square();dObj[3] = new DrawingObject();

foreach (DrawingObject drawObj in dObj){

drawObj.Draw();}

}}

I'm a Line.I'm a Circle.I'm a Square.I'm just a generic drawing object.Press any key to continue...

Polymorphism


public DrawingObject(string objectName){

}


Console.WriteLine("I'm just a generic drawing object.");}

}




}

Polymorphism

Polymorphism



Console.WriteLine(objectName);}



}}


public Line():base("ForBaseClass, DrawingObject")

{Console.WriteLine(this.ToString());

}



}

Polymorphism






}}




}



}

ForBaseClass, DrawingObjectConsoleApplicationCourseTest.LinePress any key to continue...

Polymorphism

Polymorphism






}}




}

public override string ToString(){

return "just another Line object on runtime!";}



}

Polymorphism






}}




}

public override string ToString(){

return "just another Line object on runtime!";}



}

ForBaseClass, DrawingObjectjust another Line object on runtime!Press any key to continue...

Polymorphism

Abstract Classes

Abstract Classes

• Abstract methods do not have an implementation.

• Abstract methods are implicitly virtual.

• If a class has abstract methods it must be declared abstract itself.

• One cannot create objects of an abstract class.

abstract class Stream {

public abstract void Write(char ch);public void WriteString(string s) { foreach (char ch in s) Write(s); }

}

class File: Stream{

public override void Write(char ch) {... write ch to disk...}}

sealed and internal classessealed: can’t be extended (Java’s final)

internal: can’t be used in other namespaces

Versioning

class DerivedClass: BaseClass{

public override string Meth1(){

return "MyDerived-Meth1";}

public new string Meth2(){


public string Meth3(){



DerivedClassmD = new MyDerived();BaseClass mB = (BaseClass)mD;

System.Console.WriteLine(mB.Meth1());System.Console.WriteLine(mB.Meth2());System.Console.WriteLine(mB.Meth3());

}}

Versioning

public class BaseClass{

public virtual string Meth1(){

return "BaseClass-Meth1";}public virtual string Meth2(){


return "BaseClass-Meth3";}

}











}}

Versioning

Overrides the virtual method

Meth1 using the override

keyword






}











}}

Versioning

Explicitly hide the virtual

method Meth2 using the new

keyword






}











}}

Versioning

Because no keyword is specified

in the following declaration a

warning will be issued to alert

the programmer that the method

hides the inherited member

BaseClass.Meth3()






}











}}

Versioning






}

MyDerived-Meth1BaseClass-Meth2BaseClass-Meth3

Multiple Inheritance?C#.NET doesn't allow it, Why?

Multiple Inheritance?C#.NET doesn't allow it

C++.NET doesn’t allow itJava doesn’t allow it

C++, as you know, allows it

However, C# allow multiple interfaces

However, C# allow multiple interfacesBut what are they?

Interfaces

Interfaces :D

Interfaces – The concept

Interfaces VS Abstract Classes

Interfaces

• An interface contains only the signatures of methods, delegates or events.

• The implementation of the methods is done in the class that implements the

interface.

• Can’t contain Fields!

http://msdn.microsoft.com/en-us/library/ms173114(v=vs.80).aspx


http://msdn.microsoft.com/en-us/library/awbftdfh(v=vs.80).aspx

When to use?(An Example)

Consider a Human, an Animal and a Car Class, where they all implement a crazy method called ConsumeWater().

If we have many objects of each type of Human, Animal and Car and we want to call ConsumeWater() for all objects of Human, Animal and Car; we have to call it like this:

human1.ConsumeWater();human2.ConsumeWater();human3.ConsumeWater();animal1.ConsumeWater();animal2.ConsumeWater();car1.ConsumeWater();car2.ConsumeWater();

SomeObject

Human Animal Car

And they they can’t be subclassed from one particular abstract/base class like this:

SomeObject

Human Animal Car

And they they can’t be subclassed from one particular abstract/base class like this:

Because they are not the same and they share some common properties!



But if we can implement a common functionalities from a common place, that would be nice!

interface

Human Animal Car

Implementation and not inheritance!



But if we can implement a common functionalities from a common place, that would be nice!

IWaterable

Human Animal Car


Now we can add all objects to a common list of IWaterable and just call ConsumeWater()for each IWaterable object (they are all Waterable now!)List<IWaterable> waterables = new List<IWaterable>() {“human1”, “human2”, “human3”, “animal1”, “animal2”, “car1”, “car2”};foreach(IWaterable waterable in waterables)

waterable.ConsumeWater();

Look how nice the code is and how clear the relation is. When we implement an interface we are just saying that this interface provides a certain functionality for us (and others may freely have this functionality as well.)

IWaterable

Human Animal Car


Interfaces – the Code

Interfaces – the CodePublic interface IWaterable{

public void ConsumeWater();}



Public class Human: IWaterable{

public void ConsumeWater(){

} }

Public class Animal: IWaterable{


} }

Public class Car: IWaterable{


} }





//Drinking Water}

}

Public class Animal: IWaterable{


//Drinking Water}

}

Public class Car: IWaterable{


//Cooling the engine}

}





//Drinking Water}

}

Public class Animal:IWaterable, INosiable{


//Drinking Water} public void MakeNoise(){

//Mew, Roar or Moo!}

}

Public class Car: IWaterable, INosiable{


//Cooling the engine} public void MakeNoise(){

//Rev the engine!}

}

Public interface INoisable{

public void MakeNoise();}

Interfaces

• An interface can be a member of a namespace or a class and can contain

signatures of the following members:

– Methods

– Properties

– Indexers

– Events

• “No” Fields!


http://msdn.microsoft.com/en-us/library/w86s7x04(v=vs.80).aspx

http://msdn.microsoft.com/en-us/library/2549tw02(v=vs.80).aspx

http://msdn.microsoft.com/en-us/library/8627sbea(v=vs.80).aspx

Reference VS Value Types

using System;

class Program{

static void Main(){

float lengthFloat = 7.35f;

// lose precision - explicit conversionint lengthInt = (int)lengthFloat;

// no problem - implicit conversiondouble lengthDouble = lengthInt;

Console.WriteLine("lengthInt = " + lengthInt);Console.WriteLine("lengthDouble = " + lengthDouble);Console.ReadKey();

}}


using System;

class Program{

static void Main(){

float lengthFloat = 7.35f;

// lose precision - explicit conversionint lengthInt = (int)lengthFloat;

// no problem - implicit conversiondouble lengthDouble = lengthInt;

Console.WriteLine("lengthInt = " + lengthInt);Console.WriteLine("lengthDouble = " + lengthDouble);Console.ReadKey();

}}

lengthInt = 7lengthDouble = 7



• Reference type

• variables are named appropriately (reference) because the variable holds a reference to an

object.

• In C and C++, we have something similar that which is “a pointer”, which points to an object.

While you can modify a pointer, you can't modify the value of a reference - it simply points at

the object in memory.

using System;

class Employee{

private string _name;

public string Name{

get { return _name; }set { _name = value; }

}}


Reference Typesclass Program{ static void Main()

{Employee joe = new Employee();joe.Name = "Joe";Employee bob = new Employee();bob.Name = "Bob";

Console.WriteLine("Original Employee Values:");Console.WriteLine("joe = " + joe.Name);Console.WriteLine("bob = " + bob.Name);

// assign joe reference to bob variablebob = joe;Console.WriteLine("Values After Reference Assignment:");Console.WriteLine("joe = " + joe.Name);Console.WriteLine("bob = " + bob.Name);

joe.Name = "Bobbi Jo";

Console.WriteLine("Values After Changing One Instance:");Console.WriteLine("joe = " + joe.Name);Console.WriteLine("bob = " + bob.Name);

Console.ReadKey();}

}







Console.ReadKey();}

}

Original Employee Values:joe = Joebob = BobValues After Reference Assignment:joe = Joebob = JoeValues After Changing One Instance:joe = Bobbi Jobob = Bobbi Jo







Console.ReadKey();}

}


How is that?!







Console.ReadKey();}

}

Emp Emp

joe bob







Console.ReadKey();}

}

Emp

joe

Emp

bob







Console.ReadKey();}

}

Emp

joe bob







Console.ReadKey();}

}

joe bob

EmpName = “Joe”







Console.ReadKey();}

}

joe bob

EmpName =

“Bobbi Jo”

Reference Types

• The following types are reference types:

• arrays

• class

• delegates

• interfaces

Value Types

Value Types

• A value type

– variable holds its own copy of an object and when you perform assignment from one value

type variable to another, both the left-hand-side and right-hand-side of the assignment hold

two separate copies of that value.

Value Types

• A value type

– variable holds its own copy of an object and when you perform assignment from one value

type variable to another, both the left-hand-side and right-hand-side of the assignment hold

two separate copies of that value.

• An important fact you need to understand is that when you are assigning one

reference type variable to another, only the reference is copied, not the

object. The variable holds the reference and that is what is being copied.

struct Height{

private int m_inches;

public int Inches{

get { return m_inches; }set { m_inches = value; }

}}

Value Types

class Program{

static void Main(){

Height joe = new Height();joe.Inches = 71;

Height bob = new Height();bob.Inches = 59;

Console.WriteLine("Original Height Values:");Console.WriteLine("joe = " + joe.Inches);Console.WriteLine("bob = " + bob.Inches);

bob = joe;

Console.WriteLine("Values After Value Assignment:");Console.WriteLine("joe = " + joe.Inches);Console.WriteLine("bob = " + bob.Inches);

joe.Inches = 65;

Console.WriteLine("Values After Changing One Instance:");Console.WriteLine("joe = " + joe.Inches);Console.WriteLine("bob = " + bob.Inches);

Console.ReadKey();}

}

Value Types

class Program{

static void Main(){




bob = joe;


joe.Inches = 65;


Console.ReadKey();}

}

Value TypesHeight Height

joe bob

class Program{

static void Main(){




bob = joe;


joe.Inches = 65;


Console.ReadKey();}

}


joe bob

Height

class Program{

static void Main(){




bob = joe;


joe.Inches = 65;


Console.ReadKey();}

}


joe bob

Exactly the

same

class Program{

static void Main(){




bob = joe;


joe.Inches = 65;


Console.ReadKey();}

}

Value Types71 71

joe bob

Exactly the

same

class Program{

static void Main(){




bob = joe;


joe.Inches = 65;


Console.ReadKey();}

}

Value Types71 71

joe bob

class Program{

static void Main(){




bob = joe;


joe.Inches = 65;


Console.ReadKey();}

}

Value Types65 71

joe bob

class Program{

static void Main(){




bob = joe;


joe.Inches = 65;


Console.ReadKey();}

}

Value Types65 71

joe bob

Original Height Values:joe = 71bob = 59Values After Value Assignment:joe = 71bob = 71Values After Changing One Instance:joe = 65bob = 71

Value Types

• The following types are value types:

– enum

– struct

Classes and Structs

Classes

• Reference Types

• (objects stored on the heap)

• support inheritance

• (all classes are derived from object)

• can implement interfaces

• may have a destructor

Structs

• Value Types

• (objects stored on the stack)

• no inheritance

• (but compatible with object)

• can implement interfaces

• no destructors allowed

Creating a Class Library Project for Your Project’s Logic

Now write all your code in the Class Library project and reference it in your presentation layer project

Adding References to Other Projects to Your Project

Adding References to Your Project

The Principles

• Single Responsibility Principle: design your classes so that each has a single purpose

• Open / Closed Principle: Open for extension but closed for modification

• Liskov Substitution Principle (LSP): functions that use pointers or references to base classes must be

able to use objects of derived classes without knowing it

• Interface Segregation Principle (ISP): clients should not be forced to depend upon interfaces that they

do not use.

• Dependency Inversion Principle (DIP): high level modules should not depend upon low level modules.

Both should depend upon abstractions.

abstractions should not depend upon details. Details should depend upon abstractions.

is the process of validating the correctness of a small section of code. The target code may be a method within a class, a group of members or even entire components that are isolated from all or most of their dependencies.

Question #1



return "BaseClass-Meth1";}public string Meth2(){



}









DerivedClassmD = new MyDerived();BaseClass mB = mD;


}}

Question #1



return "BaseClass-Meth1";}public string Meth2(){



}









DerivedClassmD = new MyDerived();BaseClass mB = mD;


}}

MyDerived-Meth1BaseClass-Meth2BaseClass-Meth3Press any key to continue...

Question #2class Class1 { }class Class2 : Class1{ }class Class3 { }public class TestingClass{

public static void Test(object o){

Class1 a;Class2 b;Class3 c;if (o is Class1){

Console.WriteLine("obj is Class1");a = (Class1)o;

}else if (o is Class2){

Console.WriteLine("obj is Class2");b = (Class2)o;


Console.WriteLine("obj is Class3");c = (Class3)o;

}else if((Class3)o!= null){}

}


try{

Class1 c1 = new Class1();Class2 c2 = new Class2();Class3 c3 = new Class3();Test(c1);Test(c2);Test(c3);Test("a string");

}catch(Exception e){

Console.WriteLine("Sth wrong happened!");}

}}

Question #2class Class1 { }class Class2 : Class1{ }class Class3 { }public class TestingClass{

public static void Test(object o){

Class1 a;Class2 b;Class3 c;if (o is Class1){

Console.WriteLine("obj is Class1");a = (Class1)o;


Console.WriteLine("obj is Class2");b = (Class2)o;


Console.WriteLine("obj is Class3");c = (Class3)o;

}else if((Class3)o!= null){}

}


try{

Class1 c1 = new Class1();Class2 c2 = new Class2();Class3 c3 = new Class3();Test(c1);Test(c2);Test(c3);Test("a string");

}catch(Exception e){

Console.WriteLine("Sth wrong happened!");}

}}

obj is Class1obj is Class1obj is Class3Sth wrong happened!Press any key to continue...

public interface IsBaseTest{

void Point1(object obj);}public class IsTest{

public static void Point1(object obj){

Console.WriteLine(obj.ToString());Point2("That's the point");

}

public static void Point2(string str){

Console.WriteLine(str.ToString());Point3("That's the point");

}


if (obj.ToString() == " Passed String"){

Console.WriteLine("In Point3");}

}


Point1("Passed String");}

}

Question #3

public interface IsBaseTest{

void Point1(object obj);}public class IsTest{


Console.WriteLine(obj.ToString());Point2("That's the point");

}

public static void Point2(string str){

Console.WriteLine(str.ToString());Point3("That's the point");

}


if (obj.ToString() == " Passed String"){

Console.WriteLine("In Point3");}

}


Point1("Passed String");}

}

Question #3

Passed StringThat's the pointIn Point3Press any key to continue...

That’s it for today!Hope you enjoy it!

c# starter l02-classes and objects

Technology

public childclass

public class childclass

public parentclass

child class

public void print

public class drawingobject

public class line

public class circle