using System;
using System.Collections.Generic;
using System.Threading.Tasks;

var list = new List<int>();

// 10 потоків одночасно додають по 1000 елементів
Parallel.For(0, 10, i =>
{
    for (int j = 0; j < 1000; j++)
    {
        list.Add(i * 1000 + j);  // ← НЕ thread-safe!
    }
});

Console.WriteLine($"Expected: 10000, Actual: {list.Count}");
// Типовий результат: 8500-9800 (втрачено елементи!)

// Ще гірше: можлива IndexOutOfRangeException або навіть crash!

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

var dict = new Dictionary<string, int>();

try
{
    // 10 потоків одночасно додають елементи
    Parallel.For(0, 10, i =>
    {
        for (int j = 0; j < 1000; j++)
        {
            string key = $"key-{i}-{j}";
            dict[key] = i * 1000 + j;  // ← НЕ thread-safe!
        }
    });
}
catch (Exception ex)
{
    Console.WriteLine($"Exception: {ex.GetType().Name}");
    Console.WriteLine($"Message: {ex.Message}");
}

// Типовий результат:
// Exception: InvalidOperationException
// Message: Collection was modified; enumeration operation may not execute.
// АБО: IndexOutOfRangeException, NullReferenceException

var dict = new Dictionary<string, int>();
var lockObj = new object();

// ✅ Thread-safe, але ПОВІЛЬНО
Parallel.For(0, 10, i =>
{
    for (int j = 0; j < 1000; j++)
    {
        string key = $"key-{i}-{j}";

        lock (lockObj)  // ← Всі потоки конкурують за ОДИН lock
        {
            dict[key] = i * 1000 + j;
        }
    }
});

// Проблеми:
// 1. Lock contention — всі 10 потоків чекають на один lock
// 2. Serialization — фактично виконується послідовно
// 3. Погана scalability — чим більше потоків, тим гірше

var dict = new ConcurrentDictionary<string, int>();

// Спроба додати елемент
bool added = dict.TryAdd("key1", 100);
Console.WriteLine($"Added: {added}");  // true

// Повторна спроба — не вдасться (ключ вже є)
added = dict.TryAdd("key1", 200);
Console.WriteLine($"Added: {added}");  // false

Console.WriteLine($"Value: {dict["key1"]}");  // 100 (не змінилось)

var dict = new ConcurrentDictionary<string, int>();
dict.TryAdd("key1", 100);

// ✅ Безпечний спосіб читання
if (dict.TryGetValue("key1", out int value))
{
    Console.WriteLine($"Found: {value}");
}
else
{
    Console.WriteLine("Not found");
}

// ❌ Небезпечний спосіб (може кинути KeyNotFoundException)
// int value = dict["key1"];

var dict = new ConcurrentDictionary<string, int>();

// Варіант 1: з готовим значенням
int value1 = dict.GetOrAdd("key1", 100);
Console.WriteLine(value1);  // 100 (додано)

int value2 = dict.GetOrAdd("key1", 200);
Console.WriteLine(value2);  // 100 (вже було, не змінилось)

// Варіант 2: з factory function (викликається тільки якщо ключа немає)
int value3 = dict.GetOrAdd("key2", key =>
{
    Console.WriteLine($"Computing value for {key}...");
    return ExpensiveComputation();  // Дорога операція
});

// Варіант 3: з factoryArgument (без closure allocation)
int value4 = dict.GetOrAdd("key3",
    static (key, arg) => arg * 2,  // static lambda = no closure
    factoryArgument: 50);
Console.WriteLine(value4);  // 100

var dict = new ConcurrentDictionary<string, int>();

// Варіант 1: з готовими значеннями
int result1 = dict.AddOrUpdate(
    key: "counter",
    addValue: 1,                    // Якщо ключа немає → додати 1
    updateValueFactory: (key, oldValue) => oldValue + 1  // Якщо є → інкремент
);
Console.WriteLine(result1);  // 1 (додано)

