Stack, Queue и Hashtable в C#

// Базовые операции со стеком
Stack<int> stack = new Stack<int>();
 
// Добавление элемента (O(1) в среднем)
stack.Push(42);
 
// Просмотр верхнего элемента без удаления (O(1))
int top = stack.Peek();
 
// Удаление и возврат верхнего элемента (O(1) в среднем)
int value = stack.Pop();
 
// Проверка наличия элемента (O(n) - линейный поиск)
bool contains = stack.Contains(42);

public static bool AreParenthesesBalanced(string expression)
{
    Stack<char> stack = new Stack<char>();
    
    foreach (char c in expression)
    {
        if (c == '(' || c == '[' || c == '{')
        {
            stack.Push(c);
        }
        else if (c == ')' || c == ']' || c == '}')
        {
            if (stack.Count == 0)
                return false;
                
            char top = stack.Pop();
            
            if ((c == ')' && top != '(') ||
                (c == ']' && top != '[') ||
                (c == '}' && top != '{'))
            {
                return false;
            }
        }
    }
    
    return stack.Count == 0;
}

class UndoRedoManager
{
    private Stack<ICommand> undoStack = new Stack<ICommand>();
    private Stack<ICommand> redoStack = new Stack<ICommand>();
    
    public void ExecuteCommand(ICommand command)
    {
        command.Execute();
        undoStack.Push(command);
        redoStack.Clear(); // После нового действия redo-история очищается
    }
    
    public void Undo()
    {
        if(undoStack.Count > 0)
        {
            ICommand command = undoStack.Pop();
            command.Undo();
            redoStack.Push(command);
        }
    }
    
    public void Redo()
    {
        if(redoStack.Count > 0)
        {
            ICommand command = redoStack.Pop();
            command.Execute();
            undoStack.Push(command);
        }
    }
}

// Рекурсивная версия (опасная)
public int EvaluateRecursive(Node node)
{
    if (node.IsValue)
        return node.Value;
        
    if (node.Operation == "+")
        return EvaluateRecursive(node.Left) + EvaluateRecursive(node.Right);
    // ... другие операции
}
 
// Итеративная версия с использованием стека
public int EvaluateIterative(Node root)
{
    Stack<StackFrame> stack = new Stack<StackFrame>();
    stack.Push(new StackFrame { Node = root, State = EvalState.Start });
    
    int result = 0;
    
    while (stack.Count > 0)
    {
        StackFrame current = stack.Pop();
        
        if (current.Node.IsValue)
        {
            current.Result = current.Node.Value;
            // Обработка результата...
        }
        else if (current.State == EvalState.Start)
        {
            // Сохраняем текущий контекст и обрабатываем левое поддерево
            current.State = EvalState.AfterLeft;
            stack.Push(current);
            stack.Push(new StackFrame { Node = current.Node.Left, State = EvalState.Start });
        }
        // ... остальная логика
    }
    
    return result;
}

public static string InfixToPostfix(string infix)
{
    Dictionary<string, int> precedence = new Dictionary<string, int>
    {
        {"+", 1}, {"-", 1},
        {"*", 2}, {"/", 2},
        {"^", 3}
    };
    
    Stack<string> operatorStack = new Stack<string>();
    List<string> output = new List<string>();
    string[] tokens = infix.Split(' ');
    
    foreach (string token in tokens)
    {
        if (double.TryParse(token, out _))
        {
            output.Add(token); // Число сразу добавляем в выходную строку
        }
        else if (precedence.ContainsKey(token))
        {
            // Обработка операторов с учётом приоритета
            while (operatorStack.Count > 0 && 
                   precedence.ContainsKey(operatorStack.Peek()) &&
                   precedence[operatorStack.Peek()] >= precedence[token])
            {
                output.Add(operatorStack.Pop());
            }
            operatorStack.Push(token);
        }
        else if (token == "(")
        {
            operatorStack.Push(token);
        }
        else if (token == ")")
        {
            while (operatorStack.Count > 0 && operatorStack.Peek() != "(")
            {
                output.Add(operatorStack.Pop());
            }
            
            if (operatorStack.Count > 0 && operatorStack.Peek() == "(")
            {
                operatorStack.Pop(); // Убираем "("
            }
        }
    }
    
    // Выталкиваем оставшиеся операторы
    while (operatorStack.Count > 0)
    {
        output.Add(operatorStack.Pop());
    }
    
    return string.Join(" ", output);
}

public class BoundedStack<T>
{
    private readonly T[] _items;
    private int _count;
    
    public BoundedStack(int capacity)
    {
        if (capacity <= 0)
            throw new ArgumentOutOfRangeException(nameof(capacity));
            
        _items = new T[capacity];
    }
    
    public int Count => _count;
    
    public bool IsFull => _count == _items.Length;
    
    public void Push(T item)
    {
        if (IsFull)
            throw new InvalidOperationException("Stack is full");
            
        _items[_count++] = item;
    }
    
    public T Pop()
    {
        if (_count == 0)
            throw new InvalidOperationException("Stack is empty");
            
        return _items[--_count];
    }
    
    public T Peek()
    {
        if (_count == 0)
            throw new InvalidOperationException("Stack is empty");
            
        return _items[_count - 1];
    }
}

// Это код-катастрофа! Не используйте его в реальной жизни
Stack<int> sharedStack = new Stack<int>();
 
Task.Run(() => {
    for (int i = 0; i < 1000; i++)
        sharedStack.Push(i);
});
 
Task.Run(() => {
    for (int i = 1000; i < 2000; i++)
        sharedStack.Push(i);
});
 
// Результат непредсказуем, и почти наверняка не будет содержать 2000 элементов

private Stack<int> _stack = new Stack<int>();
private object _lockObj = new object();
 
public void SafePush(int item)
{
    lock (_lockObj)
    {
        _stack.Push(item);
    }
}
 
public int SafePop()
{
    lock (_lockObj)
    {
        if (_stack.Count == 0)
            throw new InvalidOperationException("Stack is empty");
        return _stack.Pop();
    }
}

ConcurrentStack<int> concurrentStack = new ConcurrentStack<int>();
 
// Безопасное добавление
concurrentStack.Push(42);
 
// Безопасное извлечение с проверкой успешности
bool success = concurrentStack.TryPop(out int result);
 
// Оптимизированные групповые операции
int[] items = { 1, 2, 3, 4, 5 };
concurrentStack.PushRange(items);
 
int[] results = new int[3];
concurrentStack.TryPopRange(results);

void TraverseInOrderRecursive(TreeNode node)
{
    if (node == null) return;
    
    TraverseInOrderRecursive(node.Left);
    Console.WriteLine(node.Value);
    TraverseInOrderRecursive(node.Right);
}

