Polymorphism In C# With Real Time Example

We will learn about polymorphism in c# with an example and Type of polymorphism in c# in this article. That will help you understand the concepts of polymorphism in c# with real time example for fresher as well as experienced people.

What is polymorphism?

It is used to one object behaving as multiple forms. Or polymorphism means one name many forms.

Real Time Example: 

1. A person behaves as an employee in the office,  that the same person behaves as a father in the house, that the same person behaves as a customer in the shopping malls.

Description: a person is one object. It behaves as an employee in office as well as the father in the house. So the concept is here one name many forms.

Type of polymorphism

• Compile time polymorphism / Static polymorphism
• Run time polymorphism / Dynamic polymorphism

• 
  

• Static or Compile time polymorphism:

In the compile time polymorphism compiler know which method is going to call at compile time called compile-time or Static polymorphism.

The static or compile time polymorphism can be achieved by using “function overloading”.Where the compiler know which overloaded method is going to call at compile time.

function overloading means the same method name but the type of parameter should be different.

Example 1: This is the basic example to understand the concept of method overloading.

using System;

namespace MethodOverloading

{

    class Program

    {

        // Method Overloading

        public int Add(int x, int y)

        {

            return x + y;

        }

        public int Add(int x, int y, int z)

        {

            return x + y + z;

        }

        static void Main(string[] args)

        {

            Program prog = new Program();

            Console.WriteLine("Addition of Number is {0}", prog.Add(10, 20));

            Console.WriteLine("Addition of Number is {0}", prog.Add(10, 20, 30));

            Console.ReadLine();

        }

    }    

}

Read More

What is an abstract class in c#

What is an abstract class?  

•  An abstract class can contain abstract and non-abstract member.
•  An abstract class can be used as a base class 
•  An abstract method does not have body/definition.
•  An abstract class cannot be marked as a sealed class.
•  We can not create an object of abstract class.
•  We can create abstract class and method by using "abstract" keyword.
•  We can not provide the static keyword to the abstract method.
•  Once we inherit an abstract class in derived class then we must provide definition to the abstract member.
• We can implement the abstract method by using “override” keyword.

  

Syntax: Creating abstract class.

<modifier> abstract class <class_name>

{

// member

}

Syntax:  Creating the abstract method.

<modifier> abstract return_type <method_name>(<parameter_list>);

Example: Simple example to understand the basic concept of abstract class and abstract method.

using System;

namespace AbstractClassProject

{

    public abstract class DiscountedCustomer

    {

        public int CustId { get; set; }

        public string FirstName { get; set; }

        public string LastName { get; set; }

        public int Price { get; set; }

        public int Discount { get; set; }

        

        public string GetCustomer() // Non Abstract Method

        {

            return this.FirstName + " " + this.LastName;

        }

        public abstract int CalculateDiscount(); // Abstract Method       

    }

    public class Customer:DiscountedCustomer

    {        

        public override int CalculateDiscount()

        {

            return this.Price * this.Discount/100;

        }

    }

    class Program

    {

        static void Main(string[] args)

        {

            Customer customer = new Customer() {

                CustId=101,

                FirstName="Mauli",

                LastName ="Gadewar",

                 Price = 500,

                 Discount =20

            };

            Console.WriteLine("Customer Full Name is {0}", customer.GetCustomer());

            Console.WriteLine("Total Price is {0}", customer.Price);

            Console.WriteLine("Customer Discount Rs is {0} ", customer.CalculateDiscount());

            Console.ReadLine();

        }

    }

}

More information please watch video as follow:

Read More

