8 мин

10K

Каждый разработчик на .NET сталкивался с этим. Всё работает быстро, но иногда случается внезапный фриз. Игра проседает с 60 до 30 FPS на секунду. Сервис отвечает на запрос 100 мс вместо обычных 10. UI дёргается.

Виновник — Garbage Collector.

Когда GC решает собрать мусор, он останавливает все потоки приложения (Stop-The-World). Для игр и real-time сервисов это катастрофа.

Стандартные коллекции .NET создают мусор везде:

// Каждая из этих операций аллоцирует память
var list = new List<int>();           // аллокация
list.Add(42);                          // может аллоцировать при росте capacity
var result = list.Where(x => x > 10); // аллокация итератора
var arr = list.ToArray();              // аллокация массива
list.Clear();                          // O(N) — обход массива, но не аллокация

В типичном игровом кадре может быть сотни таких операций. Мусор накапливается, GC собирает его в самый неподходящий момент — во время босс-файта.

Что с этим делают обычно

Решение: GC-free коллекции с пулингом и знакомым API

GcFreeCollections — библиотека для .NET 8.0+ и Unity, которая заменяет стандартные коллекции на их GC-free аналоги.

dotnet add package GcFreeCollections --version 1.0.0

Ключевые возможности:

1. PooledList<T> — замена List<T> без аллокаций после прогрева

2. PooledDictionary<TKey,TValue> — замена Dictionary<K,V>

3. PooledHashSet<T> — замена HashSet<T>

4. PooledQueue<T>, PooledStack<T>, PooledPriorityQueue<T,P>

5. PooledMemoryStream — замена MemoryStream

6. PooledStringBuilder — замена StringBuilder с меньшим числом аллокаций

7. PooledQuery — LINQ-пайплайн без аллокаций

8. HotPath.Enter() — отлавливает случайные аллокации в DEBUG

9. Leak tracking — находит утечки пулированных объектов

10. Reference Quarantine — безопасная очистка через Maintain()

Чем отличается от стандартных коллекций

Ключевое отличие: стандартные коллекции оперируют на уровне "создал-использовал-забыл-пусть-GC разбирается". GcFreeCollections — "взял-из-пула-использовал-вернул-в-пул".

Быстрый старт

Шаг 1. Подключение пространства имён

using GcFreeCollections;

Шаг 2. PooledList — замена List

// Вместо var list = new List<int>();
using var list = PooledList<int>.Create();
list.Add(42);
list.Add(100);
list.Add(73);
foreach (var x in list) // struct enumerator, без аллокаций
{
    Console.WriteLine(x);
}
list.Clear(); // O(1), без обхода массива
// В конце using автоматически вернёт list в пул

Важно: после Clear() элементы не зануляются мгновенно. Вместо этого используется Reference Quarantine.

Шаг 3. Hot-first Clear и Maintain

// В игровом кадре
using var enemies = PooledList<Enemy>.Create();
// ... добавляем врагов, работаем ...
enemies.Clear(); // O(1) — быстрая очистка
// В конце кадра (или раз в несколько кадров)
PooledGlobals.Maintain(); // Постепенно чистим ссылки на Enemy

Шаг 4. PooledDictionary

using var dict = PooledDictionary<string, int>.Create();
dict["health"] = 100;
dict.Add("mana", 50);
if (dict.TryGetValue("health", out int health))
{
    Console.WriteLine($"Health: {health}");
}
foreach (var kv in dict) // struct enumerator
{
    Console.WriteLine($"{kv.Key}: {kv.Value}");
}

Шаг 5. PooledHashSet

using var visited = PooledHashSet<int>.Create();
visited.Add(42);
visited.Add(100);
if (visited.Contains(42))
{
    Console.WriteLine("Found");
}

Шаг 6. LINQ-пайплайн без GC

using var numbers = PooledList<int>.Create(10000);
for (int i = 0; i < 10000; i++) numbers.Add(i);
// Вместо numbers.Where(x => x > 10).Select(x => x * 2).Take(256).ToList()
using var result = numbers
    .Where(x => x > 10)
    .Select(x => x * 2)
    .Take(256)
    .ToPooledList(capacityHint: 256);
// Ни одной аллокации на всём пайплайне

Шаг 7. PooledStringBuilder

