Polymorphism

 Polymorphism means ability to have many forms. There are two types pf polymorphism. 

1. Compile time polymorphism/Overloading
2. Runtime polymorphism/Overriding

Overloading

• 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 type and different no of input parameters with the same method name.
• You should consider overloading a method when you need a couple of methods for some reason that take different parameters, but conceptually do the same thing.

    class Program  
    {  
        public class Shape  
        {  
            public void Area(float r)  
            {  
                float a = (float)3.14 * r;  
                // Function overload with 1 parameter.  
                Console.WriteLine("Area of a circle: {0}",a);  
            }  
            public void Area(float l, float b)  
            {  
                float x = (float)l* b;  
                // Function overload with 2 parameters.  
                Console.WriteLine("Area of a rectangle: {0}",x);  
            }  
            public void Area(float a, float b, float c)  
            {  
                float s = (float)(a*b*c)/2;  
                // Function  overload with 3 parameters.  
                Console.WriteLine("Area of a circle: {0}", s);  
            }  
        }  
        static void Main(string[] args)  
        {  
            Shape shape= new Shape();  
            shape.Area(2.0f);  
            shape.Area(20.0f,30.0f);  
            shape.Area(2.0f,3.0f,4.0f);  
            Console.ReadLine();  
        }  
    }  
	

Overriding

• Method overriding means changing the implementation of an inherited method.
• If a declare a method as virtual in the base class, we can override it in a derived class.
• At run-time, when client code calls the method, the CLR looks up the run-time type of the object, and invokes that override of the virtual method. 
• In the source code you can call a method on a base class, and cause a derived class's version of the method to be executed.
• Virtual methods enable you to work with groups of related objects in a uniform way. For example, suppose you have a drawing application that enables a user to create various kinds of shapes on a drawing surface. Even though this can be  achieved by no of switch statements, it will be hard to maintenance. So you can achieve the same thing by using overriding a method.

    public class Shape
    {
        public int X { get; private set; }
        public int Y { get; private set; }
        public int Height { get; set; }
        public int Width { get; set; }

        // Virtual method
        public virtual void Draw()
        {
            Console.WriteLine("Performing base class drawing tasks");
        }
    }

    public class Circle : Shape
    {
        //Override Method
        public override void Draw()
        {
            // Code to draw a circle...
            Console.WriteLine("Drawing a circle");
        }
    }
    public class Rectangle : Shape
    {
        public override void Draw()
        {
            // Code to draw a rectangle...
            Console.WriteLine("Drawing a rectangle");
        }
    }
    public class Triangle : Shape
    {
        public override void Draw()
        {
            // Code to draw a triangle...
            Console.WriteLine("Drawing a triangle");
        }
    }

    public class Program
    {
        static void Main(string[] args)
        {
            var shapes = new List
                        {
                         new Rectangle(),
                         new Triangle(),
                         new Circle()
                        };

            // invoked Draw() on each of the derived classes, not the base class.
            foreach (var shape in shapes)
            {
                shape.Draw();
            }
            Console.Read();
        }
    }
    
    Output
    Drawing a rectangle
    Drawing a triangle
    Drawing a circle
	

• A derived class is able to stop virtual inheritance by declaring an override member as "sealed".

    public class Triangle : Shape
    {
        public sealed void Draw()
        {
            // Code to draw a triangle...
            Console.WriteLine("Drawing a triangle");
        }
    }

• Using the "base" keyword, the derived class is able to access the method.

    public class Triangle : Shape
    {
        public override void Draw()
        {
	   base.Draw(); 
        }
    }