Последнее обновление: 03.01.2022

Хотя в языке C# есть массивы, которые хранят в себе наборы однотипных объектов, но работать с ними не всегда удобно. Например, массив хранит фиксированное количество объектов, однако что если мы заранее не знаем, сколько нам потребуется объектов.

И в этом случае намного удобнее применять коллекции. Еще один плюс коллекций состоит в том, что некоторые из них реализует стандартные структуры данных, например, стек, очередь, словарь, которые могут пригодиться для решения различных специальных задач.

Большая часть классов коллекций содержится в пространстве имен System.Collections.Generic.

Класс List из пространства имен System.Collections.Generic представляет простейший список однотипных объектов. Класс List типизируется типом, объекты которого будут хранится в списке.

Мы можем создать пустой список:

List people = new List();

В данном случае объект List типизируется типом string. А это значит, что хранить в этом списке мы можем только строки.

Можно сразу при создании списка инициализировать его начальными значениями. В этом случае элементы списка помещаются после вызова конструктора в фигурных скобках

List people = new List() { «Tom», «Bob», «Sam» };

В данном случае в список помещаются три строки

Также можно при создании списка инициализировать его элементами из другой коллекции, например, другого списка:

var people = new List() { «Tom», «Bob», «Sam» };
var employees = new List(people);

Можно совместить оба способа:

var people = new List() { «Tom», «Bob», «Sam» };
var employees = new List(people){«Mike»};

В данном случае в списке employees будет четыре элемента ({ «Tom», «Bob», «Sam», «Mike» }) — три добавляются из списка people и один элемент задается при инициализации.

Подобным образом можно работать со списками других типов, например:

List people = new List()
{
new Person(«Tom»),
new Person(«Bob»),
new Person(«Sam»)
};

class Person
{
public string Name { get;}
public Person(string name) => Name = name;
}

Установка начальной емкости списка

Еще один конструктор класса List принимает в качестве параметра начальную емкость списка:

List people = new List(16);

Указание начальной емкости списка позволяет в будущем увеличить производительность и уменьшить издержки на выделение памяти при добавлении элементов.

Поскольку динамическое добавление в список может приводить на низком уровне к дополнительному выделению памяти, что снижает производительность.

Если же мы знаем, что список не будет превышать некоторый размер, то мы можем передать этот размер в качестве емкости списка и избежать дополнительных выделений памяти.

Также начальную емкость можно установить с помощью свойства Capacity, которое имеется у класса List.

Обращение к элементам списка

Как и массивы, списки поддерживают индексы, с помощью которых можно обратиться к определенным элементам:

var people = new List() { «Tom», «Bob», «Sam» };

string firstPerson = people[0]; // получаем первый элемент
Console.WriteLine(firstPerson); // Tom
people[0] = «Mike»; // изменяем первый элемент
Console.WriteLine(people[0]); // Mike

Длина списка

С помощью свойства Count можно получить длину списка:

var people = new List() { «Tom», «Bob», «Sam» };
Console.WriteLine(people.Count); // 3

Перебор списка

C# позволяет осуществить перебор списка с помощью стандартного цикла foreach:/p>

var people = new List() { «Tom», «Bob», «Sam» };

foreach (var person in people)
{
Console.WriteLine(person);
}
// Вывод программы:
// Tom
// Bob
// Sam

Также можно использовать другие типы циклов и в комбинации с индексами перебирать списки:

var people = new List() { «Tom», «Bob», «Sam» };

for (int i = 0; i < people.Count; i++) { Console.WriteLine(people[i]); }

Методы списка

Среди его методов можно выделить следующие:

• void Add(T item): добавление нового элемента в список
• void AddRange(IEnumerable collection): добавление в список коллекции или массива
• int BinarySearch(T item): бинарный поиск элемента в списке. Если элемент найден, то метод возвращает индекс этого элемента в коллекции. При этом список должен быть отсортирован.
• void CopyTo(T[] array): копирует список в массив array
• void CopyTo(int index, T[] array, int arrayIndex, int count): копирует из списка начиная с индекса index элементы, количество которых равно count, и вставляет их в массив array начиная с индекса arrayIndex
• bool Contains(T item): возвращает true, если элемент item есть в списке
• void Clear(): удаляет из списка все элементы
• bool Exists(Predicate match): возвращает true, если в списке есть элемент, который соответствует делегату match
• T? Find(Predicate match): возвращает первый элемент, который соответствует делегату match. Если элемент не найден, возвращается null
• T? FindLast(Predicate match): возвращает последний элемент, который соответствует делегату match. Если элемент не найден, возвращается null
• List FindAll(Predicate match): возвращает список элементов, которые соответствуют делегату match
• int IndexOf(T item): возвращает индекс первого вхождения элемента в списке
• int LastIndexOf(T item): возвращает индекс последнего вхождения элемента в списке
• List GetRange(int index, int count): возвращает список элементов, количество которых равно count, начиная с индекса index.
• void Insert(int index, T item): вставляет элемент item в список по индексу index. Если такого индекса в списке нет, то генерируется исключение
• void InsertRange(int index, collection): вставляет коллекцию элементов collection в текущий список начиная с индекса index. Если такого индекса в списке нет, то генерируется исключение
• bool Remove(T item): удаляет элемент item из списка, и если удаление прошло успешно, то возвращает true. Если в списке несколько одинаковых элементов, то удаляется только первый из них
• void RemoveAt(int index): удаление элемента по указанному индексу index. Если такого индекса в списке нет, то генерируется исключение
• void RemoveRange(int index, int count): параметр index задает индекс, с которого надо удалить элементы, а параметр count задает количество удаляемых элементов.
• int RemoveAll((Predicate match)): удаляет все элементы, которые соответствуют делегату match. Возвращает количество удаленных элементов
• void Reverse(): изменяет порядок элементов
• void Reverse(int index, int count): изменяет порядок на обратный для элементов, количество которых равно count, начиная с индекса index
• void Sort(): сортировка списка
• void Sort(IComparer? comparer): сортировка списка с помощью объекта comparer, который передается в качестве параметра

Добавление в список

List people = new List () { «Tom» };

people.Add(«Bob»); // добавление элемента
// people = { «Tom», «Bob» };

people.AddRange(new[] { «Sam», «Alice» }); // добавляем массив
// people = { «Tom», «Bob», «Sam», «Alice» };
// также можно было бы добавить другой список
// people.AddRange(new List(){ «Sam», «Alice» });

people.

Insert(0, «Eugene»); // вставляем на первое место
// people = { «Eugene», «Tom», «Bob», «Sam», «Alice» };

people.InsertRange(1, new string[] {«Mike», «Kate»}); // вставляем массив с индекса 1
// people = { «Eugene», «Mike», «Kate», «Tom», «Bob», «Sam», «Alice» };

// также можно было бы добавить другой список
// people.

InsertRange(1, new List(){ «Mike», «Kate» });

Удаление из списка

var people = new List () { «Eugene», «Mike», «Kate», «Tom», «Bob», «Sam», «Tom», «Alice» };

people.RemoveAt(1); // удаляем второй элемент
// people = { «Eugene», «Kate», «Tom», «Bob», «Sam», «Tom», «Alice» };

people.

Remove(«Tom»); // удаляем элемент «Tom»
// people = { «Eugene», «Kate», «Bob», «Sam», «Tom», «Alice» };

// удаляем из списка все элементы, длина строки которых равна 3
people.RemoveAll(person => person.Length == 3);
// people = { «Eugene», «Kate», «Alice» };

// удаляем из списка 2 элемента начиная с индекса 1
people.

RemoveRange(1, 2);
// people = { «Eugene»};

// полностью очищаем список
people.Clear();
// people = { };

Поиск и проверка элемента

var people = new List () { «Eugene», «Mike», «Kate», «Tom», «Bob», «Sam» };

var containsBob = people.Contains(«Bob»); // true
var containsBill = people.Contains(«Bill»); // false

// проверяем, есть ли в списке строки с длиной 3 символа
var existsLength3 = people.

Exists(p => p.Length == 3); // true

// проверяем, есть ли в списке строки с длиной 7 символов
var existsLength7 = people.Exists(p => p.Length == 7); // false

// получаем первый элемент с длиной в 3 символа
var firstWithLength3 = people.Find(p => p.

Length == 3); // Tom

// получаем последний элемент с длиной в 3 символа
var lastWithLength3 = people.FindLast(p => p.Length == 3); // Sam

// получаем все элементы с длиной в 3 символа в виде списка
List peopleWithLength3 = people.FindAll(p => p.

Length == 3);
// peopleWithLength3 { «Tom», «Bob», «Sam»}

Получение диапазона и копирование в массив

List people = new List() {«Eugene», «Tom», «Mike», «Sam», «Bob» };

// получаем диапазон со второго по четвертый элемент
var range = people.GetRange(1, 3);
// range = { «Tom», «Mike», «Sam»};