using var sb = PooledStringBuilder.CreatePooled(128);
sb.Append("Player ");
sb.Append(123);
sb.Append(" HP");
string text = sb.ToString(); // Единственная аллокация — финальная строка

Шаг 8. PooledMemoryStream

using var ms = PooledMemoryStream.Create();
ms.Write(Encoding.UTF8.GetBytes("hello world"));
ms.Position = 0;
using var reader = new StreamReader(ms);
string content = reader.ReadToEnd();

Полный рабочий пример: игровой менеджер врагов

using GcFreeCollections;
public class EnemyManager
{
    private readonly PooledList<Enemy> _allEnemies;
    private readonly PooledList<Enemy> _nearbyEnemies;
    private readonly PooledHashSet<int> _deadEnemyIds;
    
    public EnemyManager(int maxEnemies)
    {
        _allEnemies = PooledList<Enemy>.Create(maxEnemies);
        _nearbyEnemies = PooledList<Enemy>.Create(64);
        _deadEnemyIds = PooledHashSet<int>.Create();
    }
    
    public void SpawnEnemy(Enemy enemy)
    {
        _allEnemies.Add(enemy);
    }
    
    public void UpdateNearbyEnemies(Vector3 playerPosition, float radius)
    {
        // Быстрая очистка (O(1))
        _nearbyEnemies.Clear();
        
        // Поиск ближайших врагов
        foreach (var enemy in _allEnemies)
        {
            if (Vector3.Distance(enemy.Position, playerPosition) < radius)
            {
                _nearbyEnemies.Add(enemy);
            }
        }
    }
    
    public void HandleDeaths()
    {
        // Используем временную коллекцию для хранения ID умерших
        using var toRemove = PooledList<int>.Create();
        
        for (int i = 0; i < _allEnemies.Count; i++)
        {
            if (_allEnemies[i].IsDead)
            {
                toRemove.Add(i);
                _deadEnemyIds.Add(_allEnemies[i].Id);
            }
        }
        
        // Удаляем мёртвых (с конца, чтобы не сбивать индексы)
        for (int i = toRemove.Count - 1; i >= 0; i--)
        {
            _allEnemies.RemoveAt(toRemove[i]);
        }
    }
    
    public void Update()
    {
        // Обновляем AI для всех врагов
        foreach (var enemy in _allEnemies)
        {
            enemy.Update();
        }
    }
    
    public void EndOfFrame()
    {
        // Постепенная очистка ссылок
        PooledGlobals.Maintain();
    }
    
    public void Dispose()
    {
        _allEnemies.Dispose();
        _nearbyEnemies.Dispose();
        _deadEnemyIds.Dispose();
    }
}

Производительность

Тестовый стенд: Intel Core i5-11400F, Windows 11, .NET 8, BenchmarkDotNet 0.15.8

List — Add + итерация

Dictionary — Add + TryGetValue

Note: Dictionary на 1000 элементах немного медленнее, но экономит 352× памяти.

HashSet — Add + Contains

LINQ — Where/Select/Take/ToList

StringBuilder / PooledStringBuilder

Note: PooledStringBuilder пока медленнее для маленьких строк, но экономит память.

Где применяется

1. Игровая разработка (Unity / Godot / Monogame)

Проблема: GC-спайки вызывают frame hitches.
Решение: Pooled-коллекции в Update/FixedUpdate.

void Update()
{
    using var activeEnemies = PooledList<Enemy>.Create();
    GetActiveEnemies(activeEnemies);
    
    foreach (var enemy in activeEnemies)
    {
        enemy.UpdateAI();
    }
} // Автоматический возврат в пул

2. Real-time сервисы (FinTech / Trading)

Проблема: GC-паузы влияют на latency-sensitive операции.
Решение: Zero-аллокации в обработке заявок.

public void ProcessOrders(ReadOnlySpan<Order> orders)
{
    using var buyOrders = PooledList<Order>.Create(orders.Length);
    using var sellOrders = PooledList<Order>.Create(orders.Length);
    
    foreach (var order in orders)
    {
        if (order.Type == OrderType.Buy)
            buyOrders.Add(order);
        else
            sellOrders.Add(order);
    }
    
    MatchOrders(buyOrders.AsSpan(), sellOrders.AsSpan());
}

3. Сетевые серверы (Multiplayer games)

Проблема: Тысячи подключений, каждое создаёт мусор.
Решение: Переиспользуемые коллекции для каждого клиента.

