C# Interface Example

C# in Hindiये Article इस वेबसाईट पर Selling हेतु उपलब्‍ध EBook C#.NET in Hindi से लिया गया है। इसलिए यदि ये Article आपके लिए उपयोगी रहा, तो निश्चित रूप से ये पुस्तक भी आपके लिए काफी उपयोगी साबित होगी। 

C#.NET in Hindi | Page:908 | Format: PDF

BUY NOW DOWNLOAD READ ONLINE

Duplicate Interface Member Explicit Implementation

पिछले दो Programs में हमने देखा कि यदि एक ही Signature व Return Type के Method यदि एक से ज्यादा Interface में Declared हो और उन सभी Interfaces को समान Class में Implement किया गया हो, तो सभी Interface समान Implementation को उपयोग में ले लेते हैं।

लेकिन यदि हम इन समान Method को अलग-अलग Implement करना चाहें, तो हम Fully Qualified Interface Name का प्रयोग करते हुए ऐसा कर सकते हैं। इसे समझने के लिए हम हमारे पिछले उदाहरण को ही निम्नानुसार Modify कर रहे हैं:

File Name: MultipleInterfaceDuplicateMethodDifferentImplementation.cs
using System;

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

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

        void IDisplay2.Display(string s)	//Explicit Method Implementation
        {
            Console.WriteLine("IDisplay2.Display() 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

            i1.Display("IDisplay1.Display()");
            i2.Display("IDisplay2.Display()");
        }
    }
}

// Output:
   IDisplay1.Display() Called via IDisplay1.Display()
   IDisplay2.Display() Called via IDisplay2.Display()

जैसाकि इस Program में हम देख सकते हैं कि IDisplay1 व IDisplay2 दोनों ही Interfaces में Display() नाम का Method है। इसलिए इन दोनों Methods को अलग-अलग Implement करने के लिए हमने इनके Interface के नाम को भी Specify किया है। यानी हमनें निम्नानुसार Fully Qualified Interface Name Use किया है:

void IDisplay2.Display(string s)
. . .
void IDisplay1.Display(string s)
. . .

परिणामस्वरूप जब i1 Interface Reference Variable के लिए Display() Method को Call किया जाता है, तो Display1.Display() Method Call होता है। जबकि जब i2 Interface Reference Variable के लिए Display() Method को Call किया जाता है, तो Display2.Display() Method Call होता है।

जब हम किसी Class में Explicit Interface Member Implement करते हैं, तो ऐसा करने पर Class Level Implementation Allowed होता है, लेकिन Required नहीं। क्योंकि Explicit Implementation Class या Structure द्वारा Method को Implement करने की Requirement को Satisfy कर देता हैं। फिर भी हम Class Level Implementation कर सकते हैं। Explicit Interface Member Implement कर सकते हैं और Class-Level व Explicit दोनों प्रकार के Interface Implement कर सकते हैं।

जब हम Explicit Interface Member Implement करते हैं, तो उस Member को हमेंशा केवल Interface Reference के माध्‍यम से ही Access किया जा सकता है। यानी हम ऐसे Method को किसी अन्‍य Class Member द्वारा Directly Access नहीं कर सकते। इसे समझने के लिए हम हमारे पिछले उदाहरण Program को ही निम्नानुसार Modify कर सकते हैं:

File Name: ExplicitInterfaceMemberImplementation.cs
using System;

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

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

        public void CallDisplay()
        {
            //Display("This is not possible. Raise Compile Error.");
            //this.Display("This is not possible. Raise Compile Error.");

            ((IDisplay)this).Display("((IDisplay)this).Display()");
        }
    }

    class MultipleInterfaceImplementation
    {
        public static void Main(string[] args)
        {
            BaseClass obj = new BaseClass();
            obj.CallDisplay();
        }
    }
}

// Output:
   IDisplay.Display() Called via ((IDisplay)this).Display()

जैसाकि हम इस Program में देख सकते हैं कि हालांकि CallDisplay() BaseClass का ही Method है, फिर भी ये Method Explicitly Implemented IDisplay.Display() Method को Directly Call नहीं कर सकता। बल्कि यदि हम Comment के रूप में Specify किए गए निम्न Statements को Uncomment कर दें-

