القائمة List في C#: Add وRemove وContains وFind وSort

List<T> مجموعة مرتّبة تكبر وتصغر كلما أضفت عناصر وحذفتها. تعيش في System.Collections.Generic، وتُفهرس مثل المصفوفة (list[0])، وهي الخيار الافتراضي لـ "مجموعة من الأشياء" في C#.

إنشاء قائمة وإضافة العناصر

يحدد معامل النوع بين علامتي الزاوية ما تحمله القائمة: List<string> وList<int> وList<Order>.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var cart = new List<string>();
        cart.Add("apples");
        cart.Add("bread");

        var names = new List<string> { "Ana", "Ben" };  // collection initializer
        names.Insert(0, "Zoe");                         // at position 0
        names.AddRange(new[] { "Chloe", "Dev" });        // several at once

        var fromArray = new List<int>(new[] { 3, 1, 2 });

        Console.WriteLine(cart.Count);
        Console.WriteLine(string.Join(", ", names));
        Console.WriteLine(names[1]);
        names[1] = "Ana B.";                             // replace by index
        Console.WriteLine(names[1]);
        Console.WriteLine(fromArray.Count);
    }
}

المخرجات:

2
Zoe, Ana, Ben, Chloe, Dev
Ana
Ana B.
3

Count خاصية لا دالة (تستخدم المصفوفات Length، وفي LINQ دالة Count()؛ أما مع القائمة فاستخدم الخاصية). تزيح Insert كل عنصر لاحق موضعًا واحدًا، فيكلّف الإدراج في مقدمة قائمة كبيرة وقتًا يتناسب مع حجمها. أما Add في النهاية فهي العملية الرخيصة.

حذف العناصر

هناك أربع طرق للحذف، بحسب ما تعرفه عن العنصر:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var scores = new List<int> { 40, 85, 62, 40, 91, 55 };

        bool removed = scores.Remove(40);          // first 40 only
        Console.WriteLine(removed + ": " + string.Join(", ", scores));

        Console.WriteLine(scores.Remove(100));     // not found, nothing happens

        scores.RemoveAt(0);                        // by index
        Console.WriteLine(string.Join(", ", scores));

        int count = scores.RemoveAll(s => s < 60); // every match
        Console.WriteLine(count + " removed: " + string.Join(", ", scores));

        try
        {
            scores.RemoveAt(10);
        }
        catch (ArgumentOutOfRangeException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name);
        }

        scores.Clear();
        Console.WriteLine(scores.Count);
    }
}

المخرجات:

True: 85, 62, 40, 91, 55
False
62, 40, 91, 55
2 removed: 62, 91
Caught ArgumentOutOfRangeException
0

تأخذ Remove قيمة ولا تحذف إلا أول تطابق. لحذف كل نسخ قيمة استخدم RemoveAll(s => s == 40). الفهرس الخاطئ في القائمة يرمي ArgumentOutOfRangeException (أما المصفوفة فترمي IndexOutOfRangeException)، في list[i] وفي RemoveAt(i) كليهما. وتحذف RemoveRange(index, count) كتلة.

Count مقابل Capacity

تحفظ القائمة عناصرها في مصفوفة داخلية. Capacity حجم تلك المصفوفة؛ وCount عدد الخانات المستخدمة. حين يبلغ Count قيمة Capacity تحجز Add التالية مصفوفة بضعف الحجم وتنسخ كل شيء إليها.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var list = new List<int>();
        Console.WriteLine("Count " + list.Count + ", Capacity " + list.Capacity);

        for (int i = 1; i <= 9; i++)
        {
            list.Add(i);
            Console.WriteLine("Count " + list.Count + ", Capacity " + list.Capacity);
        }

        var sized = new List<int>(1000); // preallocate when you know the size
        Console.WriteLine("Count " + sized.Count + ", Capacity " + sized.Capacity);
    }
}

المخرجات:

Count 0, Capacity 0
Count 1, Capacity 4
Count 2, Capacity 4
Count 3, Capacity 4
Count 4, Capacity 4
Count 5, Capacity 8
Count 6, Capacity 8
Count 7, Capacity 8
Count 8, Capacity 8
Count 9, Capacity 16
Count 0, Capacity 1000