[C#]: Explicit Interface and Implicit Interface In C# With Example [Step by Step]

In this post, we will learn the types of Interface in C#.NET with an example in a simple way.

We have already discussed the basic concept of the interface in part one of this series. If you want to learn please click on the link basic interface concept.

Type of interface in C#

• Explicit Interface
• Implicit Interface 

1. Explicit Interface:
   If the class implement two interfaces that contain a member with the same signature.to implementing those interface member in class we take help of explicit interface.

How to implement the explicit interface?

1. return_Type Interface_Name.Method_Name()  
2.         {  
3.             //...  
4.         }  

Note: The modifier is not valid to implement an explicit interface. 

Example 1:

Create two interfaces having only one method with the same signature as follow. 

1. interface IVendor  
2.    {  
3.        void GetVendor();  
4.    }  
5.    interface ISupplier  
6.    {  
7.        void GetVendor();  
8.    }  

Create one class name like 'UserService' to implementing those interfaces. 

1. public class UserService:IVendor,ISupplier  
2.    {  
3.           
4.         void IVendor.GetVendor()  
5.        {  
6.            Console.WriteLine("GetVendor() method called from IVendor interface");  
7.        }  
8.         void ISupplier.GetVendor()  
9.        {  
10.            Console.WriteLine("GetVendor() method called from ISupplier interface");  
11.        }  
12.    }  

 If you try to implement the interface member without 'interface name', then it will through an error as follows.

 

How to call the interface member?

    In the explicit interface, we can not call the interface member directly using the object of the class. we have two way of calling explicit interface as following.

There is two way of calling an explicit interface member: 

1. The first way to creating the instance of the class and typecast the interface type.
2. Second Way creating an object of the class and reference variable of the interface type.

1. class Program  
2.    {  
3.        static void Main(string[] args)  
4.        {  
5.            // The first way to creating the instance of the class and typecast the interface type.   
6.            UserService userService = new UserService();  
7.            ((IVendor)userService).GetVendor();  
8.            ((ISupplier)userService).GetVendor();  
9.   
10.            // Second Way creating an object of the class and reference variable of the interface type.  
11.   
12.            IVendor vendor = new UserService();  
13.            vendor.GetVendor();  
14.            ISupplier supplier = new UserService();  
15.            supplier.GetVendor();  
16.   
17.            Console.ReadLine();  
18.        }  
19.    } 

 Output: 

 

You can use either one of the ways of calling an explicit interface member as per the requirement.

Example 2:

1. using System;  
2.   
3. namespace CSInterfaceDemo.Customer  
4. {  
5.     interface IService1  
6.     {  
7.         void Print();  
8.     }  
9.     interface IService2  
10.     {  
11.         void Print();  
12.     }  
13.     public class Customer:IService1, IService2  
14.     {  
15.         void IService1.Print()  
16.         {  
17.             Console.WriteLine("IService1.Print()");  
18.         }  
19.         void IService2.Print()  
20.         {  
21.             Console.WriteLine("IService2.Print()");  
22.         }  
23.     }  
24.   
25.     class program  
26.     {  
27.         static void Main(string[] args)  
28.         {  
29.             // The first way to creating the instance of the class and typecast the interface type.     
30.             Customer customer = new Customer();  
31.             ((IService1)customer).Print();  
32.             ((IService2)customer).Print();  
33.   
34.             // Second Way creating an object of the class and reference variable of the interface type.   
35.             IService1 service1 = new Customer();  
36.             service1.Print();  
37.             IService2 service2 = new Customer();  
38.             service2.Print();  
39.   
40.             Console.ReadLine();  
41.         }  
42.     }  
43. }  
44. 
    

    
2. Implicit Interface: The implicit interface does not have the same signature of the interface member. We can call the implicit interface member by using the object of the class.

Note: The modifier is required to implement the implicit interface.

 How to implement the implicit interface?

1. modifier return_type interface_method_name()  
2.         {  
3.             //....
4.         }  

The following is an example of the implicit interface.

 Example 1:

1. using System;  
2.   
3. namespace CSInterfaceDemo.Customer  
4. {  
5.     interface IService1  
6.     {  
7.         void Print();  
8.     }  
9.     interface IService2  
10.     {  
11.         void Display();  
12.     }  
13.     public class Customer:IService1, IService2  
14.     {  
15.        public void Print()  
16.         {  
17.             Console.WriteLine("IService1.Print()");  
18.         }  
19.        public void Display()  
20.         {  
21.             Console.WriteLine("IService2.Display()");  
22.         }  
23.     }  
24.   
25.     class program  
26.     {  
27.         static void Main(string[] args)  
28.         {  
29.             Customer customer = new Customer();  
30.             customer.Print();  
31.             customer.Display();  
32.   
33.             Console.ReadLine();  
34.         }  
35.     }  
36. }  

 Note :
The best practice to work with the interface by adding new code. You can achieve a new requirement by adding new separate interface instead of changing the old source code. The same advice from the Interface Segregation Principle (ISP),

“Clients should not be forced to depend on methods that they do not use.” by Robert C. Martin.

 I hope you understood the basic concept of explicit and implicit interface.

More information watch video as follows:

Read More