C# Language
Arrays

वाक्य - विन्यास

• एक ऐलान की घोषणा:

  <प्रकार> [] <नाम>;

• दो आयामी सरणी की घोषणा:

  <प्रकार> [,] <नाम> = नया <प्रकार> [<मूल्य>, <मूल्य>];

• एक घोषित ऐरे की घोषणा:

  <प्रकार> [] <नाम> = नया <प्रकार> [<मूल्य>];

• घोषित एरे के लिए एक उपप्रकार की घोषणा:

  <नाम> [<मूल्य>] = नया <प्रकार> [<मूल्य>];

• मानों के बिना एक सरणी आरम्भ करना:

  <नाम> = नया <प्रकार> [<लंबाई>];

• मान के साथ एक सरणी आरम्भ करना:

  <name> = new <type> [] {<value>, <value>, <value>, ...};

• मूल्यों के साथ एक दो आयामी सरणी की शुरुआत:

  <name> = new <type> [,] {{<value>, <value>}, {<value>, <value>}, ...};

• सूचकांक I पर एक तत्व तक पहुँचना:

  <Name> [i]

• सरणी की लंबाई प्राप्त करना:

  <Name> .Length

टिप्पणियों

ऐरे कोवरियन

string[] strings = new[] {"foo", "bar"};
object[] objects = strings; // implicit conversion from string[] to object[]

यह रूपांतरण प्रकार-सुरक्षित नहीं है। निम्न कोड रनटाइम अपवाद को बढ़ाएगा:

string[] strings = new[] {"Foo"};
object[] objects = strings;

objects[0] = new object(); // runtime exception, object is not string
string str = strings[0];   // would have been bad if above assignment had succeeded

सरणी मान प्राप्त करना और सेट करना

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

// Get 
Console.WriteLine(arr[2]); // 20

// Set 
arr[2] = 100;

// Get the updated value
Console.WriteLine(arr[2]); // 100

एक ऐलान की घोषणा

एक वर्ग घोषित किया जा सकता है और चौकोर ब्रैकेट ( [] ) आरंभीकरण सिंटैक्स का उपयोग करके डिफ़ॉल्ट मान से भरा जा सकता है। उदाहरण के लिए, 10 पूर्णांकों की एक सरणी बनाना:

int[] arr = new int[10];

C # में संकेत शून्य-आधारित हैं। उपरोक्त सरणी के सूचक 0-9 होंगे। उदाहरण के लिए:

int[] arr = new int[3] {7,9,4};
Console.WriteLine(arr[0]); //outputs 7
Console.WriteLine(arr[1]); //outputs 9

जिसका अर्थ है कि सिस्टम तत्व सूचकांक को 0. से गिनना शुरू कर देता है। इसके अलावा, सरणियों के तत्वों तक पहुंच निरंतर समय में की जाती है । अर्थात सरणी के पहले तत्व तक पहुँचने के लिए दूसरे तत्व, तीसरे तत्व और इतने पर पहुँचने की समान लागत (समय में) होती है।

आप किसी सरणी को बिना इंस्टेंट किए एक सरणी के लिए एक नंगे संदर्भ की घोषणा कर सकते हैं।

int[] arr = null;   // OK, declares a null reference to an array.
int first = arr[0]; // Throws System.NullReferenceException because there is no actual array.

संग्रह आरंभीकरण सिंटैक्स का उपयोग करके कस्टम मानों के साथ एक सरणी भी बनाई और आरंभ की जा सकती है:

int[] arr = new int[] { 24, 2, 13, 47, 45 };

सरणी चर की घोषणा करते समय new int[] भाग छोड़ा जा सकता है। यह एक स्व-निहित अभिव्यक्ति नहीं है , इसलिए एक अलग कॉल के हिस्से के रूप में इसका उपयोग करना काम नहीं करता है (इसके लिए, new साथ संस्करण का उपयोग करें):

int[] arr = { 24, 2, 13, 47, 45 };  // OK
int[] arr1;
arr1 = { 24, 2, 13, 47, 45 };       // Won't compile

