Generics in C# with Example

Generics in C# with Example: जब हम एक बार Generic Class Define कर लेते हैं, तो Constructed Class बनाना काफी आसान हो जाता है। क्योंकि हम Generic Class के Parameters के रूप में जिन Actual Types को Specify करते हैं, उन्हीं Actual Types के आधार पर वह Generic Class एक Specific Class बन जाती है, जिसे Constructed Type के नाम से जाना जाता है।

इस तरह से एक Generic Type Create होने वाले Constructed Type के लिए आधार यानी Template की तरह काम करता है। इसलिए यदि हम हमारे पिछले Generic Type के आधार पर कोई Constructed Type Create करना चाहें, तो हमें केवल निम्नानुसार तरीके से Parameters Specify करने होते हैं:

विशेष काम C# Compiler स्वयं कर लेता है। यानी यदि हम इस तरह से short व int Types Specify करें, तो हमारी बनने वाली SomeClass का Constructed Type कुछ निम्नानुसार होगा:

यानी Generic Class Define करते समय हमने जहां-जहां पर T1 Generic को Specify किया होता है, वहां-वहां पर “short” Type Substitute हो जाता है और जहां-जहां पर T2 Generic को Specify किया होता है, वहां-वहां पर “int” Type Substitute हो जाता है। परिणामस्वरूप हमें उपरोक्त चित्र के Right Side में दिखाए अनुसार एक Constructed SomeClass प्राप्त हो जाता है, जिसका Actual Object या Instance Create किया जा सकता है।

इस तरह से यदि हम सरल शब्दों में Generic Class व Constructed Class के बीच के अन्तर को समझें तो Generic Class में हम जिन Generics को Specify करते हैं, Constructed Class के लिए वे Generics एक प्रकार के Placeholder की तरह काम करते हैं। इस प्रक्रिया को हम सरल तरीके से निम्न चित्र द्वारा भी Represent कर सकते हैं:

Creating Variables and Instances

जब एक बार किसी Generic Class के आधार पर Constructed Class Create कर ली जाती है, तो उस Constructed Class का Object या Instance व Variable Create किया जा सकता है। Constructed Class Type भी Regular Class Type की तरह ही होते हैं। अन्तर केवल इतना होता है कि इन्हें किसी Generic Class के Template के आधार पर Create किया गया होता है। इसलिए Normal Class Type की तरह ही Constructed Class Type के भी (Stack Area) Reference व (Heap Area) Instance दोनों Create किए जा सकते हैं। जैसे:

इस Code Segment का पहला Line जिस तरह से एक Non-Generic Class का Object Create करता है, ठीक उसी तरह से हम Generic Class के आधार पर बनी हुई Constructed Class Type का भी उपरोक्त Code अनुसार Object व Reference Create कर सकते हैं। इस प्रक्रिया को हम निम्न चित्र द्वारा भी Represent कर सकते हैं:

इस तरह से हम समझ सकते हैं कि Constructed Type द्वारा भी हमें उसी तरह का Statement Use करके Constructed Type का Object Create करना होता है, जिस तरह का Syntax लिखकर हम Regular Class का Object Create करते हैं।

जब एक बार हम Generic Class Create कर देते हैं, तो उस Generic Class के आधार पर हम जितने चाहें उतने प्रकार के Constructed Type Define कर सकते हैं और उस Constructed Type का Object Create करके उपयोग में ले सकते हैं। जैसे:

File Name: GenercStackClass.cs
using System;

namespace CSharpGenerics
{
    class MyStack<T>
    {
        T[] StackArray;
        int TOS = 0;

        public void Push(T x)
        {
            if (!IsStackFull)
                StackArray[TOS++] = x;
        }

        public T Pop()
        {
            return (!IsStackEmpty) ? StackArray[--TOS] : StackArray[0];
        }

        const int MaxStack = 10;
        bool IsStackFull { get { return TOS >= MaxStack; } }
        bool IsStackEmpty { get { return TOS <= 0; } }

        public MyStack()
        {
            StackArray = new T[MaxStack];
        }

        public void Print()
        {
            for (int i = TOS - 1; i >= 0; i--)
                Console.WriteLine(" Value: {0}", StackArray[i]);
        }
    }

    class UsingGenericClass
    {
        static void Main()
        {
            MyStack<int> StackInt = new MyStack<int>();
            MyStack<string> StackString = new MyStack<string>();

            Console.WriteLine("Integer Stack: ");
            StackInt.Push(3);
            StackInt.Push(5);
            StackInt.Push(7);
            StackInt.Push(9);
            StackInt.Print();

            Console.WriteLine("\nString Stack: ");
            StackString.Push("Kuldeep Mishra");
            StackString.Push("Raj Kumar Sharma");
            StackString.Print();
        }
    }
}

