C# description

1. Agenda
Object-Oriented Concepts
Abstraction and Encapsulation
Inheritance
Polymorphism
Interfaces and Abstract Classes
Virtual Methods
Classes
Sealed Classes
C# programming with examples

2.  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

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

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

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

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

7. 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 bit
0 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

8. Reference Types
Data Types Size Values
string
Variable
length
0-2 billion Unicode characters
object --- ---

9. Boxing and Unboxing
class Test
{
static void Main()
{
int i = 1;
object o = i; // boxing
int j = (int) o; // unboxing
}
}

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

11. 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)

12. 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/Overloading
Runtime polymorphism/Overriding

13. 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.”

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

15. 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();
Interfaces
Example

16. interface IControl {
void Paint();
}
interface IListBox: IControl {
void SetItems(string[] items);
}
interface IComboBox: ITextBox, IListBox {
}
Interfaces
Multiple Inheritance
 Classes and structs can inherit from
multiple interfaces
 Interfaces can inherit from multiple interfaces

17. interface IControl {
void Delete();
}
interface IListBox: IControl {
void Delete();
}
interface IComboBox: ITextBox, IListBox {
void IControl.Delete();
void IListBox.Delete();
}
Interfaces
Explicit Interface Members
 If two interfaces have the same method name,
you can explicitly specify interface + method
name to disambiguate their implementations

18. Classes and Structs
Similarities
 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

19. 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 Structs
Differences

20. Classes and Structs
Access 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

21. 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 T
or to types within A
Classes and Structs
Access Modifiers

22. Classes and Structs
Abstract 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

23. Classes and Structs
Sealed 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