void TraverseInOrderIterative(TreeNode root)
{
    Stack<TreeNode> stack = new Stack<TreeNode>();
    TreeNode current = root;
    
    while (stack.Count > 0 || current != null)
    {
        // Идём до конца левой ветви
        while (current != null)
        {
            stack.Push(current);
            current = current.Left;
        }
        
        // Обрабатываем узел
        current = stack.Pop();
        Console.WriteLine(current.Value);
        
        // Переходим к правому поддереву
        current = current.Right;
    }
}

public class GraphTraversal
{
    private enum NodeState { NotVisited, Visiting, Visited }
    
    public void DepthFirstTraversal(Graph graph, int startVertex)
    {
        Dictionary<int, NodeState> states = new Dictionary<int, NodeState>();
        foreach (var vertex in graph.Vertices)
            states[vertex] = NodeState.NotVisited;
            
        Stack<int> stack = new Stack<int>();
        stack.Push(startVertex);
        
        while (stack.Count > 0)
        {
            int current = stack.Peek(); // Не извлекаем сразу!
            
            if (states[current] == NodeState.NotVisited)
            {
                // Обнаружили новую вершину
                Console.WriteLine($"Обрабатываем вершину {current}");
                states[current] = NodeState.Visiting;
                
                // Добавляем соседей
                foreach (int neighbor in graph.GetNeighbors(current))
                {
                    if (states[neighbor] == NodeState.NotVisited)
                        stack.Push(neighbor);
                }
            }
            else if (states[current] == NodeState.Visiting)
            {
                // Завершаем обработку вершины
                states[current] = NodeState.Visited;
                stack.Pop(); // Теперь можно извлечь
            }
            else // NodeState.Visited
            {
                // Если мы уже полностью обработали вершину, просто извлекаем её
                stack.Pop();
            }
        }
    }
}

