Memory Management and Disposal

public static class BoxingExamples
{
    public static void Show()
    {
        int value = 42;

        object boxed = value;                 // allocates: a heap copy of the int
        int unboxed = (int)boxed;             // copies back out

        // A struct assigned to a non-generic interface is boxed too.
        IComparable comparable = value;       // allocates

        // Generic code avoids the box entirely.
        int larger = Max(value, 7);           // no allocation

        Console.WriteLine((unboxed, comparable, larger));
    }

    private static T Max<T>(T a, T b) where T : IComparable<T> =>
        a.CompareTo(b) >= 0 ? a : b;
}

public interface IDisposableLike
{
    void Dispose();
}

using System.Runtime.InteropServices;

public class NativeBuffer : IDisposable
{
    private IntPtr _handle;         // unmanaged
    private StreamWriter? _log;     // managed, and owned by this instance
    private bool _disposed;

    public NativeBuffer(int size, string logPath)
    {
        _handle = Marshal.AllocHGlobal(size);
        _log = new StreamWriter(logPath);
    }

    public void Dispose()
    {
        Dispose(disposing: true);
        GC.SuppressFinalize(this);      // the finalizer is no longer needed
    }

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed)
        {
            return;                     // Dispose must be idempotent
        }

        if (disposing)
        {
            // Called from Dispose(): other managed objects are still alive,
            // so it is safe to dispose the ones this instance owns.
            _log?.Dispose();
            _log = null;
        }

        // Always release unmanaged resources.
        if (_handle != IntPtr.Zero)
        {
            Marshal.FreeHGlobal(_handle);
            _handle = IntPtr.Zero;
        }

        _disposed = true;
    }

    ~NativeBuffer() => Dispose(disposing: false);

    protected void ThrowIfDisposed() => ObjectDisposedException.ThrowIf(_disposed, this);
}

public sealed class AsyncReportWriter : IAsyncDisposable
{
    private readonly Stream _stream;

    public AsyncReportWriter(Stream stream) => _stream = stream;

    public async ValueTask DisposeAsync()
    {
        await _stream.FlushAsync().ConfigureAwait(false);
        await _stream.DisposeAsync().ConfigureAwait(false);
    }
}

public static class AsyncDisposalUsage
{
    public static async Task RunAsync()
    {
        await using var writer = new AsyncReportWriter(Stream.Null);

        // …use writer…
    }   // await writer.DisposeAsync() runs here
}

public sealed class ImageCache
{
    private readonly Dictionary<string, WeakReference<byte[]>> _entries = new();

    public byte[] Get(string key, Func<string, byte[]> load)
    {
        if (_entries.TryGetValue(key, out var weak) && weak.TryGetTarget(out var cached))
        {
            return cached;          // still alive
        }

        byte[] fresh = load(key);
        _entries[key] = new WeakReference<byte[]>(fresh);
        return fresh;
    }
}

public static class GcDiagnostics
{
    public static void Report()
    {
        Console.WriteLine(GC.GetTotalMemory(forceFullCollection: false));    // bytes currently allocated
        Console.WriteLine(GC.GetTotalAllocatedBytes(precise: false));        // bytes ever allocated
        Console.WriteLine(GC.CollectionCount(0));                            // gen-0 collections so far

        GCMemoryInfo info = GC.GetGCMemoryInfo();
        Console.WriteLine(info.HeapSizeBytes);
        Console.WriteLine(info.PauseTimePercentage);
    }
}

dotnet tool install -g dotnet-counters
dotnet tool install -g dotnet-gcdump
dotnet tool install -g dotnet-trace

# Live counters: heap size, gen-0/1/2 counts, allocation rate, % time in GC.
dotnet-counters monitor --process-id 1234 --counters System.Runtime

# A heap snapshot that can be opened in Visual Studio or PerfView.
dotnet-gcdump collect --process-id 1234

# GC events over a window, for pause analysis.
dotnet-trace collect --process-id 1234 --providers Microsoft-Windows-DotNETRuntime:0x1:4

using System.Buffers;

public static class Pooling
{
    public static int CopyThroughPool(Stream source, Stream destination)
    {
        byte[] buffer = ArrayPool<byte>.Shared.Rent(8192);   // may be LARGER than asked for

        try
        {
            int total = 0, read;
            while ((read = source.Read(buffer, 0, buffer.Length)) > 0)
            {
                destination.Write(buffer, 0, read);
                total += read;
            }

            return total;
        }
        finally
        {
            // clearArray: true when the buffer held sensitive data.
            ArrayPool<byte>.Shared.Return(buffer, clearArray: false);
        }
    }
}

using System.Buffers;

public static class MemoryPooling
{
    public static async Task<int> ReadAsync(Stream source)
    {
        using IMemoryOwner<byte> owner = MemoryPool<byte>.Shared.Rent(4096);
        Memory<byte> buffer = owner.Memory;

        return await source.ReadAsync(buffer).ConfigureAwait(false);
    }   // owner.Dispose() returns the buffer to the pool
}