المصفوفات في C#: التصريح وLength والفرز والمصفوفات ثنائية الأبعاد والمسنّنة

تحمل المصفوفة عددًا ثابتًا من العناصر من نوع واحد، مخزّنة متجاورة في الذاكرة. تختار الطول حين تنشئها، وتقرأ العناصر وتكتبها بفهرس يبدأ من الصفر، ولا يتغيّر الطول بعد ذلك أبدًا.

التصريح بمصفوفة وتهيئتها

نوع المصفوفة هو نوع العنصر متبوعًا بـ []. هناك عدة طرق لإنشاء واحدة:

using System;

class Program
{
    static void Main()
    {
        int[] scores = new int[4];                     // 4 elements, all 0
        string[] names = { "Ana", "Ben", "Chloe" };     // initializer
        double[] prices = new double[] { 2.5, 9.99 };   // explicit form
        var days = new[] { "Mon", "Tue", "Wed" };       // type inferred: string[]

        scores[0] = 90;
        scores[3] = 72;

        Console.WriteLine(string.Join(", ", scores));
        Console.WriteLine(names[1]);
        Console.WriteLine(prices.Length + " prices, " + days.Length + " days");
    }
}

المخرجات:

90, 0, 0, 72
Ben
2 prices, 3 days

تملأ new int[4] كل عنصر بالقيمة الافتراضية للنوع: 0 للأرقام، وfalse لـ bool، وnull للنصوص والأنواع المرجعية الأخرى. الشكل المختصر { "Ana", "Ben" } لا يعمل إلا في التصريح؛ وعند الإسناد إلى متغيّر موجود تحتاج إلى names = new[] { "Dev", "Eli" };.

Length والفهرسة والعنصر الأخير

تمتد الفهارس من 0 إلى Length - 1. Length خاصية، فلا أقواس لها (بخلاف الدالة Count() في LINQ).

using System;

class Program
{
    static void Main()
    {
        int[] temps = { 18, 21, 25, 19, 16 };

        Console.WriteLine("Count: " + temps.Length);
        Console.WriteLine("First: " + temps[0]);
        Console.WriteLine("Last: " + temps[temps.Length - 1]);

        try
        {
            Console.WriteLine(temps[5]);
        }
        catch (IndexOutOfRangeException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name);
        }
    }
}

المخرجات:

Count: 5
First: 18
Last: 16
Caught IndexOutOfRangeException

القراءة أو الكتابة خارج الحدود ترمي IndexOutOfRangeException وقت التشغيل؛ ولا يلتقطها المترجم. السبب المعتاد شرط حلقة مكتوب i <= arr.Length بدل i < arr.Length.

تضيف C# 8 وما بعدها صياغة الفهرس من النهاية والنطاق، وهي أقصر للعنصر الأخير وللشرائح:

int last = temps[^1];        // 16
int[] middle = temps[1..4];  // { 21, 25, 19 }, a new array

المرور على مصفوفة

تمنحك حلقة for الفهرس؛ وتمنحك foreach كل عنصر وهي الخيار الأوضح حين تقرأ فقط.

using System;

class Program
{
    static void Main()
    {
        decimal[] prices = { 4.50m, 12.00m, 3.25m };

        for (int i = 0; i < prices.Length; i++)
        {
            prices[i] = Math.Round(prices[i] * 1.10m, 2); // raise every price by 10%
        }

        decimal total = 0;
        foreach (decimal p in prices)
        {
            total += p;
        }

        Console.WriteLine(string.Join(" | ", prices));
        Console.WriteLine("Total: " + total);
    }
}

المخرجات:

4.95 | 13.20 | 3.58
Total: 21.73

متغيّر foreach للقراءة فقط: p = 0; داخل الحلقة خطأ ترجمة. لتغيير العناصر مرّ بفهرس.

الفرز والعكس والبحث

يحمل الصنف الساكن Array الدوال المساعدة. تفرز Array.Sort في المكان ولا تعيد شيئًا، فيضيع الترتيب الأصلي.

using System;

