Утечки памяти в C#

public class Clock : Window
{
    DispatcherTimer timer;
 
    public Clock()
    {
        // Инициализация...
        timer = new DispatcherTimer
        {
            Interval = new TimeSpan(0, 0, 1)
        };
 
        timer.Start();
        timer.Tick += UpdateTime;
    }
 
    private void UpdateTime(object sender, EventArgs e)
    {
        // Обновление времени...
    }
 
    // Упс! Мы забыли отписаться от события
    protected override void OnClosed(EventArgs e)
    {
        base.OnClosed(e);
        
        // Нужно было добавить:
        // timer.Tick -= UpdateTime;
        // timer.Stop();
    }
}

public static class GlobalCache
{
    // Эта коллекция будет только расти...
    public static List<ExpensiveObject> Items = new List<ExpensiveObject>();
}
 
// Где-то в коде
void ProcessSomething()
{
    var obj = new ExpensiveObject();
    // После обработки данных добавляем в кеш и забываем
    GlobalCache.Items.Add(obj);
}

public void RegisterCallback()
{
    var largeObject = new byte[1000000]; // Большой объект
    
    // Замыкание захватывает largeObject
    Action callback = () => 
    {
        var firstByte = largeObject[0];
        Console.WriteLine($"First byte: {firstByte}");
    };
    
    // Регистрируем колбэк в долгоживущем менеджере
    CallbackManager.Register(callback);
    
    // largeObject будет жить, пока жив callback
}

public class Parent
{
    public List<Child> Children { get; } = new List<Child>();
    
    public void AddChild(Child child)
    {
        Children.Add(child);
        child.Parent = this; // Создаем обратную ссылку
    }
}
 
public class Child
{
    public Parent Parent { get; set; }
    
    // Другие данные...
}

public void ProcessFile()
{
    var fileStream = new FileStream("large.dat", FileMode.Open);
    // Работаем с файлом...
    
    // Упс! Забыли закрыть поток
    // fileStream.Dispose();
    // или использовать using
}

private static Dictionary<string, ComplexCalculationResult> _calculationCache = 
    new Dictionary<string, ComplexCalculationResult>();
 
public ComplexCalculationResult GetCalculationResult(string key)
{
    if (!_calculationCache.ContainsKey(key))
    {
        var result = PerformComplexCalculation(key);
        _calculationCache[key] = result;  // Добавляем в кеш навсегда
    }
    return _calculationCache[key];
}

public IEnumerable<ProcessedData> ProcessItems(List<RawData> items)
{
    var processor = new ExpensiveProcessor();
    return items.Select(item => processor.Process(item));
}

public class DataMonitor
{
    private readonly IDisposable _subscription;
 
    public DataMonitor(IObservable<SensorData> dataStream)
    {
        _subscription = dataStream.Subscribe(data => ProcessData(data));
    }
 
    private void ProcessData(SensorData data)
    {
        // Обработка данных...
    }
 
    // Упс! Мы не реализовали метод для отписки от потока
}

public async Task ProcessLargeDataAsync(byte[] largeData)
{
    // largeData захватывается в состоянии машины состояний для async метода
    await Task.Delay(1000);
    
    // Используем данные
    var result = CalculateResult(largeData);
    
    // Если Task сохраняется где-то, largeData будет удерживаться в памяти
}

// Антипаттерн!
public async Task<string> GetDataWrong()
{
    // Создаем новый клиент для каждого запроса
    using (var client = new HttpClient())
    {
        return await client.GetStringAsync("https://api.example.com/data");
    }
}
 
// Лучше использовать статический экземпляр
private static readonly HttpClient _sharedClient = new HttpClient();
 
public async Task<string> GetDataBetter()
{
    return await _sharedClient.GetStringAsync("https://api.example.com/data");
}

