Коллекции IEnumerable, ICollection, IList и List в C#

public interface IEnumerable
{
    IEnumerator GetEnumerator();
}

public interface IEnumerable<out T> : IEnumerable
{
    IEnumerator<T> GetEnumerator();
}

using System;
using System.Collections.Generic;
 
class Program
{
    static void Main()
    {
        // Создаем коллекцию чисел
        IEnumerable<int> numbers = new List<int> { 1, 3, 5, 7, 9 };
        
        // Перебираем элементы с помощью foreach
        foreach (var num in numbers)
        {
            Console.WriteLine($"Число: {num}");
        }
        
        // Можно использовать и обычный итератор
        IEnumerator<int> enumerator = numbers.GetEnumerator();
        try 
        {
            while (enumerator.MoveNext())
            {
                Console.WriteLine($"Через енумератор: {enumerator.Current}");
            }
        }
        finally 
        {
            enumerator.Dispose();
        }
    }
}

// Метод работает с любой коллекцией целых чисел
public static int CalculateSum(IEnumerable<int> numbers)
{
    int sum = 0;
    foreach (var num in numbers)
    {
        sum += num;
    }
    return sum;
}
 
// Вызов с различными типами коллекций
int[] array = { 1, 2, 3 };
List<int> list = new List<int> { 4, 5, 6 };
HashSet<int> set = new HashSet<int> { 7, 8, 9 };
 
Console.WriteLine(CalculateSum(array)); // Работает с массивом
Console.WriteLine(CalculateSum(list));  // Работает со списком
Console.WriteLine(CalculateSum(set));   // Работает с множеством

using System;
using System.Collections;
using System.Collections.Generic;
 
// Класс для представления диапазона чисел
public class NumberRange : IEnumerable<int>
{
    private readonly int _start;
    private readonly int _end;
 
    public NumberRange(int start, int end)
    {
        _start = start;
        _end = end;
    }
 
    // Реализация IEnumerable<int>
    public IEnumerator<int> GetEnumerator()
    {
        for (int i = _start; i <= _end; i++)
        {
            yield return i;
        }
    }
 
    // Реализация необобщенного IEnumerable
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}
 
// Использование
NumberRange range = new NumberRange(1, 5);
foreach (int num in range)
{
    Console.WriteLine(num); // Выводит: 1, 2, 3, 4, 5
}

// Создаем метод, который генерирует последовательность
public static IEnumerable<int> GenerateNumbers(int count)
{
    Console.WriteLine("Начало генерации...");
    for (int i = 0; i < count; i++)
    {
        Console.WriteLine($"Генерация числа {i}");
        yield return i;
    }
}
 
// Создаем последовательность
IEnumerable<int> sequence = GenerateNumbers(5);
Console.WriteLine("Последовательность создана, но числа еще не сгенерированы");
 
// Только при переборе начинается фактическая генерация
foreach (var num in sequence)
{
    Console.WriteLine($"Получено число: {num}");
}

// Бесконечный генератор чисел Фибоначчи
public static IEnumerable<long> Fibonacci()
{
    long current = 0;
    long next = 1;
    
    while (true)  // Бесконечный цикл!
    {
        yield return current;
        long temp = current + next;
        current = next;
        next = temp;
    }
}
 
// Использование - получаем только первые 10 чисел
foreach (var num in Fibonacci().Take(10))
{
    Console.WriteLine(num);  // 0, 1, 1, 2, 3, 5, 8, 13, 21, 34
}

// Пример цепочки LINQ-операций
var result = Enumerable.Range(1, 1000000)  // создаем последовательность
    .Where(n => n % 2 == 0)                // только четные
    .Select(n => n * n)                    // возводим в квадрат  
    .Take(5)                               // берем только первые 5
    .ToList();                             // материализуем в список
 
foreach (var item in result)
{
    Console.WriteLine(item);  // 4, 16, 36, 64, 100
}

var numbers = Enumerable.Range(1, 10)
    .Select(n => {
        Console.WriteLine($"Вычисляем {n}");
        return n * 2;
    });
 
