Класс List в C# и его методы

Класс List призван для работы со списками. В классе List есть методы по добавлению, удалению, вставке элементов и прочее. Списки -очень удобный инструмент для программирования. Списки применяются там, где количество элементов в коллекции на перед не известно. Списки выгодно отличаются от массивов тем, что по ходу выполнения программы их размер можно изменять в любую сторону.

Методы класса List

Имя	Описание
Add	Добавляет объект в конец коллекции List <T>.
AddRange	Добавляет элементы указанной коллекции в конец списка List <T>.
AsReadOnly	Возвращает для текущей коллекции оболочку IList <T>, доступную только для чтения.
BinarySearch	Перегружен. Использует алгоритм двоичного поиска для нахождения определенного элемента в отсортированном списке List <T> или в его части.
Clear	Удаляет все элементы из коллекции List <T>.
Contains	Определяет, входит ли элемент в состав List <T>.
ConvertAll<(Of <(TOutput>)>)	Преобразует элементы текущего списка List <T> в другой тип и возвращает список преобразованных элементов.
CopyTo	Перегружен. Копирует список List <T> или его часть в массив.
Equals	Определяет, равен ли заданный объект Object текущему объекту Object. (Унаследовано от Object.)
Exists	Определяет, содержит ли List <T> элементы, удовлетворяющие условиям указанного предиката.
Finalize	Позволяет объекту Object попытаться освободить ресурсы и выполнить другие операции очистки, перед тем как объект Object будет утилизирован в процессе сборки мусора. (Унаследовано от Object.)
Find	Выполняет поиск элемента, удовлетворяющего условиям указанного предиката, и возвращает первое найденное вхождение в пределах всего списка List <T>.
FindAll	Извлекает все элементы, удовлетворяющие условиям указанного предиката.
FindIndex	Перегружен. Выполняет поиск элемента, удовлетворяющего условиям указанного предиката, и возвращает отсчитываемый от нуля индекс первого найденного вхождения в пределах всего списка List <T> или его части.
FindLast	Выполняет поиск элемента, удовлетворяющего условиям указанного предиката, и возвращает последнее найденное вхождение в пределах всего списка List <T>.
FindLastIndex	Перегружен. Выполняет поиск элемента, удовлетворяющего условиям указанного предиката, и возвращает отсчитываемый от нуля индекс последнего найденного вхождения в пределах всего списка List <T> или его части.
ForEach	Выполняет указанное действие с каждым элементом списка List <T>.
GetEnumerator	Возвращает перечислитель, осуществляющий перебор элементов списка List <T>.
GetHashCode	Играет роль хэш-функции для определенного типа. (Унаследовано от Object.)
GetRange	Создает неполную копию диапазона элементов исходного списка List <T>.
GetType	Возвращает объект Type для текущего экземпляра. (Унаследовано от Object.)
IndexOf	Перегружен. Возвращает отсчитываемый от нуля индекс первого вхождения значения в списке List <T> или в его части.
Insert	Добавляет элемент в список List <T> в позиции с указанным индексом.
InsertRange	Вставляет элементы коллекции в список List <T> в позиции с указанным индексом.
LastIndexOf	Перегружен. Возвращает отсчитываемый от нуля индекс последнего вхождения значения в списке List <T> или в его части.
MemberwiseClone	Создает неполную копию текущего объекта Object. (Унаследовано от Object.)
Remove	Удаляет первое вхождение указанного объекта из коллекции List <T>.
RemoveAll	Удаляет все элементы, удовлетворяющие условиям указанного предиката.
RemoveAt	Удаляет элемент списка List <T> с указанным индексом.
RemoveRange	Удаляет диапазон элементов из списка List <T>.
Reverse	Перегружен. Изменяет порядок элементов в списке List <T> или в его части на обратный.
Sort	Перегружен. Сортирует элементы в списке List <T> или в его части.
ToArray	Копирует элементы списка List <T> в новый массив.
ToString	Возвращает объект String, который представляет текущий объект Object. (Унаследовано от Object.)
TrimExcess	яадает емкость, равную фактическому числу элементов в списке List <T>, если это число меньше порогового значения.
TrueForAll	Определяет, все ли элементы списка List <T> удовлетворяют условиям указанного предиката.

Метод Add

Метод Add() добавляет объект в конец коллекции List.

Синтаксис

public void Add(T item)

