C# Polymorphism - handle with care

Download

Overriding is the base for most of the design patterns which exists. It provides us with an essential tool called Polymorphism .

What is Polymorphism ?
Polymorphism means one interface and many forms. It is a characteristics of being able to assign a different meaning or usage to something in different contexts specifically to allow an entity such as a variable, a function or an object to have more than one form. 

There are two types of Polymorphism. 
Compile time: function or operator overloading 
Runtime: Inheritence & virtual functions

Here, we are going to talk about the Runtime Polymorphism. 

If you read the definition carefully you will see that there is going to be some type casting and compiler is going to made some assumptions. These assumptions may fail on execution. Let me explain this further.

Type casting:

There will be a parent interface (Interface, abstract class, class) and may be many child classes. These child classes will implement the polymorphic behavior in different ways. The consumer will use Parent class' variable and the reference can be changed at runtime. 

Assumptions:

If we are using an interface and we cast an variable to that interface, compiler will assume that some child class of this variable's type will implement the methods specified by the interface. If this will not come out to be true it will throw exception at runtime.

using System;

namespace AbstractClasses
{
    class Program
    {
        static void Main(string[] args)
        {
            Apple fruit = new Apple();
            fruit.Print();
            IContract contract = (IContract) fruit;
            Console.ReadLine();
        }
    }

    internal interface IContract
    {
        void Display();
    }
    #region
    internal abstract class Fruit
    {
        public abstract string Name { get; set; }

        public virtual void Print()
        {
            Console.WriteLine("from abstract class");
        }
    }

    internal class Apple: Fruit
    {
        public override string Name { get; set; }

        public void Print()
        {
            Console.WriteLine("from child");
        }
    }
    #endregion
}

Handle With Care:

There are ways using which we can improve our code. Let us talk about them.

1. We can use 'as' keyword while casting a variable to an interface. This is because using the as operator is a better coding strategy than a straight cast because it yields a null on a conversion failure rather than raising an exception. 

using System;

namespace AbstractClasses
{
    class Program
    {
        static void Main(string[] args)
        {
            Apple fruit = new Apple();
            fruit.Print();
            //IContract contract = (IContract) fruit; //Invalid cast exception

            IContract contract =  fruit as IContract;
            if(contract != null)
                contract.Display();
            Console.ReadLine();
        }
    }

    internal interface IContract
    {
        void Display();
    }
    #region
    internal abstract class Fruit
    {
        public abstract string Name { get; set; }

        public virtual void Print()
        {
            Console.WriteLine("from abstract class");
        }
    }

    internal class Apple: Fruit
    {
        public override string Name { get; set; }

        public void Print()
        {
            Console.WriteLine("from child");
        }
    }
    #endregion
}

2. We can use sealed keyword on classes which we do not want to be inherited. Then the compiler will not assume that the object being cast is going to exhibit polymorphic behavior and will check its cast to the interface at compile time.

using System;

namespace AbstractClasses
{
    class Program
    {
        static void Main(string[] args)
        {
            Apple fruit = new Apple();
            fruit.Print();
            
            IContract contract =  fruit as IContract;
            if(contract != null)
                contract.Display();
            Console.ReadLine();
        }
    }

    internal interface IContract
    {
        void Display();
    }
    #region
    internal abstract class Fruit
    {
        public abstract string Name { get; set; }

        public virtual void Print()
        {
            Console.WriteLine("from abstract class");
        }
    }

    internal sealed class Apple: Fruit
    {
        public override string Name { get; set; }

        public void Print()
        {
            Console.WriteLine("from child");
        }
    }
    #endregion
}

Compile Time Error:
Cannot convert type 'AbstractClasses.Apple' to 'AbstractClasses.IContract' via a reference conversion, boxing conversion, unboxing conversion, wrapping conversion, or null type conversion.