Interface in C# with Example

Interface in C# with Example: जिस तरह से हम Classes को Inherit कर सकते हैं, उसी तरह से हम Interfaces को भी Inherit कर सकते हैं। इसे समझने के लिए हम अपने पिछले Program को ही निम्नानुसार Modify कर सकते हैं:

 File Name: MultipleInterfaceImplementation.cs
using System;

namespace CSharpInterface
{
    interface IShape
    {
        double Area();
    }

    interface IDisplay
    {
        void Display();
    }

    interface IShapeDisplay: IShape, IDisplay { }

    class Shape
    {
      //Same as previous program
    }

    class Rectangle : Shape, IShapeDisplay
    {
      //Same as previous program
    }

    class Triangle : Shape, IShapeDisplay
    {
      //Same as previous program
    }

    class MultipleInterfaceImplementation
    {
        public static void Main(string[] args)
        {
            Rectangle newRectangle = new Rectangle(6, 7);
            Triangle newTriangle = new Triangle(12, 23);

            IShapeDisplay referenceVariable;

            referenceVariable = newRectangle as IShapeDisplay;
            if (referenceVariable != null)
                referenceVariable.Display();

            referenceVariable = newTriangle as IShapeDisplay;
            if (referenceVariable != null)
                referenceVariable.Display();
        }
    }
}

// Output:
   Area of Rectangle : 42
   Area of Triangle : 138

इस Program में हमने IShape व IDisplay दोनों Interfaces को निम्नानुसार IShapeDisplay नाम के एक नए Interface में Inherit कर लिया है:

    interface IShapeDisplay: IShape, IDisplay { }

परिणामस्वरूप IShape व IDisplay दोनों Interfaces के Area() व Display() Methods के Declaration इस नए Interface में Available हो गए हैं। हालांकि इस नए Interface की Body को हमने Empty रखा है, लेकिन यदि हम चाहें तो अपनी जरूरत के अनुसार इस Derived Interface में भी हम और Un-Implemented Methods Declare कर सकते हैं।

फिर हमने हमारी Rectangle व Triangle दोनों Classes को निम्नानुसार Define किया है, जहां हमने दोनों Classes में केवल IShapeDisplay Interface को ही Implement किया है:

class Rectangle : Shape, IShapeDisplay
. . .
class Triangle : Shape, IShapeDisplay
. . .

परिणामस्वरूप IShape व IDisplay दोनों Interfaces के दोनों Unimplemented Methods का Declaration Triangle व Rectangle Class में Implement होने के लिए Available हो जाता है, क्योंकि Inherited IShapeDisplay Interface में इन दोनों ही Interfaces के सभी Unimplemented Methods Exist हैं।

चूंकि इस बार हमने दोनों ही Derived Classes में केवल एक IShapeDisplay Interface को ही Implement किया है, इसलिए हम इन दोनों ही Classes के सभी Objects को IShapeDisplay Interface के referenceVariable में Store करके Reference कर सकते हैं और इस काम को हमने निम्नानुसार Code द्वारा किया है:

            referenceVariable = newRectangle as IShapeDisplay;
            if (referenceVariable != null)
                referenceVariable.Display();

            referenceVariable = newTriangle as IShapeDisplay;
            if (referenceVariable != null)
                referenceVariable.Display();

जैसाकि उपरोक्त Code द्वारा हम समझ सकते हैं कि referenceVariable में जिस Class के Object का Reference होता है, C# Compiler उसी Class के Display Method को Call करके Current Object के Area को Display कर देता है। परिणामस्वरूप हम एक ही Statement द्वारा दो अलग Class के Object के लिए समान Display() नाम के Method को अलग-अलग Class से Invoke कर सकते हैं।

Base Class Method as Interface Implementation

कभी-कभी ऐसी स्थिति होती है कि हम किसी Class से किसी नई Class को Derive करते हैं, जिसमें कोई Implemented Method होता है और साथ ही उसी Derived Class में हम किसी Interface को भी Implement करते हैं, जिसमें समान नाम का Unimplemented Method होता है।

इस स्थिति में हालांकि हम हमारी Derived Class में Interface के Method को Implement नहीं करते, फिर भी Interface, Base Class से Derive होने वाले Method को ही अपना Implemented Method मान लेता है और हमारा Program बिना किसी परेशानी के Normal तरीके से Run होता है। इस Concept को हम निम्न उदाहरण Program द्वारा बेहतर तरीके से समझ सकते हैं:

File Name: BaseClassMethodAsInterfaceImplementation.cs
using System;

namespace CSharpInterface
{
    interface IDisplay { void Display(string s); }

    public class BaseClass
    {
        public void Display(string s)
        {
            Console.WriteLine("Called via {0}", s);
        }
    }

    public class DerivedClass : BaseClass, IDisplay { }

    class MultipleInterfaceImplementation
    {
        public static void Main(string[] args)
        {
            DerivedClass obj = new DerivedClass();
            obj.Display("Derived Class Object");
        }
    }
}

