// Inspecting object generations in C#
object tempObj = new object();
Console.WriteLine($"Generation of tempObj: {GC.GetGeneration(tempObj)}"); // Gen 0

// Survivors promote up generations:
GC.Collect(0); // Collect Gen 0
Console.WriteLine($"Generation after Gen 0 collection: {GC.GetGeneration(tempObj)}"); // Promoted to Gen 1!

GC.Collect(1); // Collect Gen 1
Console.WriteLine($"Generation after Gen 1 collection: {GC.GetGeneration(tempObj)}"); // Promoted to Gen 2!

// Allocating on the Large Object Heap (LOH >= 85,000 bytes)
byte[] largeBuffer = new byte[85000]; // Direct to LOH!
Console.WriteLine($"Is on LOH: {GC.GetGeneration(largeBuffer) >= 2}");

// DIAGNOSTICS: Total memory allocated in bytes
long allocatedBytes = GC.GetTotalMemory(forceFullCollection: false);
Console.WriteLine($"Allocated Managed Memory: {allocatedBytes / 1024:N0} KB");

public class DatabaseResourceManager : IDisposable {
    private bool _disposed = false; // Guard flag against multiple disposes
    private IntPtr _unmanagedHandle; // Native OS handle
    private Component _managedDisposable; // Managed child disposable

    public DatabaseResourceManager() {
        _unmanagedHandle = /* allocate unmanaged resource */;
        _managedDisposable = new Component();
    }

    // Public IDisposable entry point
    public void Dispose() {
        Dispose(disposing: true);
        GC.SuppressFinalize(this); // Prevent finalizer thread from running
    }

    protected virtual void Dispose(bool disposing) {
        if (_disposed) return;

        if (disposing) {
            // Free managed child disposables (safe because called deterministically)
            _managedDisposable?.Dispose();
        }

        // Free unmanaged resources (always safe to clean)
        if (_unmanagedHandle != IntPtr.Zero) {
            CloseNativeHandle(_unmanagedHandle);
            _unmanagedHandle = IntPtr.Zero;
        }

        _disposed = true;
    }

    // Finalizer (Safety net in case consumer forgets Dispose)
    ~DatabaseResourceManager() {
        Dispose(disposing: false);
    }
}

// High-level async C# code:
public async Task<string> FetchOrderAsync(int orderId) {
    var data = await _httpClient.GetStringAsync($"https://api.internal/orders/{orderId}");
    return data.Trim();
}

// Low-level conceptual struct generated by Roslyn compiler:
[System.Runtime.CompilerServices.CompilerGenerated]
private struct FetchOrderStateMachine : IAsyncStateMachine {
    public int State;
    public AsyncTaskMethodBuilder<string> Builder;
    public int OrderId;
    private TaskAwaiter<string> _awaiter;

    public void MoveNext() {
        try {
            if (State == -1) { // Initial entry
                _awaiter = _httpClient.GetStringAsync(...).GetAwaiter();
                if (!_awaiter.IsCompleted) {
                    State = 0; // Suspended at await #0
                    Builder.AwaitUnsafeOnCompleted(ref _awaiter, ref this);
                    return; // FREE THE CURRENT THREAD!
                }
            }
            // Resumed after I/O finishes:
            string data = _awaiter.GetResult();
            Builder.SetResult(data.Trim());
        }
        catch (Exception ex) {
            Builder.SetException(ex);
        }
    }
}

public class CachedUserRepository {
    private readonly MemoryCache _cache = new MemoryCache(new MemoryCacheOptions());
    private readonly HttpClient _client = new HttpClient();

    // High performance: Zero heap allocation on cache hits!
    public ValueTask<UserDto> GetUserAsync(int userId) {
        // Fast path: Synchronous cache hit (ZERO heap allocations!)
        if (_cache.TryGetValue(userId, out UserDto? cachedUser)) {
            return new ValueTask<UserDto>(cachedUser!); // Wraps struct value directly
        }

        // Slow path: Truly asynchronous network call (Delegates to async Task helper)
        return new ValueTask<UserDto>(FetchFromApiSlowAsync(userId));
    }

    private async Task<UserDto> FetchFromApiSlowAsync(int userId) {
        var user = await _client.GetFromJsonAsync<UserDto>($"https://api/users/{userId}");
        _cache.Set(userId, user, TimeSpan.FromMinutes(10));
        return user!;
    }
}

// In a reusable Class Library / NuGet Package:
public async Task<byte[]> DownloadFileAsync(string url) {
    using var client = new HttpClient();
    
    // ConfigureAwait(false): No need to return to the caller's context!
    // Saves context switching and avoids deadlocks for consumers
    var response = await client.GetAsync(url).ConfigureAwait(false);
    return await response.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
}

// In a WPF / WinForms UI Event Handler:
private async void OnDownloadButtonClick(object sender, RoutedEventArgs e) {
    statusLabel.Text = "Downloading..."; // On UI thread
    
    // Default ConfigureAwait(true) allows continuation to update UI directly:
    byte[] data = await DownloadFileAsync("https://files.com/doc.pdf");
    
    // Resumes on UI thread:
    statusLabel.Text = $"Done! Downloaded {data.Length} bytes.";
}

