How to Declare Array in C#

How to Declare Array in C#: जब हमें किसी Program में एक ही प्रकार के बहुत सारे Data को Store करके Access व Manipulate करना होता है, तब हम इस समान प्रकार के Data को Store करने के लिए बहुत सारे Variables Declare करने के स्थान पर Array Declare करते हैं।

Array एक प्रकार का Reference Type होता है, जो समान प्रकार के Data Items को Store करने के लिए Memory के Heap Area का प्रयोग करता है और Array के हर Data Item को Store करने के लिए Continues Memory Locations का प्रयोग करता है।

इसलिए Array के सभी Data Items Memory में एक निश्चित क्रम में Store होते हैं और हर Element को Uniquely Identify करने के लिए उसके साथ एक Zero Based Unique Index Number Specified रहता है। साथ ही Array एक Fixed Data Structure होता है। इसलिए जब एक बार Array की Size को Define कर दिया जाता है, तो उसके बाद Array की Size को Modify नहीं किया जा सकता।

C/C++ व Java की तरह ही C# में भी Array Create करने के लिए हमें Bracket Notation को Use करना होता है, लेकिन C# का Array, C/C++ के Array के समान नहीं होता बल्कि Java के Array के समान एक Object होता है।

C# के Array से सम्बंधित चार मुख्‍य बातें होती हैं, जिन्हें समझना जरूरी होता है। ये चारों बातें निम्नानुसार हैं:

• Elements: किसी Array के सभी Individual Data Items को Element कहा जाता है।
• Rank/Dimension: किसी Array का कोई भी Positive Dimension हो सकता है। Array के Positive Dimension को Array का Rank कहा जाता है।
• Dimension Length: किसी Array के हर Dimension की एक Length होती है जो उस Positive Dimension के कुल Elements की संख्‍या को Represent करती है।
• Array Length: किसी Array के सभी Dimension के सभी Elements की कुल संख्‍या को Array का Length कहा जाता है।

चूंकि Array के सभी Elements को एक Zero Based Index Number द्वारा Access किया जाता है, इसलिए Array का Maximum Index Number हमेंशा Array के कुल Elements की संख्‍या से एक कम होता है। यानी यदि Array की कुल Length 10 हो, तो Array के Maximum Index Number की संख्‍या 9 होती है।

C# में भी मूल रूप से दो प्रकार के Array होते हैं, जिन्हें One-Dimensional Array व Multidimensional Array के नाम से जाना जाता है। 1-D Array को हम Elements के एक Vector की तरह मान सकते हैं। जबकि एक M-D Array को हम बहुत सारे 1-D Array का समूह मान सकते हैं। इन्हें निम्न चित्रानुसार आसानी से समझा जा सकता है:

Multi-Dimensional Array को भी हम Rectangular Array व Jagged Arrays के रूप में दो भागों में Divide कर सकते हैं। Rectangular Array ऐसा Array होता है, जिसके सभी Dimensions में समान संख्‍या में Elements होते हैं। जैसे:

        int x = myArray[4, 6, 1];

Jagged Array भी Multi-Dimensional Array होते हैं, लेकिन इसके हर Dimension को एक Independent Sub-Array द्वारा Represent किया जाता है और इसके सभी Sub-Arrays की Length Different होती है। इस प्रकार के Array को Declare करते समय हमें हर Dimension को एक अलग Bracket द्वारा Represent करना होता है। जैसे:

        int x = jagArray[2][7][4];

इस प्रकार से C# में मूल रूप से तीन प्रकार के Array होते हैं, जिन्हें निम्न चित्रानुसार दर्शाया जा सकता है:

Array – The Object

C# का Array वास्तव में System.Array Class से Derive होता है, जो कि एक BCL यानी Base Class Library Type है। इसलिए C# के किसी भी Array में Default रूप से कुछ Members Inherit होते हैं। जैसे:

• Rank: ये एक Property है, जो Array के Dimension को Return करता है।
• Length: ये एक Property है, जो Array के कुल Elements की संख्‍या को Return करता है।

