Çalıştırılabilir C# Dokümanları: List

Q: C#'ta bir List'e nasıl öğe eklenir?

list.Add(item) sona bir öğe ekler, list.AddRange(otherCollection) birçok öğe ekler ve list.Insert(index, item) bir öğeyi bir konuma koyup geri kalanları kaydırır. Bir listeyi oluştururken de doldurabilirsiniz: var names = new List { "Ana", "Ben" };.

Q: C#'ta bir List'ten öğe nasıl silinir?

Remove(value) ilk eşleşen öğeyi siler ve bir tane bulduysa true döndürür. RemoveAt(index) konuma göre siler. RemoveAll(x => condition) eşleşen her öğeyi siler ve kaç tane sildiğini döndürür. Clear() listeyi boşaltır.

Q: C#'ta bir List'in bir değer içerip içermediği nasıl kontrol edilir?

list.Contains(value) true ya da false döndürür. Equals ile karşılaştırır, bu yüzden kendi sınıflarınız için sınıf Equals'ı override etmedikçe referansları karşılaştırır. Bir property'ye göre kontrol etmek için list.Exists(p => p.Name == "Ana") ya da LINQ'in list.Any(...)'ini kullanın.

Q: C#'ta bir List bir property'ye göre nasıl sıralanır?

Sort'a bir karşılaştırma verin: people.Sort((a, b) => a.Age.CompareTo(b.Age)) yerinde sıralar. Azalan sıra için a ile b'nin yerini değiştirin. Ya da yeni bir sıralı dizi döndüren ve eşit öğeleri orijinal sıralarında tutan LINQ'i kullanın: people.OrderBy(p => p.Age).ToList().

Q: Neden "Collection was modified; enumeration operation may not execute" hatası alıyorum?

Bir foreach aynı liste üzerinde dönerken öğe eklediniz, sildiniz ya da değiştirdiniz (list[i] = x) ve enumerator bir sonraki adımında InvalidOperationException fırlatıyor. list.RemoveAll(condition) kullanın, bir for döngüsüyle geriye doğru dönün ya da list.ToList() gibi bir kopya üzerinde dolaşın.

Q: Count ile Capacity arasındaki fark nedir?

Count listedeki öğe sayısıdır. Capacity iç dizinin boyutudur ve en az Count kadardır. Dizi dolduğunda liste iki kat büyüklükte yeni bir dizi ayırır ve öğeleri kopyalar, bu yüzden Add ortalamada hızlıdır.

List<T>, öğe ekleyip çıkardıkça büyüyen ve küçülen sıralı bir koleksiyondur. System.Collections.Generic içinde yaşar, bir dizi gibi indekslenir (list[0]) ve C#'ta "bir yığın şey" için varsayılan seçimdir.

Bir liste oluşturmak ve öğe eklemek

Açılı parantezlerdeki tip parametresi listenin ne tuttuğunu söyler: 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);
    }
}

Çıktı:

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

Count bir metot değil property'dir (diziler Length kullanır, LINQ'in bir Count() metodu vardır; bir listede property'yi kullanın). Insert sonraki her öğeyi bir konum kaydırır, bu yüzden büyük bir listenin başına eklemek boyutuyla orantılı zaman alır. Sona Add ucuz işlemdir.

Öğe silmek

Öğe hakkında ne bildiğinize bağlı olarak silmenin dört yolu vardır:

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);
    }
}

Çıktı:

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

Remove bir değer alır ve yalnızca ilk eşleşmeyi siler. Bir değerin tüm kopyalarını silmek için RemoveAll(s => s == 40) kullanın. Bir listede hatalı bir indeks hem list[i] hem de RemoveAt(i) için ArgumentOutOfRangeException fırlatır (bir dizi ise IndexOutOfRangeException fırlatır). RemoveRange(index, count) bir bloğu siler.

Count ile Capacity

Bir liste öğelerini içeride bir dizide tutar. Capacity o dizinin boyutudur; Count kaç yuvanın kullanıldığıdır. Count Capacity'ye ulaştığında sonraki Add iki kat büyük bir dizi ayırır ve her şeyi kopyalar.

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);
    }
}

Çıktı:

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