المضاعفة تعني أن معظم استدعاءات Add مجرد كتابة في خانة فارغة. إن كنت تعرف تقريبًا عدد العناصر القادمة فمرّر العدد إلى المُنشئ لتتخطى النسخ الوسيطة. لاحظ أن new List<int>(1000) ما زال Count فيها 0: list[0] عليها ترمي استثناءً. السعة مساحة لا عناصر.

البحث: Contains وIndexOf وFind وExists

using System;
using System.Collections.Generic;

class Product
{
    public string Name;
    public decimal Price;
    public Product(string name, decimal price) { Name = name; Price = price; }
}

class Program
{
    static void Main()
    {
        var tags = new List<string> { "new", "sale", "gift" };
        Console.WriteLine(tags.Contains("sale"));
        Console.WriteLine(tags.IndexOf("gift"));
        Console.WriteLine(tags.IndexOf("used"));

        var products = new List<Product>
        {
            new Product("Mug", 8.50m),
            new Product("Lamp", 32.00m),
            new Product("Pen", 1.20m),
        };

        Product lamp = products.Find(p => p.Name == "Lamp");
        Console.WriteLine(lamp.Price);

        List<Product> cheap = products.FindAll(p => p.Price < 10m);
        Console.WriteLine(cheap.Count + " cheap items");

        Console.WriteLine(products.Exists(p => p.Price > 100m));
        Console.WriteLine(products.FindIndex(p => p.Name == "Pen"));

        Product missing = products.Find(p => p.Name == "Desk");
        Console.WriteLine(missing == null);

        // Contains compares references for a class without Equals:
        Console.WriteLine(products.Contains(new Product("Mug", 8.50m)));
    }
}

المخرجات:

True
2
-1
32.00
2 cheap items
False
2
True
False

تعيد Find أول تطابق أو القيمة الافتراضية للنوع (null للصنف) حين لا يطابق شيء، فافحص قبل استخدام النتيجة. يطبع السطر الأخير False لأن Contains تستخدم Equals، والصنف الذي لا يتجاوز Equals يقارن المراجع: Product جديد بالحقول نفسها كائن مختلف. ابحث بحسب خاصية بـ Exists أو Find بدلًا من ذلك، أو تجاوز Equals وGetHashCode في الصنف.

كل واحدة من هذه الدوال تمشي على القائمة من البداية، فكل استدعاء O(n). وللبحث المتكرر بمفتاح يجيب Dictionary في زمن ثابت.

فرز قائمة

تفرز Sort() في المكان بالترتيب الطبيعي للعناصر. مرّر تعبير lambda للمقارنة لتفرز بأي شيء آخر.

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

class Player
{
    public string Name;
    public int Score;
    public Player(string name, int score) { Name = name; Score = score; }
    public override string ToString() { return Name + " " + Score; }
}

class Program
{
    static void Main()
    {
        var numbers = new List<int> { 5, 2, 9, 1 };
        numbers.Sort();
        Console.WriteLine(string.Join(", ", numbers));

        numbers.Sort((a, b) => b.CompareTo(a)); // descending
        Console.WriteLine(string.Join(", ", numbers));

        var players = new List<Player>
        {
            new Player("Ana", 120),
            new Player("Ben", 95),
            new Player("Chloe", 150),
        };

        players.Sort((a, b) => a.Score.CompareTo(b.Score)); // by property
        Console.WriteLine(string.Join(", ", players));

        List<Player> byName = players.OrderByDescending(p => p.Name).ToList(); // new list
        Console.WriteLine(string.Join(", ", byName));
        Console.WriteLine(string.Join(", ", players)); // unchanged by OrderBy
    }
}

المخرجات:

1, 2, 5, 9
9, 5, 2, 1
Ben 95, Ana 120, Chloe 150
Chloe 150, Ben 95, Ana 120
Ben 95, Ana 120, Chloe 150

تعيد المقارنة رقمًا سالبًا حين يجب أن يأتي a أولًا، وموجبًا حين يجب أن يأتي b، وصفرًا عند التعادل؛ وCompareTo تنتج ذلك بالضبط. فرقان بين Sort وOrderBy في LINQ يهمّان عمليًا:

• تغيّر Sort القائمة؛ وتعيد OrderBy تسلسلًا جديدًا وتترك القائمة كما هي.
• Sort غير مستقرة: قد تتبادل العناصر المتساوية أماكنها. أما OrderBy فمستقرة، وتضيف ThenBy مفتاحًا ثانيًا: players.OrderBy(p => p.Score).ThenBy(p => p.Name).