// копируем в массив первые три элемента
string[] partOfPeople = new string[3];
people.CopyTo(0, partOfPeople, 0, 3);
// partOfPeople = { «Eugene», «Tom», «Mike»};

Расположение элементов в обратном порядке

C#. Урок 10. Коллекции

Коллекции являются одним из наиболее часто используемых инструментов в разработке программного обеспечения. В этом уроке мы познакомимся с пространством имен System.Collections.Generic, коллекциями List, Dictionary и типом Tuple.

Исходный код примеров из этой статьи можете скачать из нашего github-репозитория.

Коллекции

Самым примитивным способом хранения объектов в C# является использование массивов. Одной из основных проблем, с которой столкнется разработчик следуя такому подходу, является то, что массивы не предоставляют инструментов для динамического изменения размера. В языке C# есть два пространства имен для работы со структурами данных:

• System.Collections;
• System.Collections.Generic.

Первое из них – System.Collections предоставляет структуры данных для хранения объектов типа Object. У этого решения есть две основных проблемы – это производительность и безопасность типов. В настоящее время не рекомендуется использовать объекты классов из System.Collections. 

Для решения указанных выше проблем Microsoft были разработаны коллекции с обобщенными типами (их ещё называют дженерики), они расположены в пространстве  имен System.Collections.Generic.

Суть их заключается в том, что вы не просто создает объект класса List, но и указываете, объекты какого типа будут в нем храниться, делается это так: List, где T может быть int, string, double или какой-то ваш собственный класс. 

В рамках данного урока мы не будем подробно останавливаться на особенностях обобщенных типов, на текущий момент можете их воспринимать как псевдонимы, для реальных типов данных. 

Коллекции в языке C#. Пространство имен System.Collections.Generic

Пространство System.Collections.Generic содержит большой набор коллекций, которые позволяют удобно и эффективно решать широкий круг задач. Ниже, в таблице, перечислены некоторые из обобщенных классов с указанием интерфейсов, которые они реализуют.

Обобщенный класс	Основные интерфейсы	Описание
List	ICollection, IEnumerable, IList	Список элементов с динамически изменяемым размером
Dictionary	ICollection, IDictionary, IEnumerable	Коллекция элементов связанных через уникальный ключ
Queue	ICollection, IEnumerable	Очередь –  список, работающий по алгоритму FIFO
Stack	ICollection, IEnumerable	Стэк – список, работающий по алгоритму LIFO
SortedList	IComparer, ICollection, IDictionary	Коллекция пар “ключ-значение”, упорядоченных по ключу

Познакомимся поближе с несколькими классами из приведенной таблицы.

Класс List

Начнем наше знакомство с коллекциями с класса List. Эта коллекция является аналогом типизированного массива, который может динамически расширяться. В качестве типа можно указать любой встроенный либо пользовательский тип.

Создание объекта класса List

Можно создать пустой список и добавить в него элементы позже, с помощью метода Add():

List numsList = new List();
numsList.Add(1);

Либо воспользоваться синтаксисом, позволяющем указать набор объектов, который будет храниться в списке:

List nums = new List {1, 2, 3, 4, 5};
var words = new List {«one», «two», «three»};

Работа с объектами List

Ниже приведены таблицы, в которых перечислены некоторые полезные свойства и методы класса List. Более подробную информацию по методам и свойствам List вы можете найти в официальной документации.

Свойства класса List

Свойство	Описание
Count	Количество элементов в списке
Capacity	Емкость списка – количество элементов, которое может вместить список без изменения размера

Console.WriteLine(«Свойства»);
Console.WriteLine($»- Count: nums.Count = {nums.Count}»);
Console.WriteLine($»- Capacity: nums.Capacity = {nums.Capacity}»);

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

Метод	Описание
Add(T)	Добавляет элемент к списку
BinarySearch(T)	Выполняет поиск по списку
Clear()	Очистка списка
Contains(T)	Возвращает true, если список содержит указанный элемент
IndexOf(T)	Возвращает индекс переданного элемента
ForEach(Action)	Выполняет указанное действие для всех элементов списка
Insert(Int32, T)	Вставляет элемент в указанную позицию
Find(Predicate)	Осуществляет поиск первого элемент, для которого выполняется заданный предикат
Remove(T)	Удаляет указанный элемент из списка
RemoveAt(Int32)	Удаляет элемент из заданной позиции
Sort()	Сортирует список
Reverse()	Меняет порядок расположения элементов на противоположный