İkiye katlamak, çoğu Add çağrısının boş bir yuvaya yazmaktan ibaret olduğu anlamına gelir. Kabaca kaç öğe geleceğini biliyorsanız ara kopyaları atlamak için sayıyı constructor'a verin. new List<int>(1000)'in Count'unun yine 0 olduğuna dikkat edin: üzerinde list[0] istisna fırlatır. Kapasite yerdir, öğe değil.

Aramak: 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)));
    }
}

Çıktı:

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

Find ilk eşleşmeyi ya da hiçbir şey eşleşmediğinde tipin varsayılan değerini (bir sınıf için null) döndürür, bu yüzden sonucu kullanmadan önce kontrol edin. Son satır False yazdırır, çünkü Contains Equals kullanır ve Equals override'ı olmayan bir sınıf referansları karşılaştırır: aynı alanlara sahip yeni bir Product farklı bir nesnedir. Bunun yerine Exists ya da Find ile bir property'ye göre arayın ya da sınıfta Equals ve GetHashCode'u override edin.

Bu metotların her biri listeyi baştan dolaşır, bu yüzden her çağrı O(n)'dir. Bir anahtara göre tekrarlanan aramalar için bir Dictionary sabit zamanda cevap verir.

Bir listeyi sıralamak

Sort() öğelerin doğal sırasını kullanarak yerinde sıralar. Başka bir şeye göre sıralamak için bir karşılaştırma lambda'sı verin.

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
    }
}

Çıktı:

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

Bir karşılaştırma, a önce gelmeliyse negatif, b önce gelmeliyse pozitif, eşitlerse sıfır döndürür; CompareTo tam olarak bunu üretir. Sort ile LINQ'in OrderBy'ı arasındaki iki fark uygulamada önemlidir:

Sort listeyi değiştirir; OrderBy yeni bir dizi döndürür ve listeye dokunmaz.
Sort kararlı değildir: eşit karşılaştırılan öğeler yer değiştirebilir. OrderBy kararlıdır ve ThenBy ikinci bir anahtar ekler: players.OrderBy(p => p.Score).ThenBy(p => p.Name).

Kendi sınıfınızdan oluşan bir listede karşılaştırma olmadan Sort() çağırmak InvalidOperationException fırlatır, çünkü liste öğeleri nasıl sıralayacağını bilmez. Ya bir karşılaştırma verin ya da sınıfta IComparable<T> uygulayın.

Reverse() yerinde ters çevirir. System.Linq de bir Reverse extension'ı tanımladığı için bir List<T> üzerinde list.Reverse() hiçbir şey döndürmeyen yerinde sürümü seçer.

Döngü ve dolaşırken silme

foreach her öğeyi sırayla okur. Bir for döngüsü size indeksi de verir. Yapamayacağınız şey, aynı liste üzerindeki bir foreach'in ortasında öğe eklemek ya da silmektir:

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));
    }
}

Çıktı:

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

İstisna, "Collection was modified; enumeration operation may not execute." mesajlı InvalidOperationException'dır. İleri doğru bir for döngüsü istisna fırlatmaz, ama sildiğiniz her öğeden hemen sonrakini sessizce atlar, çünkü her şey bir indeks aşağı kayar. Geriye doğru dönmek bundan kaçınır. Üçüncü bir çözüm bir kopya üzerinde dolaşmaktır: foreach (var t in orders.ToList()).

foreach içinde bir öğenin property'sini değiştirmek (örneğin order.Status = "sent") sorun değildir. Öğe eklemek ya da silmek enumerator'ı bozar, indeksleyici üzerinden birini değiştirmek (orders[i] = 0) de öyle.

Listeler ve diziler arasında dönüşüm

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));
    }
}

Çıktı:

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

