Sealed Class
Sealed Class :
Once a class is defined as sealed class, this class cannot be inherited.
If you have ever noticed, structs are sealed. You cannot derive a class from a struct. 
One of the best usage of sealed classes is when you have a class with static members

public sealed class MySingleton {
public static readonly MySingleton Instance = new MySingleton();
private MySingleton(){ }
}

00:33 | Category: | 0 comments

Interfae
interface :
The members of the interface are public with no implementation. Abstract classes can have protected parts, static methods, etc.
A class can inherit one or more interfaces, but only one abstract class.
Abstract classes can add more functionality without destroying the child classes that were using the old version. In an interface, creation of additional functions will have an effect on its child classes, due to the necessary implementation of interface methods to classes.

interface iSampleInterface
{
  //All methods are automaticall abstract
  int AddNumbers(int Num1, int Num2);
  int MultiplyNumbers(int Num1, int Num2);
}
00:32 | Category: | 0 comments

Abstract Class

Abstract Class :
-          An abstract class means that, no object of this class can be instantiated, but can make derivations of this.
-          An abstract class can contain either abstract methods or non abstract methods.
-          An abstract class cannot be a sealed class. I.e. the following declaration is incorrect.
-          An abstract method cannot be private.
-          The access modifier of the abstract method should be same in both the abstract class and its derived class
-          An abstract method cannot have the modifier virtual. Because an abstract method is implicitly virtual.
-          An abstract member cannot be static

EX :
abstract class absClass1
{
    public abstract int AddTwoNumbers(int Num1, int Num2);
    public abstract int MultiplyTwoNumbers(int Num1, int Num2);
}
//Abstract Class2
abstract class absClass2:absClass1
{
    //Implementing AddTwoNumbers
    public override int AddTwoNumbers(int Num1, int Num2)
    {
        return Num1+Num2;
    }
}
//Derived class from absClass2
class absDerived:absClass2
{
    //Implementing MultiplyTwoNumbers
    public override int MultiplyTwoNumbers(int Num1, int Num2)
    {
        return Num1*Num2;   
    }
 }
00:31 | Category: | 0 comments

Oops Basics
Class :

A user-defined data structure that groups properties and methods. Class doesn’t occupies memory.

Object :


Object is a Building and the class is a blueprint. Instance of Class is called object. 
An object is created in memory using keyword “new”.

Property :

Attribute of object is called properties. Eg1:- A car has color as property

Encapsulation :
Encapsulation is a process of binding the data members and member functions into a single unit.

Abstraction :

Abstraction is a process of and displaying the essential features and hiding the implementation details.

Inheritance :

Reusability of Base class members in Derived Class is called Inheritance.

Polymorphism :

When a message can be processed in different ways is called polymorphism. Polymorphism means many forms.

Polymorphism is of two types: 

-          Compile time polymorphism (Early Binding)/Overloading
-          Runtime polymorphism (LateBinding)/Overriding
-           
Operator Overloading :

using System; // A three-dimensional coordinate class. 
class ThreeD { 
  int x, y, z; // 3-D coordinates   
  public ThreeD() { x = y = z = 0; } 
  public ThreeD(int i, int j, int k) { x = i; y = j; z = k; } 
  public static ThreeD operator +(ThreeD op1, ThreeD op2)   // Overload binary +. 
  { 
    ThreeD result = new ThreeD(); 
    /* This adds together the coordinates of the two points and returns the result. */ 
    result.x = op1.x + op2.x; // These are integer additions 
    result.y = op1.y + op2.y; // and the + retains its original 
    result.z = op1.z + op2.z; // meaning relative to them. 
    return result; 
  }   // Show X, Y, Z coordinates. 
  public void show() 
  { 
    Console.WriteLine(x + ", " + y + ", " + z); 
  } 
} 

public class ThreeDDemo { 
  public static void Main() { 
    ThreeD a = new ThreeD(1, 2, 3);  ThreeD b = new ThreeD(10, 10, 10);  ThreeD c = new ThreeD(); 
    c = a + b;    c.show();     c = a + b + c;      c.show();    } 
}
00:27 | Category: | 0 comments