// Пример последовательности действий для тестирования утечки
private async Task TestForMemoryLeaks()
{
    // Сделайте первый снапшот вручную в VS
 
    for (int i = 0; i < 50; i++)
    {
        await PerformOperationThatMightLeak();
        
        // Принудительная сборка мусора для более точного анализа
        // В реальном коде не рекомендуется!
        GC.Collect();
        GC.WaitForPendingFinalizers();
        GC.Collect();
    }
    
    // Сделайте второй снапшот
 
    // Очистите ресурсы и вернитесь к исходному состоянию
    CleanupResources();
    
    // Принудительная сборка мусора
    GC.Collect();
    GC.WaitForPendingFinalizers();
    GC.Collect();
    
    // Сделайте третий снапшот
}

// Пример утечки памяти в WPF-приложении, который можно обнаружить с dotMemory
public class LeakingWindow : Window
{
    public LeakingWindow()
    {
        // Подписываемся на глобальное событие
        GlobalEvents.SomeEvent += OnGlobalEvent;
    }
 
    private void OnGlobalEvent(object sender, EventArgs e)
    {
        // Обработка события
    }
 
    // Забыли отписаться от события при закрытии окна!
    // protected override void OnClosed(EventArgs e)
    // {
    //     GlobalEvents.SomeEvent -= OnGlobalEvent;
    //     base.OnClosed(e);
    // }
}

// Пример использования OzCode для анализа утечек
void PerformOperation()
{
    for (int i = 0; i < 100; i++)
    {
        var processor = new DataProcessor();
        processor.Process();
    }
    
    // Поставьте здесь точку останова
    // Затем используйте OzCode: Show All Instances of DataProcessor
    // Если вы увидите здесь 100 экземпляров - у вас утечка!
}

public class AsyncLeakyService
{
    private readonly List<Task> _pendingTasks = new List<Task>();
    
    public async Task ProcessDataAsync(byte[] largeData)
    {
        var task = InternalProcessAsync(largeData);
        _pendingTasks.Add(task); // Сохраняем ссылку на задачу
        
        // Не ждем завершения и не удаляем из списка
    }
    
    private async Task InternalProcessAsync(byte[] data)
    {
        await Task.Delay(5000); // Имитация длительной операции
        // Обработка данных
    }
}

public class SafeClock : Window
{
    private DispatcherTimer timer;
 
    public SafeClock()
    {
        timer = new DispatcherTimer
        {
            Interval = new TimeSpan(0, 0, 1)
        };
 
        timer.Start();
        timer.Tick += UpdateTime;
    }
 
    private void UpdateTime(object sender, EventArgs e)
    {
        // Обновление времени...
    }
 
    protected override void OnClosed(EventArgs e)
    {
        // Отписываемся от события перед закрытием
        timer.Tick -= UpdateTime;
        timer.Stop();
        
        base.OnClosed(e);
    }
}

public class SafeSubscriber
{
    public SafeSubscriber()
    {
        // Вместо прямой подписки на событие
        // SomeStaticClass.StaticEvent += OnStaticEvent;
 
        // Используем слабые события
        WeakEventManager<SomeStaticClass, EventArgs>.AddHandler(
            SomeStaticClass.StaticEventManager, 
            "StaticEvent", 
            OnStaticEvent);
    }
    
    private void OnStaticEvent(object sender, EventArgs e)
    {
        // Обработка события
    }
}

// Пример с Microsoft.Extensions.DependencyInjection
services.AddTransient<IShortLivedService, ShortLivedService>(); // Создаётся каждый раз заново
services.AddScoped<IScopedService, ScopedService>();           // Живёт в рамках области (запроса)
services.AddSingleton<ICacheService, CacheService>();          // Живёт всё время работы приложения

public class RxComponent : IDisposable
{
    private readonly CompositeDisposable _subscriptions = new CompositeDisposable();
    
    public RxComponent(IObservable<Data> dataStream)
    {
        // Добавляем подписку в коллекцию
        _subscriptions.Add(
            dataStream.Subscribe(data => ProcessData(data))
        );
    }
    
    private void ProcessData(Data data)
    {
        // Обработка данных...
    }
    