int result2 = dict.AddOrUpdate("counter", 1, (key, oldValue) => oldValue + 1);
Console.WriteLine(result2);  // 2 (оновлено)

// Варіант 2: з factoryArgument (без closure)
int result3 = dict.AddOrUpdate(
    key: "counter",
    addValueFactory: static (key, arg) => arg,
    updateValueFactory: static (key, oldValue, arg) => oldValue + arg,
    factoryArgument: 10
);
Console.WriteLine(result3);  // 12 (2 + 10)

var dict = new ConcurrentDictionary<string, int>();
dict.TryAdd("balance", 1000);

// Спроба оновити ТІЛЬКИ якщо поточне значення = 1000
bool updated = dict.TryUpdate(
    key: "balance",
    newValue: 900,
    comparisonValue: 1000  // Очікуване поточне значення
);
Console.WriteLine($"Updated: {updated}");  // true
Console.WriteLine($"Balance: {dict["balance"]}");  // 900

// Повторна спроба — не вдасться (значення вже 900, не 1000)
updated = dict.TryUpdate("balance", 800, 1000);
Console.WriteLine($"Updated: {updated}");  // false
Console.WriteLine($"Balance: {dict["balance"]}");  // 900 (не змінилось)

var dict = new ConcurrentDictionary<string, int>();
dict.TryAdd("key1", 100);

// Видалити та отримати значення
if (dict.TryRemove("key1", out int removedValue))
{
    Console.WriteLine($"Removed: {removedValue}");  // 100
}

// Повторна спроба — не вдасться
if (!dict.TryRemove("key1", out _))
{
    Console.WriteLine("Key not found");
}

using System;
using System.Collections.Concurrent;
using System.Threading;

public class ThreadSafeCache<TKey, TValue> where TKey : notnull
{
    private readonly ConcurrentDictionary<TKey, CacheEntry> _cache = new();
    private readonly TimeSpan _defaultTtl;

    private record CacheEntry(TValue Value, DateTime ExpiresAt);

    public ThreadSafeCache(TimeSpan defaultTtl)
    {
        _defaultTtl = defaultTtl;
    }

    public bool TryGet(TKey key, out TValue? value)
    {
        if (_cache.TryGetValue(key, out var entry))
        {
            if (entry.ExpiresAt > DateTime.UtcNow)
            {
                value = entry.Value;
                return true;
            }

            // Expired → видаляємо
            _cache.TryRemove(key, out _);
        }

        value = default;
        return false;
    }

    public void Set(TKey key, TValue value, TimeSpan? ttl = null)
    {
        var expiresAt = DateTime.UtcNow + (ttl ?? _defaultTtl);
        var entry = new CacheEntry(value, expiresAt);

        _cache[key] = entry;  // AddOrUpdate через indexer
    }

    public TValue GetOrAdd(TKey key, Func<TKey, TValue> valueFactory, TimeSpan? ttl = null)
    {
        var expiresAt = DateTime.UtcNow + (ttl ?? _defaultTtl);

        var entry = _cache.GetOrAdd(key, k =>
        {
            var value = valueFactory(k);
            return new CacheEntry(value, expiresAt);
        });

        // Перевірка expiration
        if (entry.ExpiresAt <= DateTime.UtcNow)
        {
            // Expired → видаляємо та рекурсивно викликаємо знову
            _cache.TryRemove(key, out _);
            return GetOrAdd(key, valueFactory, ttl);
        }

        return entry.Value;
    }

    public void Clear() => _cache.Clear();

    public int Count => _cache.Count;
}

// Використання:
var cache = new ThreadSafeCache<string, string>(TimeSpan.FromSeconds(10));