Console.WriteLine($»nums: {ListToString(nums)}»);            
nums.Add(6);
Console.WriteLine($»nums.Add(6): {ListToString(nums)}»);            
Console.WriteLine($»words.BinarySearch(«two»): {words.BinarySearch(«two»)}»);
Console.WriteLine($»nums.Contains(10): {nums.Contains(10)}»);
Console.WriteLine($»words.IndexOf(«three»): {words.IndexOf(«three»)}»);
Console.WriteLine($»nums.ForEach(v => v * 10)»);
nums.ForEach(v => Console.Write($»{v} => «));            
nums.Insert(3, 7);
Console.WriteLine($»nums.Insert(3, 7): {ListToString(nums)}»);
Console.WriteLine($»words.Find(v => v.Length == 3): {words.Find(v => v.Length == 3)}»);
words.Remove(«two»);
Console.WriteLine($»words.Remove(«two»): {ListToString(words)}»);

Код метода ListToString:

static private string ListToString(List list) =>
«{» + string.Join(«, «, list.ToArray()) + «}»;

Далее приведен пример работы со списком, в котором хранятся объекты пользовательского типа. Создадим класс Player, имеющий свойства: Name и Skill.

class Player
{
public string Name { get; set; }
public string Skill { get; set; }
}

Создадим список игроков и выполним с ним ряд действий:

Универсальный список List

В C# для хранения набора однотипных элементов можно использовать массивы.

Однако, что мы будем делать, если заранее не известно какое количество элементов нам необходимо хранить? Или же, количество элементов может постоянно меняться? Каждый раз создавать новый массив и копировать данные из одного массива в другой — не совсем правильный вариант. В таких случаях, наиболее удобно и правильно использовать универсальный список List.

Класс List

Класс List представляет собой простейший универсальный список для хранения однородных объектов. Размер List может динамически изменяться, а доступ к элементам списка осуществляется по целочисленному индексу. Ниже представлены основные свойства и методы List:

• Метод void Add(T item) — добавление нового элемента в список
• Метод void AddRange(ICollection collection)— добавление в список коллекции или массива
• Метод int BinarySearch(T item)— бинарный поиск элемента в списке. Если элемент найден, то метод возвращает индекс этого элемента в коллекции. При этом список должен быть отсортирован.
• Метод int IndexOf(T item)— возвращает индекс первого вхождения элемента в списке
• Метод void Insert(int index, T item)— вставляет элемент item в списке на позицию index
• Метод bool Remove(T item)— удаляет элемент item из списка, и если удаление прошло успешно, то возвращает true
• Метод void RemoveAt(int index)— удаление элемента по указанному индексу index
• Метод void Sort()— сортировка списка
• Свойство Capacity — возвращает или задает общее число элементов, которые может вместить внутренняя структура данных без изменения размера
• Свойство Count — получает число элементов, содержащихся списке.
• Свойство Item[Int32] — возвращает или задает элемент по указанному индексу.

Как и в случае с любым универсальным типом, T — это любой тип данных, который будет использоваться при работе со списком, например, можно создать список строк:

List stringList = List;

Рассмотрим работу со списком List на примере.

Пример создания и использования списка List в C#

using System;
using System.Collections.

Generic;

namespace ListExample
{
class Person
{
public string Name { get; set; }
}

class Program
{
static void Main(string[] args)
{
//при создании списка указываем его начальную емкость (Capacity = 2)
List people = new List(2);
//добавляем элементы в список
people.Add(new Person() { Name = «Вася» });
people.Add(new Person() { Name = «Петя» });
people.Add(new Person() { Name = «Ваня» });
people.Add(new Person() { Name = «Гоша» });
people.Add(new Person() { Name = «Таня» });
//выводим значения емкости списка и количество элементов в списке
Console.WriteLine($»Capacity = {people.Capacity}»);
Console.WriteLine($»Count = {people.Count}»);
//перебираем элементы в списке
foreach (Person person in people)
{
Console.WriteLine(person.Name);
}
//получаем конкретный элемент списка по его индексу
Console.WriteLine($»Второй элемент списка: {people[1].Name}»);
}
}
}

Результат работы программы будет следующий:

Во-первых, стоит обратить внимание на создание списка — здесь мы использовали конструктор с параметром в котором передели начальное значение емкости внутреннего хранилища списка (два элемента).

После этого мы добавили в список не два, а пять элементов. Как можно увидеть, никаких ошибок программа не выдала, а в список попали все пять элементов и мы смогли их перечислить в цикле, а второй элемент вывести отдельно.