İki yön de elemanları yeni bir depolamaya kopyalar, bu yüzden listeyi sonradan değiştirmek diziyi etkilemez. ConvertAll, listenin LINQ'teki Select(...).ToList()'in kendi sürümüdür. Bir listeyi Console.WriteLine(list) ile yazdırmak tip adını gösterir (System.Collections.Generic.List`1[System.String]); string.Join kullanın.

Hızlı başvuru

Görev	Kod
Oluşturmak	`var l = new List<int>();` ya da `new List<int> { 1, 2 }`
Sona eklemek	`l.Add(x)`, `l.AddRange(items)`
Bir konuma eklemek	`l.Insert(i, x)`
İlk eşleşmeyi silmek	`l.Remove(x)` (`bool` döndürür)
İndekse göre silmek	`l.RemoveAt(i)`
Koşula göre silmek	`l.RemoveAll(x => ...)` (sayı döndürür)
Öğe sayısı	`l.Count`
İçeriyor mu	`l.Contains(x)`, `l.Exists(x => ...)`
Bulmak	`l.Find(...)`, `l.FindAll(...)`, `l.FindIndex(...)`
Yerinde sıralamak	`l.Sort()`, `l.Sort((a, b) => ...)`
Sıralı kopya	`l.OrderBy(x => ...).ToList()`
Diziye	`l.ToArray()`

Yaygın hatalar

foreach içinde silmek. InvalidOperationException fırlatır; RemoveAll ya da geriye doğru bir for döngüsü kullanın.
Remove(x)'in her kopyayı silmesini beklemek. İlkini siler; RemoveAll kullanın.
Equals'ı olmayan nesnelerde Contains kullanmak. Referansları karşılaştırır; Exists ile property'ye göre arayın.
Bir kapasiteyle oluşturulmuş bir listeyi indekslemek. new List<int>(10) boştur; önce öğe ekleyin.
Sort'un eşitleri sırada tuttuğunu varsaymak. Tutmaz; eşitler arasındaki sıra önemliyse OrderBy kullanın.
Paylaşmak için bir listeyi atayıp sonra değişikliklere şaşırmak. var copy = list; aynı listedir; new List<T>(list) bir kopyadır.

Sıkça Sorulan Sorular

C#'ta bir List'e nasıl öğe eklenir?

list.Add(item) sona bir öğe ekler, list.AddRange(otherCollection) birçok öğe ekler ve list.Insert(index, item) bir öğeyi bir konuma koyup geri kalanları kaydırır. Bir listeyi oluştururken de doldurabilirsiniz: var names = new List<string> { "Ana", "Ben" };.

C#'ta bir List'ten öğe nasıl silinir?

Remove(value) ilk eşleşen öğeyi siler ve bir tane bulduysa true döndürür. RemoveAt(index) konuma göre siler. RemoveAll(x => condition) eşleşen her öğeyi siler ve kaç tane sildiğini döndürür. Clear() listeyi boşaltır.

C#'ta bir List'in bir değer içerip içermediği nasıl kontrol edilir?

list.Contains(value) true ya da false döndürür. Equals ile karşılaştırır, bu yüzden kendi sınıflarınız için sınıf Equals'ı override etmedikçe referansları karşılaştırır. Bir property'ye göre kontrol etmek için list.Exists(p => p.Name == "Ana") ya da LINQ'in list.Any(...)'ini kullanın.

C#'ta bir List bir property'ye göre nasıl sıralanır?

Sort'a bir karşılaştırma verin: people.Sort((a, b) => a.Age.CompareTo(b.Age)) yerinde sıralar. Azalan sıra için a ile b'nin yerini değiştirin. Ya da yeni bir sıralı dizi döndüren ve eşit öğeleri orijinal sıralarında tutan LINQ'i kullanın: people.OrderBy(p => p.Age).ToList().

Neden "Collection was modified; enumeration operation may not execute" hatası alıyorum?

Bir foreach aynı liste üzerinde dönerken öğe eklediniz, sildiniz ya da değiştirdiniz (list[i] = x) ve enumerator bir sonraki adımında InvalidOperationException fırlatıyor. list.RemoveAll(condition) kullanın, bir for döngüsüyle geriye doğru dönün ya da list.ToList() gibi bir kopya üzerinde dolaşın.

Count ile Capacity arasındaki fark nedir?

Count listedeki öğe sayısıdır. Capacity iç dizinin boyutudur ve en az Count kadardır. Dizi dolduğunda liste iki kat büyüklükte yeni bir dizi ayırır ve öğeleri kopyalar, bu yüzden Add ortalamada hızlıdır.

İlgili kavramlar