public T DeepClone<T>(T source) where T : class, ICloneable
{
    if (source == null) return null;
    
    Dictionary<object, object> cloneMap = new Dictionary<object, object>();
    Stack<CloneTask> stack = new Stack<CloneTask>();
    
    // Создаём поверхностный клон корня
    T rootClone = (T)source.Clone();
    cloneMap[source] = rootClone;
    
    // Добавляем задачу клонирования полей
    stack.Push(new CloneTask(source, rootClone));
    
    while (stack.Count > 0)
    {
        CloneTask task = stack.Pop();
        
        // Клонируем все ссылочные поля
        foreach (var field in task.Source.GetType().GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
        {
            object fieldValue = field.GetValue(task.Source);
            
            if (fieldValue == null || !field.FieldType.IsClass)
                continue;
                
            if (cloneMap.TryGetValue(fieldValue, out object existingClone))
            {
                // Уже клонированный объект - просто используем ссылку
                field.SetValue(task.Target, existingClone);
            }
            else if (fieldValue is ICloneable cloneable)
            {
                // Клонируем новый объект
                object fieldClone = cloneable.Clone();
                cloneMap[fieldValue] = fieldClone;
                field.SetValue(task.Target, fieldClone);
                
                // Добавляем задачу для клонирования его полей
                stack.Push(new CloneTask(fieldValue, fieldClone));
            }
        }
    }
    
    return rootClone;
}
 
private class CloneTask
{
    public object Source { get; }
    public object Target { get; }
    
    public CloneTask(object source, object target)
    {
        Source = source;
        Target = target;
    }
}

public double EvaluateExpression(string expression)
{
    Stack<double> values = new Stack<double>();
    Stack<char> operators = new Stack<char>();
    
    for (int i = 0; i < expression.Length; i++)
    {
        char c = expression[i];
        
        if (char.IsDigit(c))
        {
            // Извлекаем полное число
            StringBuilder sb = new StringBuilder();
            while (i < expression.Length && (char.IsDigit(expression[i]) || expression[i] == '.'))
                sb.Append(expression[i++]);
            i--; // Компенсируем дополнительный инкремент в цикле
            
            values.Push(double.Parse(sb.ToString()));
        }
        else if (c == '(')
        {
            operators.Push(c);
        }
        else if (c == ')')
        {
            // Вычисляем всё внутри скобок
            while (operators.Count > 0 && operators.Peek() != '(')
                ApplyOperation(values, operators.Pop());
                
            operators.Pop(); // Удаляем '('
        }
        else if (IsOperator(c))
        {
            // Применяем операторы с большим или равным приоритетом
            while (operators.Count > 0 && Precedence(operators.Peek()) >= Precedence(c))
                ApplyOperation(values, operators.Pop());
                
            operators.Push(c);
        }
    }
    
    // Применяем оставшиеся операторы
    while (operators.Count > 0)
        ApplyOperation(values, operators.Pop());
        
    return values.Pop();
}
 
private void ApplyOperation(Stack<double> values, char op)
{
    double b = values.Pop();
    double a = values.Pop();
    
    switch (op)
    {
        case '+': values.Push(a + b); break;
        case '-': values.Push(a - b); break;
        case '*': values.Push(a * b); break;
        case '/': values.Push(a / b); break;
        case '^': values.Push(Math.Pow(a, b)); break;
    }
}

public class BoundedStack<T> : IEnumerable<T>
{
    private readonly T[] _items;
    private int _top = -1;
    private readonly int _capacity;
 
    public BoundedStack(int capacity)
    {
        if (capacity <= 0)
            throw new ArgumentException("Capacity must be positive");
        
        _capacity = capacity;
        _items = new T[capacity];
    }
 
    public int Count => _top + 1;
    public bool IsFull => Count == _capacity;
 
    public void Push(T item)
    {
        if (IsFull)
            throw new InvalidOperationException("Stack overflow");
        
        _items[++_top] = item;
    }
 
    public T Pop()
    {
        if (_top < 0)
            throw new InvalidOperationException("Stack underflow");
        
        return _items[_top--];
    }
    
    // IEnumerable implementation...
}

public class MinMaxStack<T> where T : IComparable<T>
{
    private readonly Stack<T> _stack = new Stack<T>();
    private readonly Stack<T> _minStack = new Stack<T>();
    private readonly Stack<T> _maxStack = new Stack<T>();
 
    public void Push(T item)
    {
        _stack.Push(item);
        
        if (_minStack.Count == 0 || item.CompareTo(_minStack.Peek()) <= 0)
            _minStack.Push(item);
            
        if (_maxStack.Count == 0 || item.CompareTo(_maxStack.Peek()) >= 0)
            _maxStack.Push(item);
    }
 
    public T Pop()
    {
        if (_stack.Count == 0)
            throw new InvalidOperationException("Stack is empty");
            
        T item = _stack.Pop();
        
        if (_minStack.Peek().CompareTo(item) == 0)
            _minStack.Pop();
            
        if (_maxStack.Peek().CompareTo(item) == 0)
            _maxStack.Pop();
            
        return item;
    }
 
    public T GetMin() => _minStack.Peek();
    public T GetMax() => _maxStack.Peek();
}

public class CircularStack<T>
{
    private readonly T[] _buffer;
    private int _top = -1;
    private int _count;
    
    public CircularStack(int capacity)
    {
        _buffer = new T[capacity];
    }
    
    public int Count => _count;
    
    public void Push(T item)
    {
        _top = (_top + 1) % _buffer.Length;
        _buffer[_top] = item;
        
        if (_count < _buffer.Length)
            _count++;
    }
    
    public T Pop()
    {
        if (_count == 0)
            throw new InvalidOperationException("Stack is empty");
            
        T result = _buffer[_top];
        _top = (_top - 1 + _buffer.Length) % _buffer.Length;
        _count--;
        
        return result;
    }
}

public class TransactionalStack<T>
{
    private Stack<T> _stack = new Stack<T>();
    private Stack<StackCommand> _transactionLog = new Stack<StackCommand>();
    private bool _inTransaction = false;
    
    public void BeginTransaction() => _inTransaction = true;
    
    public void CommitTransaction()
    {
        _inTransaction = false;
        _transactionLog.Clear();
    }
    
    public void RollbackTransaction()
    {
        while (_transactionLog.Count > 0)
        {
            var command = _transactionLog.Pop();
            command.Undo(_stack);
        }
        _inTransaction = false;
    }
    
    public void Push(T item)
    {
        _stack.Push(item);
        if (_inTransaction)
            _transactionLog.Push(new PushCommand(item));
    }
    
    public T Pop()
    {
        T item = _stack.Pop();
        if (_inTransaction)
            _transactionLog.Push(new PopCommand(item));
        return item;
    }
    
    private interface StackCommand
    {
        void Undo(Stack<T> stack);
    }
    
    private class PushCommand : StackCommand
    {
        private readonly T _item;
        public PushCommand(T item) => _item = item;
        public void Undo(Stack<T> stack) => stack.Pop();
    }
    
    private class PopCommand : StackCommand
    {
        private readonly T _item;
        public PopCommand(T item) => _item = item;
        public void Undo(Stack<T> stack) => stack.Push(_item);
    }
}

public static class StackExtensions
{
    public static void PushRange<T>(this Stack<T> stack, IEnumerable<T> items)
    {
        foreach (var item in items)
            stack.Push(item);
    }
    
    public static Stack<T> Clone<T>(this Stack<T> original)
    {
        T[] array = new T[original.Count];
        original.CopyTo(array, 0);
        Array.Reverse(array);
        return new Stack<T>(array);
    }
    
    public static IEnumerable<T> PopUntil<T>(this Stack<T> stack, Predicate<T> predicate)
    {
        while (stack.Count > 0 && !predicate(stack.Peek()))
            yield return stack.Pop();
    }
}

// Создание очереди
Queue<string> queue = new Queue<string>();
 
// Добавление элемента в конец очереди (O(1) амортизированно)
queue.Enqueue("Первый запрос");
 
// Просмотр элемента из начала очереди без удаления (O(1))
string first = queue.Peek();
 
// Извлечение и удаление элемента из начала очереди (O(1))
string request = queue.Dequeue();
 
// Проверка наличия элемента (O(n) линейный поиск)
bool contains = queue.Contains("Второй запрос");

public void BreadthFirstSearch(Graph graph, int startVertex)
{
    bool[] visited = new bool[graph.VertexCount];
    Queue<int> queue = new Queue<int>();
    
    visited[startVertex] = true;
    queue.Enqueue(startVertex);
    
    while (queue.Count > 0)
    {
        int currentVertex = queue.Dequeue();
        Console.WriteLine($"Обрабатываем вершину {currentVertex}");
        
        // Добавляем всех непосещённых соседей
        foreach (int neighbor in graph.GetNeighbors(currentVertex))
        {
            if (!visited[neighbor])
            {
                visited[neighbor] = true;
                queue.Enqueue(neighbor);
            }
        }
    }
}

public class JobQueue
{
    private readonly Queue<Job> _jobs = new Queue<Job>();
    private readonly object _lock = new object();
    private readonly ManualResetEventSlim _jobAvailable = new ManualResetEventSlim(false);
    
    public void AddJob(Job job)
    {
        lock (_lock)
        {
            _jobs.Enqueue(job);
            _jobAvailable.Set(); // Сигнализируем о наличии работы
        }
    }
    
    public Job GetNextJob()
    {
        lock (_lock)
        {
            while (_jobs.Count == 0)
            {
                Monitor.Exit(_lock); // Временно освобождаем блокировку
                _jobAvailable.Wait(); // Ждём появления работы
                Monitor.Enter(_lock); // Снова захватываем блокировку
            }
            
            if (_jobs.Count == 1) // Если это последняя работа в очереди
                _jobAvailable.Reset(); // Сбрасываем сигнал
                
            return _jobs.Dequeue();
        }
    }
}

public void ProcessXmlByLevels(XElement root)
{
    Queue<XElement> currentLevel = new Queue<XElement>();
    currentLevel.Enqueue(root);
    
    int level = 0;
    
    while (currentLevel.Count > 0)
    {
        Console.WriteLine($"Обработка элементов уровня {level}:");
        
        Queue<XElement> nextLevel = new Queue<XElement>();
        
        while (currentLevel.Count > 0)
        {
            XElement current = currentLevel.Dequeue();
            Console.WriteLine($"  {current.Name}");
            
            // Добавляем все дочерние элементы в очередь следующего уровня
            foreach (var child in current.Elements())
            {
                nextLevel.Enqueue(child);
            }
        }
        
        currentLevel = nextLevel;
        level++;
    }
}

// Упрощённое представление внутренней логики перераспределения
private void Grow()
{
    int newCapacity = _array.Length == 0 ? DefaultCapacity : 2 * _array.Length;
    T[] newArray = new T[newCapacity];
    
    if (_size > 0)
    {
        if (_head < _tail)
        {
            // Простой случай: элементы идут последовательно
            Array.Copy(_array, _head, newArray, 0, _size);
        }
        else
        {
            // Сложный случай: элементы "обернуты" вокруг конца массива
            Array.Copy(_array, _head, newArray, 0, _array.Length - _head);
            Array.Copy(_array, 0, newArray, _array.Length - _head, _tail);
        }
    }
    
    _array = newArray;
    _head = 0;
    _tail = (_size == newCapacity) ? 0 : _size;
}

// Избегаем частых перераспределений памяти
Queue<LogMessage> logsQueue = new Queue<LogMessage>(initialCapacity: 10000);

queue.TrimExcess(); // Уменьшает объем используемой памяти

// Вместо этого (возможны проблемы производительности при больших структурах)
Queue<LargeStruct> structQueue = new Queue<LargeStruct>();
 
// Лучше использовать так
Queue<LargeStruct?> structRefQueue = new Queue<LargeStruct?>();
// Или даже так
Queue<Box<LargeStruct>> boxedQueue = new Queue<Box<LargeStruct>>();
 
public class Box<T> where T : struct
{
    public T Value { get; }
    public Box(T value) => Value = value;
}

public class HybridQueue<T>
{
    private const int InlineCapacity = 4;
    private T[] _inlineBuffer = new T[InlineCapacity];
    private Queue<T> _overflowQueue = null;
    private int _inlineCount = 0;
    
    public int Count => _inlineCount + (_overflowQueue?.Count ?? 0);
    
    public void Enqueue(T item)
    {
        if (_inlineCount < InlineCapacity)
        {
            _inlineBuffer[_inlineCount++] = item;
            return;
        }
        
        _overflowQueue ??= new Queue<T>();
        _overflowQueue.Enqueue(item);
    }
    
    public T Dequeue()
    {
        if (_inlineCount > 0)
        {
            T result = _inlineBuffer[0];
            
            // Смещаем элементы влево
            Array.Copy(_inlineBuffer, 1, _inlineBuffer, 0, --_inlineCount);
            
            return result;
        }
        
        if (_overflowQueue?.Count > 0)
            return _overflowQueue.Dequeue();
            
        throw new InvalidOperationException("Queue empty");
    }
}

// Создаем очередь задач с приоритетами
PriorityQueue<Task, int> taskQueue = new PriorityQueue<Task, int>();
 
// Добавляем задачи с разными приоритетами (меньшее число = выше приоритет)
taskQueue.Enqueue(new Task("Отправить ежемесячный отчет"), 3);
taskQueue.Enqueue(new Task("Исправить критический баг в продакшене"), 1);
taskQueue.Enqueue(new Task("Обновить документацию"), 4);
taskQueue.Enqueue(new Task("Задеплоить новую версию"), 2);
 
// Обрабатываем задачи в порядке приоритета
while (taskQueue.TryDequeue(out Task nextTask, out int priority))
{
    Console.WriteLine($"Выполняем задачу: {nextTask.Name} (приоритет: {priority})");
    // Выполнение в порядке: критический баг, деплой, месячный отчет, документация
}

// Максимальная очередь: большее значение = выше приоритет
PriorityQueue<string, int> maxQueue = new PriorityQueue<string, int>(
    Comparer<int>.Create((a, b) => b.CompareTo(a)));

public class Scheduler
{
    private class ScheduledTask
    {
        public Guid Id { get; }
        public Action Task { get; }
        public DateTime ExecutionTime { get; }
        
        public ScheduledTask(Action task, DateTime executionTime)
        {
            Id = Guid.NewGuid();
            Task = task;
            ExecutionTime = executionTime;
        }
    }
    
    private readonly PriorityQueue<ScheduledTask, DateTime> _taskQueue = 
        new PriorityQueue<ScheduledTask, DateTime>();
    private readonly CancellationTokenSource _cts = new CancellationTokenSource();
    private readonly Thread _workerThread;
    
    public Scheduler()
    {
        _workerThread = new Thread(ProcessTasks);
        _workerThread.Start();
    }
    
    public Guid ScheduleTask(Action task, DateTime executionTime)
    {
        var scheduledTask = new ScheduledTask(task, executionTime);
        lock (_taskQueue)
        {
            _taskQueue.Enqueue(scheduledTask, executionTime);
            Monitor.Pulse(_taskQueue); // Уведомляем рабочий поток о новой задаче
        }
        return scheduledTask.Id;
    }
    
    private void ProcessTasks()
    {
        while (!_cts.Token.IsCancellationRequested)
        {
            ScheduledTask nextTask = null;
            lock (_taskQueue)
            {
                if (_taskQueue.Count > 0 && 
                    _taskQueue.Peek().ExecutionTime <= DateTime.Now)
                {
                    nextTask = _taskQueue.Dequeue();
                }
                else if (_taskQueue.Count > 0)
                {
                    // Ждем до времени выполнения следующей задачи
                    TimeSpan waitTime = _taskQueue.Peek().ExecutionTime - DateTime.Now;
                    if (waitTime > TimeSpan.Zero)
                        Monitor.Wait(_taskQueue, waitTime);
                    continue;
                }
                else
                {
                    // Нет задач, ждем добавления новой
                    Monitor.Wait(_taskQueue);
                    continue;
                }
            }
            
            // Выполняем задачу вне блокировки
            try
            {
                nextTask.Task();
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Ошибка выполнения задачи: {ex.Message}");
            }
        }
    }
    
    public void Dispose()
    {
        _cts.Cancel();
        _workerThread.Join();
        _cts.Dispose();
    }
}

public class IndexedPriorityQueue<TElement, TPriority> where TPriority : IComparable<TPriority>
{
    private readonly List<(TElement Element, TPriority Priority)> _heap = new List<(TElement, TPriority)>();
    private readonly Dictionary<TElement, int> _indices = new Dictionary<TElement, int>();
    private readonly IComparer<TPriority> _comparer;
    
    public IndexedPriorityQueue(IComparer<TPriority> comparer = null)
    {
        _comparer = comparer ?? Comparer<TPriority>.Default;
    }
    
    public int Count => _heap.Count;
    
    public void Enqueue(TElement element, TPriority priority)
    {
        if (_indices.ContainsKey(element))
            throw new ArgumentException("Элемент уже существует в очереди");
            
        _heap.Add((element, priority));
        int index = _heap.Count - 1;
        _indices[element] = index;
        HeapifyUp(index);
    }
    
    public TElement Peek()
    {
        if (_heap.Count == 0)
            throw new InvalidOperationException("Очередь пуста");
            
        return _heap[0].Element;
    }
    
    public TElement Dequeue()
    {
        if (_heap.Count == 0)
            throw new InvalidOperationException("Очередь пуста");
            
        TElement result = _heap[0].Element;
        int lastIndex = _heap.Count - 1;
        
        _heap[0] = _heap[lastIndex];
        _heap.RemoveAt(lastIndex);
        
        if (_heap.Count > 0)
        {
            _indices[_heap[0].Element] = 0;
            HeapifyDown(0);
        }
        
        _indices.Remove(result);
        return result;
    }
    
    public void UpdatePriority(TElement element, TPriority newPriority)
    {
        if (!_indices.TryGetValue(element, out int index))
            throw new ArgumentException("Элемент не найден в очереди");
            
        TPriority oldPriority = _heap[index].Priority;
        _heap[index] = (element, newPriority);
        
        int comparison = _comparer.Compare(newPriority, oldPriority);
        if (comparison < 0)
            HeapifyUp(index);
        else if (comparison > 0)
            HeapifyDown(index);
    }
    
    private void HeapifyUp(int index)
    {
        var (element, priority) = _heap[index];
        
        while (index > 0)
        {
            int parentIndex = (index - 1) / 2;
            if (_comparer.Compare(priority, _heap[parentIndex].Priority) >= 0)
                break;
                
            _heap[index] = _heap[parentIndex];
            _indices[_heap[parentIndex].Element] = index;
            
            index = parentIndex;
        }
        
        _heap[index] = (element, priority);
        _indices[element] = index;
    }
    
    private void HeapifyDown(int index)
    {
        int lastIndex = _heap.Count - 1;
        var (element, priority) = _heap[index];
        
        while (true)
        {
            int leftChildIndex = index * 2 + 1;
            if (leftChildIndex > lastIndex)
                break;
                
            int smallestChildIndex = leftChildIndex;
            int rightChildIndex = leftChildIndex + 1;
            
            if (rightChildIndex <= lastIndex && 
                _comparer.Compare(_heap[rightChildIndex].Priority, _heap[leftChildIndex].Priority) < 0)
            {
                smallestChildIndex = rightChildIndex;
            }
            
            if (_comparer.Compare(priority, _heap[smallestChildIndex].Priority) <= 0)
                break;
                
            _heap[index] = _heap[smallestChildIndex];
            _indices[_heap[smallestChildIndex].Element] = index;
            
            index = smallestChildIndex;
        }
        
        _heap[index] = (element, priority);
        _indices[element] = index;
    }
}

// Приоритет на основе нескольких критериев
public class TaskPriority : IComparable<TaskPriority>
{
    public int Severity { get; } // 1-5, где 1 - критично
    public DateTime Deadline { get; }
    public bool IsBlocker { get; }
    
    public TaskPriority(int severity, DateTime deadline, bool isBlocker)
    {
        Severity = severity;
        Deadline = deadline;
        IsBlocker = isBlocker;
    }
    
    public int CompareTo(TaskPriority other)
    {
        // Сначала блокирующие задачи
        if (IsBlocker != other.IsBlocker)
            return IsBlocker ? -1 : 1;
            
        // Затем по критичности
        if (Severity != other.Severity)
            return Severity.CompareTo(other.Severity);
            
        // Наконец, по дедлайну
        return Deadline.CompareTo(other.Deadline);
    }
}
 
// Использование
var taskQueue = new PriorityQueue<WorkItem, TaskPriority>();
taskQueue.Enqueue(new WorkItem("Исправить баг авторизации"), 
                 new TaskPriority(1, DateTime.Now.AddDays(1), true));

public class ResourceAwareScheduler<T>
{
    private readonly PriorityQueue<T, int> _taskQueue = new PriorityQueue<T, int>();
    private readonly Func<T, bool> _resourceChecker;
    
    public ResourceAwareScheduler(Func<T, bool> resourceChecker)
    {
        _resourceChecker = resourceChecker;
    }
    
    public void Enqueue(T task, int priority) => _taskQueue.Enqueue(task, priority);
    
    public bool TryGetNextExecutableTask(out T task)
    {
        // Создаем временное хранилище для задач, которые не могут быть выполнены сейчас
        var tempStorage = new PriorityQueue<T, int>();
        bool found = false;
        task = default;
        
        // Ищем задачу, для которой хватает ресурсов
        while (_taskQueue.TryDequeue(out T candidate, out int priority))
        {
            if (!found && _resourceChecker(candidate))
            {
                found = true;
                task = candidate;
            }
            else
            {
                tempStorage.Enqueue(candidate, priority);
            }
        }
        
        // Возвращаем невыполнимые задачи обратно в очередь
        while (tempStorage.TryDequeue(out T item, out int priority))
        {
            _taskQueue.Enqueue(item, priority);
        }
        
        return found;
    }
}

public class ConcurrentPriorityQueue<TElement, TPriority>
{
    private readonly PriorityQueue<TElement, TPriority> _queue;
    private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
    
    public ConcurrentPriorityQueue(IComparer<TPriority> comparer = null)
    {
        _queue = new PriorityQueue<TElement, TPriority>(comparer);
    }
    
    public int Count
    {
        get
        {
            _lock.EnterReadLock();
            try
            {
                return _queue.Count;
            }
            finally
            {
                _lock.ExitReadLock();
            }
        }
    }
    
    public void Enqueue(TElement element, TPriority priority)
    {
        _lock.EnterWriteLock();
        try
        {
            _queue.Enqueue(element, priority);
        }
        finally
        {
            _lock.ExitWriteLock();
        }
    }
    
    public bool TryDequeue(out TElement element, out TPriority priority)
    {
        _lock.EnterWriteLock();
        try
        {
            return _queue.TryDequeue(out element, out priority);
        }
        finally
        {
            _lock.ExitWriteLock();
        }
    }
    
    public bool TryPeek(out TElement element, out TPriority priority)
    {
        _lock.EnterReadLock();
        try
        {
            return _queue.TryPeek(out element, out priority);
        }
        finally
        {
            _lock.ExitReadLock();
        }
    }
}

public class TaskProcessor
{
private readonly BlockingCollection<Action> _tasks = new BlockingCollection<Action>();
private readonly Thread[] _workers;
private bool _isRunning = true;
 
public TaskProcessor(int workerCount)
{
    _workers = new Thread[workerCount];
    
    for (int i = 0; i < workerCount; i++)
    {
        _workers[i] = new Thread(WorkerLoop);
        _workers[i].Start();
    }
}
 
public void EnqueueTask(Action task)
{
    _tasks.Add(task);
}
 
private void WorkerLoop()
{
    while (_isRunning)
    {
        Action task;
        try
        {
            task = _tasks.Take(); // Блокирующее взятие из очереди
        }
        catch (InvalidOperationException) // Очередь помечена как завершённая
        {
            break;
        }
        
        try
        {
            task();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Ошибка выполнения задачи: {ex.Message}");
        }
    }
}
 
public void Shutdown()
{
    _isRunning = false;
    _tasks.CompleteAdding(); // Сообщаем о завершении добавления
    
    foreach (var worker in _workers)
    {
        worker.Join();
    }
}
}

public class MessageRouter<TKey, TMessage>
{
private readonly ConcurrentDictionary<TKey, ConcurrentQueue<TMessage>> _queues = 
    new ConcurrentDictionary<TKey, ConcurrentQueue<TMessage>>();
private readonly Func<TMessage, TKey> _keySelector;
 
public MessageRouter(Func<TMessage, TKey> keySelector)
{
    _keySelector = keySelector;
}
 
public void EnqueueMessage(TMessage message)
{
    TKey key = _keySelector(message);
    
    _queues.GetOrAdd(key, _ => new ConcurrentQueue<TMessage>())
           .Enqueue(message);
}
 
public bool TryDequeueMessage(TKey key, out TMessage message)
{
    if (_queues.TryGetValue(key, out var queue))
    {
        return queue.TryDequeue(out message);
    }
    
    message = default;
    return false;
}
 
public IEnumerable<TKey> GetActiveQueues()
{
    return _queues.Where(kv => !kv.Value.IsEmpty)
                 .Select(kv => kv.Key);
}
}

public class BoundedDataProcessor<T>
{
private readonly BlockingCollection<T> _buffer;
private readonly Thread _processingThread;
private readonly Action<T> _processor;
private readonly ManualResetEventSlim _pauseEvent = new ManualResetEventSlim(true);
private volatile bool _isRunning = true;
 
public BoundedDataProcessor(int bufferCapacity, Action<T> processor)
{
    _buffer = new BlockingCollection<T>(new ConcurrentQueue<T>(), bufferCapacity);
    _processor = processor;
    
    _processingThread = new Thread(ProcessingLoop);
    _processingThread.Start();
}
 
public bool TryAdd(T item, TimeSpan timeout)
{
    return _buffer.TryAdd(item, timeout);
}
 
public void Pause()
{
    _pauseEvent.Reset();
}
 
public void Resume()
{
    _pauseEvent.Set();
}
 
private void ProcessingLoop()
{
    while (_isRunning)
    {
        _pauseEvent.Wait();
        
        T item;
        try
        {
            item = _buffer.Take();
        }
        catch (InvalidOperationException)
        {
            break;
        }
        
        try
        {
            _processor(item);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Ошибка обработки: {ex.Message}");
        }
    }
}
 
public void Shutdown()
{
    _isRunning = false;
    _pauseEvent.Set();
    _buffer.CompleteAdding();
    _processingThread.Join();
}
}

// Создаём наблюдаемую последовательность на основе очереди
public static IObservable<T> ToObservable<T>(this BlockingCollection<T> queue)
{
return Observable.Create<T>(observer =>
{
    var cancellation = new CancellationTokenSource();
    
    Task.Factory.StartNew(() =>
    {
        try
        {
            foreach (var item in queue.GetConsumingEnumerable(cancellation.Token))
            {
                observer.OnNext(item);
            }
            observer.OnCompleted();
        }
        catch (OperationCanceledException)
        {
            observer.OnCompleted();
        }
        catch (Exception ex)
        {
            observer.OnError(ex);
        }
    }, cancellation.Token);
    
    return new Action(() => cancellation.Cancel());
});
}

// Упрощенная версия однопоточной очереди
public class RingBufferQueue<T>
{
private readonly T[] _buffer;
private readonly int _mask;
private long _head = 0; // Позиция для чтения
private long _tail = 0; // Позиция для записи
 
public RingBufferQueue(int capacity)
{
    // Округляем до степени двойки для эффективности
    int size = 1;
    while (size < capacity) size <<= 1;
    
    _buffer = new T[size];
    _mask = size - 1;
}
 
public bool TryEnqueue(T item)
{
    long currentTail = _tail;
    long nextTail = currentTail + 1;
    
    if ((nextTail - _head) > _buffer.Length)
        return false; // Буфер полон
        
    _buffer[currentTail & _mask] = item;
    _tail = nextTail;
    
    return true;
}
 
public bool TryDequeue(out T item)
{
    long currentHead = _head;
    
    if (currentHead >= _tail)
    {
        item = default;
        return false; // Буфер пуст
    }
    
    item = _buffer[currentHead & _mask];
    _head = currentHead + 1;
    
    return true;
}
}

public class TelemetryBuffer
{
private readonly ConcurrentQueue<TelemetryPoint> _pointsQueue = new ConcurrentQueue<TelemetryPoint>();
private readonly TimeSpan _flushInterval;
private readonly int _maxBatchSize;
private readonly Func<IEnumerable<TelemetryPoint>, Task> _sendBatchAsync;
private Timer _flushTimer;
 
public TelemetryBuffer(TimeSpan flushInterval, int maxBatchSize, 
                      Func<IEnumerable<TelemetryPoint>, Task> sendBatchAsync)
{
    _flushInterval = flushInterval;
    _maxBatchSize = maxBatchSize;
    _sendBatchAsync = sendBatchAsync;
    
    _flushTimer = new Timer(FlushCallback, null, flushInterval, flushInterval);
}
 
public void EnqueuePoint(TelemetryPoint point)
{
    _pointsQueue.Enqueue(point);
    
    // Если размер очереди превысил порог, инициируем немедленную отправку
    if (_pointsQueue.Count >= _maxBatchSize)
    {
        FlushAsync().ConfigureAwait(false);
    }
}
 
private async void FlushCallback(object state)
{
    await FlushAsync();
}
 
private async Task FlushAsync()
{
    if (_pointsQueue.IsEmpty)
        return;
        
    // Извлекаем текущий батч для отправки
    List<TelemetryPoint> batchToSend = new List<TelemetryPoint>(_maxBatchSize);
    
    while (batchToSend.Count < _maxBatchSize && _pointsQueue.TryDequeue(out var point))
    {
        batchToSend.Add(point);
    }
    
    if (batchToSend.Count > 0)
    {
        try
        {
            await _sendBatchAsync(batchToSend);
        }
        catch (Exception ex)
        {
            // Возвращаем неотправленные точки в очередь
            foreach (var point in batchToSend)
            {
                _pointsQueue.Enqueue(point);
            }
            
            Console.WriteLine($"Ошибка отправки батча: {ex.Message}");
        }
    }
}
 
public void Dispose()
{
    _flushTimer.Dispose();
}
}

public class AsyncQueue<T>
{
private readonly ConcurrentQueue<T> _queue = new ConcurrentQueue<T>();
private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(0);
 
public void Enqueue(T item)
{
    _queue.Enqueue(item);
    _semaphore.Release();
}
 
public async Task<T> DequeueAsync(CancellationToken cancellationToken = default)
{
    await _semaphore.WaitAsync(cancellationToken);
    
    if (_queue.TryDequeue(out var item))
        return item;
        
    // Ещё одна попытка, на случай гонки потоков
    if (_queue.TryDequeue(out item))
        return item;
        
    throw new InvalidOperationException("Не удалось извлечь элемент из очереди, несмотря на сигнал семафора");
}
 
public async Task<T> PeekAsync(CancellationToken cancellationToken = default)
{
    await _semaphore.WaitAsync(cancellationToken);
    
    try
    {
        if (_queue.TryPeek(out var item))
            return item;
            
        throw new InvalidOperationException("Не удалось просмотреть элемент в очереди");
    }
    finally
    {
        _semaphore.Release(); // Возвращаем билет в семафор
    }
}
 
public int Count => _queue.Count;
}

public class EventQueue<T> : IDisposable
{
private readonly AsyncQueue<T> _queue = new AsyncQueue<T>();
private readonly CancellationTokenSource _cts = new CancellationTokenSource();
private readonly Task _processingTask;
 
public event EventHandler<T> ItemProcessed;
public event EventHandler<Exception> ProcessingError;
 
public EventQueue()
{
    _processingTask = ProcessItemsAsync(_cts.Token);
}
 
public void Enqueue(T item)
{
    _queue.Enqueue(item);
}
 
private async Task ProcessItemsAsync(CancellationToken token)
{
    while (!token.IsCancellationRequested)
    {
        try
        {
            T item = await _queue.DequeueAsync(token);
            OnItemProcessed(item);
        }
        catch (OperationCanceledException) when (token.IsCancellationRequested)
        {
            // Нормальное завершение при отмене
            break;
        }
        catch (Exception ex)
        {
            OnProcessingError(ex);
        }
    }
}
 
protected virtual void OnItemProcessed(T item)
{
    ItemProcessed?.Invoke(this, item);
}
 
protected virtual void OnProcessingError(Exception ex)
{
    ProcessingError?.Invoke(this, ex);
}
 
public void Dispose()
{
    _cts.Cancel();
    try
    {
        _processingTask.Wait(TimeSpan.FromSeconds(5));
    }
    catch (AggregateException) { }
    
    _cts.Dispose();
}
}

// Где-то в ViewModel
private readonly EventQueue<UserAction> _actionQueue = new EventQueue<UserAction>();
 
public MainViewModel()
{
    _actionQueue.ItemProcessed += ActionQueue_ItemProcessed;
}
 
private void ActionQueue_ItemProcessed(object sender, UserAction action)
{
    // Это выполняется в фоновом потоке!
    var result = ProcessAction(action);
    
    // Отправляем результат обратно в UI-поток
    Application.Current.Dispatcher.Invoke(() =>
    {
        Results.Add(result);
    });
}
 
public void QueueAction(UserAction action)
{
    _actionQueue.Enqueue(action);
}

public class ProgressiveDataProcessor<TInput, TOutput>
{
private readonly Channel<TInput> _inputChannel;
private readonly Channel<TOutput> _outputChannel;
private readonly Func<TInput, CancellationToken, Task<TOutput>> _processor;
private readonly CancellationTokenSource _cts = new CancellationTokenSource();
private readonly Task[] _workers;
 
public ProgressiveDataProcessor(
    Func<TInput, CancellationToken, Task<TOutput>> processor,
    int maxConcurrency = 4,
    int capacity = 100)
{
    _processor = processor;
    
    // Ограниченный входной канал
    _inputChannel = Channel.CreateBounded<TInput>(new BoundedChannelOptions(capacity)
    {
        FullMode = BoundedChannelFullMode.Wait // Блокирует при заполнении
    });
    
    // Неограниченный выходной канал
    _outputChannel = Channel.CreateUnbounded<TOutput>();
    
    // Запускаем обработчики
    _workers = new Task[maxConcurrency];
    for (int i = 0; i < maxConcurrency; i++)
    {
        _workers[i] = ProcessAsync(_cts.Token);
    }
}
 
public ValueTask EnqueueAsync(TInput item, CancellationToken cancellationToken = default)
{
    return _inputChannel.Writer.WriteAsync(item, cancellationToken);
}
 
public void Complete()
{
    _inputChannel.Writer.Complete();
}
 
public async Task CompleteAndWaitAsync()
{
    Complete();
    await Task.WhenAll(_workers);
    _outputChannel.Writer.Complete();
}
 
public IAsyncEnumerable<TOutput> ReadAllOutputsAsync(CancellationToken cancellationToken = default)
{
    return _outputChannel.Reader.ReadAllAsync(cancellationToken);
}
 
private async Task ProcessAsync(CancellationToken token)
{
    try
    {
        await foreach (var input in _inputChannel.Reader.ReadAllAsync(token))
        {
            try
            {
                var output = await _processor(input, token);
                await _outputChannel.Writer.WriteAsync(output, token);
            }
            catch (Exception ex) when (!(ex is OperationCanceledException))
            {
                // Логирование ошибок, возможно, отправка в специальный канал ошибок
                Console.WriteLine($"Ошибка обработки: {ex.Message}");
            }
        }
    }
    catch (OperationCanceledException) when (token.IsCancellationRequested)
    {
        // Нормальное завершение
    }
}
 
public void Dispose()
{
    _cts.Cancel();
    _cts.Dispose();
}
}

// Создаем процессор, который трансформирует строки в их длины
var processor = new ProgressiveDataProcessor<string, int>(
    async (input, token) => 
    {
        await Task.Delay(100); // Имитация тяжелой обработки
        return input.Length;
    },
    maxConcurrency: 8
);
 
// Запускаем задачу чтения результатов
_ = Task.Run(async () =>
{
    await foreach (var length in processor.ReadAllOutputsAsync())
    {
        Console.WriteLine($"Длина: {length}");
    }
});
 
// Отправляем данные на обработку
string[] inputs = { "apple", "banana", "cherry", "date", "elderberry" };
foreach (var item in inputs)
{
    await processor.EnqueueAsync(item);
}
 
// Завершаем и ждем окончания обработки
await processor.CompleteAndWaitAsync();

public class MergedDataStream<T> : IDisposable
{
private readonly Channel<TimestampedData<T>> _channel;
private readonly List<Task> _producers = new List<Task>();
private readonly CancellationTokenSource _cts = new CancellationTokenSource();
 
public MergedDataStream(int capacity = 1000)
{
    _channel = Channel.CreateBounded<TimestampedData<T>>(new BoundedChannelOptions(capacity)
    {
        FullMode = BoundedChannelFullMode.Wait,
        SingleReader = true,  // Оптимизация для одного потребителя
        SingleWriter = false  // Множество писателей
    });
}
 
public void AddDataSource(Func<CancellationToken, IAsyncEnumerable<T>> sourceFactory, string sourceName)
{
    var task = Task.Run(async () =>
    {
        try
        {
            await foreach (var item in sourceFactory(_cts.Token))
            {
                var timestamped = new TimestampedData<T>
                {
                    Data = item,
                    Timestamp = DateTime.UtcNow,
                    Source = sourceName
                };
                
                await _channel.Writer.WriteAsync(timestamped, _cts.Token);
            }
        }
        catch (OperationCanceledException) when (_cts.Token.IsCancellationRequested)
        {
            // Нормальное завершение
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Ошибка в источнике {sourceName}: {ex.Message}");
            // Мы могли бы отправить специальное "сообщение об ошибке" в канал
        }
        finally
        {
            Console.WriteLine($"Источник {sourceName} завершил работу");
        }
    });
    
    _producers.Add(task);
}
 
public async IAsyncEnumerable<TimestampedData<T>> ReadAllAsync(
    [EnumeratorCancellation] CancellationToken cancellationToken = default)
{
    var combinedToken = CancellationTokenSource.CreateLinkedTokenSource(
        cancellationToken, _cts.Token).Token;
    
    await foreach (var item in _channel.Reader.ReadAllAsync(combinedToken))
    {
        yield return item;
    }
}
 
public async Task CompleteWhenAllSourcesCompletedAsync()
{
    await Task.WhenAll(_producers);
    _channel.Writer.Complete();
}
 
public void Dispose()
{
    _cts.Cancel();
    _cts.Dispose();
}
 
public class TimestampedData<TData>
{
    public TData Data { get; set; }
    public DateTime Timestamp { get; set; }
    public string Source { get; set; }
}
}

var merger = new MergedDataStream<double>();
 
// Добавляем источник данных с датчика температуры
merger.AddDataSource(async token =>
{
    var random = new Random(42);
    while (!token.IsCancellationRequested)
    {
        await Task.Delay(100, token);
        yield return 20 + random.NextDouble() * 5; // Температура в диапазоне 20-25°C
    }
}, "TemperatureSensor");
 
// Добавляем источник данных с датчика влажности
merger.AddDataSource(async token =>
{
    var random = new Random(123);
    while (!token.IsCancellationRequested)
    {
        await Task.Delay(250, token);
        yield return 40 + random.NextDouble() * 20; // Влажность в диапазоне 40-60%
    }
}, "HumiditySensor");
 
// Читаем и обрабатываем объединенный поток данных
_ = Task.Run(async () =>
{
    await foreach (var data in merger.ReadAllAsync())
    {
        Console.WriteLine($"[{data.Timestamp:HH:mm:ss.fff}] {data.Source}: {data.Data:F2}");
    }
});
 
// Останавливаем через 5 секунд
await Task.Delay(5000);
merger.Dispose();

// Классическая Hashtable
Hashtable classicTable = new Hashtable();
classicTable.Add("key1", "значение 1");
classicTable.Add(42, new Person("John", "Doe")); // Разнородные ключи и значения
classicTable.Add(new DateTime(2023, 5, 10), 100.5m);
 
// Современный Dictionary с типизацией
Dictionary<string, int> scoresByName = new Dictionary<string, int>();
scoresByName.Add("Alice", 95);
scoresByName.Add("Bob", 87);
scoresByName["Charlie"] = 92; // Альтернативный синтаксис

Hashtable inventory = new Hashtable();
 
// Добавление элементов (O(1) в среднем)
inventory.Add("Меч", 10);
inventory.Add("Щит", 5);
inventory.Add("Зелье здоровья", 25);
 
// Проверка наличия ключа (O(1) в среднем)
bool hasSword = inventory.ContainsKey("Меч"); // true
 
// Получение значения (O(1) в среднем)
int potionCount = (int)inventory["Зелье здоровья"];
 
// Удаление элемента (O(1) в среднем)
inventory.Remove("Щит");
 
// Перебор элементов (O(n), где n - размер таблицы)
foreach (DictionaryEntry item in inventory)
{
    Console.WriteLine($"{item.Key}: {item.Value}");
}

public class CustomKey
{
    public string Part1 { get; }
    public int Part2 { get; }
    
    public CustomKey(string part1, int part2)
    {
        Part1 = part1;
        Part2 = part2;
    }
    
    // Переопределяем GetHashCode для хорошего распределения
    public override int GetHashCode()
    {
        unchecked // Отключаем проверку переполнения для ускорения
        {
            // Простая реализация с использованием простого числа
            int hash = 17;
            hash = hash * 23 + (Part1?.GetHashCode() ?? 0);
            hash = hash * 23 + Part2.GetHashCode();
            return hash;
        }
    }
    
    // ВНИМАНИЕ: При переопределении GetHashCode всегда переопределяйте Equals
    public override bool Equals(object obj)
    {
        if (obj is CustomKey other)
        {
            return
                (Part1 == other.Part1 || (Part1 != null && Part1.Equals(other.Part1))) &&
                Part2 == other.Part2;
        }
        return false;
    }
}

Hashtable unsafeTable = new Hashtable();
Hashtable threadSafeTable = Hashtable.Synchronized(unsafeTable);
 
// Теперь threadSafeTable можно безопасно использовать из разных потоков

ConcurrentDictionary<string, int> concurrentCounter = new ConcurrentDictionary<string, int>();
 
// Атомарное добавление или обновление
concurrentCounter.AddOrUpdate(
    "views", // ключ
    1,       // значение, если ключ отсутствует
    (key, oldValue) => oldValue + 1  // функция обновления существующего значения
);
 
// Атомарное получение или добавление
int currentValue = concurrentCounter.GetOrAdd("downloads", 0);

public class UserIndexer
{
    private readonly List<User> _users = new List<User>();
    private readonly Dictionary<string, User> _usersByEmail = new Dictionary<string, User>();
    private readonly Dictionary<int, List<User>> _usersByAge = new Dictionary<int, List<User>>();
    
    public void AddUser(User user)
    {
        _users.Add(user);
        
        // Индекс по email (уникальное поле)
        _usersByEmail[user.Email] = user;
        
        // Индекс по возрасту (множество пользователей одного возраста)
        if (!_usersByAge.ContainsKey(user.Age))
            _usersByAge[user.Age] = new List<User>();
        
        _usersByAge[user.Age].Add(user);
    }
    
    public User FindByEmail(string email)
    {
        // O(1) поиск вместо O(n)
        return _usersByEmail.TryGetValue(email, out var user) ? user : null;
    }
    
    public IEnumerable<User> FindByAge(int age)
    {
        // O(1) поиск вместо O(n)
        return _usersByAge.TryGetValue(age, out var users) ? users : Enumerable.Empty<User>();
    }
}

public class Memoizer
{
    private Dictionary<string, object> _cache = new Dictionary<string, object>();
    
    public TResult Memoize<TResult>(Func<TResult> function, string cacheKey)
    {
        if (_cache.TryGetValue(cacheKey, out var cachedResult))
            return (TResult)cachedResult;
            
        // Вычисляем результат и сохраняем в кэше
        TResult result = function();
        _cache[cacheKey] = result;
        return result;
    }
    
    // Перегрузка для функций с параметром
    public TResult Memoize<TParam, TResult>(Func<TParam, TResult> function, TParam param)
    {
        string cacheKey = $"{typeof(TParam).Name}:{param?.GetHashCode() ?? 0}";
        
        return Memoize(() => function(param), cacheKey);
    }
}