// Output:
	Called via Derived Class Object

जैसाकि हम इस Program में देख सकते हैं कि हमारे IDisplay Interface में एक Unimplemented Display() Method है। साथ ही हमारी BaseClass में भी Display() नाम का एक Implemented Method है।

इसलिए जब हम DerivedClass को BaseClass से Derive करते हैं और साथ ही Derived Class में IDisplay Method को Implement भी करते हैं, DerivedClass को निम्नानुसार तरीके से Specify करने पर भी हमें कोई Error प्राप्त नहीं होताए जबकि हमने इस Derived Class में IDisplay Interface के Unimplemented Display() Method को Implement भी नहीं किया है।

ऐसा इसलिए होता है क्योंकि जब हम DerivedClass को BaseClass से Derive करते हैं, तो Base Class में Implemented Display() Method हमारी Derived Class में भी Available हो जाता है। परिणामस्वरूप हमारा IDisplay Interface उसी Derived Display() Method को ही अपना Implemented Display() Method मान लेता है।

Multiple Interface with Duplicate Member

कभी-कभी ऐसी स्थिति होती है कि हमें किसी Class में एक से ज्यादा Interfaces को Implement करने की जरूरत होती है, जिनमें समान Return Type व Signature के एक से ज्यादा Unimplemented Methods होते हैं।

इस प्रकार की स्थिति में हम हमारी Class में यदि केवल एक ही बार उस समान Return Type व Signature को Implement कर दें] तो दोनों ही Interface उस समान Implementation द्वारा ही Satisfy हो जाते हैं। जैसे:

File Name: MultipleInterfaceDuplicateMember.cs
using System;

namespace CSharpInterface
{
    interface IDisplay1 { void Display(string s); }
    interface IDisplay2 { void Display(string s); }

    public class BaseClass : IDisplay1, IDisplay2
    {
        public void Display(string s)
        {
            Console.WriteLine("Called via {0}", s);
        }
    }

    class MultipleInterfaceImplementation
    {
        public static void Main(string[] args)
        {
            BaseClass obj = new BaseClass();
            obj.Display("Base Class Object");
        }
    }
}

Output:
	Called via Base Class Object

इस Program में हालांकि हमने BaseClass में IDisplay1 व IDisplay2 नाम के दो अलग Interfaces Implement किए हैं, जिनमें Display() नाम के Method को Declare किया गया है, लेकिन दोनों ही Interface इस समान Display() Implementation को उपयोग में ले लेते हैं। इसलिए हमें इन्हें अलग-अलग Implement करने की जरूरत नहीं होती क्योंकि दोनों ही Methods का Signature व Return Type एक समान है।

Multiple Interface Reference

जैसाकि हमने पिछले Programs में देखा है कि Interface वास्तव में Reference Type होते हैं, जहां as Operator या Object की Casting करके हम Interface के Reference को Retrieve कर सकते हैं।

इसलिए यदि किसी Class में एक से ज्यादा Interfaces को Implement किया गया हो, तो हम उस Class से अलग-अलग Interfaces के References को Casting के माध्‍यम से Retrieve कर सकते हैं। जैसे:

File Name: MultipleInterfaceReferenceFromSameClass.cs
using System;

namespace CSharpInterface
{
    interface IDisplay1 { void Display(string s); }
    interface IDisplay2 { void Display(string s); }

    public class BaseClass : IDisplay1, IDisplay2
    {
        public void Display(string s)
        {
            Console.WriteLine("Called via {0}", s);
        }
    }

    class MultipleInterfaceImplementation
    {
        public static void Main(string[] args)
        {
            BaseClass obj = new BaseClass();
            IDisplay1 i1 = (IDisplay1)obj; 	//Get reference to IDisplay1
            IDisplay2 i2 = (IDisplay2)obj; 	//Get reference to IDisplay2

            obj.Display("Base Class");
            i1.Display("IDisplay1 Interface");
            i2.Display("IDisplay2 Interface");
        }
    }
}

// Output:
   Called via Base Class
   Called via IDisplay1 Interface
   Called via IDisplay2 Interface

इस Program में हमने BaseClass में IDisplay1 व IDisplay2 नाम के दो Interfaces को Implement किया है। इसलिए जब हम इस Class का एक Object obj Create करते हैं, तो इसी Class में IDisplay1 व IDispaly2 दोनों के References होते हैं। इसलिए Create होने वाले obj Object के IDisplay1 व IDisplay2 के References को Retrieve करने के लिए हमने निम्नानुसार Statement द्वारा obj की Casting की है:

IDisplay1 i1 = (IDisplay1)obj;       //Get reference to IDisplay1
IDisplay2 i2 = (IDisplay2)obj;       //Get reference to IDisplay2

इस तरह से हम एक ही Base Class Object में Implemented विभिन्न Interfaces के Reference Part को उपरोक्तानुसार Casting के माध्‍यम से Retrieve कर सकते हैं और Interface Reference द्वारा Class में Implemented Methods को Call कर सकते हैं।