    public void Dispose()
    {
        // Отписываемся от всех событий одной командой
        _subscriptions.Dispose();
    }
}

public async Task ProcessWithCancellationAsync(CancellationToken cancellationToken)
{
    // Создаём источник токена с тайм-аутом
    using var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
    using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(
        cancellationToken, timeoutCts.Token);
    
    try 
    {
        await LongRunningTaskAsync(linkedCts.Token);
    }
    catch (OperationCanceledException) 
    {
        // Обработка отмены операции
    }
}

public class ResourceManager : IDisposable
{
    private bool _disposed = false;
    private readonly FileStream _fileStream;
    
    public ResourceManager(string filePath)
    {
        _fileStream = new FileStream(filePath, FileMode.Open);
    }
    
    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                // Освобождаем управляемые ресурсы
                _fileStream?.Dispose();
            }
            
            // Освобождаем неуправляемые ресурсы здесь
            // ...
            
            _disposed = true;
        }
    }
    
    // Реализация IDisposable
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    
    // Финализатор для страховки
    ~ResourceManager()
    {
        Dispose(false);
    }
}

public void ProcessFile(string path)
{
    using (var stream = new FileStream(path, FileMode.Open))
    {
        // Работа с файлом...
    } // stream.Dispose() вызывается автоматически здесь
}

public void ProcessFile(string path)
{
    using var stream = new FileStream(path, FileMode.Open);
    // Работа с файлом...
} // stream.Dispose() вызывается в конце метода

public class WeakCache<TKey, TValue> where TValue : class
{
    private readonly Dictionary<TKey, WeakReference<TValue>> _cache = 
        new Dictionary<TKey, WeakReference<TValue>>();
    
    public void Add(TKey key, TValue value)
    {
        _cache[key] = new WeakReference<TValue>(value);
    }
    
    public bool TryGetValue(TKey key, out TValue value)
    {
        value = null;
        
        if (!_cache.TryGetValue(key, out var weakRef))
            return false;
            
        return weakRef.TryGetTarget(out value);
    }
    
    // Периодическая очистка "мёртвых" ссылок
    public void CleanupDeadReferences()
    {
        var keysToRemove = _cache
            .Where(pair => !pair.Value.TryGetTarget(out _))
            .Select(pair => pair.Key)
            .ToList();
            
        foreach (var key in keysToRemove)
            _cache.Remove(key);
    }
}

private readonly MemoryCache _cache = new MemoryCache("MyCache");
 
public void CacheItem(string key, object value)
{
    // Элемент будет автоматически удалён через 10 минут
    _cache.Set(key, value, new CacheItemPolicy
    {
        AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(10),
        // Или удалится, если система нуждается в памяти
        Priority = CacheItemPriority.Default
    });
}

private readonly Microsoft.Extensions.Caching.Memory.MemoryCache _cache = 
    new Microsoft.Extensions.Caching.Memory.MemoryCache(
        new Microsoft.Extensions.Caching.Memory.MemoryCacheOptions());
 
public void CacheItem(string key, object value)
{
    _cache.Set(key, value, TimeSpan.FromMinutes(10));
}

public class TaskTracker
{
    private readonly ConcurrentDictionary<Guid, Task> _tasks = 
        new ConcurrentDictionary<Guid, Task>();
    
    public Task StartTask(Func<Task> taskFunc)
    {
        var id = Guid.NewGuid();
        var task = taskFunc().ContinueWith(t => 
        {
            // Удаляем задачу после завершения
            _tasks.TryRemove(id, out _);
            // Пробрасываем исключения, если они были
            if (t.IsFaulted && t.Exception != null)
                throw t.Exception.InnerException ?? t.Exception;
            return t.Result;
        });
        
        _tasks[id] = task;
        return task;
    }
    
    // Отмена всех незавершенных задач при необходимости
    public async Task CancelAllAsync(CancellationToken token)
    {
        var tasks = _tasks.Values.ToArray();
        await Task.WhenAny(Task.WhenAll(tasks), Task.Delay(-1, token))
            .ConfigureAwait(false);
    }
}

