What is Interface in C#

What is Interface in C#: Interface Type को हम लगभग Abstract Base Class के समान ही मान सकते हैं। जिस तरह से किसी Abstract Class को हमेंशा Derive करना जरूरी होता है, उसी तरह से किसी भी Interface को हमेंशा किसी Class या Structure में Implement करना जरूरी होता है।

साथ ही जिस तरह से Abstract Class में Abstract Methods() Declare किए जाते हैं, जिनका Implementation हमेंशा उनकी Derived Classes में किया जाता है, ठीक उसी प्रकार से Interface में जिन Methods को Declare या Specify किया जाता है, उनका Implementation उन Classes या Structures में किया जाता है, जिनमें इन Interfaces को Use किया जाता है।

लेकिन जिस तरह से हम Abstract Classes में अन्‍य Members जैसे कि Constructors, Properties, Methods, Fields आदि को Declare कर सकते हैं, Interface में हम सिर्फ और सिर्फ Methods के Prototypes तथा Constants को ही Declare किया जाता है।

Interface एक User Defined Reference Type होता है, जो कि Methods के एक समूह को Specify तो करता है, लेकिन उन्हें Implement नहीं करताए बल्कि जो Classes इन Interfaces को Use करते हैं, उन Classes में Interface के सभी Declared Methods को Implement करना होता है। सरल शब्दों में कहें तो Interface Type, Abstract Members का एक Named Set होता है।

Interface एक प्रकार से Multiple Inheritance व Polymorphism की सुविधा Provide करने का काम करता है। क्योंकि C# भी Java की तरह ही Object Oriented Programming System के Multiple Inheritance Concept को Directly Support नहीं करता। Interface के Concept को बेहतर तरीके से समझने के लिए हम एक उदाहरण देखते हैं, जो कि निम्नानुसार है:

File Name: InterfaceUnderstanding.cs
using System;

namespace CSharpInterface
{
    class Class1
    {
        public string Name;
        public int Age;
    }

    class Class2
    {
        public string First;
        public string Last;
        public double PersonsAge;
    }

    class Program
    {
        static void PrintInfo(Class1 item)
        {
            Console.WriteLine("Name: {0}, Age {1}", item.Name, item.Age);
        }

        static void Main()
        {
            Class1 obj = new Class1() { Name = "Kuldeep Mishra", Age = 31 };
            PrintInfo(obj);
        }
    }
}

Output:
Name: Kuldeep Mishra, Age 31

इस Program में हमने Class1 व Class2 नाम की दो Classes Create की हैं और Program नाम की Class में Defined Main() Method में Class1 Type का एक Object obj Create किया है।

फिर obj Object को Create करने के बाद इसके Items की Values को Display करने के लिए हमने इसे इसी Program में Defined PrintInfo() नाम के Static Method में Parameter की तरह Pass कर दिया है।

परिणामस्वरूप PrintInfo() नाम का Static Method अपना काम करता है और हमारे obj Object के Data को Output के रूप में Display कर देता है।

इस Program में Defined PrintInfo() Method तब तक अच्छी तरह से काम करता है, जब तक कि हम इस Method में Parameter के रूप में केवल Class1 Type का Object Pass करते हैं। जैसे ही हम इस Method में Class2 Type का Object Pass करते हैं, ये Method अपना काम ठीक से करने में अक्षम हो जाता है।

यानी ये Method Class2 के Objects के Data Members की Values को Display नहीं कर सकताए बल्कि यदि हम Class2 Type के Object को PrintInfo() Method में Parameter के रूप में Pass करते हैं, तो C# Compiler हमें Compile Time Error Return करता है।

क्योंकि Class2 में जिन Data Members को Specify किया गया है, वे Data Members Class1 में Defined Data Members से पूरी तरह से अलग हैं और PrintInfo() Method Class2 Type के Objects के Data Members के बारे में कुछ नहीं जानता।

Interface हमें यही करने की सुविधा Provide करता है। यानी Interface का प्रयोग करके हम एक ही नाम के Method को अलग-अलग Class के Objects के लिए समान प्रकार से Call कर सकते हैं, जबकि अलग-अलग Class के Objects के लिए अलग-अलग Methods Call होते हैं और अलग-अलग तरह की Requirements को पूरा करते हैं।

सरल शब्दों में कहें तो Interface हमें “Same Method Multiple Form” व “Single Statement Multiple Form” दोनों प्रकार के Polymorphism की सुविधा Provide करने के अलावा Indirectly Multiple-Inheritance की भी सुविधा भी Provide करता है।

