optimizing-memory-allocation
/optimizing-memory-allocation
Stosuje wzorce zero-allocation w .NET z Span, ArrayPool i ObjectPool, by zmniejszyć presję na GC.
- Autor
- christian289 ↗
- Repozytorium
- dotnet-with-claudecode ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 21.07.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 2
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 2
Brak sygnałów. Repozytorium zmienione 21.07.2026, bez odwołań do wycofanych modeli i API.
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. Core Concepts
- 2. Key APIs
- 3. Span<T>, ReadOnlySpan<T>
- 4. ArrayPool<T>
- 5. ObjectPool<T>
- 6. Memory<T>
- 7. Required NuGet Package
- 8. Important Notes
- 9. References
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.