// C++ - ручне управління пам'яттю
int* CreateArray() {
    int* arr = new int[1000];
    // ... робота з масивом ...
    delete[] arr;  // Потрібно пам'ятати звільнити!
    return arr;    // ❌ ПОМИЛКА: повертаємо dangling pointer
}

void ProcessData() {
    int* data = new int[500];
    // ... складна логіка ...
    if (error) {
        return;  // ❌ Memory leak - забули delete[]
    }
    delete[] data;
}

var person = new Person("John", 30);

// Псевдокод роботи CLR при алокації
object AllocateObject(Type type)
{
    int size = CalculateSize(type);  // Розмір з header + fields + padding

    if (allocationPointer + size > gen0End)
    {
        // Недостатньо місця - запускаємо GC
        GC.Collect(0);  // Збираємо Gen0

        if (allocationPointer + size > gen0End)
        {
            // Все ще недостатньо - розширюємо heap
            ExpandHeap();
        }
    }

    // Розміщуємо об'єкт
    void* address = allocationPointer;
    InitializeObject(address, type);
    allocationPointer += size;

    return (object)address;
}

void StackVsHeapDemo()
{
    // Stack: value type
    int x = 42;  // 4 байти на стеку

    // Stack: struct (якщо не boxed)
    Point p = new Point(10, 20);  // 8 байт на стеку

    // Heap: reference type
    Person person = new Person();  // Референс (4/8 байт) на стеку
                                    // Об'єкт на heap

    // Heap: boxing
    object boxedX = x;  // Створює об'єкт на heap з значенням 42

} // <-- При виході: stack очищується автоматично
  //     Heap об'єкти стають eligible for GC

struct Point
{
    public int X;  // 4 байти
    public int Y;  // 4 байти
    // Загалом: 8 байт
}

class Container
{
    public int id;        // 4 байти inline в об'єкті
    public Point point;   // 8 байт inline в об'єкті
    // Загалом в об'єкті: Object Header + MethodTable + 4 + 8 = ~28-40 байт
}

void Method()
{
    Point p;  // 8 байт на стеку
    Container c = new Container();  // Референс на стеку, об'єкт на heap
}

class Person
{
    public string Name;  // Референс на string (який теж на heap)
    public int Age;      // 4 байти inline
}

Person p1 = new Person();  // Heap: Person об'єкт
Person p2 = p1;            // Stack: обидві змінні вказують на ОДИН об'єкт

p2.Age = 30;
Console.WriteLine(p1.Age);  // 30 - змінили через p2, але p1 бачить зміни!

int value = 42;           // Stack: 4 байти
object boxed = value;     // Heap: створюється об'єкт Int32 з value 42
                          // Stack: референс на цей об'єкт

// Unboxing - зворотній процес
int unboxed = (int)boxed; // Копіювання значення з heap на stack

// ❌ Погано: Boxing у циклі
List<object> items = new List<object>();
for (int i = 0; i < 10000; i++)
{
    items.Add(i);  // 10000 boxing операцій = 10000 heap алокацій!
}

// ✅ Добре: Використання generic колекції
List<int> items = new List<int>();
for (int i = 0; i < 10000; i++)
{
    items.Add(i);  // Без boxing, зберігається inline
}

class Node
{
    public Node Next;
    public string Data;
}

void Example()
{
    Node head = new Node { Data = "A" };  // Root
    head.Next = new Node { Data = "B" };
    head.Next.Next = new Node { Data = "C" };
    Node orphan = new Node { Data = "X" };  // Недосяжний після наступного рядка
    orphan = null;

    // GC marking:
    // 1. Знайти roots: head (локальна змінна)
    // 2. Маркувати Node "A" як reachable
    // 3. Слідувати за Next, маркувати "B"
    // 4. Слідувати за Next, маркувати "C"
    // 5. Node "X" не маркований -> garbage
}

Before Compaction:
[Obj A][    ][Obj B][        ][Obj C][    ]
 ^live  ^dead ^live   ^dead   ^live  ^dead

After Compaction:
[Obj A][Obj B][Obj C][                    ]
                      ^ Free space for new objects

// До compaction
Node n1 = /* 0x1000 */;
Node n2 = /* 0x2000 */;
n1.Next = n2;  // Next вказує на 0x2000

// Після compaction
// n2 переміщений на 0x1100
// GC автоматично оновлює:
n1.Next = /* тепер 0x1100 */;

void Gen0Example()
{
    for (int i = 0; i < 1000; i++)
    {
        // Кожна ітерація створює об'єкти у Gen0
        var temp = new StringBuilder();
        temp.Append("Temporary data ");
        temp.Append(i);
        string result = temp.ToString();

        // temp та проміжні string об'єкти стають garbage
        // після завершення ітерації
    }
    // Під час циклу може статися декілька Gen0 collections
}

class Gen1Scenario
{
    private List<string> _cache = new List<string>();

    void ProcessRequests()
    {
        for (int i = 0; i < 100; i++)
        {
            string data = FetchData(i);  // Gen0

            // Деякі дані кешуються - виживуть Gen0 GC
            if (i % 10 == 0)
            {
                _cache.Add(data);  // Переміститься до Gen1, потім Gen2
            }

            ProcessData(data);  // Більшість data стане garbage в Gen0
        }
    }
}

// Статичний кеш - швидко потрапить у Gen2
public static class ApplicationCache
{
    // Ці об'єкти будуть жити весь час роботи додатку
    private static Dictionary<string, UserProfile> _userCache
        = new Dictionary<string, UserProfile>();

    private static ConnectionPool _connections = new ConnectionPool();

    // Gen2 об'єкти!
}

// Singleton - також Gen2
public class ConfigurationManager
{
    private static readonly Lazy<ConfigurationManager> _instance =
        new Lazy<ConfigurationManager>(() => new ConfigurationManager());

    public static ConfigurationManager Instance => _instance.Value;  // Gen2
}

void FullGCDemo()
{
    Console.WriteLine("Before GC:");
    Console.WriteLine($"Gen0: {GC.CollectionCount(0)}");
    Console.WriteLine($"Gen1: {GC.CollectionCount(1)}");
    Console.WriteLine($"Gen2: {GC.CollectionCount(2)}");

    // Full GC - збере всі покоління
    GC.Collect(2, GCCollectionMode.Forced, blocking: true, compacting: true);

    Console.WriteLine("\nAfter Full GC:");
    Console.WriteLine($"Gen0: {GC.CollectionCount(0)}");  // +1
    Console.WriteLine($"Gen1: {GC.CollectionCount(1)}");  // +1
    Console.WriteLine($"Gen2: {GC.CollectionCount(2)}");  // +1
}

Initial State:
[Gen2][Gen1][Gen0: Obj A | Obj B | Obj C][Free]
              ^live   ^dead  ^live

After Gen0 GC:
[Gen2][Gen1: Obj A | Obj C][Gen0][Free]
     Gen1 boundary moved ↑

After Another Gen0+Gen1 GC (Obj A та C survive):
[Gen2: Obj A | Obj C][Gen1][Gen0][Free]
     Gen2 boundary moved ↑

// SOH - малий об'єкт
byte[] small = new byte[84_999];  // Розташується в SOH
Console.WriteLine(GC.GetGeneration(small));  // 0 (Gen0)

// LOH - великий об'єкт
byte[] large = new byte[85_000];  // Розташується в LOH
Console.WriteLine(GC.GetGeneration(large));  // 2 (LOH завжди Gen2)

LOH Before Allocation:
[Large Obj A: 100KB][Free: 50KB][Obj B: 200KB][Free: 150KB][Obj C: 80KB]

Allocate 120KB object:
Need 120KB, but largest free block is 150KB
[Obj A][Free][Obj B][New Obj: 120KB][Free: 30KB][Obj C]

Проблема: free block 50KB може ніколи не бути використаний,
якщо всі нові об'єкти >50KB

unsafe void PinningExample()
{
    byte[] buffer = new byte[1000];

    // Pinning - фіксуємо об'єкт у пам'яті (не може бути переміщений GC)
    fixed (byte* ptr = buffer)
    {
        // Викликаємо native функцію, яка очікує вказівник
        NativeApi.ProcessData(ptr, buffer.Length);

        // Під час цього buffer НЕ МОЖЕ бути переміщений compaction!
    }
    // Після виходу з fixed, об'єкт unpinned
}

// Альтернатива: GCHandle
void PinWithGCHandle()
{
    byte[] buffer = new byte[1000];

    GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
    try
    {
        IntPtr ptr = handle.AddrOfPinnedObject();
        NativeApi.ProcessData(ptr, buffer.Length);
    }
    finally
    {
        handle.Free();  // Unpinning
    }
}

Heap перед GC compaction:
[Obj A][Pinned B][Obj C][Free]

Compaction неможливий для B, тому:
[Obj A][Pinned B][  ][Obj C][Free]
              ↑ gap - фрагментація!

SOH:  [Obj A][Obj C][Free]  ← Може бути компактований
POH:  [Pinned B][Pinned D]  ← Окремий heap для pinned об'єктів

// WPF/WinForms Desktop Application
public partial class MainWindow : Window
{
    // Workstation GC - низькі паузи для responsive UI
    private async void LoadData_Click(object sender, RoutedEventArgs e)
    {
        // GC може відбутись під час роботи,
        // але паузи короткі -> UI responsive
        var data = await DataService.FetchLargeDataset();
        DataGrid.ItemsSource = data;
    }
}

<PropertyGroup>
    <ServerGarbageCollection>true</ServerGarbageCollection>

    <!-- Опціонально: кількість GC heaps (за замовчуванням = logical cores) -->
    <GCHeapCount>8</GCHeapCount>
</PropertyGroup>

// ASP.NET Core Web API
public class OrdersController : ControllerBase
{
    // Server GC - throughput важливіший за latency
    [HttpPost]
    public async Task<IActionResult> ProcessBulkOrders([FromBody] List<Order> orders)
    {
        // Обробка тисяч orders паралельно
        var tasks = orders.Select(ProcessOrder);
        await Task.WhenAll(tasks);

        // Server GC ефективно працює з багатопотоковим навантаженням
        return Ok();
    }
}

<PropertyGroup>
    <!-- За замовчуванням увімкнено, але можна вимкнути -->
    <ConcurrentGarbageCollection>true</ConcurrentGarbageCollection>
</PropertyGroup>

// У коді (до запуску GC):
System.Runtime.GCSettings.LatencyMode = GCLatencyMode.Batch;
// Batch mode - без background, компактує агресивніше

void AllocateTillGC()
{
    int collectionsBefore = GC.CollectionCount(0);

    // Продовжуємо алокувати, поки не спрацює Gen0 GC
    while (GC.CollectionCount(0) == collectionsBefore)
    {
        var obj = new byte[1024];  // 1 KB
        // Gen0 budget зменшується...
    }

    Console.WriteLine("Gen0 GC triggered!");
}

// ❌ ПОГАНА практика у більшості випадків
GC.Collect();

// Збір конкретного покоління
GC.Collect(0);  // Тільки Gen0
GC.Collect(1);  // Gen0 + Gen1
GC.Collect(2);  // Full GC (Gen0 + Gen1 + Gen2)

// З додатковими параметрами
GC.Collect(2,
    GCCollectionMode.Optimized,  // Оптимальний час для збору
    blocking: true,               // Чекати завершення
    compacting: true);            // З компактуванням

// Симуляція: реєстрація на memory pressure
AppDomain.CurrentDomain.MonitoringIsEnabled = true;

void MonitorMemory()
{
    long before = GC.GetTotalMemory(forceFullCollection: false);

    // При низькому рівні пам'яті ОС повідомить CLR
    // CLR може викликати aggressive Gen2 GC

    long after = GC.GetTotalMemory(forceFullCollection: false);

    Console.WriteLine($"Memory: {before / 1024 / 1024} MB -> {after / 1024 / 1024} MB");
}

bool TryNoGCRegion()
{
    long totalMemory = 10 * 1024 * 1024;  // 10 MB budget

    try
    {
        // Запитуємо CLR: "Не викликай GC, поки є 10 MB"
        if (GC.TryStartNoGCRegion(totalMemory))
        {
            // Критична секція - GC не спрацює (якщо вистачить budget)
            PerformLatencySensitiveOperation();

            return true;
        }

        return false;
    }
    finally
    {
        if (GC.TryStartNoGCRegion(0))  // Перевірка, чи в no-gc режимі
            GC.EndNoGCRegion();
    }
}

void PerformLatencySensitiveOperation()
{
    // Наприклад: real-time audio processing, high-frequency trading
    for (int i = 0; i < 1000; i++)
    {
        ProcessFrame();  // Немає GC паузи!
    }
}

class GCMonitor
{
    static void Main()
    {
        Console.WriteLine("=== GC Statistics ===\n");

        // Загальна пам'ять
        long totalMemory = GC.GetTotalMemory(forceFullCollection: false);
        Console.WriteLine($"Total Memory: {totalMemory / 1024 / 1024} MB");

        // Кількість збірок по поколіннях
        Console.WriteLine($"Gen0 Collections: {GC.CollectionCount(0)}");
        Console.WriteLine($"Gen1 Collections: {GC.CollectionCount(1)}");
        Console.WriteLine($"Gen2 Collections: {GC.CollectionCount(2)}");

        // Створюємо об'єкт і відслідковуємо його покоління
        var obj = new object();
        Console.WriteLine($"\nObject generation: {GC.GetGeneration(obj)}");

        GC.Collect();
        Console.WriteLine($"After GC(0): {GC.GetGeneration(obj)}");

        GC.Collect();
        Console.WriteLine($"After GC(1): {GC.GetGeneration(obj)}");

        // GC Settings
        Console.WriteLine($"\n=== GC Configuration ===");
        Console.WriteLine($"GC Mode: {(GCSettings.IsServerGC ? "Server" : "Workstation")}");
        Console.WriteLine($"Latency Mode: {GCSettings.LatencyMode}");
        Console.WriteLine($"LOH Compaction: {GCSettings.LargeObjectHeapCompactionMode}");

        // GC Max Generation
        Console.WriteLine($"Max Generation: {GC.MaxGeneration}");  // Зазвичай 2
    }
}

=== GC Statistics ===

Total Memory: 2 MB
Gen0 Collections: 0
Gen1 Collections: 0
Gen2 Collections: 0

Object generation: 0
After GC(0): 1
After GC(1): 2

=== GC Configuration ===
GC Mode: Workstation
Latency Mode: Interactive
LOH Compaction: Default
Max Generation: 2

class ProblematicCode
{
    void OpenFile()
    {
        FileStream fs = new FileStream("data.txt", FileMode.Open);
        byte[] buffer = new byte[1024];
        fs.Read(buffer, 0, buffer.Length);

        // ❌ ПОМИЛКА: Не закрили файл!
        // fs.Dispose() не викликано

    } // fs вийшов з scope, але FILE HANDLE ще відкритий!
      // GC зібере FileStream об'єкт, але handle залишиться!
}

public interface IDisposable
{
    void Dispose();
}

class FileLogger : IDisposable
{
    private FileStream _fileStream;

    public FileLogger(string path)
    {
        _fileStream = new FileStream(path, FileMode.Append);
    }

    public void Dispose()
    {
        // Звільнити unmanaged resource
        _fileStream?.Dispose();
        _fileStream = null;
    }

    public void Log(string message)
    {
        if (_fileStream == null)
            throw new ObjectDisposedException(nameof(FileLogger));

        byte[] data = Encoding.UTF8.GetBytes(message + Environment.NewLine);
        _fileStream.Write(data, 0, data.Length);
    }
}

// Використання
using (var logger = new FileLogger("app.log"))
{
    logger.Log("Application started");
    logger.Log("Processing data");
} // Dispose() викликається автоматично

class ResourceManager : IDisposable
{
    // Unmanaged resource
    private IntPtr _nativePtr;

    // Managed resource (також IDisposable)
    private FileStream _fileStream;

    // Flag для відстеження disposed стану
    private bool _disposed = false;

    public ResourceManager(string filePath)
    {
        // Алокуємо unmanaged memory
        _nativePtr = Marshal.AllocHGlobal(1024);

        // Відкриваємо файл
        _fileStream = new FileStream(filePath, FileMode.Create);
    }

    // Public Dispose method
    public void Dispose()
    {
        // Викликаємо protected Dispose з disposing=true
        Dispose(disposing: true);

        // Вказуємо GC: не викликати finalizer
        GC.SuppressFinalize(this);
    }

    // Protected virtual Dispose method
    protected virtual void Dispose(bool disposing)
    {
        // Перевірка: чи вже disposed?
        if (_disposed)
            return;

        if (disposing)
        {
            // Звільняємо MANAGED resources
            _fileStream?.Dispose();
        }

        // Звільняємо UNMANAGED resources (завжди!)
        if (_nativePtr != IntPtr.Zero)
        {
            Marshal.FreeHGlobal(_nativePtr);
            _nativePtr = IntPtr.Zero;
        }

        _disposed = true;
    }

    // Destructor (Finalizer)
    ~ResourceManager()
    {
        // Викликається GC, якщо Dispose() не був викликаний
        // disposing=false -> тільки unmanaged cleanup
        Dispose(disposing: false);
    }

    // Helper method для перевірки disposed стану
    private void ThrowIfDisposed()
    {
        if (_disposed)
            throw new ObjectDisposedException(GetType().Name);
    }

    public void WriteData(byte[] data)
    {
        ThrowIfDisposed();
        _fileStream.Write(data, 0, data.Length);
    }
}

class AsyncResourceManager : IAsyncDisposable
{
    private NetworkStream _networkStream;
    private SemaphoreSlim _semaphore = new SemaphoreSlim(1);
    private bool _disposed = false;

    public async ValueTask DisposeAsync()
    {
        if (_disposed)
            return;

        await DisposeAsyncCore().ConfigureAwait(false);

        // Cleanup synchronous resources
        Dispose(disposing: false);

        GC.SuppressFinalize(this);
        _disposed = true;
    }

    protected virtual async ValueTask DisposeAsyncCore()
    {
        // Асинхронне очищення
        if (_networkStream != null)
        {
            await _networkStream.FlushAsync().ConfigureAwait(false);
            await _networkStream.DisposeAsync().ConfigureAwait(false);
        }

        _semaphore?.Dispose();
    }

    protected virtual void Dispose(bool disposing)
    {
        // Синхронні unmanaged resources (якщо є)
    }
}

// Використання з await using
async Task ProcessAsync()
{
    await using var manager = new AsyncResourceManager();

    // Асинхронна робота
    await manager.ProcessDataAsync();

} // DisposeAsync() викликається автоматично

using (FileStream fs = new FileStream("data.txt", FileMode.Open))
{
    // Робота з файлом
    byte[] buffer = new byte[1024];
    fs.Read(buffer, 0, buffer.Length);

    // Навіть якщо exception -> Dispose() викликається!
}
// fs.Dispose() гарантовано викликано

FileStream fs = new FileStream("data.txt", FileMode.Open);
try
{
    byte[] buffer = new byte[1024];
    fs.Read(buffer, 0, buffer.Length);
}
finally
{
    if (fs != null)
        ((IDisposable)fs).Dispose();
}

void ProcessFile()
{
    using FileStream fs = new FileStream("data.txt", FileMode.Open);
    using StreamReader reader = new StreamReader(fs);

    // Використання fs та reader
    string content = reader.ReadToEnd();
    Console.WriteLine(content);

    // Dispose викликається при виході з методу (в ЗВОРОТНОМУ порядку):
    // 1. reader.Dispose()
    // 2. fs.Dispose()
}

async Task ProcessDataAsync()
{
    // Traditional await using
    await using (var stream = new NetworkStream(...))
    {
        await stream.WriteAsync(data);
        await stream.FlushAsync();
    } // await stream.DisposeAsync()

    // await using declaration
    await using var connection = new AsyncDatabaseConnection();
    await connection.ExecuteQueryAsync("SELECT * FROM Users");

} // await connection.DisposeAsync()

// await using (var res = new AsyncResource())
var res = new AsyncResource();
try
{
    // Use resource
}
finally
{
    if (res != null)
        await res.DisposeAsync().ConfigureAwait(false);
}

// Традиційний синтаксис (рідко використовується)
using (FileStream input = File.OpenRead("input.txt"),
       output = File.OpenWrite("output.txt"))
{
    input.CopyTo(output);
}

// Краще: using declarations
void CopyFile()
{
    using var input = File.OpenRead("input.txt");
    using var output = File.OpenWrite("output.txt");

    input.CopyTo(output);
}

async Task ProcessWithMultipleResources()
{
    using var connection = new SqlConnection(connectionString);
    await using var transaction = await connection.BeginTransactionAsync();
    using var semaphore = new SemaphoreSlim(1);

    await semaphore.WaitAsync();
    try
    {
        // Робота з resources
        await ExecuteInTransactionAsync(connection, transaction);
        await transaction.CommitAsync();
    }
    finally
    {
        semaphore.Release();
    }

    // Dispose order (reverse):
    // 1. semaphore.Dispose()
    // 2. await transaction.DisposeAsync()
    // 3. connection.Dispose()
}

class ResourceHolder
{
    private IntPtr _handle;

    public ResourceHolder()
    {
        _handle = AllocateResource();
    }

    // Finalizer (деструктор)
    ~ResourceHolder()
    {
        // Cleanup код
        if (_handle != IntPtr.Zero)
        {
            FreeResource(_handle);
            _handle = IntPtr.Zero;
        }
    }
}

// Що генерує компілятор:
protected override void Finalize()
{
    try
    {
        // Ваш cleanup код тут
        if (_handle != IntPtr.Zero)
        {
            FreeResource(_handle);
            _handle = IntPtr.Zero;
        }
    }
    finally
    {
        base.Finalize();  // Автоматичний виклик finalizer базового класу
    }
}

class ImageCache
{
    private Dictionary<string, WeakReference<Image>> _cache = new();

    public Image GetImage(string path)
    {
        if (_cache.TryGetValue(path, out var weakRef) &&
            weakRef.TryGetTarget(out var image))
        {
            return image;  // Cache hit
        }

        // Cache miss - завантажити
        var newImage = Image.Load(path);
        _cache[path] = new WeakReference<Image>(newImage);
        return newImage;
    }
}

64-bit процес:
┌──────────────┬──────────────┬─────────────┐
│ Sync Block 8B│MethodTable 8B│ Fields...   │
└──────────────┴──────────────┴─────────────┘
Мінімум: 24 байти для порожнього об'єкта

32-bit процес:
┌──────────────┬──────────────┬─────────────┐
│ Sync Block 4B│MethodTable 4B│ Fields...   │
└──────────────┴──────────────┴─────────────┘
Мінімум: 12 байт

struct BadLayout
{
    byte b1;    // 1 byte
    long l1;    // 8 bytes
    byte b2;    // 1 byte
}
// Actual size: 24 bytes (з padding!)

struct GoodLayout
{
    long l1;    // 8 bytes
    byte b1;    // 1 byte
    byte b2;    // 1 byte
}
// Actual size: 16 bytes

// ❌ ПОГАНО - після кожної операції
void ProcessItems()
{
    foreach (var item in items)
    {
        ProcessItem(item);
        GC.Collect();  // Катастрофа для performance!
    }
}

// ✅ ДОБРЕ - довіряйте GC
void ProcessItems()
{
    foreach (var item in items)
    {
        ProcessItem(item);
    }
    // GC сам вирішить, коли збирати
}

using (var logger = new FileLogger("app.log"))
{
    logger.Write("Test");
} // Dispose викликається автоматично