При этом, свойство Capacity также автоматически изменилось и стало равным восьми.

Здесь может возникнуть сразу два закономерных вопроса:

1. Зачем нам необходимо свойство Capacity у List, если размер списка и так динамически изменяется?
2. Что произойдет, если установить значение Capacity меньше, чем текущее количество элементов в списке?

Начнем со второго вопроса. Перепишем нашу программу следующим образом:

List people = new List(2);
//добавляем элементы в список
people.Add(new Person() { Name = «Вася» });
people.Add(new Person() { Name = «Петя» });
people.Add(new Person() { Name = «Ваня» });
people.Add(new Person() { Name = «Гоша» });
people.Add(new Person() { Name = «Таня» });
//Устанавливаем новой значение Capacity
people.Capacity = 4;

Как только мы запустим приложение, то сразу же получим исключение:

Отсюда следует, что, во-первых, нельзя устанавливать значение Capacity меньше, чем текущее количество элементов в списке и, во-вторых, для избежания исключительных ситуаций, свойство Capacity наиболее безопасно устанавливать ДО начала добавления элементов в список.

Что касается того, зачем нам, в принципе, необходимо свойство Capacity, то здесь нам поможет следующий пример:

using System;
using System.Collections.Generic;
using System.Diagnostics;

namespace ListExample2
{
class Program
{
static void Main(string[] args)
{
Stopwatch stopwatch = new Stopwatch();

List numbers = new List();
stopwatch.Restart();
for (int i = 0; i < 100000000; i++) numbers.Add(i.ToString()); Console.WriteLine(string.Format("На добавление {0} элементов затрачено: {1:00} мс", numbers.Count, stopwatch.ElapsedMilliseconds)); Console.WriteLine($"Capacity: {numbers.Capacity}"); } } }

Здесь мы создаем очень-очень большой список строк и наполняем его значениями в цикле, а затем — выводим затраченное время в консоль. Результат работы будет следующим:

Теперь перепишем нашу программу и при создании списка укажем ему сразу начальную емкость:

Как видно из результатов, даже при использовании списка с достаточно простыми типами данных (в нашем случае — это string), начальное указание емкости хранилища позволяет сэкономить время работы программы, так как нам уже не потребуется динамически менять размеры внутреннего хранилища списка.

Также стоит отметить, что при динамическом изменении размера списка свойство Capacity изменяется на значение равному степени двойки, т.е. 2, 4, 8, 16 и т.д, что, опять же приводит к использованию лишней памяти нашей программой. Если вам необходимо, чтобы размер внутреннего хранилища соответствовал реальному количеству элементов в списке, необходимо использовать метод TrimExcess(), например:

List numbers = new List();
for (int i = 0; i < 100000000; i++) numbers.Add(i.ToString()); Console.WriteLine($"Capacity: {numbers.Capacity}"); numbers.TrimExcess(); Console.WriteLine($"Capacity: {numbers.Capacity}");

Результат работы:

Итого

Сегодня мы рассмотрели основные моменты по работе со списком List в C#, научились создавать список, выводить значения из списка в консоль, а также разобрались с тем, зачем нам необходимо свойство Capacity и как его использовать.

C# List

Summary: in this tutorial, you’ll learn how to use the C# List class to manipulate list elements effectively.

The C# List class allows you to manage a list of values of any type. The List class represents a strongly typed list of objects that can be accessed by index.

The T inside the angle brackets specifies the type of elements in the list. For example, you can have a list of integers, strings, and objects.

The List belongs to the System.Collections.Generic namespace.

The following creates a new list of strings:

List states = new List();Code language: C# (cs)

And you can make it shorter by using the var keyword:

var states = new List();Code language: C# (cs)

To add an element to a list, you use the Add() method. For example, the following uses the Add() method to add three strings to the list:

var states = new List(); states.Add(«California»);
states.Add(«Texas»);
states.Add(«New York»);Code language: C# (cs)

To iterate over the elements of a list, you use the foreach statement. The foreach statement assigns the current list element to a variable in each iteration from the first to the last element.

For example, the following uses the foreach statement to iterate over the elements of the states list:

var states = new List(); states.Add(«California»);
states.Add(«Texas»);
states.Add(«New York»); foreach (var state in states)
{
Console.WriteLine(state);
}Code language: C# (cs)

Output:

California
Texas
New YorkCode language: C# (cs)

To simplify creating and populating a list, you can use a collection initializer. For example, the following creates a list and populates it with three elements:

var states = new List() { «California», «Texas», «New York»
};Code language: C# (cs)