// 1. Synchronous Exclusive Locking with lock
private readonly object _syncLock = new object();
private int _accountBalance = 1000;

public void Deposit(int amount) {
    lock (_syncLock) { // Compiled to Monitor.Enter(_syncLock) with try/finally
        _accountBalance += amount;
    }
}

// 2. Asynchronous Resource Throttling with SemaphoreSlim (e.g. Rate Limiting)
public class RateLimitedApiClient {
    // Allow maximum 3 concurrent API calls at any given moment
    private readonly SemaphoreSlim _throttle = new SemaphoreSlim(initialCount: 3, maxCount: 3);
    private readonly HttpClient _client = new HttpClient();

    public async Task<string> FetchWithThrottlingAsync(string url) {
        // Asynchronously wait for an open slot without blocking threads!
        await _throttle.WaitAsync(); 
        try {
            return await _client.GetStringAsync(url);
        }
        finally {
            _throttle.Release(); // Always release in finally block!
        }
    }
}

string logEntry = "2026-09-26 21:45:10 [ERROR] Database timeout on port 5432";

// TRADITIONAL SUBSTRING: Allocates 3 new string objects on the managed heap!
string date = logEntry.Substring(0, 10);
string level = logEntry.Substring(20, 7);

// HIGH-PERFORMANCE ZERO-ALLOCATION PARSING WITH SPAN:
ReadOnlySpan<char> span = logEntry.AsSpan();

// Slicing creates views into the original memory buffer (ZERO HEAP ALLOCATION!)
ReadOnlySpan<char> dateSpan = span.Slice(0, 10);
ReadOnlySpan<char> levelSpan = span.Slice(20, 7);

// Parse integer directly from span without string conversion:
ReadOnlySpan<char> portSpan = span.Slice(span.LastIndexOf(' ') + 1);
int.TryParse(portSpan, out int portNumber); // Zero allocations!

Console.WriteLine($"Parsed port: {portNumber}");

// DEADLOCK IN WPF / WINFORMS / LEGACY ASP.NET:
public string GetData() {
    // Calling .Result synchronously blocks the UI thread:
    return FetchFromNetworkAsync().Result; // DEADLOCK HAPPENS HERE!
}

private async Task<string> FetchFromNetworkAsync() {
    using var client = new HttpClient();
    // By default captures UI SynchronizationContext:
    var json = await client.GetStringAsync("https://api/orders"); 
    // Continuation needs UI thread, but UI thread is blocked waiting above!
    return json;
}

// SAFE ARCHITECTURE: Async All The Way Down!
public async Task<string> GetDataSafeAsync() {
    // Await frees the thread completely; no deadlock possible!
    return await FetchFromNetworkSafeAsync();
}

private async Task<string> FetchFromNetworkSafeAsync() {
    using var client = new HttpClient();
    // ConfigureAwait(false) doesn't capture UI context:
    return await client.GetStringAsync("https://api/orders").ConfigureAwait(false);
}

public class ConcurrencyDemo {
    // 1. volatile: Guarantees visibility across CPU cores (flag pattern)
    private volatile bool _isRunning = true;
    public void Stop() => _isRunning = false;

    // 2. Interlocked: Lock-free atomic increment (Fastest for counters)
    private int _requestCounter = 0;
    public void RecordRequest() {
        // Atomic hardware-level increment, safe across 100 threads
        Interlocked.Increment(ref _requestCounter);
    }

    // 3. Interlocked CompareExchange: Optimistic lock-free update
    private int _maxScore = 0;
    public void UpdateMaxScore(int newScore) {
        int current;
        do {
            current = _maxScore;
            if (newScore <= current) break;
        } while (Interlocked.CompareExchange(ref _maxScore, newScore, current) != current);
    }

    // 4. lock: Required when updating multiple correlated objects
    private readonly object _orderLock = new object();
    private readonly List<string> _orders = new();
    public void AddOrder(string order) {
        lock (_orderLock) {
            _orders.Add(order);
        }
    }
}

// Reads a massive 50GB log file line-by-line with CONSTANT RAM usage!
public static IEnumerable<string> ReadErrorLines(string filePath) {
    using var reader = new StreamReader(filePath);
    string? line;
    while ((line = reader.ReadLine()) != null) {
        if (line.Contains("[ERROR]")) {
            yield return line; // Yields one line at a time!
        }
    }
    // Automatically cleans up the StreamReader when enumeration ends!
}

// Consumer: Evaluates lazily, stops after finding 5 errors:
foreach (var error in ReadErrorLines("massive_production.log").Take(5)) {
    Console.WriteLine($"Found: {error}");
}
// The StreamReader is disposed immediately after taking 5 lines!
// The remaining 49.9 GB of the file is NEVER loaded into RAM!