حلقة foreach في C#: المصفوفات وList وDictionary والفهرس والأخطاء

تنفّذ foreach جسمها مرة لكل عنصر في مجموعة، بالترتيب، دون فهرس تديره:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        string[] players = { "Ava", "Noah", "Mia" };
        foreach (string player in players)
        {
            Console.WriteLine($"Welcome, {player}");
        }

        var scores = new List<int> { 72, 88, 95 };
        int total = 0;
        foreach (int score in scores)
        {
            total += score;
        }
        Console.WriteLine($"Total: {total}");

        foreach (char c in "C#7")
        {
            Console.Write($"[{c}]");
        }
        Console.WriteLine();
    }
}

المخرجات:

Welcome, Ava
Welcome, Noah
Welcome, Mia
Total: 255
[C][#][7]

تعمل الحلقة بالطريقة نفسها على مصفوفة، وList<T>، ونص (نوع العنصر char)، وHashSet<T>، واستعلام LINQ، وأي تسلسل آخر. يمكن أن يكون النوع المصرّح به var، وهذا شائع حين يكون نوع العنصر طويلًا: foreach (var order in pendingOrders).

ماذا تفعل foreach خلف الكواليس

تطلب foreach من المجموعة معدِّدًا (enumerator) وتمشي عليه. في List<int> يحوّل المترجم الحلقة تقريبًا إلى هذا:

List<int>.Enumerator e = scores.GetEnumerator();
try
{
    while (e.MoveNext())
    {
        int score = e.Current;
        // loop body
    }
}
finally
{
    e.Dispose();
}

تنتج عن ذلك ثلاث نتائج. يعمل أي نوع له دالة GetEnumerator() عامة، وتأتي عادة من تنفيذ IEnumerable<T>. ويُتخلّص من المعدِّد حتى حين يرمي الجسم استثناءً أو يُنفّذ break. ومتغيّر العنصر نسخة جديدة من e.Current في كل مرور، ولهذا لا يستطيع الإسناد إليه تغيير المجموعة.

النوع الذي لا يملك GetEnumerator لا يمكن استخدامه:

error CS1579: foreach statement cannot operate on variables of type 'Order' because 'Order' does not contain a public instance or extension definition for 'GetEnumerator'

نفّذ IEnumerable<T> على النوع، أو مرّ على المجموعة التي يحتويها (order.Lines بدل order). يمكنك كتابة تسلسلاتك الخاصة بـ yield return، وهي مشروحة في صفحة IEnumerable وyield.

المرور على قاموس

عناصر القاموس قيم KeyValuePair<TKey, TValue> لها الخاصيتان Key وValue:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var stock = new Dictionary<string, int>
        {
            ["apples"] = 12,
            ["pears"] = 0,
            ["kiwis"] = 30,
        };

        foreach (KeyValuePair<string, int> item in stock)
        {
            Console.WriteLine($"{item.Key}: {item.Value}");
        }

        foreach (string fruit in stock.Keys)
        {
            Console.Write($"<{fruit}>");
        }
        Console.WriteLine();

        Console.WriteLine($"Units in stock: {stock.Values.Sum()}");

        foreach (var item in stock.OrderByDescending(p => p.Value))
        {
            Console.WriteLine($"{item.Value,3} {item.Key}");
        }
    }
}

المخرجات:

apples: 12
pears: 0
kiwis: 30
<apples><pears><kiwis>
Units in stock: 42
 30 kiwis
 12 apples
  0 pears

لا يعد Dictionary بأي ترتيب تعداد. عمليًا يتبع ترتيب الإدراج حتى تحذف مدخلات، لكن الشيفرة التي تعتمد على الترتيب يجب أن ترتّب صراحة، كما تفعل الحلقة الأخيرة بـ OrderByDescending، أو تستخدم SortedDictionary.

في .NET Core 2.0 وما بعده (وكل .NET حديثة) لـ KeyValuePair دالة Deconstruct، فيمكن تقسيم الزوج إلى متغيّرين مباشرة في ترويسة الحلقة:

// modern .NET: KeyValuePair deconstruction
foreach (var (fruit, count) in stock)
{
    Console.WriteLine($"{fruit}: {count}");
}

هذا الشكل الأقصر وهو الذي ستراه في الشيفرة الحالية. لا يُترجم على .NET Framework، حيث لا توجد Deconstruct في KeyValuePair؛ استخدم item.Key وitem.Value هناك.

الحصول على الفهرس

ليس لـ foreach فهرس خاص بها. الطريقتان المعتادتان للحصول على واحد: عدّاد تديره بنفسك، أو شكل Select في LINQ الذي يمرّر الفهرس مع كل عنصر:

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        string[] podium = { "Kenji", "Sofia", "Omar" };

        int place = 1;
        foreach (string name in podium)
        {
            Console.WriteLine($"{place}. {name}");
            place++;
        }

        foreach (var entry in podium.Select((name, index) => new { name, index }))
        {
            Console.WriteLine($"index {entry.index}: {entry.name}");
        }
    }
}

المخرجات:

1. Kenji
2. Sofia
3. Omar
index 0: Kenji
index 1: Sofia
index 2: Omar

العدّاد هو الأرخص والأوضح. إن وجدت نفسك تستخدم الفهرس لقراءة podium[i - 1] أو لكتابة podium[i] = ... فانتقل إلى حلقة for، المصمّمة لهذا بالضبط.

