Исполняемые доки C#: List

Q: Как добавить элементы в List в C#?

list.Add(item) добавляет один элемент в конец, list.AddRange(otherCollection) добавляет много, а list.Insert(index, item) помещает элемент на позицию и сдвигает остальные. Список можно заполнить и при создании: var names = new List { "Ana", "Ben" };.

Q: Как удалить элемент из List в C#?

Remove(value) удаляет первый совпавший элемент и возвращает true, если нашёл его. RemoveAt(index) удаляет по позиции. RemoveAll(x => condition) удаляет все элементы, удовлетворяющие условию, и возвращает их количество. Clear() очищает список.

Q: Как проверить, содержит ли List значение, в C#?

list.Contains(value) возвращает true или false. Он сравнивает через Equals, поэтому для ваших классов сравниваются ссылки, если класс не переопределяет Equals. Чтобы проверить по свойству, используйте list.Exists(p => p.Name == "Ana") или list.Any(...) из LINQ.

Q: Как отсортировать List по свойству в C#?

Передайте сравнение в Sort: people.Sort((a, b) => a.Age.CompareTo(b.Age)) сортирует на месте. Поменяйте a и b местами для сортировки по убыванию. Или используйте LINQ, который возвращает новую отсортированную последовательность и сохраняет порядок равных элементов: people.OrderBy(p => p.Age).ToList().

Q: Почему возникает «Collection was modified; enumeration operation may not execute»?

Вы добавили, удалили или заменили (list[i] = x) элементы, пока foreach перебирал тот же список, и перечислитель выбросил InvalidOperationException на следующем шаге. Используйте list.RemoveAll(condition), обратный цикл for или перебирайте копию, например list.ToList().

Q: Чем Count отличается от Capacity?

Count это количество элементов в списке. Capacity это размер внутреннего массива, который не меньше Count. Когда массив заполняется, список выделяет новый вдвое большего размера и копирует элементы, поэтому Add в среднем быстрый.

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() сортирует на месте в естественном порядке элементов. Чтобы сортировать по чему-то другому, передайте лямбду сравнения.

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.

Краткая справка

Задача	Код
Создать	`var l = new List<int>();` или `new List<int> { 1, 2 }`
Добавить в конец	`l.Add(x)`, `l.AddRange(items)`
Вставить на позицию	`l.Insert(i, x)`
Удалить первое совпадение	`l.Remove(x)` (возвращает `bool`)
Удалить по индексу	`l.RemoveAt(i)`
Удалить по условию	`l.RemoveAll(x => ...)` (возвращает количество)
Число элементов	`l.Count`
Содержит	`l.Contains(x)`, `l.Exists(x => ...)`
Найти	`l.Find(...)`, `l.FindAll(...)`, `l.FindIndex(...)`
Сортировать на месте	`l.Sort()`, `l.Sort((a, b) => ...)`
Отсортированная копия	`l.OrderBy(x => ...).ToList()`
В массив	`l.ToArray()`

Частые ошибки

Удаление внутри foreach. Выбрасывает InvalidOperationException; используйте RemoveAll или обратный цикл for.
Ожидание, что Remove(x) удалит все копии. Он удаляет первую; используйте RemoveAll.
Contains для объектов без Equals. Сравниваются ссылки; ищите по свойству через Exists.
Обращение по индексу к списку, созданному с ёмкостью. new List<int>(10) пуст; сначала добавьте элементы.
Ожидание, что Sort сохранит порядок равных элементов. Не сохранит; используйте OrderBy, когда порядок среди равных важен.
Присваивание списка, чтобы поделиться им, и удивление от изменений. var copy = list; это тот же список; new List<T>(list) это копия.

Часто задаваемые вопросы

Как добавить элементы в List в C#?

list.Add(item) добавляет один элемент в конец, list.AddRange(otherCollection) добавляет много, а list.Insert(index, item) помещает элемент на позицию и сдвигает остальные. Список можно заполнить и при создании: var names = new List<string> { "Ana", "Ben" };.

Как удалить элемент из List в C#?

Remove(value) удаляет первый совпавший элемент и возвращает true, если нашёл его. RemoveAt(index) удаляет по позиции. RemoveAll(x => condition) удаляет все элементы, удовлетворяющие условию, и возвращает их количество. Clear() очищает список.

Как проверить, содержит ли List значение, в C#?

list.Contains(value) возвращает true или false. Он сравнивает через Equals, поэтому для ваших классов сравниваются ссылки, если класс не переопределяет Equals. Чтобы проверить по свойству, используйте list.Exists(p => p.Name == "Ana") или list.Any(...) из LINQ.

Как отсортировать List по свойству в C#?

Передайте сравнение в Sort: people.Sort((a, b) => a.Age.CompareTo(b.Age)) сортирует на месте. Поменяйте a и b местами для сортировки по убыванию. Или используйте LINQ, который возвращает новую отсортированную последовательность и сохраняет порядок равных элементов: people.OrderBy(p => p.Age).ToList().

Почему возникает «Collection was modified; enumeration operation may not execute»?

Вы добавили, удалили или заменили (list[i] = x) элементы, пока foreach перебирал тот же список, и перечислитель выбросил InvalidOperationException на следующем шаге. Используйте list.RemoveAll(condition), обратный цикл for или перебирайте копию, например list.ToList().

Чем Count отличается от Capacity?

Count это количество элементов в списке. Capacity это размер внутреннего массива, который не меньше Count. Когда массив заполняется, список выделяет новый вдвое большего размера и копирует элементы, поэтому Add в среднем быстрый.

Связанные концепции