استدعاء Sort() على قائمة من صنفك دون مقارنة يرمي InvalidOperationException، لأن القائمة لا تعرف كيف ترتّب العناصر. إما أن تمرّر مقارنة أو تنفّذ IComparable<T> في الصنف.

تعكس Reverse() في المكان. ولأن System.Linq تعرّف أيضًا توسيع Reverse، فإن list.Reverse() على List<T> تختار النسخة التي تعمل في المكان، والتي لا تعيد شيئًا.

المرور، والحذف أثناء المرور

تقرأ foreach كل عنصر بالترتيب. وتمنحك حلقة for الفهرس أيضًا. ما لا تستطيعه هو إضافة عناصر أو حذفها في منتصف foreach على القائمة نفسها:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var orders = new List<int> { 120, 15, 80, 5, 60 };

        try
        {
            foreach (int total in orders)
            {
                if (total < 20) orders.Remove(total);
            }
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name);
        }

        orders = new List<int> { 120, 15, 80, 5, 60 };

        // Fix 1: RemoveAll
        var a = new List<int>(orders);
        a.RemoveAll(t => t < 20);
        Console.WriteLine(string.Join(", ", a));

        // Fix 2: loop backwards, so removals do not shift items you have not seen
        var b = new List<int>(orders);
        for (int i = b.Count - 1; i >= 0; i--)
        {
            if (b[i] < 20) b.RemoveAt(i);
        }
        Console.WriteLine(string.Join(", ", b));
    }
}

المخرجات:

Caught InvalidOperationException
120, 80, 60
120, 80, 60

الاستثناء InvalidOperationException برسالة "Collection was modified; enumeration operation may not execute." حلقة for الأمامية لا ترمي، لكنها تتخطى بصمت العنصر الذي يلي كل عنصر تحذفه، لأن كل شيء يزاح فهرسًا واحدًا للخلف. المرور المعكوس يتجنّب ذلك. والحل الثالث المرور على نسخة: foreach (var t in orders.ToList()).

تغيير خاصية في عنصر داخل foreach (مثل order.Status = "sent") مقبول. أما إضافة العناصر أو حذفها فتكسر المعدِّد، وكذلك استبدال عنصر عبر المفهرس (orders[i] = 0).

التحويل بين القوائم والمصفوفات

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

class Program
{
    static void Main()
    {
        string[] cities = { "Oslo", "Lima", "Pune" };

        List<string> list = cities.ToList();       // or new List<string>(cities)
        list.Add("Kyiv");

        string[] back = list.ToArray();
        Console.WriteLine(back.Length);
        Console.WriteLine(cities.Length);           // the original array is unchanged

        List<int> lengths = list.ConvertAll(c => c.Length);
        Console.WriteLine(string.Join(", ", lengths));
        Console.WriteLine(string.Join(" / ", list));
    }
}

المخرجات:

4
3
4, 4, 4, 4
Oslo / Lima / Pune / Kyiv

الاتجاهان كلاهما ينسخ العناصر إلى تخزين جديد، فتغيير القائمة لاحقًا لا يؤثر في المصفوفة. ConvertAll هي نسخة القائمة الخاصة من Select(...).ToList() في LINQ. وطباعة قائمة بـ Console.WriteLine(list) تُظهر اسم النوع (System.Collections.Generic.List`1[System.String])؛ استخدم string.Join.

مرجع سريع

أخطاء شائعة

• الحذف داخل foreach. يرمي InvalidOperationException؛ استخدم RemoveAll أو حلقة for معكوسة.
• توقّع أن تحذف Remove(x) كل النسخ. تحذف الأولى؛ استخدم RemoveAll.
• استخدام Contains على كائنات بلا Equals. تقارن المراجع؛ ابحث بحسب خاصية بـ Exists.
• الفهرسة في قائمة أُنشئت بسعة. new List<int>(10) فارغة؛ أضف العناصر أولًا.
• افتراض أن Sort تبقي المتعادلات بترتيبها. لا تفعل؛ استخدم OrderBy حين يهمّ الترتيب بين المتساويات.
• إسناد قائمة لمشاركتها ثم التفاجؤ بالتغييرات. var copy = list; هي القائمة نفسها؛ وnew List<T>(list) نسخة.