متغيّر الحلقة للقراءة فقط

لا يمكنك الإسناد إلى متغيّر التكرار:

foreach (string name in names)
{
    name = name.Trim();
    // error CS1656: Cannot assign to 'name' because it is a 'foreach iteration variable'
}

حتى لو سُمح بذلك فلن يغيّر سوى نسخة محلية. لتحويل كل عنصر ابنِ تسلسلًا جديدًا (names.Select(n => n.Trim()).ToArray()) أو استخدم حلقة for تكتب names[i] = names[i].Trim().

ما يمكنك فعله يعتمد على كون العنصر صنفًا أو بنية. في الصنف يحمل المتغيّر مرجعًا، فتغيير خاصية يغيّر الكائن في المجموعة:

using System;
using System.Collections.Generic;

class Order
{
    public int Id;
    public string Status;
}

class Program
{
    static void Main()
    {
        var orders = new List<Order>
        {
            new Order { Id = 1, Status = "paid" },
            new Order { Id = 2, Status = "paid" },
        };

        foreach (Order order in orders)
        {
            order.Status = "shipped";
        }

        foreach (Order order in orders)
        {
            Console.WriteLine($"Order {order.Id}: {order.Status}");
        }
    }
}

المخرجات:

Order 1: shipped
Order 2: shipped

لو كان Order بنية struct لفشل الإسناد نفسه بالخطأ CS1654 (Cannot modify members of 'order' because it is a 'foreach iteration variable')، لأن المتغيّر نسخة من القيمة لا مرجع إليها.

تعديل المجموعة: InvalidOperationException

إضافة عناصر إلى List أو Dictionary أو حذفها بينما تمشي عليها foreach تكسر المعدِّد. ترمي MoveNext التالية InvalidOperationException برسالة "Collection was modified; enumeration operation may not execute.":

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var cart = new List<string> { "milk", "expired yogurt", "bread", "expired ham" };

        try
        {
            foreach (string item in cart)
            {
                if (item.StartsWith("expired"))
                    cart.Remove(item);
            }
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine($"{e.GetType().Name}: collection was modified");
        }

        cart = new List<string> { "milk", "expired yogurt", "bread", "expired ham" };

        // Fix 1: loop over a copy
        foreach (string item in cart.ToList())
        {
            if (item.StartsWith("expired"))
                cart.Remove(item);
        }
        Console.WriteLine(string.Join(", ", cart));

        // Fix 2: let the collection do it
        var cart2 = new List<string> { "milk", "expired yogurt", "bread" };
        cart2.RemoveAll(item => item.StartsWith("expired"));
        Console.WriteLine(string.Join(", ", cart2));
    }
}

المخرجات:

InvalidOperationException: collection was modified
milk, bread
milk, bread

الحلول، من الأبسط إلى الأكثر مرونة:

• RemoveAll(predicate) على List<T> تحذف كل تطابق في مرور واحد.
• المرور على نسخة بـ ToList() أو ToArray()، ثم تعديل الأصل بحرية.
• الجمع أولًا ثم التطبيق: اجمع المفاتيح المراد حذفها في قائمة منفصلة أثناء الحلقة، ثم احذفها بعدها. هذا هو النمط المعتاد مع Dictionary.
• حلقة for معكوسة مع RemoveAt(i).

لـ Dictionary استثناء واحد يستحق المعرفة. منذ .NET Core 3.0 لم يعد استبدال قيمة مفتاح موجود (stock[key] = 0) أو حذف المدخلات أثناء foreach عليه يرمي استثناءً، بينما تظل إضافة مفتاح جديد ترمي. في .NET Framework ترمي الثلاثة كلها، فجمع المفاتيح أولًا هو الشكل الذي يعمل في كل مكان.

break وcontinue والمجموعات الفارغة null

تتصرف break وcontinue كما في كل حلقة أخرى:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] readings = { 21, -1, 23, 999, 22 };

        foreach (int r in readings)
        {
            if (r < 0) continue;          // skip sensor errors
            if (r == 999) break;          // end-of-data marker
            Console.WriteLine($"reading {r}");
        }

        List<string> tags = null;
        foreach (string tag in tags ?? Enumerable.Empty<string>())
        {
            Console.WriteLine(tag);
        }
        Console.WriteLine("no tags, no crash");
    }
}

المخرجات:

reading 21
reading 23
no tags, no crash

المرور على مجموعة null يرمي NullReferenceException حين تُستدعى GetEnumerator. تحوّل ?? Enumerable.Empty<T>() تسلسلًا قد يكون null إلى تسلسل فارغ؛ والأفضل من ذلك أن تعيد دوالك مجموعات فارغة بدل null.

foreach مقابل List.ForEach

لـ List<T> دالة ForEach(Action<T>): names.ForEach(n => Console.WriteLine(n));. ليست مثل الحلقة. جسمها تعبير lambda، فلا تتوفر break ولا continue ولا yield، ولا تنهي return إلا استدعاء العنصر الحالي. وهي موجودة على List<T> فقط، لا على المصفوفات أو التسلسلات الأخرى. فضّل جملة foreach؛ واستخدم ForEach فقط لفعل في سطر واحد لديك أصلًا كدالة.