Constructor in C#

Constructor in C#: दुनिया का कोई भी Real World Object ऐसा नहीं हो सकताए जिसके Create होते समय उसके विभिन्न Characteristics का कोई प्रारम्भिक मान न हो और सभी मान बाद में Set किए जाऐं। यानी मानलो कि कोई Company एक cpuCabinet बनाती है, तो Company कोई भी cpuCabinet ऐसा नहीं बना सकती, जिसके निर्माण के समय उस cpuCabinet Object का कोई Length, Width व Height ना हो। क्योंकि कम्पनी जो भी cpuCabinet बना,गा, उस हर cpuCabinet का कुछ न कुछ प्रारम्भिक Dimension जरूर होगा।

इसी Concept के आधार पर C# में भी ये सुविधा प्रदान की गई है कि किसी भी Class का कोई भी Object Create होते समय, उसके विभिन्न Fields में प्रारम्भिक मान Initialized हो सके। लेकिन जिस तरह से हम किसी Primary Type के Variable को Declare करते ही Assignment Operator का प्रयोग करके उसे किसी Initial Value से Initialize करते हैं, ठीक उसी तरह से हम किसी Class के Object को Create करते समय ही Assignment Operator का प्रयोग करके उसे Initialize नहीं कर सकते।

बल्कि Create होने वाले Object के विभिन्न Characteristics या Fields के प्रारम्भिक मान Initialize करने के लिए हमें एक Special Method Create करना होता है, जो कि Object को विभिन्न प्रकार की Initial Values से Initialize करने का काम करता है। इस Special Method को ही Object Oriented Programming Language में Constructors कहा जाता है।

चूंकि Constructor एक Special Method होता है, इसलिए इसकी कुछ मुख्‍य विशेषताऐं होती हैं, जो एक Constructor Method को Class के अन्‍य Member Methods से अलग बनाती हैं। Constructor एक Special Method होता है, जिसका वही नाम होता है, जो उसकी Class का नाम होता है, जिसमें उसे Member Method को Define किया गया होता है। उदाहरण के लिए यदि हम Box Class का Constructor Define करना चाहें, तो जिस डमजीवक का नाम Box() होगा, वही Method उस Box Class का Constructor होगा

चूंकि Constructor का वही नाम होता है, जो Class का नाम होता है, इसलिए जब भी हम उस Class का कोई Object Create करते हैं, तो Object के Create होते ही उसमें Defined Constructor Method Execute हो जाता है। इसीलिए हम Class के Constructor Method में ही उस Class के Create होने वाले Objects के Data Members को Initialize किए जाने वाले प्रारम्भिक मान Specify कर देते हैं।

Constructors की जरूरत हमें इसलिए भी पडती है क्योंकि जब भी कोई Object Create होता है, तो उसके सभी Data Members को कुछ न कुछ प्रारम्भिक मान जरूर होता है। इसलिए यदि हम किसी Class में Constructors को Define नहीं करते हैं, तो Object Create होने के बाद हमें उस Object के विभिन्न Instance Variables को Value Assign करना पडता है और इस जरूरत को पूरा करने के लिए हमें सामान्‍यत: SetSize() या SetValues() जैसा कोई Member Method Create करना पडता है तथा हर Create होने वाले Object के लिए इस Method को Manually Call करना पडता है।

Constructors की एक विशेषता और होती है कि Constructors किसी भी तरह का Parameter तो Accept कर सकते हैं, लेकिन किसी भी तरह का मान Return नहीं करते न ही इन्हें Manually Call किया जा सकताए बल्कि Class का Object Create करते समय, Constructors Automatically Invoke होते हैं।

जबकि किसी External Class में जब हम Object Create करते समय उसे Initialize भी करना चाहते हैं, तो किसी External Class में Object Create करते समय उसी स्थिति में Constructor Execute होता है, जबकि उसे Public Access के साथ Define किया गया हो।

इसलिए सामान्‍यत: सभी Constructors को public Keyword के साथ ही Define किया जाता है, ताकि कोई भी अन्‍य Class उस Class के Object Create करते समय उसे Initialize भी कर सके। Constructors के Concept को हम निम्न उदाहरण द्वारा बेहतर तरीके से समझ सकते हैं।

