Agenda

Object-Oriented ConceptsAbstraction and EncapsulationInheritancePolymorphismInterfaces and Abstract ClassesVirtual MethodsClassesSealed ClassesC# programming with examples

Encapsulation and abstraction is the advanced mechanism in C# that lets your program to hide unwanted code within a capsule and shows only essential features of an object.

Encapsulation is used to hide its members from outside class or interface, whereas abstraction is used to show only essential features.

Access Modifier – Public, Private, Protected, Internal & Protected Internal

Key Object-Oriented Concepts

Foreach

using System; namespace foreach_loop{  class Program   {     static void Main(string[] args)      {        string[] arr = new string[5]; // declaring array         //Storing value in array element        arr[0] = "Steven";        arr[1] = "Clark";        arr[2] = "Mark";        arr[3] = "Thompson";        arr[4] = "John";         //retrieving value using foreach loop        foreach (string name in arr)         {           Console.WriteLine("Hello " + name);         }        Console.ReadLine();      }   }}

switch case

switch (opt)

{

case 1:

result = num1 + num2;

Console.WriteLine("\n{0} + {1} = {2}", num1, num2, result);

break;

case 2:

result = num1 - num2;

Console.WriteLine("\n{0} - {1} = {2}", num1, num2, result);

break;

default:

Console.WriteLine("\nInvalid option.Please try again.");

Break;

}

Array

using System; namespace Declare_Array{  class Program   {     static void Main(string[] args)      {        int[] num = new int[6]; //Declaring Array                  //Initializing array        num[0] = 6;        num[1] = 23;        num[2] = 12;        num[3] = 9;        num[4] = 14;        num[5] = 52;         //Showing value of Array        Console.WriteLine("1st value:\t{0}", num[0]);        Console.WriteLine("2nd value:\t{0}", num[1]);        Console.WriteLine("3rd value:\t{0}", num[2]);        Console.WriteLine("4th value:\t{0}", num[3]);        Console.WriteLine("5th value:\t{0}", num[4]);        Console.WriteLine("6th value:\t{0}", num[5]);         Console.ReadLine();                 }   }}

Data Types

C# is a strongly typed language. It means, that you cannot use variable without data types.

Data types tell the compiler that which type of data is used for processing.

Such as if you want to work with string value then you will have to assign string type variable to work with.

C# provides two types of data types: Value types and Reference types. A Value type data type stores copy of the value whereas the 

Reference typedata types stores the address of the value.

Value types

Data Types

Size Values

sbyte 8 bit -128 to 127

byte 8 bit 0 to 255

short 16 bit -32,768 to 32,767

ushort 16 bit 0 to 65,535

int 32 bit-2,147,483,648 to 2,147,483,647

uint 32 bit 0 to 4,294,967,295

long 64 bit-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

ulong 64 bit0 to 18,446,744,073,709,551,615

char 16 bit 0 to 65535

float 32 bit -1.5 x 1045 to 3.4 x 1038

double 64 bit -5 x 10324 to 1.7 x 10308

decimal 128 bit -1028 to 7.9 x 1028

bool --- True or false

Reference Types

Data Types Size Values

stringVariable length

0-2 billion Unicode characters

object --- ---

Boxing and Unboxing

class Test

{

static void Main()

{

int i = 1;

object o = i; // boxing

int j = (int) o; // unboxing

}

}

Overloading and Overriding

class Person

{

private String firstName;

private String lastName;

Person()

{

this.firstName = "";

this.lastName = "";

}

Person(String FirstName)

{

this.firstName = FirstName;

this.lastName = "";

}

Person(String FirstName, String LastName)

{

this.firstName = FirstName;

this.lastName = LastName;

}

}

Calling overloading method

Person(); // as a constructor and call method without parameter

Person(userFirstName); // as a constructor and call method with one parameter(like User's first Name)

Person(userFirstName,userLastName); // as a constructor and call method with one parameter(like User's first Name)

Polymorphism

Polymorphism provides following features: It allows you to invoke methods of derived class through base class reference during runtime.It has the ability for classes to provide different implementations of methods that are called through the same name.

Polymorphism is of two types: Compile time polymorphism/OverloadingRuntime polymorphism/Overriding

Polymorphism

Compile Time Polymorphism

 Compile time polymorphism is method and operators overloading. It is also called early binding. In method overloading method performs the different task at the different input parameters.

 

Runtime Time Polymorphism Runtime time polymorphism is done using inheritance and virtual functions. Method overriding is called runtime polymorphism. It is also called late binding.

 

“When overriding a method, you change the behavior of the method for the derived class. Overloading a method simply involves having another method with the same prototype.”

Interfaces

An interface defines a contract An interface is a type Includes methods, properties, indexers, events Any class or struct implementing an interface must support all parts of the contract

Interfaces provide no implementation When a class or struct implements an interface it must provide the implementation

Interfaces provide polymorphism Many classes and structs may implement

a particular interface

public interface IDelete { void Delete();}public class TextBox : IDelete { public void Delete() { ... }}public class Car : IDelete { public void Delete() { ... }}

TextBox tb = new TextBox();IDelete iDel = tb;iDel.Delete();

Car c = new Car();iDel = c;iDel.Delete();

InterfacesExample

interface IControl { void Paint();}interface IListBox: IControl { void SetItems(string[] items);}interface IComboBox: ITextBox, IListBox {}

InterfacesMultiple Inheritance

Classes and structs can inherit from multiple interfaces

Interfaces can inherit from multiple interfaces

interface IControl { void Delete();}interface IListBox: IControl { void Delete();}interface IComboBox: ITextBox, IListBox { void IControl.Delete(); void IListBox.Delete();}

InterfacesExplicit Interface Members

If two interfaces have the same method name, you can explicitly specify interface + method name to disambiguate their implementations

Classes and StructsSimilarities

Both are user-defined types Both can implement multiple interfaces Both can contain

Data Fields, constants, events, arrays

Functions Methods, properties, indexers, operators, constructors

Type definitions Classes, structs, enums, interfaces, delegates

Class Struct

Reference type Value type

Can inherit from any non-sealed reference type

No inheritance(inherits only from System.ValueType)

Can have a destructor No destructor

Can have user-defined parameterless constructor

No user-defined parameterless constructor

Classes and StructsDifferences

Classes and StructsAccess Modifiers

Access modifiers specify who can use a type or a member

Access modifiers control encapsulation Top-level types (those directly in a namespace)

can be public or internal Class members can be public, private, protected, internal, or protected internal

Struct members can be public, private or internal

If the access modifier is

Then a member defined in type T and assembly A is accessible

public to everyone

private within T only (the default)

protected to T or types derived from T

internal to types within A

protected internal

to T or types derived from Tor to types within A

Classes and StructsAccess Modifiers

Classes and StructsAbstract Classes

An abstract class is one that cannot be instantiated

Intended to be used as a base class May contain abstract and non-abstract

function members Similar to an interface Cannot be sealed

Classes and StructsSealed Classes

A sealed class is one that cannot be used as a base class

Sealed classes can’t be abstract All structs are implicitly sealed Why seal a class?

To prevent unintended derivation Code optimization

Virtual function calls can be resolved at compile-time