Пример:

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>();

        Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);

        dinosaurs.Add("Tyrannosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        dinosaurs.Add("Compsognathus");

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);
        Console.WriteLine("Count: {0}", dinosaurs.Count);

        Console.WriteLine("\nContains(\"Deinonychus\"): {0}",
            dinosaurs.Contains("Deinonychus"));

        Console.WriteLine("\nInsert(2, \"Compsognathus\")");
        dinosaurs.Insert(2, "Compsognathus");

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\ndinosaurs[3]: {0}", dinosaurs[3]);

        Console.WriteLine("\nRemove(\"Compsognathus\")");
        dinosaurs.Remove("Compsognathus");

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        dinosaurs.TrimExcess();
        Console.WriteLine("\nTrimExcess()");
        Console.WriteLine("Capacity: {0}", dinosaurs.Capacity);
        Console.WriteLine("Count: {0}", dinosaurs.Count);

        dinosaurs.Clear();
        Console.WriteLine("\nClear()");
        Console.WriteLine("Capacity: {0}", dinosaurs.Capacity);
        Console.WriteLine("Count: {0}", dinosaurs.Count);
    }
}

/* This code example produces the following output:

Capacity: 0

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus

Capacity: 8
Count: 5

Contains("Deinonychus"): True

Insert(2, "Compsognathus")

Tyrannosaurus
Amargasaurus
Compsognathus
Mamenchisaurus
Deinonychus
Compsognathus

dinosaurs[3]: Mamenchisaurus

Remove("Compsognathus")

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus

TrimExcess()
Capacity: 5
Count: 5

Clear()
Capacity: 5
Count: 0
*/

Метод AddRange

Добавляет элементы указанной коллекции в конец списка List<T>. Т.е. все элементы, которые вы передаёте как аргумент добавляются один за другим в конец списка.

Порядок элементов коллекции сохраняется в списке List<T>.

Если новое значение свойства Count (текущее значение Count плюс размер коллекции) превышает значение Capacity, емкость списка List<T> увеличивается путем автоматического перераспределения внутреннего массива для размещения новых элементов, и существующие элементы копируются в новый массив перед добавлением новых элементов.

Если список List<T> может вместить новые элементы без увеличения значения свойства Capacity, этот метод является операцией порядка сложности O(n), где n — количество добавляемых элементов. Если емкость приходится увеличивать для размещения новых элементов, этот метод становится операцией порядка сложности O(n + m), где n — число добавляемых элементов, а m равно Count.

Синтаксис

public ReadOnlyCollection<T> AsReadOnly()

Пример:

В следующем примере кода демонстрируется метод AddRange и ряд других методов класса List<T>, применяемых к диапазонам. Создается массив строк, который передается в конструктор, и список заполняется элементами массива. Вызывается метод AddRange с указанием списка в качестве аргумента. В результате текущие элементы списка добавляются в его конец, т. е. все элементы дублируются.

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
         string[] input = { "Brachiosaurus",
                           "Amargasaurus",
                           "Mamenchisaurus" };// массив строк, который добавляется в список         
         List<string> dinosaurs = new List<string>(input); // создаём список из исходного массива         
         Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);

         // выводим на экран список        
         Console.WriteLine();
         foreach( string dinosaur in dinosaurs ) //пока есть элементы в списке, выводим их на экран        
         {
            Console.WriteLine(dinosaur);        
         }
         Console.WriteLine("\nAddRange(dinosaurs)");
         dinosaurs.AddRange(dinosaurs); // добавляем диапазон значений в список
         Console.WriteLine();          foreach( string dinosaur in dinosaurs )
         {
            Console.WriteLine(dinosaur); // снова выводим список
         }
         Console.WriteLine("\nRemoveRange(2, 2)");
         dinosaurs.RemoveRange(2, 2); //  удаляем из списка 2 элемента начиная со второго
         Console.WriteLine();
         foreach( string dinosaur in dinosaurs )
         {
            Console.WriteLine(dinosaur); // снова выводим список
         }
         input = new string[] { "Tyrannosaurus",
                               "Deinonychus",
                               "Velociraptor"};// создаём новый список строк
         Console.WriteLine("\nInsertRange(3, input)");
         dinosaurs.InsertRange(3, input); // вставляем диапазон значений imput, начиная с третьей позиции. (0,1,2,3)
         Console.WriteLine();
         foreach( string dinosaur in dinosaurs )
         {
             Console.WriteLine(dinosaur); // выводим список на экран
         }
         Console.WriteLine("\noutput = dinosaurs.GetRange(2, 3).ToArray()");
         string[] output = dinosaurs.GetRange(2, 3).ToArray(); // создаём массив, выбирая из списка диапазон значений длинной 3, начиная со второго элемента
         Console.WriteLine();
         foreach( string dinosaur in output )
         {
            Console.WriteLine(dinosaur); // выводим список на экран
         }
       }
   }
  /* This code example produces the following output:

Capacity: 3

Brachiosaurus
Amargasaurus
Mamenchisaurus

AddRange(dinosaurs)

Brachiosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Amargasaurus
Mamenchisaurus

RemoveRange(2, 2)

Brachiosaurus
Amargasaurus
Amargasaurus
Mamenchisaurus

InsertRange(3, input)

Brachiosaurus
Amargasaurus
Amargasaurus
Tyrannosaurus
Deinonychus
Velociraptor
Mamenchisaurus

output = dinosaurs.GetRange(2, 3).ToArray()

Amargasaurus
Tyrannosaurus
Deinonychus
*/