Defining Interface

किसी Interface Definition में हम केवल Data Members व Static Members को Specify नहीं कर सकते। बल्कि Non-Static Methods, Properties, Events व Indexers का केवल Declaration या Prototype ही Specify कर सकते हैं, क्योंकि ये सभी Internally Methods ही होते हैं।

साथ ही इन Interfaces में इन Methods का कोई Definition या Implementation नहीं होताए बल्कि जिस Class या Structure में इन Methods को Use करना होता है, उनमें ही Interface के सभी Declared Methods को Implement किया जाता है।

इसी तरह से Class व Structures की तरह ही Interface Declarations का भी Partial Declarations किया जा सकता है। Interface Definition Create करने का Syntax निम्नानुसार होता है:

	interface IShape
	{
		double area();
	}

Interface Definition के साथ हम किसी भी Access Modifier का प्रयोग कर सकते हैं, लेकिन Interface के Members के साथ किसी भी Access Modifier को Specify नहीं किया जा सकता।

Interface Implementation

Interface को केवल Structure या Class ही Implement कर सकते हैं। जबकि Interface को किसी Class या Structure में Implement करने के लिए हमें Interface को ठीक उसी तरह से Base Class की तरह Specify करना होता है, जिस तरह से हम किसी Class को Derive करते समय Base Class को Specify करते हैं।

उदाहरण के लिए यदि हम इस IShape Interface को Rectangle Class में Implement करना चाहें, तो हमें हमारी Rectangle Class को निम्नानुसार Specify करना होगा:

	class Rectangle : IShape
	{
		// Data Members
		//Methods

		//Interface Method Implementation
		double area(){}
	}

जब हम किसी Interface को किसी Class में Implement करते हैं, तो हमें उस Implement की जाने वाली Class में Interface के Method को Define भी करना जरूरी होता है। इसीलिए उपरोक्त Code में हमने area() नाम के Method को Opening व Closing Curly Braces Specify करके Implement किया है।

इस तरह से यदि हम चाहें, तो अपने Shape Class वाले Example को निम्नानुसार तरीके से IShape Interface को Implement करते हुए Redesign भी कर सकते हैं:

File Name: InterfaceImplementation.cs
using System;

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

    class Shape
    {
        public double dim1, dim2;

        public Shape(double dimension1, double dimension2)
        {
            dim1 = dimension1;
            dim2 = dimension2;
        }
    }

    class Rectangle : Shape, IShape
    {
        public Rectangle(double dimension1, double dimension2) : base(dimension1, dimension2) { }

        public double area()
        {
            Console.WriteLine("\nInside Area for Rectangle : ");
            return dim1 * dim2;
        }
    }

    class Triangle : Shape, IShape
    {
        public Triangle(double dimension1, double dimension2) : base(dimension1, dimension2) { }

        public double area()
        {
            Console.WriteLine("\nInside Area for Triangle : ");
            return dim1 * dim2 / 2;
        }
    }

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

            IShape referenceShape;

            referenceShape = newRectangle;
            Console.WriteLine("Area is " + referenceShape.area());

            referenceShape = newTriangle;
            Console.WriteLine("Area is " + referenceShape.area());
        }
    }
}

// Output:
   Inside Area for Rectangle : 
   Area is 42

   Inside Area for Triangle : 
   Area is 138

ये Program Exactly वही Output दे रहा है, जो Inheritance Chapter के अन्तर्गत VirtualAndOverrideMethods.cs Program दे रहा था। क्योंकि जिस तरह से एक Abstract Class में Method का केवल Declaration होता है, उसी तरह से Interface में भी किसी Method का केवल Declaration ही होता है।

इसलिए इस Program में हमने Abstract Class के स्थान पर IShape नाम का एक Interface Create कर लिया है और Rectangle व Triangle Class में IShape Interface को Implement करके दोनों ही Derived Classes में area() नाम के Method को Define यानी Implement कर लिया है।

Interface is Reference Type

हालांकि Interface कोई Data Structure नहीं होताए बल्कि केवल Operations का एक Collection होता है। इसलिए हम किसी Interface का Direct Object तो Create नहीं कर सकते, लेकिन हम किसी Interface का Reference Variable जरूर Create कर सकते हैं और जिस-जिस Class में किसी Interface को Implement किया गया होता है, उन सभी Classes के Objects के Reference को Interface Type के Reference Variable में Store करके उन Classes के Members को इस Interface Reference Variable द्वारा Invoke कर सकते हैं।