// 100 потоків одночасно працюють з кешем
Parallel.For(0, 100, i =>
{
    string key = $"key-{i % 10}";  // 10 різних ключів

    string value = cache.GetOrAdd(key, k =>
    {
        Console.WriteLine($"[Thread {i}] Computing {k}...");
        Thread.Sleep(100);  // Симуляція дорогої операції
        return $"value-{k}";
    });

    Console.WriteLine($"[Thread {i}] Got: {value}");
});

// Тільки 10 обчислень (по одному на ключ), решта взяли з кешу

using System;
using System.Collections.Concurrent;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Diagnostics;

public class WordCounter
{
    private readonly ConcurrentDictionary<string, int> _wordCounts = new();

    public void ProcessFile(string filePath)
    {
        // Читаємо файл та розбиваємо на слова
        string content = File.ReadAllText(filePath);
        var words = content
            .Split(new[] { ' ', '\n', '\r', '\t', '.', ',', '!', '?' },
                   StringSplitOptions.RemoveEmptyEntries)
            .Select(w => w.ToLowerInvariant());

        // Підраховуємо кожне слово
        foreach (string word in words)
        {
            // AddOrUpdate: якщо слова немає → додати 1, якщо є → інкремент
            _wordCounts.AddOrUpdate(
                key: word,
                addValue: 1,                           // Якщо слова немає
                updateValueFactory: (key, oldValue) => oldValue + 1  // Якщо є
            );
        }
    }

    public void PrintTopWords(int count = 10)
    {
        var topWords = _wordCounts
            .OrderByDescending(kvp => kvp.Value)
            .Take(count);

        Console.WriteLine($"\nTop {count} words:");
        foreach (var kvp in topWords)
        {
            Console.WriteLine($"  {kvp.Key}: {kvp.Value}");
        }
    }

    public int TotalWords => _wordCounts.Values.Sum();
    public int UniqueWords => _wordCounts.Count;
}

// Використання:
var counter = new WordCounter();
var files = Directory.GetFiles(@"C:\Logs", "*.txt");

Console.WriteLine($"Processing {files.Length} files...");
var sw = Stopwatch.StartNew();

// ❌ ПОВІЛЬНО: Послідовна обробка
// foreach (var file in files)
// {
//     counter.ProcessFile(file);
// }

// ✅ ШВИДКО: Паралельна обробка
Parallel.ForEach(files, file =>
{
    counter.ProcessFile(file);
    Console.WriteLine($"Processed: {Path.GetFileName(file)}");
});

sw.Stop();
Console.WriteLine($"\nCompleted in {sw.ElapsedMilliseconds}ms");
Console.WriteLine($"Total words: {counter.TotalWords:N0}");
Console.WriteLine($"Unique words: {counter.UniqueWords:N0}");

counter.PrintTopWords(10);

using System.Collections.Concurrent;

var queue = new ConcurrentQueue<int>();

// Enqueue — додати елемент (завжди успішно)
queue.Enqueue(1);
queue.Enqueue(2);
queue.Enqueue(3);

// TryDequeue — забрати елемент
if (queue.TryDequeue(out int result))
{
    Console.WriteLine($"Dequeued: {result}");  // 1 (FIFO)
}

// TryPeek — подивитись без видалення
if (queue.TryPeek(out int peeked))
{
    Console.WriteLine($"Peeked: {peeked}");  // 2
}

// Count — приблизна кількість (snapshot)
Console.WriteLine($"Count: {queue.Count}");  // ~2

// IsEmpty — перевірка чи порожня
Console.WriteLine($"IsEmpty: {queue.IsEmpty}");  // false

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;

var queue = new ConcurrentQueue<string>();
var cts = new CancellationTokenSource();

// Producer: генерує повідомлення
var producer = Task.Run(() =>
{
    int messageId = 0;
    while (!cts.Token.IsCancellationRequested)
    {
        string message = $"Message-{messageId++}";
        queue.Enqueue(message);
        Console.WriteLine($"[Producer] Enqueued: {message}");
        Thread.Sleep(Random.Shared.Next(50, 150));
    }
});

// Consumer: обробляє повідомлення
var consumer = Task.Run(() =>
{
    while (!cts.Token.IsCancellationRequested)
    {
        if (queue.TryDequeue(out string? message))
        {
            Console.WriteLine($"[Consumer] Processing: {message}");
            Thread.Sleep(Random.Shared.Next(100, 200));  // Симуляція обробки
        }
        else
        {
            Thread.Sleep(10);  // Черга порожня, трохи почекати
        }
    }
});

// Працюємо 5 секунд
await Task.Delay(5000);
cts.Cancel();

await Task.WhenAll(producer, consumer);
Console.WriteLine($"Final queue count: {queue.Count}");

using System.Collections.Concurrent;

var stack = new ConcurrentStack<int>();

// Push — додати елемент
stack.Push(1);
stack.Push(2);
stack.Push(3);

// TryPop — забрати елемент
if (stack.TryPop(out int result))
{
    Console.WriteLine($"Popped: {result}");  // 3 (LIFO)
}

// TryPeek — подивитись без видалення
if (stack.TryPeek(out int peeked))
{
    Console.WriteLine($"Peeked: {peeked}");  // 2
}

// PushRange — додати кілька елементів одразу (ефективніше)
int[] items = { 10, 20, 30 };
stack.PushRange(items);

// TryPopRange — забрати кілька елементів одразу
int[] buffer = new int[2];
int popped = stack.TryPopRange(buffer);
Console.WriteLine($"Popped {popped} items: {string.Join(", ", buffer)}");
// Popped 2 items: 30, 20

using System;
using System.Collections.Concurrent;
using System.IO;
using System.Threading.Tasks;

var imageFiles = Directory.GetFiles(@"C:\Images", "*.jpg");
var processedImages = new ConcurrentBag<string>();

Console.WriteLine($"Processing {imageFiles.Length} images...");

Parallel.ForEach(imageFiles, imageFile =>
{
    // Симуляція обробки зображення
    string fileName = Path.GetFileName(imageFile);
    Console.WriteLine($"[Thread {Thread.CurrentThread.ManagedThreadId}] Processing: {fileName}");

    Thread.Sleep(Random.Shared.Next(50, 150));  // Симуляція роботи

    // Додаємо результат у ConcurrentBag (lock-free для цього потоку!)
    processedImages.Add($"processed_{fileName}");
});

Console.WriteLine($"\nProcessed {processedImages.Count} images");

// Забираємо всі результати (тут може бути "крадіжка", але це одноразова операція)
var results = processedImages.ToArray();
foreach (var result in results.Take(5))
{
    Console.WriteLine($"  - {result}");
}

using System.Collections.Concurrent;
using System.Threading.Tasks;

// ✅ ДОБРЕ: Parallel.ForEach з локальною обробкою
var bag = new ConcurrentBag<string>();

Parallel.ForEach(Directory.GetFiles(@"C:\Logs"), file =>
{
    // Кожен потік обробляє свої файли і додає результати
    var lines = File.ReadAllLines(file);
    foreach (var line in lines)
    {
        if (line.Contains("ERROR"))
        {
            bag.Add(line);  // Додає у локальний список цього потоку
        }
    }
});

// Після завершення — забираємо всі результати
var errors = bag.ToArray();
Console.WriteLine($"Found {errors.Length} errors");

using System.Collections.Concurrent;

// Створення з обмеженням capacity = 10
var collection = new BlockingCollection<int>(boundedCapacity: 10);

// Add — додати елемент (блокується якщо повна)
collection.Add(1);
collection.Add(2);

// TryAdd — спроба додати з timeout
bool added = collection.TryAdd(3, TimeSpan.FromSeconds(1));
Console.WriteLine($"Added: {added}");

// Take — забрати елемент (блокується якщо порожня)
int item = collection.Take();
Console.WriteLine($"Taken: {item}");  // 1

// TryTake — спроба забрати з timeout
if (collection.TryTake(out int result, TimeSpan.FromSeconds(1)))
{
    Console.WriteLine($"Taken: {result}");  // 2
}

// CompleteAdding — сигнал що більше не буде елементів
collection.CompleteAdding();

// IsCompleted — перевірка чи завершено додавання та черга порожня
Console.WriteLine($"IsCompleted: {collection.IsCompleted}");

// IsAddingCompleted — перевірка чи викликано CompleteAdding
Console.WriteLine($"IsAddingCompleted: {collection.IsAddingCompleted}");

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;

var collection = new BlockingCollection<string>(boundedCapacity: 5);

// Producer: додає повідомлення
var producer = Task.Run(() =>
{
    for (int i = 0; i < 10; i++)
    {
        string message = $"Message-{i}";
        collection.Add(message);
        Console.WriteLine($"[Producer] Added: {message}");
        Thread.Sleep(100);
    }

    collection.CompleteAdding();  // Сигнал що більше не буде
    Console.WriteLine("[Producer] Completed adding");
});

// Consumer: обробляє повідомлення
var consumer = Task.Run(() =>
{
    // GetConsumingEnumerable блокується поки чекає елементи
    // та автоматично завершується після CompleteAdding
    foreach (string message in collection.GetConsumingEnumerable())
    {
        Console.WriteLine($"[Consumer] Processing: {message}");
        Thread.Sleep(150);  // Симуляція обробки
    }

    Console.WriteLine("[Consumer] No more items");
});

await Task.WhenAll(producer, consumer);
Console.WriteLine("Done!");

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;

var collection = new BlockingCollection<int>(boundedCapacity: 20);

// 3 Producers: генерують числа
var producers = Enumerable.Range(0, 3).Select(producerId =>
    Task.Run(() =>
    {
        for (int i = 0; i < 10; i++)
        {
            int value = producerId * 100 + i;
            collection.Add(value);
            Console.WriteLine($"[Producer {producerId}] Added: {value}");
            Thread.Sleep(Random.Shared.Next(50, 150));
        }
        Console.WriteLine($"[Producer {producerId}] Finished");
    })
).ToArray();

// Чекаємо поки всі producers завершать роботу
Task.Run(async () =>
{
    await Task.WhenAll(producers);
    collection.CompleteAdding();
    Console.WriteLine("[Coordinator] All producers finished, CompleteAdding called");
});

// 2 Consumers: обробляють числа
var consumers = Enumerable.Range(0, 2).Select(consumerId =>
    Task.Run(() =>
    {
        foreach (int value in collection.GetConsumingEnumerable())
        {
            Console.WriteLine($"[Consumer {consumerId}] Processing: {value}");
            Thread.Sleep(Random.Shared.Next(100, 200));
        }
        Console.WriteLine($"[Consumer {consumerId}] No more items");
    })
).ToArray();

await Task.WhenAll(consumers);
Console.WriteLine("Pipeline completed!");

using System.Collections.Immutable;

// Створення порожнього списку
var list1 = ImmutableList<int>.Empty;
Console.WriteLine($"list1.Count: {list1.Count}");  // 0

// Add створює НОВУ колекцію
var list2 = list1.Add(10);
Console.WriteLine($"list1.Count: {list1.Count}");  // 0 (не змінився!)
Console.WriteLine($"list2.Count: {list2.Count}");  // 1

// Можна ланцюжком
var list3 = list2.Add(20).Add(30).Add(40);
Console.WriteLine($"list3: [{string.Join(", ", list3)}]");  // [10, 20, 30, 40]

// Remove також створює нову колекцію
var list4 = list3.Remove(20);
Console.WriteLine($"list3: [{string.Join(", ", list3)}]");  // [10, 20, 30, 40] (не змінився)
Console.WriteLine($"list4: [{string.Join(", ", list4)}]");  // [10, 30, 40]

// Індексація (read-only)
Console.WriteLine($"list3[1]: {list3[1]}");  // 20

// SetItem — "змінити" елемент за індексом (створює нову колекцію)
var list5 = list3.SetItem(1, 999);
Console.WriteLine($"list3: [{string.Join(", ", list3)}]");  // [10, 20, 30, 40]
Console.WriteLine($"list5: [{string.Join(", ", list5)}]");  // [10, 999, 30, 40]

using System.Collections.Immutable;
using System.Diagnostics;

// ❌ ПОВІЛЬНО: кожен Add створює нову колекцію
var sw = Stopwatch.StartNew();
var list = ImmutableList<int>.Empty;
for (int i = 0; i < 10000; i++)
{
    list = list.Add(i);  // 10,000 нових колекцій!
}
sw.Stop();
Console.WriteLine($"Without builder: {sw.ElapsedMilliseconds}ms");  // ~150ms

// ✅ ШВИДКО: Builder накопичує зміни, потім створює фінальну колекцію
sw.Restart();
var builder = ImmutableList.CreateBuilder<int>();
for (int i = 0; i < 10000; i++)
{
    builder.Add(i);  // Модифікує mutable builder
}
var finalList = builder.ToImmutable();  // Одна immutable колекція
sw.Stop();
Console.WriteLine($"With builder: {sw.ElapsedMilliseconds}ms");  // ~5ms (в 30x швидше!)

using System.Collections.Immutable;

// Створення порожнього словника
var dict1 = ImmutableDictionary<string, int>.Empty;

// Add створює нову колекцію
var dict2 = dict1.Add("apple", 10);
var dict3 = dict2.Add("banana", 20).Add("cherry", 30);

Console.WriteLine($"dict1.Count: {dict1.Count}");  // 0
Console.WriteLine($"dict3.Count: {dict3.Count}");  // 3

// Індексація (read-only)
Console.WriteLine($"dict3[\"banana\"]: {dict3["banana"]}");  // 20

// TryGetValue
if (dict3.TryGetValue("apple", out int value))
{
    Console.WriteLine($"Found: {value}");  // 10
}

// SetItem — "змінити" значення (створює нову колекцію)
var dict4 = dict3.SetItem("banana", 999);
Console.WriteLine($"dict3[\"banana\"]: {dict3["banana"]}");  // 20 (не змінився)
Console.WriteLine($"dict4[\"banana\"]: {dict4["banana"]}");  // 999

// Remove
var dict5 = dict4.Remove("cherry");
Console.WriteLine($"dict4.Count: {dict4.Count}");  // 3
Console.WriteLine($"dict5.Count: {dict5.Count}");  // 2

// SetItems — batch update
var updates = new Dictionary<string, int>
{
    ["apple"] = 100,
    ["banana"] = 200
};
var dict6 = dict5.SetItems(updates);
Console.WriteLine($"dict6[\"apple\"]: {dict6["apple"]}");  // 100

using System.Collections.Immutable;

// ImmutableStack — LIFO
var stack1 = ImmutableStack<int>.Empty;
var stack2 = stack1.Push(10).Push(20).Push(30);

var stack3 = stack2.Pop(out int top);
Console.WriteLine($"Top: {top}");  // 30
Console.WriteLine($"stack2.Peek(): {stack2.Peek()}");  // 30 (не змінився)
Console.WriteLine($"stack3.Peek(): {stack3.Peek()}");  // 20

// ImmutableQueue — FIFO
var queue1 = ImmutableQueue<string>.Empty;
var queue2 = queue1.Enqueue("A").Enqueue("B").Enqueue("C");

var queue3 = queue2.Dequeue(out string first);
Console.WriteLine($"First: {first}");  // A
Console.WriteLine($"queue2.Peek(): {queue2.Peek()}");  // A (не змінився)
Console.WriteLine($"queue3.Peek(): {queue3.Peek()}");  // B

using System.Collections.Immutable;

// ImmutableHashSet — неупорядкована множина
var set1 = ImmutableHashSet<string>.Empty;
var set2 = set1.Add("apple").Add("banana").Add("cherry");
var set3 = set2.Add("apple");  // Дублікат — не додається

Console.WriteLine($"set2.Count: {set2.Count}");  // 3
Console.WriteLine($"set3.Count: {set3.Count}");  // 3 (не змінився)

// Contains — перевірка наявності
Console.WriteLine($"Contains 'banana': {set3.Contains("banana")}");  // true

// Union, Intersect, Except — операції над множинами
var setA = ImmutableHashSet.Create("a", "b", "c");
var setB = ImmutableHashSet.Create("b", "c", "d");

var union = setA.Union(setB);        // [a, b, c, d]
var intersect = setA.Intersect(setB); // [b, c]
var except = setA.Except(setB);       // [a]

Console.WriteLine($"Union: [{string.Join(", ", union)}]");
Console.WriteLine($"Intersect: [{string.Join(", ", intersect)}]");
Console.WriteLine($"Except: [{string.Join(", ", except)}]");

// ImmutableSortedSet — упорядкована множина
var sorted1 = ImmutableSortedSet<int>.Empty;
var sorted2 = sorted1.Add(30).Add(10).Add(20);

Console.WriteLine($"Sorted: [{string.Join(", ", sorted2)}]");  // [10, 20, 30]

using System.Collections.Immutable;

// Створення з елементів
var array1 = ImmutableArray.Create(1, 2, 3, 4, 5);

// Індексація — O(1) (швидше ніж ImmutableList!)
Console.WriteLine($"array1[2]: {array1[2]}");  // 3

// "Модифікація" створює НОВИЙ масив (копіює всі елементи!)
var array2 = array1.Add(6);  // O(n) — копіює весь масив!

// SetItem — також O(n)
var array3 = array1.SetItem(2, 999);

Console.WriteLine($"array1: [{string.Join(", ", array1)}]");  // [1, 2, 3, 4, 5]
Console.WriteLine($"array3: [{string.Join(", ", array3)}]");  // [1, 2, 999, 4, 5]

using System.Collections.Immutable;

public class AppConfiguration
{
    // Immutable словник — thread-safe для читання
    private ImmutableDictionary<string, string> _settings;

    public AppConfiguration()
    {
        _settings = ImmutableDictionary<string, string>.Empty;
    }

    // Читання — thread-safe без locks
    public string? GetSetting(string key)
    {
        _settings.TryGetValue(key, out string? value);
        return value;
    }

    // Запис — атомарна заміна через Interlocked
    public void SetSetting(string key, string value)
    {
        ImmutableDictionary<string, string> original, updated;
        do
        {
            original = _settings;
            updated = original.SetItem(key, value);
        }
        while (Interlocked.CompareExchange(ref _settings, updated, original) != original);
    }

    // Batch update
    public void SetSettings(Dictionary<string, string> updates)
    {
        ImmutableDictionary<string, string> original, updated;
        do
        {
            original = _settings;
            updated = original.SetItems(updates);
        }
        while (Interlocked.CompareExchange(ref _settings, updated, original) != original);
    }

    public ImmutableDictionary<string, string> GetAllSettings()
    {
        return _settings;  // Безпечно повертати — immutable!
    }
}

// Використання:
var config = new AppConfiguration();

// 100 потоків одночасно читають та пишуть
Parallel.For(0, 100, i =>
{
    // Запис
    config.SetSetting($"key-{i % 10}", $"value-{i}");

    // Читання (без locks!)
    string? value = config.GetSetting($"key-{i % 10}");
    Console.WriteLine($"[Thread {i}] Read: {value}");
});

// Отримати snapshot всіх налаштувань
var snapshot = config.GetAllSettings();
Console.WriteLine($"Total settings: {snapshot.Count}");