Метод AsReadOnly

Возвращает для текущей коллекции оболочку IList<T>, доступную только для чтения. Т.е можно создать оболочку данного объекта, доступного только для чтения. При этом важным моментом является то, что при изменении исходного объекта оболочка меняется тут же.

Чтобы предотвратить любые изменения списка List<T>, доступ к List<T> следует предоставлять только через эту оболочку.

Коллекция, предназначенная только для чтения, — это просто коллекция с оболочкой, предотвращающей ее изменение, т. е. если в базовую коллекцию вносятся изменения, они отражаются в коллекции, доступной только для чтения.

Этот метод является операцией порядка сложности O(1).

Синтаксис

public ReadOnlyCollection<T> AsReadOnly()

Пример:

В следующем примере кода демонстрируется использование метода AsReadOnly. Создается список строк List<T> с емкостью 4, поскольку известен конечный размер списка (4). Список заполняется четырьмя строками, и с помощью метода AsReadOnly возвращается доступная только для чтения реализация универсального интерфейса IList<T>, служащая оболочкой для исходного списка.

Элементу исходного списка присваивается значение "Coelophysis" с помощью свойства Item (индексатор в C#), и содержимое списка, доступного только для чтения, выводится вновь, демонстрируя, что это лишь оболочка исходного списка.

using System;
using System.Collections.Generic;
public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>(4);// создаём список из 4 строк
        Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);
        // Добавляем по очереди по одному элементу
        dinosaurs.Add("Tyrannosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        // Выводим на экран
        Console.WriteLine();
        foreach(string s in dinosaurs)
        {
            Console.WriteLine(s);
        }
        Console.WriteLine("\nIList<string> roDinosaurs = dinosaurs.AsReadOnly()");
        IList<string> roDinosaurs = dinosaurs.AsReadOnly(); // Создаём дубликат "только для чтения"
        Console.WriteLine("\nElements in the read-only IList:");
        // Выводим на экран
        foreach(string dinosaur in roDinosaurs)
        {
            Console.WriteLine(dinosaur);
        }
        Console.WriteLine("\ndinosaurs[2] = \"Coelophysis\"");
        dinosaurs[2] = "Coelophysis"; //изменяем в начальном списке 2-ой элемент
        // Выводим на экран оболочку "только для чтения"
        Console.WriteLine("\nElements in the read-only IList:");
        foreach(string dinosaur in roDinosaurs)
        {
            Console.WriteLine(dinosaur);
        }
    }
}
/* This code example produces the following output:
Capacity: 4
Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
IList<string> roDinosaurs = dinosaurs.AsReadOnly()
Elements in the read-only IList:
Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
dinosaurs[2] = "Coelophysis"
Elements in the read-only IList:
Tyrannosaurus
Amargasaurus
Coelophysis
Deinonychus */

Метод BinarySearch (T)

Выполняет поиск элемента по всему отсортированному списку List<T>, используя компаратор по умолчанию, и возвращает индекс элемента, отсчитываемый от нуля.

Важные моменты:

1. Список List<T> уже должен быть отсортирован в соответствии с реализацией компаратора, в противном случае будет получен неверный результат.
2. Если список List<T> содержит несколько элементов с одинаковыми значениями, метод BinarySearch ( T ) возвращает только один элемент, причем не обязательно самый первый.
3. Допускается сравнение значения null с любым ссылочным типом; оно не генерирует исключение при использовании универсального интерфейса IComparable<T>.При сортировке значение null считается меньшим любого другого объекта.
4. Если List<T> не содержит заданного значения, метод BinarySearch ( T ) возвращает отрицательное целое число. К этому числу можно применить операцию поразрядного дополнения (~) для получения индекса первого элемента, большего, чем искомое значение.Вставка значения в список List<T> должна производиться в позиции, заданной этим индексом, чтобы сохранить порядок сортировки.
5. Для определения порядка элементов списка метод BinarySearch ( T ) использует компаратор (Шаблон сравнения) по умолчанию Comparer<T>.Default для типа T
Перед сравнением проверяется реализован ли для данного типа данных Т шаблон сравнения Comparer<T>.Default, и использует эту реализацию, если она доступна.
Если она недоступна,Comparer<T>.Default проверяет, реализует ли тип T интерфейс IComparable. Если тип T не реализует эти интерфейсы,Comparer<T>.Default генерирует исключение InvalidOperationException.
6. Этот метод является операцией порядка сложности O(log n), где n — количество элементов в диапазоне.

Синтаксис

public int BinarySearch (T item)

Пример:

В следующем примере кода демонстрируется перегрузка методаSort() и перегрузка методаBinarySearch(T).Создается список строк List<T>, который заполняется четырьмя строками в произвольном порядке.Список выводится, сортируется и затем выводится снова.

