dotnet-performance

.NET Performance

Performance optimization and measurement for .NET applications. This meta-skill provides navigation to ~10 performance-focused skills covering zero-allocation coding, benchmarking, profiling, Native AOT, and optimization patterns.

When to Use This Skill

Load this skill when:

• Optimizing application performance and allocations
• Measuring performance with BenchmarkDotNet
• Profiling memory or CPU usage
• Building Native AOT applications
• Tuning garbage collection
• Reducing memory allocations

Quick Navigation

Optimization Patterns

Memory Management

Measurement

AOT & Compilation

Platform-Specific

Performance Decision Trees

Which Optimization Technique?

Reduce allocations → Span<T>, ArrayPool<T> (dotnet-performance-patterns)
        ↓
Improve throughput → Struct optimization (dotnet-csharp-type-design-performance)
        ↓
Reduce startup time → Native AOT (dotnet-native-aot)
        ↓
Optimize queries → LINQ optimization (dotnet-linq-optimization)

Which Measurement Tool?

When to Use Native AOT?

Complete Skill List

Optimization Patterns (3 skills)

• dotnet-performance-patterns - Span, ArrayPool, ref struct
• dotnet-csharp-type-design-performance - Struct vs class design
• dotnet-linq-optimization - IQueryable vs IEnumerable

Memory & GC (2 skills)

• dotnet-gc-memory - GC tuning, LOH/POH
• dotnet-performance-patterns - Memory patterns

Benchmarking & Profiling (3 skills)

• dotnet-benchmarkdotnet - BenchmarkDotNet
• dotnet-profiling - dotnet-counters, trace, dump
• dotnet-ci-benchmarking - CI performance gating

AOT & Compilation (5 skills)

• dotnet-native-aot - PublishAot, descriptors
• dotnet-aot-architecture - AOT-first design
• dotnet-aot-wasm - Blazor/Uno WASM
• dotnet-trimming - Trimming annotations
• dotnet-multi-targeting - Polyfills, multi-TFM

Platform-Specific (1 skill)

• dotnet-maui-aot - MAUI iOS/Catalyst optimization

Build Optimization (2 skills)

• dotnet-build-optimization - Slow build diagnosis
• dotnet-artifacts-output - UseArtifactsOutput

Performance Patterns

Zero-Allocation Patterns

// Use Span<T> instead of arrays
public void Process(Span<byte> data) { }

// Use ArrayPool<T> for temporary buffers
var buffer = ArrayPool<byte>.Shared.Rent(1024);
try { /* use buffer */ }
finally { ArrayPool<byte>.Shared.Return(buffer); }

// Use stackalloc for small fixed buffers
Span<int> stack = stackalloc int[100];

Struct Design

// Mark readonly for immutability
public readonly struct Point(double x, double y);

// Use ref readonly for large structs
public ref readonly Point GetOrigin();

// Seal classes for devirtualization
public sealed class Calculator { }

GC Optimization

• Use GC.TryStartNoGCRegion for critical sections
• Pool objects to reduce Gen 0 collections
• Avoid LOH fragmentation with ArrayPool
• Consider GC configs for server apps

Cross-References

• Fundamentals → dotnet-fundamentals
• Architecture → dotnet-architecture
• Security → dotnet-security
• Web → dotnet-web

Version Assumptions

• .NET 8.0+ for modern patterns
• Native AOT requires .NET 7.0+
• HybridCache requires .NET 8.0+
• BenchmarkDotNet works on all versions

Anti-Patterns to Avoid

1. Premature optimization - Measure first
2. Ignoring GC pressure - Monitor allocations
3. Using ValueTask incorrectly - Don't await twice
4. Async void methods - Always use Task
5. Ignoring async state machine overhead - Consider sync for hot paths

See Also

• INDEX.md - Complete skill index
• TAXONOMY.md - Taxonomy schema