To check if an element exists in a list, you use Contains() method. The Contains() method returns true if an element exists in a list. Otherwise, it returns false.

For example:

var states = new List()
{ «California», «Texas», «New York»
}; Console.WriteLine(states.Contains(«Texas»)); Console.WriteLine(states.Contains(«Washington»)); Code language: C# (cs)

In this example, the states list contains «Texas». Therefore, the following method call returns true:

states.Contains(«Texas»);Code language: C# (cs)

Also, because the states list doesn’t contain «Washington», the Contains() method returns false:

states.Contains(«Washington»);Code language: C# (cs)

The List class allows you to access its elements using indices. The first element has an index of 0, the second element has an index of 1, and so on:

listObject[index]Code language: C# (cs)

The following uses the for statement to iterate over the list elements and convert them to uppercase:

var states = new List()
{ «California», «Texas», «New York»
}; for (int i = 0; i < states.Count; i++) { states[i] = states[i].ToUpper(); Console.WriteLine(states[i]); }Code language: C# (cs)

Output:

CALIFORNIA
TEXAS
NEW YORKCode language: C# (cs)

To insert an element into a list at a specified index, you use the Insert() method. For example, the following inserts an element at the index 0 and another element at the index 1:

var states = new List()
{ «California», «Texas», «New York»
}; states.Insert(0, «Alaska»);
states.Insert(1, «Arizona»); foreach (var state in states)
{
Console.WriteLine(state);
}Code language: C# (cs)

Output:

Alaska
Arizona
California
Texas
New YorkCode language: C# (cs)

To sort a list, you use the Sort() method. The Sort() method sorts the list elements using the default comparer.

For example, the following uses the Sort() method to sort a list of strings in ascending order:

var states = new List()
{ «California», «Texas», «Arizona», «New York», «Alaska»
}; states.Sort(); foreach (var state in states)
{
Console.WriteLine(state);
}Code language: C# (cs)

Output:

C# List Collection

The List is a collection of strongly typed objects that can be accessed by index and having methods for sorting, searching, and modifying list. It is the generic version of the ArrayList that comes under System.Collections.Generic namespace.

List Characteristics

• List equivalent of the ArrayList, which implements IList.
• It comes under System.Collections.Generic namespace.
• List can contain elements of the specified type. It provides compile-time type checking and doesn't perform boxing-unboxing because it is generic.
• Elements can be added using the Add(), AddRange() methods or collection-initializer syntax.
• Elements can be accessed by passing an index e.g. myList[0]. Indexes start from zero.
• List performs faster and less error-prone than the ArrayList.

Creating a List

The List is a generic collection, so you need to specify a type parameter for the type of data it can store. The following example shows how to create list and add elements.

List primeNumbers = new List();
primeNumbers.Add(1); // adding elements using add() method
primeNumbers.Add(3);
primeNumbers.Add(5);
primeNumbers.Add(7); var cities = new List();
cities.Add(«New York»);
cities.Add(«London»);
cities.Add(«Mumbai»);
cities.Add(«Chicago»);
cities.Add(null);// nulls are allowed for reference type list //adding elements using collection-initializer syntax
var bigCities = new List() { «New York», «London», «Mumbai», «Chicago»
};

In the above example, List primeNumbers = new List(); creates a list of int type. In the same way, cities and bigCities are string type list. You can then add elements in a list using the Add() method or the collection-initializer syntax.

You can also add elements of the custom classes using the collection-initializer syntax. The following adds objects of the Student class in the List.

var students = new List() { new Student(){ Id = 1, Name=»Bill»}, new Student(){ Id = 2, Name=»Steve»}, new Student(){ Id = 3, Name=»Ram»}, new Student(){ Id = 4, Name=»Abdul»}
};

Adding an Array in a List

Use the AddRange() method to add all the elements from an array or another collection to List.

AddRange() signature: void AddRange(IEnumerable collection)

string[] cities = new string[3]{ «Mumbai», «London», «New York» }; var popularCities = new List(); // adding an array in a List
popularCities.AddRange(cities); var favouriteCities = new List(); // adding a List
favouriteCities.AddRange(popularCities);

Accessing a List

A list can be accessed by an index, a for/foreach loop, and using LINQ queries. Indexes of a list start from zero. Pass an index in the square brackets to access individual list items, same as array. Use a foreach or for loop to iterate a List collection.