Затем используется перегрузка методаBinarySearch(T) для поиска двух строк, не включенных в список, и эти строки вставляются с помощью методаInsert.Возвращаемое значение методаBinarySearch(T) будет отрицательным в каждом случае, поскольку строки не входят в список.Поразрядное дополнение (оператор ~ в C# и Visual C++,Xor -1 в Visual Basic) этого отрицательного числа дает индекс первого элемента в списке, большего, чем искомая строка, и вставка в эту позицию позволяет сохранить порядок сортировки.Вторая искомая строка больше любого элемента списка, поэтому позиция вставки приходится на конец списка.

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new  List<string>();
        dinosaurs.Add("Pachycephalosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }
        Console.WriteLine("\n Сортируем список");
        dinosaurs.Sort();
        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("применяем метод BinarySearch и вставляем в найденную позицию
          элемент "Coelophysis":");
        int index = dinosaurs.BinarySearch("Coelophysis");
        if (index < 0)
        {
            dinosaurs.Insert(~index, "Coelophysis"); // ищем значение "Coelophysis",
            // ~index - необходимо, в случе, если нет такого элемента в списке,
            // тогда index будет увеличен до индекса первого элемента, большего,
            // чем искомое значение
        }

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("применяем метод BinarySearch и вставляем в найденную
              позицию элемент "Tyrannosaurus":");
        index = dinosaurs.BinarySearch("Tyrannosaurus");
        if (index < 0)
        {
            dinosaurs.Insert(~index, "Tyrannosaurus");
        }

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }
    }
}

/* Этот код показывает работу метода BinarySearch(T item):

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Deinonychus

Сортируем список

Amargasaurus
Deinonychus
Mamenchisaurus
Pachycephalosaurus

применяем метод BinarySearch и вставляем в найденную позицию элемент "Coelophysis":

Amargasaurus
Coelophysis
Deinonychus
Mamenchisaurus
Pachycephalosaurus

применяем метод BinarySearch и вставляем в найденную позицию элемент "Tyrannosaurus":

Amargasaurus
Coelophysis
Deinonychus
Mamenchisaurus
Pachycephalosaurus
Tyrannosaurus*/

Метод BinarySearch (T, IComparer<T>)

Метод BinarySearch ( T item, IComparer<T> comparer) Выполняет поиск элемента по всему отсортированному списку List<T>, используя указанный компаратор, и возвращает индекс элемента, отсчитываемый от нуля.

Отсчитываемый от нуля индекс элемента item в отсортированном списке List<T>, если элемент item найден; в противном случае — отрицательное число, которое является поразрядным дополнением индекса следующего элемента, большего, чем item, или, если большего элемента не существует, поразрядным дополнением значения Count.

Важные моменты:
1. Компаратор определяет способ сравнения элементов.Например, для поиска строки без учета регистра в качестве компаратора можно использовать экземпляр класса CaseInsensitiveComparer.
2. Если указан параметр comparer, элементы списка List<T> сравниваются с заданным значением с помощью указанной реализации IComparer<T>.
3. Если в качестве comparer задано null, компаратор по умолчанию Comparer<T>.Default проверяет, реализует ли тип T универсальный интерфейс IComparable<T>, и использует эту реализацию, если она доступна.Если она недоступна, Comparer<T>.Default проверяет, реализует ли тип T интерфейс IComparable.Если тип T не реализует эти интерфейсы, Comparer<T>.Default генерирует исключение InvalidOperationException.
4. Список List<T> уже должен быть отсортирован в соответствии с реализацией компаратора, в противном случае будет получен неверный результат.
5. Если список List<T> содержит несколько элементов с одинаковыми значениями, метод BinarySearch ( T item, IComparer<T> comparer) возвращает только один элемент, причем не обязательно самый первый.
6. Допускается сравнение значения null с любым ссылочным типом; оно не генерирует исключение при использовании универсального интерфейса IComparable<T>.При сортировке значение null считается меньшим любого другого объекта.
7. Если List<T> не содержит заданного значения, метод BinarySearch ( T item, IComparer<T> comparer) возвращает отрицательное целое число. К этому числу можно применить операцию поразрядного дополнения (~) для получения индекса первого элемента, большего, чем искомое значение.Вставка значения в список List<T> должна производиться в позиции, заданной этим индексом, чтобы сохранить порядок сортировки.
8. Для определения порядка элементов списка метод BinarySearch ( T item, IComparer<T> comparer) использует компаратор (Шаблон сравнения) по умолчанию Comparer<T>.Default для типа T
Перед сравнением проверяется реализован ли для данного типа данных Т шаблон сравнения Comparer<T>.Default, и использует эту реализацию, если она доступна.
Если она недоступна,Comparer<T>.Default проверяет, реализует ли тип T интерфейс IComparable. Если тип T не реализует эти интерфейсы,Comparer<T>.Default генерирует исключение InvalidOperationException.
9. Этот метод является операцией порядка сложности O(log n), где n — количество элементов в диапазоне.

Синтаксис

public int BinarySearch (T item, IComparer<T> comparer)

Пример:

В следующем примере кода демонстрируется перегрузка метода Sort(IComparer<T>) и перегрузка метода BinarySearch(T, IComparer<T>).

В примере определяется альтернативный компаратор для строк с именем DinoCompare, реализующий универсальный интерфейс IComparer<string> (IComparer(Of String) в Visual Basic, IComparer<String^> в Visual C++).Компаратор действует следующим образом: сначала сравниваемые операнды проверяются на равенство null, причем пустая ссылка считается меньшей, чем непустая.Затем сравниваются длины строк, и более длинная строка считается большей.Если длины совпадают, используется обычное сравнение строк.

Создается список строк List<T>, который заполняется четырьмя строками в произвольном порядке.Список выводится, сортируется с использованием альтернативного компаратора и затем выводится снова.

Затем используется перегрузка метода BinarySearch (T, IComparer<T>) для поиска нескольких строк, не включенных в список, с помощью альтернативного компаратора.Эти строки вставляются с использованием метода Insert.Эти два метода включены в состав функции SearchAndInsert вместе с кодом, выполняющим поразрядное дополнение (оператор ~ в C#) отрицательного числа, возвращаемого методом BinarySearch(T, IComparer<T>), и используют результат в качестве индекса для вставки новой строки

using System;
using System.Collections.Generic;
public class DinoComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        if (x == null)
        {
            if (y == null)
            {
                // Если x == null и y == null, то они равны
                return 0;
            }
            else
            {
                // Если x == null и y != null, то у больше
                return -1;
            }
        }
        else
        {
            // Если x != null...
            //
            if (y == null)
                // ...и y == null, то x больше.
            {
                return 1;
            }
            else
            {
                // ...и y != null, сравниваем их длину
                //
                int retval = x.Length.CompareTo(y.Length);
                if (retval != 0)
                {
                    // Если их длины не равны,
                    // то более длинная строка больше.
                    //
                    return retval;
                }
                else
                {
                    // Если длины одинаковы,
                    // сравниваем строки базовым методом
                    // сравнения
                    return x.CompareTo(y);
                }
            }
        }
    }
}