class Program
{
    static void Main()
    {
        int[] scores = { 72, 95, 60, 88, 79 };

        Array.Sort(scores);
        Console.WriteLine("Ascending:  " + string.Join(", ", scores));

        Array.Reverse(scores);
        Console.WriteLine("Descending: " + string.Join(", ", scores));

        Console.WriteLine("Index of 60: " + Array.IndexOf(scores, 60));
        Console.WriteLine("Index of 99: " + Array.IndexOf(scores, 99));
        Console.WriteLine("Any above 90: " + Array.Exists(scores, s => s > 90));
        Console.WriteLine("First below 75: " + Array.Find(scores, s => s < 75));

        string[] names = { "chloe", "Ana", "ben" };
        Array.Sort(names, StringComparer.OrdinalIgnoreCase);
        Console.WriteLine(string.Join(", ", names));

        string[] fruits = { "kiwi", "banana", "fig" };
        Array.Sort(fruits, (a, b) => a.Length.CompareTo(b.Length)); // by length
        Console.WriteLine(string.Join(", ", fruits));
    }
}

المخرجات:

Ascending:  60, 72, 79, 88, 95
Descending: 95, 88, 79, 72, 60
Index of 60: 4
Index of 99: -1
Any above 90: True
First below 75: 72
Ana, ben, chloe
fig, kiwi, banana

تعيد Array.IndexOf القيمة -1 حين تكون القيمة غائبة. وتعيد Array.Find القيمة الافتراضية للنوع (0 هنا) حين لا يطابق شيء، وهذا ملتبس مع الأرقام؛ استخدم Array.FindIndex حين يهمّ ذلك. والفرز التنازلي في استدعاء واحد هو Array.Sort(scores, (a, b) => b.CompareTo(a)).

إن احتجت إلى النتيجة المفروزة دون المساس بالأصل، يعيد LINQ مصفوفة جديدة: var sorted = scores.OrderBy(s => s).ToArray();. راجع LINQ.

تغيير الحجم: المصفوفة لا تكبر

الطول ثابت. تنشئ Array.Resize مصفوفة جديدة بالحجم المطلوب، وتنسخ العناصر، وتحدّث المتغيّر الذي تمرّره بـ ref.

using System;

class Program
{
    static void Main()
    {
        string[] queue = { "Ana", "Ben" };
        string[] before = queue;

        Array.Resize(ref queue, 4);
        queue[2] = "Chloe";

        Console.WriteLine(queue.Length);
        Console.WriteLine(before.Length);             // the old array is unchanged
        Console.WriteLine(queue[3] == null);          // new slots get the default
        Console.WriteLine(ReferenceEquals(before, queue));
    }
}

المخرجات:

4
2
True
False

كل تغيير حجم ينسخ كل العناصر. تكبير مصفوفة عنصرًا عنصرًا في حلقة بطيء، وهو بالضبط ما تفعله List<T> عنك بكفاءة أكبر، بمضاعفة مصفوفتها الداخلية.

المصفوفات أنواع مرجعية: النسخ

إسناد مصفوفة إلى متغيّر آخر ينسخ المرجع لا العناصر. فيشير الاسمان إلى المصفوفة نفسها.

using System;

class Program
{
    static void Main()
    {
        int[] original = { 1, 2, 3 };

        int[] alias = original;
        alias[0] = 100;
        Console.WriteLine(original[0]); // 100: same array

        int[] copy = (int[])original.Clone();
        copy[1] = 200;
        Console.WriteLine(original[1]); // 2: independent array

        int[] target = new int[5];
        Array.Copy(original, 0, target, 1, 3); // source, start, dest, start, count
        Console.WriteLine(string.Join(", ", target));
    }
}

المخرجات:

100
2
0, 100, 2, 3, 0

وينطبق الأمر نفسه حين تمرّر مصفوفة إلى دالة: تستطيع الدالة تغيير عناصر المستدعي. تصنع Clone وArray.Copy وCopyTo وToArray() في LINQ كلها نسخة سطحية. وفي مصفوفة الكائنات تحمل المصفوفة الجديدة مراجع إلى الكائنات نفسها، فتغيير copy[0].Name ما زال يغيّر ما تراه original[0].

مقارنة المصفوفات بـ == تقارن المراجع. لمقارنة المحتوى استخدم a.SequenceEqual(b) من System.Linq.