चूंकि C# में Array एक Reference Type होता है, इसलिए सभी Reference Type की तरह ही Array भी Memory में दो हिस्सों में Store होता है। जहां Heap Area में तो Array के सभी Actual Data Items Store होते हैं और Stack में उस Heap Area का Reference Store होता है। हालांकि Reference, Stack के अलावा किसी विशेष Situation में Heap Area में भी Store हो सकता है। जैसे:

चूंकि Array हमेंशा Reference Type होता है, इसलिए किसी Array के Elements Value Type या Reference Type में से कुछ भी हो सकते हैं। जब Array में Stored सभी Data Items Value Type होते हैं, तो इस प्रकार का Array Value Type Array कहलाता है, जबकि Array में Stored सभी Data Items Reference Type के References होने पर बनने वाला Array Reference Type Array कहलाता है। एक Value Type Array को हम निम्नानुसार चित्र द्वारा Represent कर सकते हैं:

Declaring One-Dimensional or Rectangular Array

Syntactically One-Dimensional Array व Rectangular Array एक समान ही होते हैं, जबकि Jagged Array को थोडा अलग तरीके से Declare किया जाता है।

One-Dimensional Array Declare करने के लिए हमें Type Name व Variable Name के बीच एक Square Single Bracket का प्रयोग करना होता है। जबकि Rank Specifiers के रूप में हमें Commas का प्रयोग करना होता है। ये Commas Array के Dimensions की संख्‍या को निश्चित करते हैं।

यानी यदि एक Comma Specify किया जाए, तो बनने वाला Array 2-Dimensional होता है। यदि दो Comma Specify किए जाएें, तो बनने वाला Array 3-Dimensional होता है और यही प्रक्रिया आगे भी जारी रहती है।

जबकि हम Array के साथ जो Type Specify करते हैं, वह Array का Base Type होता है। यानी Array के सभी Elements उसी Type के होते हैं। उदाहरण के लिए यदि हम Integer Values को Store करने के लिए One-Dimensional Array Create करना हो, तो हमारा Array Declaration कुछ निम्नानुसार होता है:

        int [] intVals;

C/C++ में हम Array की कुल Length को Bracket के बीच Specify करते हैं, लेकिन C# में Array एक Simple Data Type नहीं बल्कि System.Array Type का एक Object होता है। इसलिए Array की Size Define करने के लिए या तो new Operator का प्रयोग करते हुए System.Array() Constructor को Use किया जाता है या फिर Array के हर Element को उसकी Basic Values से Initialize किया जाता है।

यदि हम एक से ज्यादा Dimensions का Array Create करना चाहें, तो हमें Brackets के बीच Comma को Use करना होता है। जैसे:

        int [ , ] intVals;

ये Declaration वास्तव में एक 2-Dimensional Array Create करेगा, क्योंकि Bracket Notation के बीच एक Single Comma को Use किया गया है। जबकि:

        int [ , , , , ] intVals;

ये Declaration वास्तव में एक 5-Dimensional Array Create करेगा, क्योंकि Bracket Notation के बीच चार Commas Specify किए गए हैं।

Instantiating One-Dimensional or Rectangular Array

Array Declare कर देने मात्र से Array Memory में कोई Space Reserve नहीं करताए क्योंकि अभी तक C# Compiler को पता ही नहीं होता कि Array में किसी Specific Type के कितने Elements Store करने हैं।

इसलिए Array को Declare करने के बाद हमें System.Array Type को new Operator का प्रयोग करते हुए Instantiate करना होता है और Reserve होने वाली Memory का Reference Newly Create होने वाले Array Variable को Assign करना होता है। जबकि Create होने वाले कुल Elements की संख्‍या को System.Array[] Constructor में Argument की तरह Specify करना होता है। जैसे:

        int [ ] arr2 = new int[4];

        MyClass[ ] mcArr = new MyClass[4];

जबकि यदि Multi-Dimensional Rectangular Array Create करना हो, तो हम Comma का प्रयोग करते हुए निम्नानुसार Statement Use कर सकते हैं:

        int [ , , ] arr3 = new int[3, 6, 2];

ये Statements Execute होने पर निम्न चित्रानुसार Memory Reserve करता है:

