Tuesday, November 6, 2018

C# - Polymorphism

Polymorphism is major concept of object programming and in general term, it stands for ‘Many Shape’, it means the one function can perform different thing depend on context.
In C#, Polymorphism can be categories in two group.
·                   Static Polymorphism
·                   Dynamic Polymorphism


Static Polymorphism:

In Static polymorphism, the calling method will be decided on compile time so it is also called Early Binding. In C#, it will be achieved by Function Overloading or Operator Overloading

Function Overloading: we can defined multiple function with same name but its signature will be different, it is called function overloading. In method signature, we are not considering return type.

The following code shows How same function ‘Render()’ render different shape based on passed input type ( Circle,  Rectangle).

public class RenderShape
    {
        public void Render(Circle circle)
        {
            Console.Writeline("Rendering Circle");
        }

        public void Render(Rectangle rectangle)
        {
            Console. Writeline ("Rendering Rectangle");
        }
    }

    public class RenderEngine
    {
        public void Render()
        {
            RenderShape renderShape = new RenderShape();

            renderShape.Render(new Circle());

            renderShape.Render(new Rectangle());

        }
    }


Output:

Rendering Circle
Rendering Rectangle



Dynamic Polymorphism –

In Dynamic polymorphism, the calling method will be decided on runtime so it is also called Late Binding.  In C#, it will be achieved by implementation of Abstract Class or Interface.

Abstract:  
In C#, Abstract class is used for partial implementation and it contains abstract method, which must be implemented by derived class eg. Circle, Rectangle. Abstract class can have some common code, which will be shared among all derived class.


        public abstract class Shape
            {
                public abstract void Render();
            }

        public class Circle : Shape
        {
            public override void Render()
            {
                Console.Write("Rendering Circle");
            }
        }

        public class Rectangle : Shape
        {
            public override void Render()
            {
                Console.Write("Rendering Rectangle");
            }
        }

  
       public class RenderEngine
        {
            public void Render()
            {
                Shape shape = new Circle();
                shape.Render();

                shape = new Rectangle();
                shape.Render();
            }
        }


Interface:
Interface is a basically contract, which have only signature of methods or property. the class which will be implement this interface have to define the signature.


        public interface IShape
            {
                void Render();
            }


        public class Circle : IShape
        {
            public void Render()
            {
                Console.Write("Rendering Circle");
            }
        }

        public class Rectangle : IShape
        {
            public void Render()
            {
                Console.Write("Rendering Rectangle");
            }
 }

        public class RenderEngine
        {
            public void Render()
            {
                IShape shape = new Circle();
                shape.Render();

                shape = new Rectangle();
                shape.Render();
            }
        }


Thanks for visiting !!

No comments:

SQL Server - Identify unused indexes

 In this blog, we learn about the index usage information (SYS.DM_DB_INDEX_USAGE_STATS) and analyze the index usage data (USER_SEEKS, USER_S...