public async Task ProcessDataAsync()
{
    // Не захватываем контекст синхронизации
    var data = await GetDataAsync().ConfigureAwait(false);
    
    // Дальнейшая обработка не привязана к исходному контексту
    var processed = ProcessData(data);
    
    // Здесь тоже не захватываем контекст
    await SaveResultAsync(processed).ConfigureAwait(false);
}

public void RegisterLongLivedAction()
{
    // Большой объект, который должен жить только в этом методе
    var data = LoadLargeData();
    
    // Эта лямбда захватывает переменную data
    Action callback = () => ProcessData(data.Id);
    
    // Где-то регистрируем долгоживущий колбэк
    EventAggregator.RegisterCallback("event_name", callback);
}

public void RegisterLongLivedActionFixed()
{
    var data = LoadLargeData();
    
    // Захватываем только необходимое
    int dataId = data.Id;
    Action callback = () => ProcessData(dataId);
    
    EventAggregator.RegisterCallback("event_name", callback);
    
    // Теперь весь объект data может быть собран GC
}

public class ObjectPool<T> where T : class, new()
{
    private readonly ConcurrentBag<T> _objects = new ConcurrentBag<T>();
    private readonly Func<T> _objectGenerator;
 
    public ObjectPool(Func<T> objectGenerator = null)
    {
        _objectGenerator = objectGenerator ?? (() => new T());
    }
 
    public T Get()
    {
        if (_objects.TryTake(out T item)) 
            return item;
            
        return _objectGenerator();
    }
 
    public void Return(T item)
    {
        _objects.Add(item);
    }
}
 
// Использование:
using(var buffer = bufferPool.Get())
{
    // Работаем с буфером...
    bufferPool.Return(buffer);
}

// Вместо класса
public struct Point3D
{
    public float X;
    public float Y;
    public float Z;
 
    public Point3D(float x, float y, float z)
    {
        X = x;
        Y = y;
        Z = z;
    }
}
 
// Использование
void ProcessPoints(int count)
{
    for (int i = 0; i < count; i++)
    {
        // Не создаёт давления на кучу
        var point = new Point3D(i, i * 2, i * 3);
        ProcessPoint(point);
    }
}

// Оптимизированное чтение большого файла
public async Task<string> ReadLargeFileAsync(string filePath)
{
    using var fileStream = new FileStream(
        filePath, 
        FileMode.Open, 
        FileAccess.Read, 
        FileShare.Read, 
        bufferSize: 4096, // Подходящий размер буфера
        useAsync: true); // Асинхронный режим для потоков
        
    using var streamReader = new StreamReader(fileStream);
    return await streamReader.ReadToEndAsync();
}

public async Task ProcessLargeFileAsync(string filePath)
{
    using var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, true);
    using var streamReader = new StreamReader(fileStream);
    
    string line;
    while ((line = await streamReader.ReadLineAsync()) != null)
    {
        // Обрабатываем строку за строкой
        await ProcessLineAsync(line);
    }
}

public class Parent
{
    public List<Child> Children { get; } = new List<Child>();
 
    public void AddChild(Child child)
    {
        Children.Add(child);
        child.SetParent(this);
    }
    
    public void RemoveChild(Child child)
    {
        Children.Remove(child);
        child.ClearParent();
    }
}
 
public class Child
{
    private Parent _parent;
    
    public void SetParent(Parent parent)
    {
        _parent = parent;
    }
    
    public void ClearParent()
    {
        _parent = null;
    }
}

// Вместо этого
public void ProcessItems(List<Item> items)
{
    var processor = new ExpensiveProcessor();
    items.ForEach(item => processor.Process(item));
}
 
// Используйте это
public void ProcessItemsBetter(List<Item> items)
{
    var processor = new ExpensiveProcessor();
    
    // Локальная функция
    void ProcessItem(Item item)
    {
        processor.Process(item);
    }
    
    foreach (var item in items)
    {
        ProcessItem(item);
    }
}