// Первый перебор
foreach (var n in numbers) 
    Console.WriteLine($"Первый проход: {n}");
    
// Второй перебор - вычисления повторяются!
foreach (var n in numbers) 
    Console.WriteLine($"Второй проход: {n}");

// Ошибка деления на ноль не возникнет здесь
var dangerous = Enumerable.Range(-5, 11)
    .Select(n => 10 / n);  // Потенциальное деление на ноль!
 
try
{
    // Ошибка произойдет только здесь, при итерации
    foreach (var item in dangerous)
    {
        Console.WriteLine(item);
    }
}
catch (DivideByZeroException)
{
    Console.WriteLine("Произошла ошибка деления на ноль");
}

// Неэффективно - вычисления повторяются
var query = expensiveData.Where(x => ExpensiveFilter(x));
var count = query.Count();  // Первый проход
var firstItems = query.Take(10).ToList();  // Второй проход
 
// Эффективно - вычисляем один раз
var filteredList = expensiveData.Where(x => ExpensiveFilter(x)).ToList();
var count = filteredList.Count;  // Быстрая операция
var firstItems = filteredList.Take(10).ToList();  // Быстрая операция

// Неоптимально: фильтруем после трансформации
var result1 = collection
    .Select(x => ExpensiveTransform(x))  // Трансформируем все элементы
    .Where(x => x > 100);                // Затем фильтруем
 
// Оптимально: фильтруем до трансформации
var result2 = collection
    .Where(x => SimpleEstimate(x) > 100)  // Сначала отфильтровываем
    .Select(x => ExpensiveTransform(x));  // Трансформируем только нужные

// Неоптимально: перебираем всю коллекцию
bool exists = collection.Where(x => x.Name == "John").Count() > 0;
 
// Оптимально: останавливаемся при первом совпадении
bool exists = collection.Any(x => x.Name == "John");

public interface ICollection<T> : IEnumerable<T>, IEnumerable
{
    int Count { get; }
    bool IsReadOnly { get; }
    void Add(T item);
    void Clear();
    bool Contains(T item);
    void CopyTo(T[] array, int arrayIndex);
    bool Remove(T item);
}

using System;
using System.Collections.Generic;
 
class Program
{
    static void Main()
    {
        // Создаем коллекцию строк
        ICollection<string> fruits = new List<string>();
        
        // Добавляем элементы
        fruits.Add("Яблоко");
        fruits.Add("Банан");
        fruits.Add("Апельсин");
        
        // Проверяем наличие элемента
        bool hasApple = fruits.Contains("Яблоко");
        Console.WriteLine($"Коллекция содержит яблоко: {hasApple}");
        
        // Получаем количество элементов
        Console.WriteLine($"Всего фруктов: {fruits.Count}");
        
        // Копируем в массив
        string[] fruitArray = new string[fruits.Count];
        fruits.CopyTo(fruitArray, 0);
        Console.WriteLine("Массив фруктов: " + string.Join(", ", fruitArray));
        
        // Удаляем элемент
        bool removed = fruits.Remove("Банан");
        Console.WriteLine($"Банан удален: {removed}");
        Console.WriteLine($"Осталось фруктов: {fruits.Count}");
        
        // Очищаем коллекцию
        fruits.Clear();
        Console.WriteLine($"После очистки: {fruits.Count}");
    }
}

// Метод ожидает IEnumerable - можно только читать
public static void PrintCollection<T>(IEnumerable<T> items)
{
    foreach (var item in items)
    {
        Console.WriteLine(item);
    }
    // Нельзя изменять коллекцию
    // items.Add(...); // Ошибка компиляции!
}
 
// Метод ожидает ICollection - можно изменять
public static void ProcessCollection<T>(ICollection<T> items, T newItem)
{
    // Можем узнать размер
    Console.WriteLine($"Размер до: {items.Count}");
    
    // Можем изменять коллекцию
    items.Add(newItem);
    
    Console.WriteLine($"Размер после: {items.Count}");
}