Initializing One-Dimensional or Rectangular Array

जब हम कोई Array Create करते हैं तो Array के सभी Elements Automatically उनके Type के अनुसार Default Values से Initialize हो जाते हैं।

उदाहरण के लिए यदि हम Integer Type का Array Create करें, तो Array के सभी Elements मान 0 से Initialize हो जाते हैं। इसी तरह से यदि हम Floating Point Type का Array Create करते हैं, तो Array के सभी Elements मान 0.0 से Initialize हो जाते हैं। Boolean Type का Array Create करने पर Array के सभी Elements false मान से तथा Reference Types का Array Create करने पर सभी Elements null से Initialize हो जाते हैं। जैसे:

        int [ ] intArr = new int[4];

ये Statement Memory में निम्नानुसार तरीके से Memory Reserve करता है:

जबकि हम हमारी जरूरत के अनुसार भी किसी Array को Create करते ही किसी Specific मान से Initialize कर सकते हैं।

किसी One-Dimensional Array को Initialize करने के लिए हमें Initialization List को Array Creation Expression के Just बाद Curly Braces के बीच Enclose करना होता है। जबकि Initialize किए जाने वाले सभी मानों को Comma से Separate रखा जाता है।

जब हम Initialization List Specify करते हैं, तब Array का Dimension Specify करना Compulsory नहीं होताए क्योंकि C# Compiler Initialization List के कुल Elements की संख्‍या के आधार पर Automatically Array की Length तय कर लेता है। जैसे:

        int[] intArr = new int[] { 10, 20, 30, 40 };

जब हम उपरोक्तानुसार Code लिखते हैं, तो C# Compiler निम्न चित्रानुसार चार Integer Values को Store करने के लिए Memory Reserve करता है।

जैसाकि हम उपरोक्त Statement में देख सकते हैं कि हालांकि हमने Array की Size को Specify नहीं किया है, फिर भी C# Compiler Memory के Heap Area में कुल चार Integer Values को Store करने के लिए Space Reserve करता है और Reserved Array का Base Address intArr को Assign कर देता है।

जिस तरह से हम One-Dimensional Array को Initialize करते हैं, उसी तरह से हम Multi-Dimensional Rectangular Arrays को भी Initialize कर सकते हैं। उदाहरण के लिए यदि हमें 2-Dimensional Rectangular Array Create करना हो, तो हम निम्नानुसार Statement द्वारा एक 2-D Array Create कर सकते हैं:

int[ , ] intArray2 = new int[ , ] { 
					{10, 1}, 
					{2, 10}, 
					{11, 9} 
				} ;

ये Statement Memory के Heap Area में निम्न चित्रानुसार Memory Reserve करता है:

Array Initialization के लिए हम Shortcut Syntax का भी प्रयोग कर सकते हैं। जैसे:

        int[ , ] intArray2 = new int[ , ] {10, 1} ;

इस Statement को हम निम्नानुसार भी लिख सकते हैं:

        int[ ] intArray2 = {10, 1};

इसी तरह से हम किसी Multi-Dimensional Array को भी Shortcut Syntax का प्रयोग करके Initialize कर सकते हैं। जैसे:

        int[ , ] intArray2 = new int[ , ] { {10, 1}, {2, 10}, {11, 9} } ;

इस 2-D Array को Shortcut तरीके से हम निम्नानुसार भी लिख सकते हैं:

        int[ , ] intArray2 = { {10, 1}, {2, 10}, {11, 9} } ;

var Keyword का प्रयोग करके हम किसी Array को भी उसी तरह से Declare कर सकते हैं, जिस तरह से किसी Value Type या Reference Type को Declare करते हैं। जैसे:

        int[ , ] intArray2 = new int[ , ] { {10, 1}, {2, 10}, {11, 9} } ;

इस Statement को var Keyword का प्रयोग करते हुए निम्नानुसार Declare किया जा सकता है:

        var intArray2 = new [ , ] { {10, 1}, {2, 10}, {11, 9} } ;