// Output:
   Integer Stack: 
    Value: 9
    Value: 7
    Value: 5
    Value: 3

   String Stack: 
    Value: Raj Kumar Sharma
    Value: Kuldeep Mishra

इस Program में हमने एक Stack Class Create की है। हम जानते हैं कि Stack एक LIFO (Last In First Out) Data Structure होता है। इसलिए Stack में जो भी Data Enter किया जाता है, वह Object की Top Position पर Store होता है और यदि किसी Item को Remove किया जाता है, तो वह Item भी Stack की Top Position से ही Remove होता है।

लेकिन इस Program की विशेषता ये है कि हमने हमारी Stack Class को एक Generic Class की तरह Define किया है। क्योंकि Stack में हम किसी भी Type के Data को Store कर सकते हैं। इसलिए यदि हम किसी एक Particular Type के Data को Store करने के लिए Stack Class Create करें, तो किसी दूसरे तरह के Data को Store करने के लिए उस Class को Use नहीं कर सकते।

लेकिन Generic Type की Class को हम किसी भी तरह का Data Store करने के लिए Use कर सकते हैं। क्योंकि Generic Stack Type किस तरह का Data Hold करेगा, ये बात Generic Type के आधार पर Create होने वाले Constructed Type पर आधारित होती है और Constructed Type हमारे द्वारा Specified Parameters के आधार पर Data Store करने के लिए Generic Stack Class को Modify करके Constructed Type Create करता है।

जब ये Program Run होता है तो Main() Method में सबसे पहले Specified निम्न Statement Execute होता है:

MyStack<int> StackInt = new MyStack<int>();

ये Method Execute होते ही हमारी Generic Stack Class निम्नानुसार Integer Value के लिए Modify हो जाती है:

    class MyStack<int>
    {
        int[] StackArray;
        int TOS = 0;

        public void Push(int x)
        {
            if (!IsStackFull)
                StackArray[TOS++] = x;
        }

        public int Pop()
        {
            return (!IsStackEmpty) ? StackArray[--TOS] : StackArray[0];
        } 

        const int MaxStack = 10;
        bool IsStackFull { get { return TOS >= MaxStack; } }
        bool IsStackEmpty { get { return TOS <= 0; } }

        public MyStack()
        {
            StackArray = new int[MaxStack];
        }

        public void Print()
        {
            for (int i = TOS - 1; i >= 0; i--)
                Console.WriteLine(" Value: {0}", StackArray[i]);
        }
    }

इसी तरह से जब Main() Method का निम्न Statement Execute होता है:

MyStack<string> StackString = new MyStack<string>();

तो हमारी Generic Stack Class निम्नानुसार तरीके से Modify हो जाती है:

    class MyStack<string>
    {
        string[] StackArray;
        int TOS = 0;

        public void Push(string x)
        {
            if (!IsStackFull)
                StackArray[TOS++] = x;
        }

        public string Pop()
        {
            return (!IsStackEmpty) ? StackArray[--TOS] : StackArray[0];
        } 

        const int MaxStack = 10;
        bool IsStackFull { get { return TOS >= MaxStack; } }
        bool IsStackEmpty { get { return TOS <= 0; } }

        public MyStack()
        {
            StackArray = new string[MaxStack];
        }

        public void Print()
        {
            for (int i = TOS - 1; i >= 0; i--)
                Console.WriteLine(" Value: {0}", StackArray[i]);
        }
    }

यानी Main() Method में Constructed Type के साथ हम जब int Type को Parameter की तरह Specify करते हैं, तो Generic Stack Class, Integer Value के लिए Constructed Type बन जाता है। परिणामस्वरूप उपरोक्त Program Integer Type के मानों को निम्नानुसार Statements द्वारा Stack में Fill करके Display कर देता है:

            Console.WriteLine("Integer Stack: ");
            StackInt.Push(3);
            StackInt.Push(5);
            StackInt.Push(7);
            StackInt.Push(9);
            StackInt.Print();

जबकि string Type को Parameter की तरह Specify करने पर हमारी Generic Stack Class, String Type के Data के लिए Constructed Type बन जाता है और निम्नानुसार Statements द्वारा String Type के मानों को Stack में Push करके Output में Display कर देता है:

            Console.WriteLine("\nString Stack: ");
            StackString.Push("Kuldeep Mishra");
            StackString.Push("Raj Kumar Sharma");
            StackString.Print();

इस तरह से हम एक Generic Class Create करके उसके Objects को अलग-अलग Type के Data के लिए समान प्रकार से उपयोग में ले सकते हैं।