List numbers = new List() { 1, 2, 5, 7, 8, 10 };
Console.WriteLine(numbers[0]); // prints 1
Console.WriteLine(numbers[1]); // prints 2
Console.WriteLine(numbers[2]); // prints 5
Console.WriteLine(numbers[3]); // prints 7 // using foreach LINQ method
numbers.ForEach(num => Console.WriteLine(num + «, «));//prints 1, 2, 5, 7, 8, 10, // using for loop
for(int i = 0; i < numbers.Count; i++) Console.WriteLine(numbers[i]);

Accessing a List using LINQ

The List implements the IEnumerable interface. So, we can query a list using LINQ query syntax or method syntax, as shown below.

var students = new List() { new Student(){ Id = 1, Name=»Bill»}, new Student(){ Id = 2, Name=»Steve»}, new Student(){ Id = 3, Name=»Ram»}, new Student(){ Id = 4, Name=»Abdul»} }; //get all students whose name is Bill
var result = from s in students where s.Name == «Bill» select s; foreach(var student in result) Console.WriteLine(student.Id + «, » + student.Name);

Insert Elements in List

Use the Insert() method inserts an element into the List collection at the specified index.

Insert() signature:void Insert(int index, T item);

var numbers = new List(){ 10, 20, 30, 40 }; numbers.Insert(1, 11);// inserts 11 at 1st index: after 10. foreach (var num in numbers) Console.Write(num);

Remove Elements from List

Use the Remove() method to remove the first occurrence of the specified element in the List collection. Use the RemoveAt() method to remove an element from the specified index. If no element at the specified index, then the ArgumentOutOfRangeException will be thrown.

Remove() signature: bool Remove(T item)

RemoveAt() signature: void RemoveAt(int index)

var numbers = new List(){ 10, 20, 30, 40, 10 }; numbers.Remove(10); // removes the first 10 from a list numbers.RemoveAt(2); //removes the 3rd element (index starts from 0) //numbers.RemoveAt(10); //throws ArgumentOutOfRangeException foreach (var el in intList) Console.Write(el); //prints 20 30

Check Elements in List

Use the Contains() method to determine whether an element is in the List or not.

var numbers = new List(){ 10, 20, 30, 40 };
numbers.Contains(10); // returns true
numbers.Contains(11); // returns false
numbers.Contains(20); // returns true

List Class Hierarchy

The following diagram illustrates the List hierarchy.

List Class Properties and Methods

The following table lists the important properties and methods of List class:

Property Usage

Items	Gets or sets the element at the specified index
Count	Returns the total number of elements exists in the List

Method Usage

Add	Adds an element at the end of a List.
AddRange	Adds elements of the specified collection at the end of a List.
BinarySearch	Search the element and returns an index of the element.
Clear	Removes all the elements from a List.
Contains	Checks whether the specified element exists or not in a List.
Find

C# List

Data management is a fundamental aspect of programming, and it often involves dealing with collections of objects. One versatile and commonly used collection type is the List. In this article, we will explore the List data structure in C#, its operations, properties, and various scenarios where it proves to be a powerful tool.

Introduction to C# List

A list is a dynamic data structure that allows you to store and manipulate collections of objects. It provides flexibility and convenience, allowing you to easily add, remove, access, and modify elements within the collection. Compared to arrays, lists offer dynamic resizing, which means they can grow or shrink as needed without requiring manual memory management.

The List class is part of the System.Collections.Generic namespace, and provides a rich set of methods and properties for manipulating and accessing elements. With Lists, you can add, remove, insert, search, sort, and iterate over elements effortlessly.

To create a list in C#, you can use the List class, where T represents the type of objects you want to store in the list. For example, let's create a list of strings using the List class and the collection initializer syntax:

using System;
using System.Collections.Generic; class Program
{ static void Main() { List fruits = new List(); // Add fruits to the list fruits.Add(«Apple»); fruits.Add(«Banana»); fruits.Add(«Orange»); fruits.Add(«Grapes»); // Display the fruits Console.WriteLine(«Fruit List:»); foreach (string fruit in fruits) { Console.WriteLine(fruit); } }
}

Output:

The above program creates a List named fruits and adds four fruit names to it using the Add method. Then, it iterates over the list of the fruits using a foreach loop and displays each fruit name on the console.

Basic Operations

Lists in C# provide a rich set of methods for performing basic operations. Let's explore some of the commonly used methods:

1. Add:

The Add method is used to append an element to the end of a list. It increases the count of elements in the list by one. In the above section, we have created a list using Add() method.

2. Remove:

The Remove method is used to remove the first occurrence of a specified element from a list. If the element is found and removed, it shifts the remaining elements (if any) to fill the gap and decreases the count of elements in the list by one.

Here we have an example of how to remove an element from a list:

using System; using System.Collections.Generic; class Program { static void Main() { // Creating a list of fruits List fruits = new List { «Apple», «Banana», «Orange», «Grapes» }; // Display the original list of fruits Console.WriteLine(«Original list of fruits:»); PrintList(fruits); // Remove an item from the list Console.WriteLine(«Removing 'Banana' from the list…»); fruits.Remove(«Banana»); // Display the updated list of fruits Console.WriteLine(«Updated list of fruits:»); PrintList(fruits); } // Helper method to print the contents of a list static void PrintList(List list) { foreach (string item in list) { Console.WriteLine(item); } Console.WriteLine(); } }

Output:

The above program starts by creating a list of fruits. It then displays the original list of fruits. Next, it removes the item «Banana» from the list using the Remove method. Finally, it displays the updated list of fruits. The output shows the original list and the updated list after removing the «Banana» item.

3. Insert:

The Insert method allows you to insert an element at a specified index position within a list. It shifts the existing elements (if any) and increases the count of elements in the list by one.

The Insert method shifts the existing elements from the specified index onwards to the right, making room for the new element. It then inserts the specified item at the provided index position.

Consider the example that demonstrates Insert method in a list C#:

using System;
using System.Collections.Generic; class Program
{ static void Main() { // Creating a list of fruits List fruits = new List { «Apple», «Banana», «Orange», «Grapes» }; // Display the original list of fruits Console.WriteLine(«Original list of fruits:»); PrintList(fruits); // Insert an item into the list Console.WriteLine(«Inserting 'Mango' at index 1…»); fruits.Insert(1, «Mango»); // Display the updated list of fruits Console.WriteLine(«Updated list of fruits:»); PrintList(fruits); } // Helper method to print the contents of a list static void PrintList(List list) { foreach (string item in list) { Console.WriteLine(item); } Console.WriteLine(); }
}

Output:

It's important to note that the index parameter should be within the valid range of the list. If the index is less than zero or greater than the count of elements in the list, an ArgumentOutOfRangeException will be thrown.

The Insert method is useful when you need to add an element at a specific position in a list, allowing you to control the order and placement of elements within the list.

4. IndexOf:

The IndexOf method allows you to find the index of the first occurrence of a specified element in a list. It returns an integer value representing the index of the element if found, or -1 if the element is not present in the list.

The IndexOf method performs a linear search through the list, comparing each element with the specified item using the default equality comparer for the element type. If a matching element is found, the method returns the index of that element in the list. If the element is not found, it returns -1.

Here's a program that demonstrates using the IndexOf method in a list in C#:

using System;
using System.Collections.Generic; class Program
{ static void Main() { // Creating a list of fruits List fruits = new List { «Apple», «Banana», «Orange», «Grapes» }; // Display the original list of fruits Console.WriteLine(«Original list of fruits:»); PrintList(fruits); // Find the index of a specific item in the list Console.WriteLine(«Finding the index of 'Orange'…»); int index = fruits.IndexOf(«Orange»); Console.WriteLine(«'Orange' is found at index: » + index); } // Helper method to print the contents of a list static void PrintList(List list) { foreach (string item in list) { Console.WriteLine(item); } Console.WriteLine(); }
}

Output:

The IndexOf method is useful when you need to locate the position of a specific element within a list or determine if it exists in the list at all. It allows you to access the index information for further processing or manipulation of the list.

5. Contains:

The Contains method is a member of the List class that allows you to check whether a specific element exists in a list. It returns a Boolean value indicating whether the element is found or not.

The Contains method performs a linear search through the list, comparing each element with the specified item using the default equality comparer for the element type. If a matching element is found, the method returns true; otherwise, it returns false.

Consider the below example to check whether the given fruit exists or not.

using System;
using System.Collections.Generic; class Program
{ static void Main() { // Creating a list of fruits List fruits = new List { «Apple», «Banana», «Orange», «Grapes» }; // Display the original list of fruits Console.WriteLine(«Original list of fruits:»); PrintList(fruits); // Check if an item exists in the list Console.WriteLine(«Checking if 'Banana' exists in the list…»); bool exists = fruits.Contains(«Banana»); Console.WriteLine(«'Banana' exists in the list: » + exists); } // Helper method to print the contents of a list static void PrintList(List list) { foreach (string item in list) { Console.WriteLine(item); } Console.WriteLine(); }
}

Output: