Przejdź do treści
Biblioteka skilli
Programowanie · Budowanie i kod

optimizing-memory-allocation

/optimizing-memory-allocation

Stosuje wzorce zero-allocation w .NET z Span, ArrayPool i ObjectPool, by zmniejszyć presję na GC.

Licencja
MIT
Ostatnia zmiana repozytorium
21.07.2026

Ocena i bezpieczeństwo

84/ 100Klasa: dobry
Format9 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
2
Przestarzałość

Brak sygnałów. Repozytorium zmienione 21.07.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Stosuje wzorce zero-allocation w .NET z Span, ArrayPool i ObjectPool, by zmniejszyć presję na GC.

Oryginalny opis (EN)

Implements Zero Allocation patterns using Span, ArrayPool, and ObjectPool for memory efficiency in .NET. Use when reducing GC pressure or optimizing high-performance memory operations.

Jak działa

  1. 1. Core Concepts
  2. 2. Key APIs
  3. 3. Span<T>, ReadOnlySpan<T>
  4. 4. ArrayPool<T>
  5. 5. ObjectPool<T>
  6. 6. Memory<T>
  7. 7. Required NuGet Package
  8. 8. Important Notes
  9. 9. References
Sekcje z nagłówków SKILL.md, w oryginale · 214 linii, 543 słów
Podgląd SKILL.md
---
description: "Implements Zero Allocation patterns using Span, ArrayPool, and ObjectPool for memory efficiency in .NET. Use when reducing GC pressure or optimizing high-performance memory operations."
user-invocable: false
model: sonnet
---

# .NET Memory Efficiency, Zero Allocation

A guide for APIs that minimize GC pressure and enable high-performance memory management.

**Quick Reference:** See [QUICKREF.md](QUICKREF.md) for essential patterns at a glance.

## 1. Core Concepts

- .NET CLR GC Heap Memory Optimization
- Understanding Stack allocation vs Heap allocation
- Stack-only types through ref struct

## 2. Key APIs

| API | Purpose | NuGet |
|-----|---------|-------|
| `Span<T>`, `Memory<T>` | Stack-based memory slicing | BCL |
| `ArrayPool<T>.Shared` | Reduce GC pressure through array reuse | BCL |
| `DefaultObjectPool<T>` | Object pooling | Microsoft.Extensions.ObjectPool |
| `MemoryCache` | In-memory caching | System.Runtime.Caching |

---

## 3. Span<T>, ReadOnlySpan<T>

### 3.1 Basic Usage

```csharp
// Zero Allocation when parsing strings
public void ParseData(ReadOnlySpan<char> input)
{
    // String manipulation without Heap allocation
    var firstPart = input.Slice(0, 10);
    var secondPart = input.Slice(10);
}

// Array slicing
public void ProcessArray(int[] data)
{
    Span<int> span = data.AsSpan();
    Span<int> firstHalf = span[..^(span.Length / 2)];
    Span<int> secondHalf = span[(span.Length / 2)..];
}
```

### 3.2 String Processing Optimization

```csharp
// ❌ Bad example: Substring allocates new string
string part = text.Substring(0, 10);

// ✅ Good example: AsSpan has no allocation
ReadOnlySpan<char> part = text.AsSpan(0, 10);
```

### 3.3 Using with stackalloc

```csharp
public void ProcessSmallBuffer()
{
    // Allocate small buffer on Stack (no Heap allocation)
    Span<byte> buffer = stackalloc byte[256];
    FillBuffer(buffer);
}
```

---

## 4. ArrayPool<T>

Reduces GC pressure by reusing large arrays.

### 4.1 Basic Usage

```csharp
namespace MyApp.Services;

public sealed class DataProcessor
{
    public void ProcessLargeData(int size)
    {
        // Rent array (minimize Heap allocation)
        var buffer = ArrayPool<byte>.Shared.Rent(size);

        try
        {
            // Use buffer (only use up to requested size)
            ProcessBuffer(buffer.AsSpan(0, size));
        }
        finally
        {
            // Must return
            ArrayPool<byte>.Shared.Return(buffer);
        }
    }
}
```

### 4.2 clearArray Option