public class BackgroundWorker : IDisposable
{
    private readonly CancellationTokenSource _cts = new CancellationTokenSource();
    private readonly Task _backgroundTask;
 
    public BackgroundWorker()
    {
        // Запускаем долгоживущую задачу
        _backgroundTask = Task.Run(async () =>
        {
            while (!_cts.Token.IsCancellationRequested)
            {
                await DoWorkAsync(_cts.Token);
                await Task.Delay(1000, _cts.Token);
            }
        }, _cts.Token);
    }
 
    private async Task DoWorkAsync(CancellationToken token)
    {
        // Реализация работы...
    }
 
    public void Dispose()
    {
        _cts.Cancel();
        try
        {
            // Ждём завершения задачи с таймаутом
            _backgroundTask.Wait(TimeSpan.FromSeconds(5));
        }
        catch (AggregateException)
        {
            // Ожидаемое исключение при отмене
        }
        _cts.Dispose();
    }
}

public class AutoCleaningCache<TKey, TValue>
{
    private readonly Dictionary<TKey, CacheEntry> _cache = new Dictionary<TKey, CacheEntry>();
    private readonly Timer _cleanupTimer;
    
    private class CacheEntry
    {
        public TValue Value { get; }
        public DateTime LastAccess { get; set; }
        
        public CacheEntry(TValue value)
        {
            Value = value;
            LastAccess = DateTime.UtcNow;
        }
    }
    
    public AutoCleaningCache(TimeSpan cleanupInterval, TimeSpan itemExpiration)
    {
        _cleanupTimer = new Timer(_ => Cleanup(itemExpiration), null, 
                                 cleanupInterval, cleanupInterval);
    }
    
    private void Cleanup(TimeSpan expiration)
    {
        var now = DateTime.UtcNow;
        var keysToRemove = _cache
            .Where(kv => (now - kv.Value.LastAccess) > expiration)
            .Select(kv => kv.Key)
            .ToList();
            
        foreach (var key in keysToRemove)
            _cache.Remove(key);
    }
    
    // Методы для работы с кешем
}

// Вместо этого
public class BigObject
{
    public byte[] LargeData { get; } // Например, кеш изображений
    public int Id { get; }
    public string Name { get; }
    
    // И еще куча полей...
}
 
// Попробуйте это
public class LightweightReference
{
    public int Id { get; }
    public string Name { get; }
    
    // Только необходимые метаданные, без тяжелых данных
    private readonly Lazy<byte[]> _largeData;
    
    public byte[] GetLargeData() => _largeData.Value;
}

public async Task<ProcessedResult> ProcessLargeDataOutOfProcess(byte[] largeData)
{
    using var process = new Process
    {
        StartInfo = new ProcessStartInfo
        {
            FileName = "DataProcessor.exe",
            UseShellExecute = false,
            RedirectStandardInput = true,
            RedirectStandardOutput = true,
            CreateNoWindow = true
        }
    };
    
    process.Start();
    
    // Отправляем данные в отдельный процесс
    await process.StandardInput.BaseStream.WriteAsync(largeData, 0, largeData.Length);
    process.StandardInput.Close();
    
    // Получаем результат
    var resultJson = await process.StandardOutput.ReadToEndAsync();
    return JsonConvert.DeserializeObject<ProcessedResult>(resultJson);
}

public class CompactIntegerSet
{
    private const int BitsPerInt = 32;
    private readonly int[] _bits;
    
    public CompactIntegerSet(int capacity)
    {
        int arraySize = (capacity + BitsPerInt - 1) / BitsPerInt;
        _bits = new int[arraySize];
    }
    
    public void Add(int value)
    {
        int arrayIndex = value / BitsPerInt;
        int bitIndex = value % BitsPerInt;
        
        _bits[arrayIndex] |= (1 << bitIndex);
    }
    
    public bool Contains(int value)
    {
        int arrayIndex = value / BitsPerInt;
        int bitIndex = value % BitsPerInt;
        
        return (_bits[arrayIndex] & (1 << bitIndex)) != 0;
    }
}