File Name: UsingStaticProperty.cs
using System;

namespace CSharpClass
{
    class Watch
    {
        public byte hour { set; get; }
        public byte minute { set; get; }

        public Watch()
        {
            hour = 12;
            minute = 0;
        }

        public void SetTime(byte h, byte m)
        {
            hour = h;
            minute = m;
        }

        public void DisplayTime()
        {
            Console.WriteLine(hour + ":" + minute);
        }
    }

    class UsingWatchConstructor
    {
        static void Main(String[] arg)
        {
            Watch hmt = new Watch();
            Console.Write("Time of the HMT Watch is: ");
            hmt.DisplayTime();

            Watch sonata = new Watch();
            sonata.SetTime(10, 12);
            Console.Write("Time of the Sonata Watch is: ");
            sonata.DisplayTime();
        }
    }
}

// Output:
   Time of the HMT Watch is: 12:0
   Time of the Sonata Watch is: 10:12

इस Program में हमने Watch नाम की एक Class Create की है, जिसमें hour व minute नाम की दो Auto-Implemented Properties हैं, तथा SetTime() व DisplayTime() नाम के दो Methods हैं, जो कि Current Watch के Time को Set व Display करने का काम करते हैं। इनके अलावा हमने एक Constructor भी Create किया है, जो कि कोई Parameter Accept नहीं करता।

जब ये Program Run होता है, तो सबसे पहले निम्न Statement द्वारा hmt नाम का एक Watch Type का एक नया Object Create करता है:

Watch hmt = new Watch();

जब ये Statement Execute होता है, तो new Operator के साथ Specified Watch() Constructor Execute होता है।

जब हम किसी Class में कोई Constructor Specify नहीं करते, तो Compiler स्वयं ही हमें एक Default Compiler Provide करता है, जो कि एक No-Argument Constructor होता है। लेकिन यदि हम हमारी Class में कोई Constructor Create करते हैं, तो Compiler हमें Default Constructor Provide नहीं करताए बल्कि Object Create करते समय Compiler हमारे द्वारा Create किए गए Constructor को ही Execute करता है।

इसीलिए जब उपरोक्त Statement Execute होता है, तो Watch Class में हमारे द्वारा निम्नानुसार Specify किया गया Watch() Constructor Execute होता है:

        public Watch()
        {
            hour = 12;
            minute = 0;
        }

और hmt Object के hour का मान 12 व minute का मान 0 Set कर देता है। परिणामस्वरूप जब हम DisplayTime() Method को hmt Object के लिए Call करते हैं, तो हमें निम्नानुसार Output प्राप्त होता है:

Time of the HMT Watch is: 12:0

इसी तरह से जब हमारे Program का निम्नानुसार दूसरा Statement Execute होता है:

Watch sonata = new Watch();

तो ये Statement भी sonata नाम का Watch Type का एक नया Object Create करता है और उसके hour का मान 12 व minute का मान 0 Set कर देता है। लेकिन इस sonata Object को एक नया Time Set करने के लिए हमने अगले Statement में SetTime() नाम के Method को निम्नानुसार तरीके से Call किया है:

hmt.SetTime(10, 12);

परिणामस्वरूप जब हम इस sonata Object के Time को DisplayTime() Method द्वारा Display करते हैं, तो हमें निम्नानुसार Output प्राप्त होता है:

Time of the Sonata Watch is: 10:12

Parameterized Constructor in C#

जिस तरह से पिछले Program में हमने एक No-Argument Default Constructor Create किया है, उसी तरह से हम किसी Constructor को Parameter के साथ भी Define कर सकते हैं। जब हम Parameterized Constructor Create करते हैं, तब हमें Default Constructor को Create करना भी जरूरी हो जाता है, अन्‍यथा हम हमारे Program में Default Constructor का प्रयोग नहीं कर सकते। क्योंकि Parameterized Constructor Create करने पर C# Compiler हमें No-Argument यानी Default Constructor Provide नहीं करता।