```csharp
// Initialize before returning when handling sensitive data
ArrayPool<byte>.Shared.Return(buffer, clearArray: true);
```

---

## 5. ObjectPool<T>

Reuses expensive objects.

```csharp
namespace MyApp.Services;

using Microsoft.Extensions.ObjectPool;

public sealed class HeavyObjectProcessor
{
    private readonly ObjectPool<HeavyObject> _pool;

    public HeavyObjectProcessor()
    {
        var policy = new DefaultPooledObjectPolicy<HeavyObject>();
        _pool = new DefaultObjectPool<HeavyObject>(policy, maximumRetained: 100);
    }

    public void Process()
    {
        var obj = _pool.Get();

        try
        {
            obj.DoWork();
        }
        finally
        {
            _pool.Return(obj);
        }
    }
}
```

---

## 6. Memory<T>

Unlike Span<T>, can be stored in fields or used in async methods.

```csharp
public sealed class AsyncProcessor
{
    private Memory<byte> _buffer;

    public AsyncProcessor(int size)
    {
        _buffer = new byte[size];
    }

    // Memory<T> can be used in async methods
    public async Task ProcessAsync()
    {
        await FillBufferAsync(_buffer);
        ProcessData(_buffer.Span);
    }
}
```

---

## 7. Required NuGet Package

```xml
<ItemGroup>
  <PackageReference Include="Microsoft.Extensions.ObjectPool" Version="9.0.*" />
</ItemGroup>
```

---

## 8. Important Notes

### ⚠️ Span<T> Constraints

- `Span<T>`, `ReadOnlySpan<T>` **cannot be used with async-await**
- Cannot be boxed (ref struct)
- Cannot be stored as class field (use Memory<T>)
- Cannot be captured in lambdas/closures

### ⚠️ ArrayPool Return Required

- Arrays rented with `Rent()` must be returned with `Return()`
- Use try-finally pattern
- Memory leak occurs if not returned

### ⚠️ Rented Size vs Actual Size

```csharp
// Array larger than requested may be returned
var buffer = ArrayPool<byte>.Shared.Rent(100);
// buffer.Length >= 100 (not exactly 100)

// Use only requested size when actually using
ProcessBuffer(buffer.AsSpan(0, 100));
```

---

## 9. References

- [Span<T> - Microsoft Docs](https://learn.microsoft.com/en-us/dotnet/api/system.span-1)
- [ArrayPool<T> - Microsoft Docs](https://learn.microsoft.com/en-us/dotnet/api/system.buffers.arraypool-1)

Pliki w paczce (2)
  • QUICKREF.md 1 KB
  • SKILL.md 5 KB

Wersje

W bazie nie ma innych skilli o nazwie optimizing-memory-allocation.

Migawka bazy z 13.11.2026 · wersja paczki c9d8425d2460 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100dotnext-memory
    Dostarcza bezalokacyjne procedury pamięci z pakietów DotNext: SpanOwner, BufferWriterSlim, PoolingBufferWriter, SparseBufferWriter i MemoryAllocator nad ArrayPool, tablicami i pamięcią niezarządzaną, do zmniejszania alokacji w gorących ścieżkach.
  • 100memory
    Opisuje typy InlineArray i Span w Swift 6.2 do dostępu do pamięci bez narzutu, kolekcji o stałym rozmiarze i bezpiecznych alternatyw dla wskaźników, przy optymalizacji krytycznych ścieżek.
  • 90csharp-zero-gc
    Przygotowuje plany pracy bez alokacji w C#, z poziomami zobowiązań, kryteriami akceptacji i strażnikami przed regresją.
  • 100span-memory-refactor
    Przerabia gorący kod C# na Span i Memory, żeby ograniczyć alokacje przy parsowaniu, krojeniu tekstu i pracy z buforami.
  • 100csharp
    Pomaga programować w C# i .NET: LINQ, async/await, dopasowanie wzorców, rekordy, Entity Framework Core i usługi ASP.NET Core, w tym optymalizacja pamięci typami span i memory.
  • 84optimizing-io-operations
    Optymalizuje operacje wejścia-wyjścia i pliki w .NET do przetwarzania dużych danych i zadań konkursowych.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.