public class SegmentedList<T>
{
    private const int SegmentSize = 1000;
    private readonly List<T[]> _segments = new List<T[]>();
    
    public int Count { get; private set; }
    
    public void Add(T item)
    {
        int segmentIndex = Count / SegmentSize;
        int itemIndex = Count % SegmentSize;
        
        if (segmentIndex >= _segments.Count)
        {
            _segments.Add(new T[SegmentSize]);
        }
        
        _segments[segmentIndex][itemIndex] = item;
        Count++;
    }
    
    public T this[int index]
    {
        get
        {
            if (index < 0 || index >= Count)
                throw new IndexOutOfRangeException();
                
            int segmentIndex = index / SegmentSize;
            int itemIndex = index % SegmentSize;
            
            return _segments[segmentIndex][itemIndex];
        }
    }
    
    // Можно освобождать неиспользуемые сегменты
    public void TrimExcess()
    {
        int neededSegments = (Count + SegmentSize - 1) / SegmentSize;
        if (_segments.Count > neededSegments)
        {
            _segments.RemoveRange(neededSegments, _segments.Count - neededSegments);
        }
    }
}

public T ExecuteInIsolation<T>(Func<T> riskyOperation)
{
    AppDomain isolatedDomain = null;
    try
    {
        // Создаём изолированный домен
        isolatedDomain = AppDomain.CreateDomain(
            "IsolatedDomain", 
            null, 
            new AppDomainSetup { ApplicationBase = AppDomain.CurrentDomain.BaseDirectory });
            
        // Создаём экземпляр обёртки в изолированном домене
        var wrapper = (OperationWrapper)isolatedDomain.CreateInstanceAndUnwrap(
            typeof(OperationWrapper).Assembly.FullName, 
            typeof(OperationWrapper).FullName);
            
        // Выполняем операцию
        return wrapper.Execute(riskyOperation);
    }
    finally
    {
        // Выгружаем домен вместе со всей его памятью
        if (isolatedDomain != null)
            AppDomain.Unload(isolatedDomain);
    }
}
 
// Обёртка для передачи в другой домен
[Serializable]
public class OperationWrapper : MarshalByRefObject
{
    public T Execute<T>(Func<T> operation)
    {
        return operation();
    }
}

public void MemoryIntensiveOperation()
{
    // Сообщаем GC, что мы ожидаем временный всплеск аллокаций
    using (new MemoryPressure(50 * 1024 * 1024)) // Примерно 50 МБ
    {
        // Выполняем операцию, требующую много памяти
        var largeResult = ComputeLargeTemporaryResult();
        ProcessResult(largeResult);
    } // Здесь MemoryPressure.Dispose() подсказывает GC, что можно запустить сборку
}
 
public class MemoryPressure : IDisposable
{
    private readonly long _bytesAllocated;
    
    public MemoryPressure(long bytesAllocated)
    {
        _bytesAllocated = bytesAllocated;
        // Сообщаем GC о предстоящем давлении на память
        GC.AddMemoryPressure(_bytesAllocated);
    }
    
    public void Dispose()
    {
        // Сообщаем GC, что давление снято
        GC.RemoveMemoryPressure(_bytesAllocated);
    }
}

public class LightweightMemoryProfiler
{
    private readonly Timer _profilingTimer;
    private readonly Dictionary<string, WeakReference> _trackedObjects = new Dictionary<string, WeakReference>();
    
    public LightweightMemoryProfiler(TimeSpan interval)
    {
        _profilingTimer = new Timer(_ => CollectStatistics(), null, interval, interval);
    }
    
    public void TrackObject(object obj, string tag)
    {
        _trackedObjects[tag] = new WeakReference(obj);
    }
    
    private void CollectStatistics()
    {
        var stats = new Dictionary<string, bool>();
        
        foreach (var pair in _trackedObjects)
        {
            stats[pair.Key] = pair.Value.IsAlive;
        }
        
        // Логирование или отправка телеметрии
        LogStatistics(stats);
    }
}