//Display(“This is not possible. Raise Compile Error.”);
//this.Display(“This is not possible. Raise Compile Error.”);

तो C# Compiler हमें Compile Time Error Return करता है। इसलिए Explicit Interface Member Implementation करने पर ऐसी Classes से Inherit की गई Derived Classes भी इन Methods को Directly Access करने में अक्षम हो जाती हैं।

क्योंकि इन्हें हमेंशा Interface के Reference द्वारा ही Access किया जा सकता है और इसीलिए हमने इस Program में Explicit Interface Member को Access करने के लिए निम्नानुसार Casting तरीके को Use किया है:

((IDisplay)this).Display(“((IDisplay)this).Display()”);

हम कभी भी किसी Explicit Interface Member Implementation के साथ किसी Access Modifier का प्रयोग नहीं कर सकते। क्योंकि Default रूप से सभी Explicit Interface Member Implementations Private होते हैं। जबकि यदि हम इनके साथ किसी Access Modifier को Manually Specify करते हैं, तो C# Compiler हमें Compile Time Error Return करता है।

जब हम किसी Interface को Implement करते हैं, तो हमें उस Interface में Declared सभी Members को Implement करना जरूरी होता है। उदाहरण के लिए यदि किसी Interface में 100 Unimplemented Members हैं, तो यदि हम उस Interface को अपनी किसी Class में Implement करेंगे, तो हमें उस Interface में Specified सभी 100 Members को Compulsory रूप से Implement यानी Define करना जरूरी होगा।

यानी हम Selected Members को ही Implement नहीं कर सकते। इसलिए सामान्‍यत: Interfaces को जहां तक हो सके, छोटा ही रखा जाता है और इसमें Most Important रूप से Compulsory Unimplemented Members को Declare किया जाता है।

Interface Reference As Method Parameter and Return Value

चूंकि Interface एक Reference Type होता है और जिस Class में इसे Implement किया जाता है, उस Class के किसी भी Object के Reference को Interface Type के Reference Variable में Store करके उस Object के लिए विभिन्न प्रकार के Members को Dot Operator के माध्‍यम से Access किया जा सकता है।

ठीक इसी तरह से हम किसी Interface Variable को किसी Method के Parameter के रूप में भी Specify कर सकते हैं और Parameter के रूप में उन Classes के Objects को Pass कर सकते हैं, जिनमें उस Interface को Implement किया गया है। इस Concept को हम निम्न उदाहरण द्वारा आसानी से समझ सकते हैं:

File Name: InterfaceReferenceAsParameterAndReturnValue.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;
        }

        public static void Display(string type, IShape obj)
        {
            Console.WriteLine("Area of {0} : {1} ", type, obj.Area());
        }
    }

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

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

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

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

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

            Shape.Display("Rectangle", newRectangle);
            Shape.Display("Triangle", newTriangle);
        }
    }
}

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

इस Program में हमने Shape Class के अन्दर ही Display() Method को एक Static Method की तरह Define किया है। जिसकी वजह से उसकी दोनों Derived Classes में ये Static Method Available हो जाता है, जिसे दोनों Derived Classes के Objects को Display करने के लिए Use किया जा सकता है। इस Method को निम्नानुसार Define किया गया है:

        public static void Display(string type, IShape obj)
        {
            Console.WriteLine("Area of {0} : {1} ", type, obj.Area());
        }

इस Method में हमने दो Parameters Specify किए हैं। पहला Parameter एक String Type की Value Accept करता है। जबकि दूसरा Parameter IShape Interface Type का एक Reference Variable है।

चूंकि हमने Triangle व Rectangle दोनों ही Derived Classes में IShape Interface को Implement किया है, इसलिए इस Display() Method में जब हम दूसरे Argument के रूप में निम्नानुसार Triangle या Rectangle Type के Object का Reference Specify करते हैं:

Shape.Display(“Rectangle”, newRectangle);
Shape.Display(“Triangle”, newTriangle);

तो Display() Method के दूसरे Argument के रूप में Specified obj Reference Variable इन Parameter के रूप में आने वाले Objects के References को Store करता है और उन Objects के लिए उन्हीं की Class में Defined Area() नाम के Method को Call करता है। परिणामस्वरूप हमें उपरोक्त Program के अनुसार Output प्राप्त होता है।