Parameterized Constructor का प्रयोग करके हम हमारे पिछले Program को ही इस तरह से Modify कर सकते हैं कि Object Create करने के बाद उसके Time को Set करने के लिए SetTime() Method को Call न करना पडे। बल्कि Object Create करते ही Object के Time को Set किया जा सके।

// File Name: ParameterizedConstructor.cs
using System;

namespace CSharpClass
{
    class Watch
    {
        public byte hour { set; get; }
        public byte minute { set; get; }

        public Watch()
        {
            hour = 12;
            minute = 0;
        }

        public Watch(byte h, byte m)
        {
            hour = h;
            minute = m;
        }

        public void DisplayTime()
        {
            Console.WriteLine(hour + ":" + minute);
        }
    }

    class UsingParameterizedConstructor
    {
        static void Main(String[] arg)
        {
            Watch hmt = new Watch();
            Console.Write("Time of the HMT Watch is: ");
            hmt.DisplayTime();

            Watch sonata = new Watch(10, 12);
            Console.Write("Time of the Sonata Watch is: ");
            sonata.DisplayTime();
        }
    }
}

// Output:
   Time of the HMT Watch is: 12:0
   Time of the Sonata Watch is: 10:12

जैसाकि इस Program में भी हम देख सकते हैं कि हमें वही Output प्राप्त हो रहा है, जो पिछले Program का प्राप्त हुआ था। लेकिन इस Program में हमने sonata के Time को Set करने के लिए SetTime() Method को Call नहीं किया है, बल्कि sonata नाम का Object Create करते समय हमने निम्न Statement का प्रयोग किया है:

            Watch sonata = new Watch(10, 12);

जिसमें में Watch() नाम के Constructor को हमने दो Parameters Pass कर दि, हैं। परिणामस्वरूप इस बार sonata Object Create करते समय C# Compiler, No-Argument Constructor को Execute नहीं करताए बल्कि निम्नानुसार Define किए गए 2-Argument Constructor को Execute करता है:

public Watch(byte h, byte m)
        {
hour = h;
minute = m;
}

Constructor Overloading

चूंकि हमारे पिछले Program में हमने Watch नाम के दो Constructors Define किए हैं, जिनका नाम समान है लेकिन Parameters में अन्तर है। इसलिए इस प्रक्रिया को Constructor Overloading भी कहा जा सकता है।

Optional Parameters or Default Parameters

एक Method के साथ हम जो भी प्रक्रिया कर सकते हैं, वे सारी प्रक्रियाऐं एक Constructor के साथ भी की जा सकती हैं। यानी यदि हम चाहें, तो Constructor में Parameters को Default Values यानी Optional Parameters भी Specify कर सकते हैं।

जब हम Optional Parameters Specify करते हैं, तब यदि किसी Constructor के सभी Parameters को Default Value Assign किया गया हो, तो हमें No-Argument, Default Constructor Define करना जरूरी नहीं होता। जैसे:

// File Name: DefaultParameterizedConstructor.cs
using System;

namespace CSharpClass
{
    class Watch
    {
        public byte hour { set; get; }
        public byte minute { set; get; }

        public Watch(byte h = 12, byte m = 0)
        {
            hour = h;
            minute = m;
        }

        public void DisplayTime()
        {
            Console.WriteLine(hour + ":" + minute);
        }
    }

    class UsingDefaultParameterizedConstructor
    {
        static void Main(String[] arg)
        {
            Watch hmt = new Watch();
            Console.Write("Time of the HMT Watch is: ");
            hmt.DisplayTime();

            Watch sonata = new Watch(10, 12);
            Console.Write("Time of the Sonata Watch is: ");
            sonata.DisplayTime();
        }
    }
}

// Output:
   Time of the HMT Watch is: 12:0
   Time of the Sonata Watch is: 10:12

इस Program में हमने हमारी Watch Class से No-Argument Default Constructor को Remove कर दिया है और Default Constructor द्वारा Fulfill की जाने वाली Requirement को पूरा करने के लिए 2-Argument Constructor के hour व minute दोनों Parameters को निम्नानुसार Default Value Assign कर दिया है:

public Watch(byte h = 12, byte m = 0)
{
hour = h;
minute = m;
}

