analyzing-dotnet-performance

Scan C#/.NET code for performance anti-patterns and output prioritized fixes.

1|Updated May 21, 2026
One-click install
npx skills add https://github.com/1k-off/umbraco-observability-playground --skill analyzing-dotnet-performance-1k-off
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: analyzing-dotnet-performance
Source: https://github.com/1k-off/umbraco-observability-playground/tree/main/.agents/skills/analyzing-dotnet-performance
Command: npx skills add https://github.com/1k-off/umbraco-observability-playground --skill analyzing-dotnet-performance-1k-off

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps you quickly identify common .NET performance anti-patterns that cause excessive allocations, slower execution, and scalability issues, then translates them into prioritized, concrete code fixes.

Core Features & Use Cases

  • Performance anti-pattern scanning: Detects ~50 targeted issues across async patterns, memory/string handling, collections & LINQ, regex usage, serialization, and I/O.
  • Prioritized, severity-based reporting: Classifies findings as 🔴 Critical, 🟡 Moderate, or ℹ️ Info, with escalation rules for hot paths and high repetition.
  • Evidence-driven output: Produces exact hit counts and includes file+line locations plus one-line fixes and any caveats (e.g., version requirements).

Use case examples:

  • Auditing an allocation-heavy API endpoint before a release to reduce latency and GC pressure.
  • Reviewing hot-path code to eliminate culture-sensitive string operations, inefficient LINQ chains, and problematic regex usage.
  • Running a systematic pre-optimization pass to surface risky async/task patterns (e.g., deadlock-prone sync-over-async).

Quick Start

Use the analyzing-dotnet-performance skill to scan your C# repository for performance anti-patterns and return a prioritized list of findings with concrete fixes and exact counts.

Frequently Asked Questions about analyzing-dotnet-performance

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I find .NET performance anti-patterns in my C# codebase?

Scanning C# source code targets ~50 performance anti-patterns across async, memory, strings, LINQ, and regex, producing prioritized findings with exact hit counts, file/line evidence, and one-line fixes.

What causes high memory allocations in .NET hot paths and how are they flagged?

High memory allocations in .NET hot paths trigger severity escalation rules based on hot-path context and repetition counts, classifying findings as critical, moderate, or info with exact hit counts.

How do I audit async patterns for deadlock-prone sync-over-async issues before a release?

Auditing async patterns for deadlock-prone sync-over-async issues involves running a systematic pre-optimization scan of the codebase to surface risky task patterns and return prioritized fixes with file evidence.

Can I use this to detect inefficient LINQ chains and regex usage in C#?

Yes, code scanning detects inefficient LINQ chains and problematic regex usage by targeting known anti-patterns, returning evidence-backed findings with severity levels and one-line fix recommendations.

What is the best way to prioritize .NET code fixes for GC pressure and latency?

The best way to prioritize .NET code fixes for GC pressure is severity-based reporting that classifies anti-patterns as critical, moderate, or info, applying escalation rules for hot paths and high repetition.

Does the performance analysis require external profiling dependencies or tools?

No external profiling dependencies are required; the analysis operates directly by scanning C#/.NET source code recipes to count exact occurrences and apply severity escalation rules using hot-path context.