इसीलिए इस Program में हमने IShape Interface का एक Reference referenceShape Create किया है और निम्नानुसार Code द्वारा newRectangle व newTriangle नाम के Objects का Pointer इस Variable में Store करके:

referenceShape = newRectangle;
. . .
referenceShape = newTriangle;

निम्नानुसार Common Statement द्वारा

Console.WriteLine(“Area is ” + referenceShape.area());
. . .
Console.WriteLine(“Area is ” + referenceShape.area());

Triangle व Rectangle Type के दो अलग Objects के लिए area() नाम के Common नाम के Method को Call किया है, फिर भी जिस समय जिस Class Type का Reference referenceShape Variable में होता है, उसी Class का area() Method Call होता है। परिणामस्वरूप समान Statement अलग-अलग Objects का Area Return करता है और हमें उपरोक्तानुसार Output प्राप्त होता है।

इस Program के आधार पर समझने वाली बात ये है कि हालांकि हम Triangle व Rectangle नाम की दो अलग Classes के area() नाम के Method को Call करते हैं, फिर भी समान नाम का Method अलग-अलग Class के Object के लिए अलग-अलग Call होता है।

यानी जब IShape के referenceShape Variable में Rectangle Type के Object का Pointer होता है, तब निम्न Statement Use करके area() Method को Call करने पर Rectangle Class का area() Method Call होता है:

referenceShape.area()

जबकि जब IShape के referenceShape Variable में Triangle Type के Object का Pointer होता है, तब यही Statement Use करके area() Method को Call करने पर Triangle Class का area() Method Call होता है। यानी इस प्रक्रिया को हम “Single Statement Multiple Form” या “Single Method Multiple Call” कह सकते हैं, जो कि Object Oriented Programming System के Polymorphism का उदाहरण है।

Interface Define करने का सबसे मुख्‍य फायदा यही होता है, कि अलग-अलग प्रकार के Objects की समान प्रकार की Functionality के लिए हम समान नाम के Methods को ही Define या Implement करते हैं।

जिसकी वजह से हमारे Application Program में हमें विभिन्न Types में समान प्रकार के कामों को पूरा करने के लिए Define किए जाने वाले विभिन्न Methods के नामों को अलग-अलग याद रखने की जरूरत नहीं होती। बल्कि समान प्रकार की जरूरत को पूरा करने वाले सभी Methods के नाम समान ही होते हैं। लेकिन जब Object Type बदल जाता है, तो समान प्रकार का Method ही उस Object Type के लिए अलग तरह का Result Generate करता है। ठीक उसी तरह से जिस तरह से उपरोक्त Program में Triangle व Rectangle Type के Objects का Area अलग-अलग होता है।

लेकिन जब हम Triangle Type के Object के लिए area() Method को Call करते हैं, तो Triangle Object का Area Calculate होता है। जबकि Rectangle Type के Object के लिए area() Method को Call करने पर Rectangle Object का Area Calculate होता है। यानी Method का नाम समान होने के बादजूद Object के आधार पर Method की Working व Output बदल जाता है, जो कि OOPS के Polymorphism Concept का ही Implementation है।

हालांकि ये Program Normal तरीके से काम कर रहा है, लेकिन कई बार Type Casting की समस्या पैदा होती है, क्योंकि हम IShape Interface के Reference Variable में एक Class Type के Reference को Store कर रहे हैं। इसलिए Type Casting की समस्या से बचने के लिए हमें हमेंशा Casting करने के बाद ही Class Type के Reference को Interface Type के Reference Variable में Store करना चाहिए। यानी हमें निम्न Statements को:

referenceShape = newRectangle;
. . .
referenceShape = newTriangle;

निम्नानुसार Type Cast करके Interface Type के Reference Variable में Store करना चाहिए:

referenceShape = (IShape)newRectangle;
. . .
referenceShape = (IShape)newTriangle;

जब हम इस तरह से Type Casting कर देते हैं, तो किसी भी तरह का Type Casting Related Error Generate होने की सम्भावना नहीं रहती है।

Using as Operator with Interface

पिछले Section में हमने Class के Object की Type Casting करके Object के Reference को Interface Type के Reference Variable में Store किया है। इसी जरूरत को हम as Operator का प्रयोग करके भी पूरा कर सकते हैं।