public class GameRoom
{
    private readonly PooledList<Player> _players;
    private readonly PooledList<Message> _pendingMessages;
    
    public void Broadcast(Message msg)
    {
        for (int i = 0; i < _players.Count; i++)
        {
            _players[i].Send(msg);
        }
    }
}

4. VR/AR приложения

Проблема: Любой пропущенный кадр вызывает дискомфорт.
Решение: Стабильный frame pacing без GC.

5. Аудио/DSP обработка

Проблема: Аллокации в аудио-потоке вызывают щелчки.
Решение: Pooled-буферы в реальном времени.

6. Unity Editor инструменты

Проблема: Стандартные коллекции в Editor Tooling создают мусор.
Решение: GC-free коллекции для парсеров и генераторов.

Сравнение с конкурентами

Когда GcFreeCollections выигрывает:

• Нужны знакомые API (List/Dictionary/HashSet) без аллокаций

• Проект на чистом .NET (не только Unity)

• Нужен LINQ-пайплайн без мусора

• Важны инструменты отладки (Leak tracking, HotPath guard)

• Не хотите писать свои пулы и отлаживать их

Когда стоит выбрать альтернативу:

• Unity Collections + Burst — если вы активно используете Job System и вам нужна максимальная производительность за счёт нативного кода

• Стандартные коллекции — для небольших проектов без требований к GC

• Roaring Bitmaps — если вам нужно компактное хранение множеств целых чисел

• Самописный пул — если у вас очень специфические требования и есть время на отладку

Отладка и инструменты

Отслеживание утечек (DEBUG)

// В конце сессии или при выгрузке уровня
PooledGlobals.LogLeaks(); // Логирует все объекты, не возвращённые в пул
PooledGlobals.AssertClosedPool(); // Бросает исключение, если есть утечки

Защита от случайных аллокаций в hot path (DEBUG)

void CriticalUpdate()
{
    using var hot = HotPath.Enter(); // Любая аллокация внутри выбросит исключение
    
    // Если здесь случится new List<int>() или другая аллокация — получите исключение
    using var list = PooledList<int>.Create(); // OK
    list.Add(42); // OK
}

Leak tracking для сложных сценариев

В DEBUG режиме каждый объект, взятый из пула, отслеживается. При вызове LogLeaks() вы увидите, где был создан объект, который не вернули в пул.

Unity Integration

using UnityEngine;
using GcFreeCollections;
public class PooledGameManager : MonoBehaviour
{
    private PooledList<GameObject> _activeProjectiles;
    
    void Start()
    {
        _activeProjectiles = PooledList<GameObject>.Create(256);
    }
    
    void Update()
    {
        _activeProjectiles.Clear(); // O(1) быстрая очистка
        
        foreach (var proj in FindObjectsOfType<Projectile>())
        {
            _activeProjectiles.Add(proj.gameObject);
        }
    }
    
    void LateUpdate()
    {
        // В конце кадра — постепенная очистка
        PooledGlobals.Maintain();
    }
    
    void OnDestroy()
    {
        _activeProjectiles.Dispose();
        PooledGlobals.AssertClosedPool(); // Убедимся, что всё вернули
    }
}

Бесплатное тестирование — без ограничений. Коммерческое использование требует лицензии.

NuGet: https://www.nuget.org/packages/GcFreeCollections

GitHub (бенчмарки): https://github.com/likeslines-maker/GcFreeCollections

GcFreeCollections — это библиотека GC-free коллекций для .NET и Unity.

Она решает конкретную проблему: непредсказуемые паузы из-за сборки мусора в real-time системах.

В отличие от стандартных коллекций:

• Не создаёт мусора после прогрева (экономия памяти до 7481×)

• Clear() работает за O(1) вместо O(N)

• Есть пулинг из коробки

В отличие от Unity Collections:

• Работает на любом .NET (не только Unity)

• Привычный API (List/Dictionary/HashSet)

• Есть LINQ-пайплайн без аллокаций

В отличие от самописных пулов:

• Уже отлажено и протестировано

• Есть инструменты отладки (Leak tracking, HotPath guard)

• Поддерживает сложные структуры (Dictionary, HashSet)

Если ваш проект страдает от GC-спайков — попробуйте GcFreeCollections. Стабильный frame rate и предсказуемая латентность того стоят.