अवैध रूप से टाइप किए गए सरणियाँ

वैकल्पिक रूप से, var कीवर्ड के साथ संयोजन में, विशिष्ट प्रकार को छोड़ा जा सकता है ताकि सरणी का प्रकार अनुमानित हो:

// same as int[]
var arr = new [] { 1, 2, 3 };
// same as string[]
var arr = new [] { "one", "two", "three" };
// same as double[]
var arr = new [] { 1.0, 2.0, 3.0 };

एक सरणी पर Iterate करें

int[] arr = new int[] {1, 6, 3, 3, 9};

for (int i = 0; i < arr.Length; i++) 
{
    Console.WriteLine(arr[i]);
}

फोरच का उपयोग करना:

foreach (int element in arr) 
{
    Console.WriteLine(element);
}

बिंदुओं के साथ असुरक्षित पहुंच का उपयोग करना https://msdn.microsoft.com/en-ca/library/y31yhkeb.aspx

unsafe
{
    int length = arr.Length;
    fixed (int* p = arr)
    {
        int* pInt = p;
        while (length-- > 0)
        {
            Console.WriteLine(*pInt);
            pInt++;// move pointer to next element
        }
    }
}

आउटपुट:

1
6
3
3
9

बहुआयामी सरणियाँ

Arrays में एक से अधिक आयाम हो सकते हैं। निम्नलिखित उदाहरण दस पंक्तियों और दस स्तंभों के दो आयामी सरणी बनाता है:

int[,] arr = new int[10, 10];

तीन आयामों की एक सरणी:

int[,,] arr = new int[10, 10, 10];

आप घोषणा पर सरणी को इनिशियलाइज़ भी कर सकते हैं:

int[,] arr = new int[4, 2] { {1, 1}, {2, 2}, {3, 3}, {4, 4} };

// Access a member of the multi-dimensional array:
Console.Out.WriteLine(arr[3, 1]);  // 4

दांतेदार गिरफ्तारी

दांतेदार सरणियाँ ऐसी सरणियाँ हैं जो आदिम प्रकारों के बजाय, सरणियाँ (या अन्य संग्रह) शामिल करती हैं। यह सरणी के एक सरणी की तरह है - प्रत्येक सरणी तत्व में एक और सरणी होती है।

वे बहुआयामी सरणियों के समान हैं, लेकिन इसमें थोड़ा अंतर है - चूंकि बहुआयामी सरणियाँ एक निश्चित संख्या में पंक्तियों और स्तंभों तक सीमित होती हैं, दांतेदार सरणियों के साथ, हर पंक्ति में एक अलग संख्या में स्तंभ हो सकते हैं।

एक दांतेदार सरणी की घोषणा

उदाहरण के लिए, 8 कॉलम के साथ दांतेदार ऐरे को घोषित करना:

int[][] a = new int[8][];

दूसरी [] संख्या के बिना आरंभिक है। उप सरणियों को शुरू करने के लिए, आपको अलग से ऐसा करने की आवश्यकता होगी:

for (int i = 0; i < a.length; i++) 
{
    a[i] = new int[10];
}

मान प्राप्त करना / स्थापित करना

अब, सबरेज़ में से एक प्राप्त करना आसान है। आइये a : के ३ कॉलम के सभी नंबरों को प्रिंट करते हैं।

for (int i = 0; i < a[2].length; i++)
{
    Console.WriteLine(a[2][i]);
}

एक विशिष्ट मूल्य प्राप्त करना:

a[<row_number>][<column_number>]

एक विशिष्ट मूल्य निर्धारित करना:

a[<row_number>][<column_number>] = <value>

याद रखें : यह हमेशा बहुआयामी सरणियों (मैट्रिक्स) के बजाय दांतेदार सरणियों (सरणियों के सरणियों) का उपयोग करने की सिफारिश की जाती है। यह तेज़ और उपयोग करने के लिए सुरक्षित है।

कोष्ठक के क्रम पर ध्यान दें

int के एक-आयामी सरणियों के पांच आयामी सरणियों के तीन आयामी सरणी पर विचार करें। यह C # के रूप में लिखा गया है:

int[,,][,,,,][] arr = new int[8, 10, 12][,,,,][];

सीएलआर प्रकार प्रणाली में, कोष्ठक के क्रम के लिए सम्मेलन उलटा होता है, इसलिए उपरोक्त arr उदाहरण के साथ हमारे पास है:

    arr.GetType().ToString() == "System.Int32[][,,,,][,,]"

और इसी तरह:

    typeof(int[,,][,,,,][]).ToString() == "System.Int32[][,,,,][,,]"

जाँच कर रहा है कि एक सरणी में दूसरा सरणी है या नहीं

public static class ArrayHelpers
{
    public static bool Contains<T>(this T[] array, T[] candidate)
    {
        if (IsEmptyLocate(array, candidate))
            return false;

        if (candidate.Length > array.Length)
            return false;

        for (int a = 0; a <= array.Length - candidate.Length; a++)
        {
            if (array[a].Equals(candidate[0]))
            {
                int i = 0;
                for (; i < candidate.Length; i++)
                {
                    if (false == array[a + i].Equals(candidate[i]))
                        break;
                }
                if (i == candidate.Length)
                    return true;
            }
        }
        return false;
    }

    static bool IsEmptyLocate<T>(T[] array, T[] candidate)
    {
        return array == null
            || candidate == null
            || array.Length == 0
            || candidate.Length == 0
            || candidate.Length > array.Length;
    }
}

/// नमूना

byte[] EndOfStream = Encoding.ASCII.GetBytes("---3141592---");
byte[] FakeReceivedFromStream = Encoding.ASCII.GetBytes("Hello, world!!!---3141592---");
if (FakeReceivedFromStream.Contains(EndOfStream))
{
    Console.WriteLine("Message received");
}

एक सरणी को बार-बार गैर-डिफ़ॉल्ट मान से भरना

जैसा कि हम जानते हैं कि हम डिफ़ॉल्ट मान के साथ एक सरणी घोषित कर सकते हैं:

int[] arr = new int[10];

इस सरणी होने मूल्य के प्रत्येक तत्व के साथ 10 पूर्णांकों की एक सरणी पैदा करेगा 0 (प्रकार का डिफ़ॉल्ट मान int )।

एक गैर-डिफ़ॉल्ट मान के साथ आरंभीकृत सरणी बनाने के लिए, हम Enumerable.Repeat उपयोग System.Linq Enumerable.Repeat से कर सकते हैं:

1. "सच" से भरे आकार 10 का एक bool सरणी बनाने के लिए

   bool[] booleanArray = Enumerable.Repeat(true, 10).ToArray(); 
   

2. "100" से भरे आकार 5 का एक int सरणी बनाने के लिए

   int[] intArray = Enumerable.Repeat(100, 5).ToArray();
   

3. "C #" से भरे आकार 5 का एक string एरे बनाने के लिए

   string[] strArray = Enumerable.Repeat("C#", 5).ToArray();
   

प्रतिलिपि बनाना

स्थैतिक Array.Copy() विधि के साथ एक आंशिक सरणी को कॉपी करना, दोनों, स्रोत और गंतव्य में इंडेक्स 0 पर शुरुआत:

var sourceArray = new int[] { 11, 12, 3, 5, 2, 9, 28, 17 };
var destinationArray= new int[3];
Array.Copy(sourceArray, destinationArray, 3);

// destinationArray will have 11,12 and 3

स्रोत के इंडेक्स 0 और गंतव्य में निर्दिष्ट इंडेक्स की शुरुआत से CopyTo() इंस्टेंस विधि के साथ पूरे एरे को कॉपी करना:

var sourceArray = new int[] { 11, 12, 7 };
var destinationArray = new int[6];
sourceArray.CopyTo(destinationArray, 2);

// destinationArray will have 0, 0, 11, 12, 7 and 0

किसी सरणी ऑब्जेक्ट की प्रतिलिपि बनाने के लिए Clone का उपयोग किया जाता है।

var sourceArray = new int[] { 11, 12, 7 };
var destinationArray = (int)sourceArray.Clone();