इसी तरह से यदि किसी One-Dimensional Array को var Keyword का प्रयोग करके Declare करना हो, तब भी यही तरीका Use किया जाता है। जैसे:

        int[ ] intArray2 = {10, 1};

इस Statement को var Keyword प्रयोग करते हुए निम्नानुसार भी लिखा जा सकता है:

        var intArray2 = new [ ] {10, 1};

Jagged Array

Jagged Array वास्तव में Array का Array होता है, जो कि Rectangular Array की तरह नहीं होताए जिसके सभी Sub-Array में समान Elements होते हैं, बल्कि ये एक ऐसा Array होता है, जिसके हर Element पर एक अन्‍य Sub-Array का Reference Stored रहता है और हर Sub-Array की Size भिन्न हो सकती है। जैसे:

        int[ ][ ] jagArr = new int[3][];                      //Declare and Create Top-Level Array.

इस Array को Declare करने पर इसके लिए निम्न चित्रानुसार Memory Reserve होती है:

Declaring Jagged Array

Jagged Array को Declare करते समय हमें हर Dimension के लिए एक Separate Square Bracket Use करना पडता है। जबकि Bracket Pairs की कुल संख्‍या द्वारा Array का Dimension या Rank तय होता है। जैसे:

        int[ ][ ] jagArr;

ये Statement तय करता है कि jagArr एक 2-Dimensioanl Array है। Jagged Array को भी हम Shortcut तरीके से Instantiate कर सकते हैं। जैसे:

        int[ ][ ] jagArr = new int[3][ ];

जब ये Statement Execute होगा, तो Memory में निम्नानुसार तरीके से एक Array Create होगा:

जब हम Jagged Array Create करते हैं, तो पहला Dimension हमेंशा Main Array होता है। जबकि सभी Sub-Arrays के References इसी Main Array में Element की तरह Store होते हैं। इसलिए Jagged Array के पहले Dimension का जो मान होता है, दूसरे Dimension का मान उसके बराबर या कम ही हो सकता है ज्यादा नहीं। जैसे:

        int[ ][ ] jagArr = new int[3][4];            //Wrong! Compiler Error

ये एक गलत Statement है, क्योंकि इस Statement में पहला Dimension अधिकतम 3 Sub-Array को Reference कर सकता है। जबकि दूसरे Dimension में हमने मान 4 Specify करके Compiler को इस बात का Instruction दिया है कि हम 4 Sub-Arrays को jagArr द्वारा Reference करना चाहते हैं।

Instantiating Jagged Array

Rectangle Array की तरह हम Jagged Array को पूरी तरह से Single Step में Initialize नहीं कर सकते। चूंकि Jagged Array कई Sub-Arrays का Independent Array होता है, इसलिए हर Sub-Array को Separately Create व Initialize करना जरूरी होता है। Jagged Array को Initialize करने के लिए हमें निम्न Steps Follow करने पडते हैं:

• Top Level Array को Initialize करना होता है।
• सभी Sub-Arrays को Separately Initialize करना होता है और फिर सभी Newly Created Arrays को Main Array में Appropriate Position पर Assign करना होता है।

उदाहरण के लिए यदि हमें 2-Dimensioanl Jagged Array को Initialize करना हो, जबकि पहले Dimension की Size 3 हो, तो हमारा Declaration कुछ निम्नानुसार हो सकता है:

        int[ ][ ] Arr = new int[3][ ];

इस Statement के Execute होने पर C# Compiler निम्नानुसार Memory Reserve करेगा:

फिर तीनों Sub-Array को हम निम्नानुसार तरीके से Declare करते हुए Main Array के तीनों Elements को Initialize कर सकते हैं:

        Arr[0] = new int[] {10, 20, 30};

        Arr[1] = new int[] {40, 50, 60, 70};

        Arr[2] = new int[] {80, 90, 100, 110, 120};

इन तीनों Statements के Execute होने पर निम्नानुसार तरीके से Memory Reserve होगा:

चूंकि Jagged Array के हर Element पर एक Independent Array होता है, इसलिए हर Independent Array एक Rectangular Array हो सकता है और हर Element पर Stored Array स्वयं एक Jagged Array अथवा Multi-Dimensional Array हो सकता है।