public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>();
        dinosaurs.Add("Pachycephalosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        Display(dinosaurs);

        DinoComparer dc = new DinoComparer();

        Console.WriteLine("\nSort with alternate comparer:");
        dinosaurs.Sort(dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, "Coelophysis", dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, "Oviraptor", dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, "Tyrannosaur", dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, null, dc);
        Display(dinosaurs);
    }

    private static void SearchAndInsert(List<string> list,
        string insert, DinoComparer dc)
    {
        Console.WriteLine("\nПрименение бинарного поиска
        BinarySearch и вставка элемента  \"{0}\":", insert);
        int index = list.BinarySearch(insert, dc);
        if (index < 0)
        {
            list.Insert(~index, insert);
        }
    }
    private static void Display(List<string> list)
    {
        Console.WriteLine();
        foreach( string s in list )
        {
            Console.WriteLine(s);
        }
    }
}

/* Это пример работы вышенаписанной программы:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Deinonychus

Сортировка сторонним (своим) шаблоном сравнения:

Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

//Применение бинарного поиска BinarySearch и
//вставка элемента "Coelophysis":

Coelophysis
Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

//Применение бинарного поиска BinarySearch и
//вставка элемента "Oviraptor":

Oviraptor
Coelophysis
Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

//Применение бинарного поиска BinarySearch и
//вставка элемента "Tyrannosaur":

Oviraptor
Coelophysis
Deinonychus
Tyrannosaur
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

Применение бинарного поиска BinarySearch и
//вставка элемента "":

Oviraptor
Coelophysis
Deinonychus
Tyrannosaur
Amargasaurus
Mamenchisaurus
Pachycephalosaurus
*/

Метод Clear()

Удаляет все элементы из коллекции List<T>. Данный метод предназначен, для того чтобы удалеить все элементы списка. Список List является динамической структурой, поэтому в нём реализованы операции динамического вставления элементов, удаления, можно так же и очистить весь список List.

Особенности и примечания:

1. Свойству Count присваивается значение 0, и из элементов коллекции удаляются ссылки на другие объекты.
2. Значение свойства Capacity не изменяется. Чтобы сбросить емкость списка List<T>, вызовите метод TrimExcess или задайте свойство Capacity непосредственно. При уменьшении емкости перераспределяется память и все элементы копируются в коллекцию List<T>. Усечение пустого списка List<T> устанавливает емкость List<T> равной значению по умолчанию.
3. Этот метод является операцией порядка сложности O(n), где n равно Count.

Синтаксис

public void Clear()

Пример:

В следующем примере кода демонстрируется метод Clear и ряд других свойств и методов универсального класса List<T>. В конце программы используется метод Clear для удаления всех элементов из списка, и затем вновь выводятся значения свойств Capacity и Count.

using System;
using System.Collections.Generic;
public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>();

        Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);

        dinosaurs.Add("Tyrannosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        dinosaurs.Add("Compsognathus");

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);
        Console.WriteLine("Count: {0}", dinosaurs.Count);

        Console.WriteLine("\nContains(\"Deinonychus\"): {0}",
            dinosaurs.Contains("Deinonychus"));

        Console.WriteLine("\nInsert(2, \"Compsognathus\")");
        dinosaurs.Insert(2, "Compsognathus"); // вставляем во вторую позицию элемент "Compsognathus"

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\ndinosaurs[3]: {0}", dinosaurs[3]);

        Console.WriteLine("\nRemove(\"Compsognathus\")");
        dinosaurs.Remove("Compsognathus"); // удаляем элемент "Compsognathus"

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        dinosaurs.TrimExcess(); // очищаем ёмкость списка
        Console.WriteLine("\nTrimExcess()");
        Console.WriteLine("Capacity: {0}", dinosaurs.Capacity);
        Console.WriteLine("Count: {0}", dinosaurs.Count);

        dinosaurs.Clear(); // очищаем сам список
        Console.WriteLine("\nClear()");
        Console.WriteLine("Capacity: {0}", dinosaurs.Capacity);
        Console.WriteLine("Count: {0}", dinosaurs.Count);
    }
}

/* This code example produces the following output:
Capacity: 0
Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus
Capacity: 8
Count: 5
Contains("Deinonychus"): True
Insert(2, "Compsognathus")
Tyrannosaurus
Amargasaurus
Compsognathus
Mamenchisaurus
Deinonychus
Compsognathus
dinosaurs[3]: Mamenchisaurus
Remove("Compsognathus")
Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus
TrimExcess()
Capacity: 5
Count: 5
Clear()
Capacity: 5
Count: 0
  */