जिस तरह से हम किसी Class में Implemented Interface के Reference Variable में उस Class के Reference को Store कर सकते हैं। उसी तरह से हम किसी Method में भी किसी Class के Reference Type में उसकी Implemented Class के Object का Reference Store कर सकते हैं और उस Reference को उस Method से Value या Reference की तरह Return कर सकते हैं।

Return होने वाला Reference Variable उसी Object को Refer करता है, जिसे Method के अन्दर Refer कर रहा होता है। लेकिन जब हम इस प्रक्रिया को Use करते हैं, तब हमें इस बात का ध्‍यान रखना जरूरी होता है कि Return होने वाला Reference Variable Method के बाहर भी Available व Live रहे।

Array of Interface Types

चूंकि हम किसी Interface को किसी भी Class में Implement कर सकते हैं, भले ही वे Classes Same Class Hierarchy की Classes हों या न हों। Interface की इस विशेषता के कारण Interface एक बहुत ही Powerful Programming Construct बन जाता है। जिसे हम निम्नानुसार एक उदाहरण द्वारा ज्यादा बेहतर तरीके से समझ सकते हैं:

File Name: ArrayOfInterfaceType.cs
using System;

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

    class Shape
    {
        public double dim1, dim2;

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

        public static void Display(IShape obj)
        {
            Console.WriteLine("Area of Shape : {0} ", obj.Area());
        }
    }

    class Rectangle : Shape, IShape
    {
      // Same as before
    }

    class Triangle : Shape, IShape
    {
      // Same as before
    }

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

        public double Area()
        {
            return 22 / 7 * dim1 * dim1;
        }
    }

    class MultipleInterfaceImplementation
    {
        public static void Main(string[] args)
        {
            IShape[] InterfaceArray = { new Rectangle(6, 7), new Triangle(12, 23), new Circle(7) };

            foreach (IShape i in InterfaceArray)
                Shape.Display(i);
        }
    }
}

// Output:
   Area of Shape : 42 
   Area of Shape : 138 
   Area of Shape : 147

इस Program में हमने सबसे पहले Circle Type Create किया है और फिर Main() Method में InterfaceArray नाम का IShape Interface Type का एक Array Create किया है। साथ ही इस Array में Rectangle, TriangleCircle Type के तीन Object Create करके इनके Reference से Initialize किया है।

परिणामस्वरूप InterfaceArray के Index Number 0 पर एक Rectangle का, Index Number 1 पर एक Triangle का व Index Number 2 पर एक Circle Object का Reference Stored है।

फिर हमने एक foreach Loop द्वारा इस InterfaceArray में विभिन्न Index Numbers पर Stored References वाले Objects को Shape.Display() नाम के Static Method में Argument के रूप में Pass किया है, जहां Shape.Display() Method आने वाले सभी Object References के Area() Method को Call करके उनका Area Calculate करके Display करता है।

इस तरह से हम समझ सकते हैं कि हम किसी Implemented Interface के से Associated Class के Objects को एक Array Element के रूप में Store करके उन सभी Objects के लिए समान Statement द्वारा अलग-अलग Methods को Call करके अलग-अलग तरह की जरूरतों को पूरा कर सकते हैं, जो कि Polymorphism का ही एक और उदाहरण है। (C# Interface Example)

Interface in C# with Example
Delegates in C#

C# in Hindiये Article इस वेबसाईट पर Selling हेतु उपलब्‍ध EBook C#.NET in Hindi से लिया गया है। इसलिए यदि ये Article आपके लिए उपयोगी रहा, तो निश्चित रूप से ये पुस्तक भी आपके लिए काफी उपयोगी साबित होगी। 

C#.NET in Hindi | Page:908 | Format: PDF

BUY NOW DOWNLOAD READ ONLINE

Download All Hindi EBooks

सभी हिन्दी EBooks C, C++, Java, C#, ASP.NET, Oracle, Data Structure, VB6, PHP, HTML5, JavaScript, jQuery, WordPress, etc... के DOWNLOAD LINKS प्राप्‍त करें, अपने EMail पर।

Register करके Login करें। इस Popup से छुटकारा पाएें।