public static class CollectionExtensions
{
    public static async Task AddRangeAsync<T>(this ICollection<T> collection, 
                                            IEnumerable<T> items,
                                            CancellationToken cancellationToken = default)
    {
        foreach (var item in items)
        {
            // Проверяем, не запрошена ли отмена операции
            cancellationToken.ThrowIfCancellationRequested();
            
            // Здесь можно добавить асинхронную обработку перед добавлением
            await Task.Delay(10, cancellationToken); // Имитация асинхронной работы
            
            collection.Add(item);
        }
    }
}
 
// Пример использования
async Task ExampleAsync()
{
    ICollection<string> names = new List<string>();
    string[] newNames = { "Алексей", "Борис", "Виктория" };
    
    await names.AddRangeAsync(newNames);
    
    foreach (var name in names)
    {
        Console.WriteLine(name);
    }
}

public class BoundedUniqueCollection<T> : ICollection<T>
{
    private readonly HashSet<T> _items;
    private readonly int _capacity;
    
    public BoundedUniqueCollection(int capacity)
    {
        _capacity = capacity > 0 ? capacity : throw new ArgumentException("Емкость должна быть положительной");
        _items = new HashSet<T>();
    }
    
    public int Count => _items.Count;
    
    public bool IsReadOnly => false;
    
    public void Add(T item)
    {
        if (_items.Count >= _capacity && !_items.Contains(item))
            throw new InvalidOperationException($"Коллекция достигла максимальной емкости в {_capacity} элементов");
            
        _items.Add(item);
    }
    
    public void Clear() => _items.Clear();
    
    public bool Contains(T item) => _items.Contains(item);
    
    public void CopyTo(T[] array, int arrayIndex) => _items.CopyTo(array, arrayIndex);
    
    public bool Remove(T item) => _items.Remove(item);
    
    public IEnumerator<T> GetEnumerator() => _items.GetEnumerator();
    
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

var boundedCollection = new BoundedUniqueCollection<int>(3);
boundedCollection.Add(1);
boundedCollection.Add(2);
boundedCollection.Add(3);
// boundedCollection.Add(4); // Вызовет исключение - превышена емкость
 
boundedCollection.Add(2); // Работает, так как 2 уже есть в коллекции

public interface IList<T> : ICollection<T>, IEnumerable<T>, IEnumerable
{
T this[int index] { get; set; }  // Индексатор
int IndexOf(T item);             // Поиск индекса элемента
void Insert(int index, T item);  // Вставка элемента по индексу
void RemoveAt(int index);        // Удаление элемента по индексу
}

using System;
using System.Collections.Generic;
 
class Program
{
    static void Main()
    {
        IList<int> numbers = new List<int> { 10, 20, 30 };
        
        // Доступ по индексу
        Console.WriteLine($"Второй элемент: {numbers[1]}");  // 20
        
        // Изменение элемента
        numbers[1] = 25;
        Console.WriteLine($"Измененный элемент: {numbers[1]}");  // 25
        
        // Вставка элемента
        numbers.Insert(1, 15);
        
        // Удаление по индексу
        numbers.RemoveAt(0);
        
        // Вывод всех элементов
        for (int i = 0; i < numbers.Count; i++)
        {
            Console.WriteLine($"numbers[{i}] = {numbers[i]}");
        }
    }
}

// Демонстрация разницы между ICollection<T> и IList<T>
ICollection<string> namesCollection = new List<string> { "Анна", "Борис", "Виктор" };
IList<string> namesList = new List<string> { "Анна", "Борис", "Виктор" };
 
// С ICollection<T> мы можем только:
namesCollection.Add("Григорий");
namesCollection.Remove("Борис");
 
// С IList<T> мы можем также:
namesList[0] = "Алексей";        // Заменить по индексу
namesList.Insert(2, "Дмитрий");  // Вставить по индексу
int position = namesList.IndexOf("Виктор");  // Найти индекс
namesList.RemoveAt(position);    // Удалить по индексу

IList<int> numbers = new List<int> { 5, 2, 9, 1, 7 };
 
// Сортировка через Array (работает только с Array или List)
if (numbers is List<int> list)
{
    list.Sort();
}
 
// Альтернативно через LINQ (возвращает новую коллекцию)
IEnumerable<int> sortedNumbers = numbers.OrderBy(n => n);
 
// Поиск минимального/максимального элементов через LINQ
int min = numbers.Min();
int max = numbers.Max();
 
// Бинарный поиск (только на отсортированных списках)
if (numbers is List<int> sortedList)
{
    int index = sortedList.BinarySearch(7);
    if (index >= 0)
        Console.WriteLine($"Элемент найден в позиции {index}");
}

IList<string> sharedList = new List<string>();
object lockObject = new object();
 
// В многопоточной среде:
lock (lockObject)
{
    sharedList.Add("Новый элемент");
    string item = sharedList[0];
    sharedList.RemoveAt(0);
}

using System.Collections.Concurrent;
 
// ConcurrentBag не реализует IList, но безопасен в многопоточной среде
ConcurrentBag<string> concurrentCollection = new ConcurrentBag<string>();
 
// Параллельное добавление
Parallel.For(0, 100, i => 
{
    concurrentCollection.Add($"Элемент {i}");
});

using System.Collections.Immutable;
 
// Создание неизменяемого списка
ImmutableList<int> immutableList = ImmutableList.Create<int>(1, 2, 3);
 
// Любые изменения создают новую коллекцию
ImmutableList<int> newList = immutableList.Add(4);

public class List<T> : IList<T>
{
    private T[] _items;
    private int _size;
    private const int DefaultCapacity = 4;
    