इसीलिए अब C# Compiler इसी एक Constructor को Use करके hmt Object भी Create कर देता है, जो कि कोई Parameter Accept नहीं कर रहा है और sonata Object भी Create कर देता है, जो कि दो Parameters Accept कर रहा है।

Static Constructor in C#

चूंकि Constructor भी एक प्रकार का Method ही होता है, इसलिए जिस तरह से हम किसी Method को Static Define कर सकते हैं, उसी तरह से हम किसी Constructor को भी static Keyword का प्रयोग करके Static Define कर सकते हैं।

जिस तरह से Constructor सामान्‍यत: किसी Class के Objects के Data Members को Initialize करने का काम करते हैं, उसी तरह से Static Constructors, Class Level Static Data Members को Initialize करने के लिए Define किए जाते हैं। यानी Static Constructors का प्रयोग Class के Static Data Members को Initialize करने के लिए किया जाता है।

Class Level Static Data Members किसी भी Static Member के Reference होने तथा Class का कोई भी Object Create होने से पहले Initialize होते हैं। Static Constructors का नाम भी Class के नाम के समान ही होता है और Static Constructors भी कोई Value Return नहीं करते।

static Constructors Create करते समय भी हमें static Keyword को Constructor के नाम से पहले Specify करना जरूरी होता है। हालांकि एक Class में एक से ज्यादा Normal Constructors हो सकते हैं। लेकिन Class Level Static Constructor एक Class में केवल एक ही होता है। साथ ही Static Constructors किसी तरह का कोई Parameter Accept नहीं कर सकते, न ही Static Constructor के साथ किसी Access Modifier का ही प्रयोग किया जा सकता है।

एक ही Class में Static व Normal दोनों तरह के Constructors हो सकते हैं। Static Method की तरह ही Static Constructor भी Class के Data Members यानी Fields को Directly Access नहीं कर सकताए न ही this Accessor को Use कर सकता है, जिसके बारे में हम आगे Discuss करेंगे।

साथ ही हम किसी Static Constructor को भी ठीक उसी तरह से Manually Call नहीं कर सकते, जिस तरह से Normal Constructor को Manually Call नहीं कर सकते। बल्कि Static Constructors हमेंशा Class का कोई भी Object Create होने से पहले तथा Class के किसी भी Static Member के Reference होने से पहले Automatically Call होता है। Static Constructor को हम कुछ निम्नानुसार तरीके से Use कर सकते हैं:

// File Name: StaticConstructor.cs
using System;

namespace CSharpClass
{
    class RandomNumberClass
    {
        private static Random RandomKey; 	// Private static field

        static RandomNumberClass() 		// Static constructor
        {
            RandomKey = new Random(); 		// Initialize RandomKey
        }

        public int GetRandomNumber()
        {
            return RandomKey.Next();
        }
    }

    class UsingStaticConstructor
    {
        static void Main()
        {
            RandomNumberClass a = new RandomNumberClass();
            RandomNumberClass b = new RandomNumberClass();
            RandomNumberClass c = new RandomNumberClass();

            Console.WriteLine("Next Random #: {0}", a.GetRandomNumber());
            Console.WriteLine("Next Random #: {0}", b.GetRandomNumber());
            Console.WriteLine("Next Random #: {0}", c.GetRandomNumber());
        }
    }
}

// Output:
   Next Random #: 2090460463
   Next Random #: 1340983266
   Next Random #: 200353911

Object Initializers

अभी तक हमने जितने Object Create किए हैं, उन सभी को Create करने के लिए हमने new Operator के बाद एक Constructor को Specify किया है, जबकि Constructor Parameterized भी हो सकता है और Default भी।

लेकिन C# हमें Object के हर Data Member व Property को Initialize करने के लिए Object Initializers List Specify करने की भी सुविधा Provide करता है। यानी हम Object Create करते समय ही Object के विभिन्न Data Members व Properties को अलग-अलग Initialize कर सकते हैं। किसी Object Initializers List को हम निम्नानुसार दो तरीकों से Specify कर सकते हैं:

new TypeName        { FieldOrProp = InitExpr, FieldOrProp = InitExpr, …}
new TypeName(ArgList)   { FieldOrProp = InitExpr, FieldOrProp = InitExpr, …}

जब हम Object Initializers का प्रयोग करके Object के Fields या Properties को Initialize करते हैं, तब Initialize होने वाले Fields या Properties का Object Create करने वाले Code द्वारा Accessible यानी Public Access में होना जरूरी होता है।

साथ ही Initialization तब Execute होता है, जब Constructor पूरी तरह से Execute हो चुके होते हैं। इसलिए यदि Constructor द्वारा किसी Property या Field का मान Set किया गया हो, तो Initializers द्वारा उन Properties व Fields के मान Overwrite हो सकते हैं।

// File Name: ObjectInitializer.cs
using System;

namespace CSharpClass
{
    class Watch
    {
        public byte hour { set; get; }
        public byte minute { set; get; }

        public void DisplayTime()
        {
            Console.WriteLine(hour + ":" + minute);
        }
    }

    class UsingObjectInitializer
    {
        static void Main(String[] arg)
        {
            Watch sonata = new Watch() { hour = 10, minute = 12 };
            sonata.SetTime(10, 12);
            Console.Write("Time of the Sonata Watch is: ");
            sonata.DisplayTime();
        }
    }
}

// Output:
   Time of the Sonata Watch is: 10:12

जैसाकि इस Program में हम देख सकते हैं कि sonata Object Create करने के लिए हमने निम्नानुसार Object Initializers का प्रयोग किया है:

Watch sonata = new Watch() { hour = 10, minute = 12 };

इसलिए जैसे ही ये Object Create होता है, hour नाम की Property को Set करने के लिए मान 10 व minute नाम की Property को Set करने के लिए मान 12 Specify कर दिया है। इसलिए Create होने वाले Object में Create होते ही ये मान Initialize हो जाते हैं और इस Object के Time को DisplayTime() Method का प्रयोग करने पर हमें उपरोक्त Program के Output के अनुसार Result प्राप्त होता है।

readonly Modifier

हम किसी Class के किसी भी Field को readonly Modifier के साथ Declare कर सकते हैं। जब हम किसी Field को readonly Modifier के साथ Declare करते हैं, तो वह Field Exactly const Field की तरह Behave करता है। यानी हम इस readonly Field के मान को Change नहीं कर सकते, ठीक उसी तरह से जिस तरह से किसी const Field के मान को Change नहीं कर सकते।

हालांकि हम किसी const Field के मान को केवल उसी समय Initialize कर सकते हैं, जब हम Constant को Declare करते हैं। लेकिन readonly Field को const की तरह Declare करते समय भी Initialize किया जा सकता है और किसी Constructor द्वारा भी Initialize किया जा सकता है, जबकि यदि Field Static हो तो Initialize करने के लिए Static Constructor का प्रयोग किया जा सकता है।

जब हम const Field Declare करते हैं, तब Constant Declare करते ही यानी Compile Time में हमें Constant Identifier को Value Initialize करना जरूरी होता है। लेकिन जब हम readonly Field Declare करते हैं, तब हम Program के Runtime में readonly Variable को Value Assign कर सकते हैं। जिसकी वजह से हमें विभिन्न परिस्थितियों में या विभिन्न Constructors द्वारा अलग-अलग Object को अलग-अलग तरह की Value Set करने की सुविधा मिल जाती है, जो कि const Variables के साथ सम्भव नहीं है क्योंकि const Data Members एक प्रकार के Static Data Member की तरह Class Level होते हैं और Class के सभी Objects के लिए Common होते हैं, जबकि readonly Data Members हर Object के लिए अलग-अलग भी हो सकते हैं और Static Field की तरह भी हो सकते हैं।

साथ ही readonly Fields Memory में Storage Reserve करते हैं और Memory में Store होते हैं। जबकि const Members Memory में Storage Reserve नहीं करते, बल्कि C/C++ के #define की तरह Compile Time में Expand होते हैं और जहां-जहां पर भी const Symbol को Use किया गया होता है, वहां-वहां पर const Symbol अपनी Value से Replace हो जाता है।