यदि हम किसी ऐसे Class Object Reference को Cast करके किसी Interface के Reference Variable में Store करना चाहते हैं, जिसमें उस Interface को Implement नहीं किया गया है, तो Cast Operation Perform नहीं होताए बल्कि एक Exception Raise होता है।

क्योंकि हम केवल उसी Class के Object का Reference Casting करके Interface के Reference Variable में Store कर सकते हैं, जिसमें Interface को Implement किया गया है। इसलिए इस समस्या से बचने के लिए हम as Operator को Use कर सकते हैं।

यानी इस Keyword के माध्‍यम से हम इस बात का पता लगा सकते हैं कि कोई Particular Type किसी Particular Interface को Support करता है या नहीं और Return होने वाले Result के आधार पर हम हमारे Program के Code को Create कर सकते हैं।

जब हम as Operator को Use करते हैं तो यदि Class में Interface को Implement किया गया होता है, तो ये Specified Expression Interface का Reference Return करता है। जबकि यदि Interface को Class में Implement न किया गया हो, तो Specified Expression Exception Raise करने के स्थान पर null Return करता है।

परिणामस्वरूप इस as Operator को Use करते हुए यदि हम हमारे पिछले Program के Code को Modify करना चाहें, तो हमारा Code कुछ निम्नानुसार हो सकता है:

referenceShape = newRectangle as IShape;
. . .
referenceShape = newTriangle as IShape;

फिर हम referenceShape Reference Variable को निम्नानुसार if Statement द्वारा Appropriate Value के लिए Check कर सकते हैं:

if( newRectangle != null) { . . . }

Implementing Multiple Interface

C# Multiple Inheritance को Support नहीं करता। यानी हम एक से ज्यादा Classes को किसी एक नई Child Class में Inherit नहीं कर सकते। लेकिन हम एक से ज्यादा Interfaces को एक ही Class में Inherit कर सकते हैं, जो कि एक प्रकार से Multiple Inheritance की सुविधा का ही Alternative तरीका है।

जब हम एक से ज्यादा Interfaces को किसी Class में Implement करना चाहते हैं, तो हमें सभी Implement किए जाने वाले Interfaces को एक Comma Separated List के रूप में Specify करना होता है। साथ ही सभी Specified Interfaces में जितने भी Un-Implemented Methods होते हैं, उन्हें Implement करना भी जरूरी होता है। जैसे:

File Name: MultipleInterfaceImplementation.cs
using System;

namespace CSharpInterface
{
    interface IShape { double Area(); }
    interface IDisplay  { void Display(); }

    class Shape
    {
        public double dim1, dim2;

        public Shape(double dimension1, double dimension2)
        {
            dim1 = dimension1;
            dim2 = dimension2;
        }
    }

    class Rectangle : Shape, IShape, IDisplay
    {
        public Rectangle(double dimension1, double dimension2) : base(dimension1, dimension2) { }

        public double Area()
        {
            return dim1 * dim2;
        }

        public void Display()
        {
            Console.WriteLine("Area of Rectangle : " + Area());
        }
    }

    class Triangle : Shape, IShape, IDisplay
    {
        public Triangle(double dimension1, double dimension2) : base(dimension1, dimension2) { }

        public double Area()
        {
            return dim1 * dim2 / 2;
        }

        public void Display()
        {
            Console.WriteLine("Area of Triangle : " + Area());
        }
    }

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

            newRectangle.Display();
            newTriangle.Display();
        }
    }
}

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

ये Program भी Exactly पिछले Program जैसा ही Output देता है, लेकिन इस Program में हमने Shape Class की दोनों Derived Classes में IShape व IDisplay नाम के दो Interface को निम्नानुसार Implement भी किया है साथ ही Base Class को Derive भी किया है:

class Triangle : Shape, IShape, IDisplay
. . .
class Rectangle : Shape, IShape, IDisplay
. . .

चूंकि इस बार हम Triangle व Rectangle दोनों Classes में दो Interfaces को Implement कर रहे हैं, इसलिए हम दोनों में से किसी एक के Reference Variable में Triangle या Rectangle Class के Reference को Store करके Common Statement द्वारा अलग-अलग Class के Objects के लिए अलग-अलग Area() व Display() Method को Call नहीं कर सकते।

इसीलिए हमने निम्नानुसार Statement द्वारा दोनों Classes के Objects के साथ Display() Method को अलग-अलग Statement द्वारा Call किया है:

newRectangle.Display();
newTriangle.Display();