    // Остальные поля и методы...
}

// Примеры производительности List<T>
List<int> numbers = new List<int>();
 
// Быстрая операция - O(1) амортизированная сложность
numbers.Add(10);  
 
// Медленная операция - O(n) сложность
numbers.Insert(0, 5);  
 
// Быстрая операция - O(1) сложность
int value = numbers[1];  
 
// Медленная операция - O(n) сложность
numbers.Remove(5);

// Демонстрация изменения емкости
public static void DemonstrateCapacityChanges()
{
    List<int> list = new List<int>();
    Console.WriteLine($"Начальная емкость: {list.Capacity}");
    
    for (int i = 0; i < 10; i++)
    {
        list.Add(i);
        Console.WriteLine($"Размер: {list.Count}, Емкость: {list.Capacity}");
    }
}

// Оптимизация использования памяти
// Если мы знаем, что будем хранить около 1000 элементов
List<string> optimizedList = new List<string>(1000);
 
// После всех операций можно уменьшить емкость до фактического размера
optimizedList.TrimExcess();

List<string> cities = new List<string> { "Москва", "Нью-Йорк", "Лондон", "Токио", "Париж" };
 
// Диапазонные операции
cities.AddRange(new[] { "Берлин", "Рим" });
cities.InsertRange(2, new[] { "Мадрид", "Барселона" });
cities.RemoveRange(1, 3);
 
// Поиск
int parisIndex = cities.IndexOf("Париж");
int lastIndex = cities.LastIndexOf("Москва");
bool containsTokyo = cities.Contains("Токио");
 
// Сортировка и упорядочивание
cities.Sort();
cities.Reverse();
 
// Преобразования
string[] cityArray = cities.ToArray();
List<string> capitalsOnly = cities.GetRange(0, 3);
 
// Выборка и фильтрация (возвращают новую коллекцию)
var filteredCities = cities.Where(c => c.StartsWith("М")).ToList();

List<int> numbers = new List<int> { 5, 3, 9, 1, 7 };
 
// Встроенная сортировка
numbers.Sort();  // [1, 3, 5, 7, 9]
 
// Сортировка с компаратором
numbers.Sort((a, b) => b.CompareTo(a));  // [9, 7, 5, 3, 1]
 
// Эффективный бинарный поиск (работает только на отсортированных списках)
numbers.Sort();
int index = numbers.BinarySearch(5);  // Вернет 2 (индекс элемента 5)

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
 
List<Person> people = new List<Person>
{
    new Person { Name = "Анна", Age = 30 },
    new Person { Name = "Борис", Age = 25 },
    new Person { Name = "Виктор", Age = 35 }
};
 
// Сортировка по возрасту
people.Sort((p1, p2) => p1.Age.CompareTo(p2.Age));
 
// Альтернативный способ с использованием Comparison<T>
Comparison<Person> byName = (p1, p2) => p1.Name.CompareTo(p2.Name);
people.Sort(byName);

List<string> fruits = new List<string> { "Яблоко", "Банан", "Груша" };
 
// Конвертация в массив (создает копию)
string[] fruitArray = fruits.ToArray();
 
// Создание списка из другой коллекции
List<int> lengths = new List<int>(fruits.Select(f => f.Length));
 
// Преобразование элементов с использованием ConvertAll
List<int> lengths2 = fruits.ConvertAll(f => f.Length);

List<string> items = new List<string> { "один", "два", "три", "четыре", "пять" };
 
// Находит первый элемент, удовлетворяющий условию
string found = items.Find(s => s.Length > 3);  // "четыре"
 
// Находит все элементы, удовлетворяющие условию
List<string> longWords = items.FindAll(s => s.Length > 3);  // ["четыре", "пять"]
 
// Находит индекс элемента, удовлетворяющего условию
int index = items.FindIndex(s => s.StartsWith("т"));  // 2 (индекс "три")
 
// Находит последний элемент, удовлетворяющий условию
string lastItem = items.FindLast(s => s.Contains("е"));  // "четыре"

// Неоптимально: возвращаем List, когда клиенту нужна только итерация
public List<Customer> GetCustomers() { ... }
 
// Лучше: возвращаем IEnumerable, если клиенту не нужно модифицировать
public IEnumerable<Customer> GetCustomers() { ... }

// Неэффективно: запрос выполняется дважды
var query = dbContext.Products.Where(p => p.Price > 100);
var count = query.Count();
var first10 = query.Take(10).ToList();
 
// Эффективно: материализуем запрос один раз
var filteredProducts = dbContext.Products.Where(p => p.Price > 100).ToList();
var count = filteredProducts.Count;
var first10 = filteredProducts.Take(10).ToList();

// Слишком ограничительно, если нужна только итерация
public void ProcessItems(List<Item> items) { ... }
 
// Слишком обобщенно, если нужен доступ по индексу
public void ProcessItems(IEnumerable<Item> items) { ... }
 
// Оптимально: используйте наиболее подходящий интерфейс
public void ProcessItems(IReadOnlyList<Item> items) { ... }

// Сценарий: чтение данных, преобразование и вывод
// Подходит IEnumerable (только чтение)
public IEnumerable<string> GetFormattedNames(IEnumerable<Person> people)
{
    return people.Select(p => $"{p.LastName}, {p.FirstName}");
}
 
// Сценарий: добавление элементов без доступа по индексу
// Подходит ICollection (модификация)
public void AddVisitorsToLog(ICollection<LogEntry> log, IEnumerable<Visitor> visitors)
{
    foreach (var visitor in visitors)
    {
        log.Add(new LogEntry(visitor.Id, DateTime.Now));
    }
}
 
// Сценарий: случайный доступ и модификация элементов
// Подходит IList (индексация)
public void UpdatePriorities(IList<Task> tasks)
{
    for (int i = 0; i < tasks.Count; i++)
    {
        tasks[i].Priority = CalculatePriority(tasks[i], i);
    }
}
 
// Сценарий: сложная работа с данными, сортировка, поиск
// Подходит List<T> (расширенные возможности)
public List<Product> FilterAndSortProducts(List<Product> products, decimal minPrice)
{
    products.RemoveAll(p => p.Price < minPrice);
    products.Sort((a, b) => a.Price.CompareTo(b.Price));
    return products.GetRange(0, Math.Min(10, products.Count));
}