[TestMethod]
public void Operation_ShouldNotLeakMemory()
{
    WeakReference reference = null;
    
    // Действие, которое потенциально может вызвать утечку
    Action potentiallyLeakyAction = () =>
    {
        var target = new SuspectedLeakyObject();
        reference = new WeakReference(target);
        target.PerformOperation();
    };
    
    // Выполняем действие
    potentiallyLeakyAction();
    
    // Принудительно запускаем GC
    GC.Collect();
    GC.WaitForPendingFinalizers();
    GC.Collect();
    
    // Проверяем, что объект был собран
    Assert.IsFalse(reference.IsAlive, "Memory leak detected: object was not collected");
}

public class MemoryHealthMonitor
{
    private readonly Dictionary<string, long> _baselineMemory = new Dictionary<string, long>();
    private readonly TimeSpan _warningThreshold;
    
    public MemoryHealthMonitor(TimeSpan warningThreshold)
    {
        _warningThreshold = warningThreshold;
        // Запускаем периодический сбор метрик
        Task.Run(async () => await MonitorMemoryAsync());
    }
    
    private async Task MonitorMemoryAsync()
    {
        while (true)
        {
            var currentProcess = Process.GetCurrentProcess();
            long workingSet = currentProcess.WorkingSet64;
            long privateBytes = currentProcess.PrivateMemorySize64;
            
            // Проверяем тренды роста памяти
            CheckMemoryTrends("WorkingSet", workingSet);
            CheckMemoryTrends("PrivateBytes", privateBytes);
            
            await Task.Delay(_warningThreshold);
        }
    }
    
    private void CheckMemoryTrends(string metricName, long currentValue)
    {
        if (!_baselineMemory.ContainsKey(metricName))
        {
            _baselineMemory[metricName] = currentValue;
            return;
        }
        
        long baseline = _baselineMemory[metricName];
        double growthRate = (double)(currentValue - baseline) / baseline;
        
        if (growthRate > 0.5) // 50% рост
        {
            // Отправляем уведомление о возможной утечке
            LogPossibleLeak(metricName, baseline, currentValue, growthRate);
            // Делаем снимок снапшота здесь или собираем диагностические данные
        }
    }
}

public class ImmutableRecord
{
    // Все поля только для чтения
    public readonly int Id;
    public readonly string Name;
    public readonly DateTime CreatedAt;
    
    public ImmutableRecord(int id, string name, DateTime createdAt)
    {
        Id = id;
        Name = name ?? throw new ArgumentNullException(nameof(name));
        CreatedAt = createdAt;
    }
    
    // Создаём новый экземпляр при "изменении"
    public ImmutableRecord WithName(string newName)
    {
        return new ImmutableRecord(Id, newName, CreatedAt);
    }
}

// Вместо этого
public void TransformData(List<DataItem> items)
{
    foreach (var item in items)
    {
        item.Value = TransformItem(item.Value);
    }
}
 
// Используйте это
public IEnumerable<DataItem> TransformData(IEnumerable<DataItem> items)
{
    return items.Select(item => new DataItem
    {
        Id = item.Id,
        Value = TransformItem(item.Value)
    });
}

public void ProcessData(object data)
{
#if DEBUG
    // Код только для отладки
    DebugTools.TrackObject(data, "ProcessData input");
#endif
 
    // Основной код
}

// Вместо этого в горячем цикле
for (int i = 0; i < veryLargeArray.Length; i++)
 
// Используйте это
int length = veryLargeArray.Length;
for (int i = 0; i < length; i++)

// Вместо этого
string result = "";
for (int i = 0; i < 1000; i++)
{
    result += $"Item {i}, ";
}
 
// Используйте это
var sb = new StringBuilder(24000); // Приблизительно оцениваем нужную ёмкость
for (int i = 0; i < 1000; i++)
{
    sb.Append("Item ").Append(i).Append(", ");
}
string result = sb.ToString();