//destinationArray will be created and will have 11,12,17.

CopyTo और Clone दोनों उथली प्रतिलिपि का प्रदर्शन करते हैं, जिसका अर्थ है कि सामग्री में मूल सरणी में तत्वों के समान ऑब्जेक्ट के संदर्भ हैं।

अनुक्रमिक संख्याओं की एक सरणी बनाना

LINQ एक विधि प्रदान करता है जिससे अनुक्रमिक संख्याओं से भरा संग्रह बनाना आसान हो जाता है। उदाहरण के लिए, आप एक ऐरे की घोषणा कर सकते हैं जिसमें 1 और 100 के बीच पूर्णांक होते हैं।

Enumerable.Range विधि हमें निर्दिष्ट प्रारंभ स्थिति और तत्वों की संख्या से पूर्णांक संख्याओं का अनुक्रम बनाने की अनुमति देती है।

विधि दो तर्क लेती है: प्रारंभिक मूल्य और उत्पन्न करने के लिए तत्वों की संख्या।

Enumerable.Range(int start, int count)

ध्यान दें कि count नकारात्मक नहीं हो सकती।

उपयोग:

int[] sequence = Enumerable.Range(1, 100).ToArray();

यह 100 ( [1, 2, 3, ..., 98, 99, 100] ) के माध्यम से 1 से युक्त एक सरणी उत्पन्न करेगा।

क्योंकि Range विधि एक IEnumerable<int> , हम उस पर अन्य LINQ विधियों का उपयोग कर सकते हैं:

int[] squares = Enumerable.Range(2, 10).Select(x => x * x).ToArray();

यह एक ऐसा सरणी उत्पन्न करेगा जिसमें 4 : [4, 9, 16, ..., 100, 121] पर शुरू होने वाले 10 पूर्णांक वर्ग शामिल हैं।

समानता के लिए सरणियों की तुलना करना

LINQ दो IEnumerable s की समानता की जाँच के लिए एक अंतर्निहित फ़ंक्शन प्रदान करता है, और उस फ़ंक्शन का उपयोग सरणियों पर किया जा सकता है।

SequenceEqual फ़ंक्शन true लौटेगा यदि सरणियों की लंबाई समान है और संबंधित सूचकांकों में मान समान हैं, और अन्यथा false हैं।

int[] arr1 = { 3, 5, 7 };
int[] arr2 = { 3, 5, 7 };
bool result = arr1.SequenceEqual(arr2);
Console.WriteLine("Arrays equal? {0}", result);

यह प्रिंट करेगा:

Arrays equal? True

IEnumerable <> उदाहरणों के रूप में आता है

सभी सरणियाँ गैर-जेनेरिक IList इंटरफ़ेस (और इसलिए गैर-जेनेरिक ICollection और IEnumerable आधार इंटरफेस) को लागू करती हैं।

इससे भी महत्वपूर्ण बात, एक आयामी सरणियों IList<> और IReadOnlyList<> जेनेरिक इंटरफेस (और उनके आधार इंटरफेस) को उस डेटा के प्रकार के लिए लागू करते हैं, जिसमें वे होते हैं। इसका मतलब यह है कि उन्हें जेनेरिक एनेमरेबल प्रकार के रूप में माना जा सकता है और पहले बिना गैर-सरणी रूप में परिवर्तित करने की आवश्यकता के बिना कई तरीकों से पारित किया गया।

int[] arr1 = { 3, 5, 7 };
IEnumerable<int> enumerableIntegers = arr1; //Allowed because arrays implement IEnumerable<T>
List<int> listOfIntegers = new List<int>();
listOfIntegers.AddRange(arr1); //You can pass in a reference to an array to populate a List.

इस कोड को चलाने के बाद, सूची listOfIntegers 3, 5, और 7 मान वाली एक List<int> होगी।

IEnumerable<> समर्थन का अर्थ है सरणियों को LINQ के साथ arr1.Select(i => 10 * i) किया जा सकता है, उदाहरण के लिए arr1.Select(i => 10 * i) ।