المصفوفات ثنائية الأبعاد (متعددة الأبعاد)

تُصرَّح الشبكة المستطيلة بفاصلة داخل القوسين. وتُفهرس بالشكل [row, col].

using System;

class Program
{
    static void Main()
    {
        int[,] seats = new int[2, 3]; // 2 rows, 3 columns
        seats[0, 1] = 1;
        seats[1, 2] = 1;

        int[,] grid =
        {
            { 1, 2, 3 },
            { 4, 5, 6 },
        };

        Console.WriteLine("Rows: " + grid.GetLength(0));
        Console.WriteLine("Cols: " + grid.GetLength(1));
        Console.WriteLine("Length: " + grid.Length + ", Rank: " + grid.Rank);

        for (int r = 0; r < seats.GetLength(0); r++)
        {
            for (int c = 0; c < seats.GetLength(1); c++)
            {
                Console.Write(seats[r, c] == 1 ? "X " : ". ");
            }
            Console.WriteLine();
        }
    }
}

المخرجات:

Rows: 2
Cols: 3
Length: 6, Rank: 2
. X . 
. . X 

Length في المصفوفة ثنائية الأبعاد العدد الكلي للعناصر (6 لشبكة 2 في 3)، ولهذا تستخدم الحلقات المتداخلة GetLength(0) وGetLength(1). وRank عدد الأبعاد. وتعمل الأبعاد الثلاثة بالطريقة نفسها: new int[4, 4, 4] وcube[x, y, z]. وتزور foreach على مصفوفة ثنائية الأبعاد كل عنصر صفًا بعد صف.

المصفوفات المسنّنة (مصفوفات من المصفوفات)

المصفوفة المسنّنة (jagged) int[][] مصفوفة عناصرها مصفوفات، ويمكن أن يكون لكل مصفوفة داخلية طولها الخاص. تناسب بيانات مثل "الطلبات لكل عميل" حيث تختلف الصفوف في الحجم.

using System;

class Program
{
    static void Main()
    {
        int[][] orders = new int[3][]; // 3 rows, none created yet
        orders[0] = new[] { 20, 35 };
        orders[1] = new[] { 12 };
        orders[2] = new[] { 8, 15, 40, 22 };

        for (int i = 0; i < orders.Length; i++)
        {
            Console.WriteLine("Customer " + i + ": " + orders[i].Length
                + " orders, " + string.Join(", ", orders[i]));
        }

        int[][] empty = new int[2][];
        Console.WriteLine(empty[0] == null);
    }
}

المخرجات:

Customer 0: 2 orders, 20, 35
Customer 1: 1 orders, 12
Customer 2: 4 orders, 8, 15, 40, 22
True

تنشئ new int[3][] المصفوفة الخارجية فقط؛ ويبدأ كل صف null، وorders[0][0] قبل إسناد صف ترمي NullReferenceException. الصياغة new int[3][4] غير مسموحة؛ تنشئ كل صف بنفسك.

استخدم [,] لشبكة حقيقية (لوحة، مصفوفة رياضية، بكسلات) و[][] حين تختلف أطوال الصفوف أو تريد تبديل صفوف كاملة.

المصفوفة مقابل List

التحويل استدعاء واحد في الاتجاهين: new List<int>(arr) أو arr.ToList()، وlist.ToArray(). List<T> هي النسخة القابلة للنمو.

أخطاء شائعة

• i <= arr.Length في حلقة. آخر فهرس صالح هو Length - 1؛ وهذا يرمي IndexOutOfRangeException.
• طباعة المصفوفة مباشرة. تطبع Console.WriteLine(arr) القيمة System.Int32[]؛ استخدم string.Join.
• توقّع أن تعيد Array.Sort المصفوفة المفروزة. تعيد void وتفرز في المكان.
• النسخ بـ =. هذا ينسخ المرجع؛ استخدم Clone() أو ToArray().
• استخدام صفوف المصفوفة المسنّنة قبل إنشائها. كل صف في new T[n][] يكون null حتى يُسند إليه.
• استخدام Length لصفوف مصفوفة ثنائية الأبعاد. تعدّ كل العناصر؛ استخدم GetLength(0).