analyzing-dotnet-performance

Identify performance anti-patterns in C#/.NET code using grep and regex.

2|Updated Apr 6, 2026
One-click install
npx skills add https://github.com/bingeli1379/eli-marketplace --skill analyzing-dotnet-performance-bingeli1379
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: analyzing-dotnet-performance
Source: https://github.com/bingeli1379/eli-marketplace/tree/main/plugins/sdd-dotnet/skills/analyzing-dotnet-performance
Command: npx skills add https://github.com/bingeli1379/eli-marketplace --skill analyzing-dotnet-performance-bingeli1379

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill automates the review of C#/.NET code for performance bottlenecks, helping developers identify and resolve anti-patterns.

Core Features & Use Cases

  • Performance Analysis: Scan for over 50 anti-patterns across various areas of .NET code, including async, memory, strings, collections, LINQ, regex, serialization, and I/O.
  • Hot Path Detection: Audit hot paths and allocation-heavy patterns in the codebase.
  • Codebase Analysis: Perform a systematic scan for known anti-patterns before releasing new versions.
  • Second Opinion: Use as a second-opinion tool after manual performance review.

Quick Start

Run the analyzing-dotnet-performance skill with the target C# code source and hot-path context, e.g., analyze-dotnet-performance --source code.cs --hot-path myhotpath.

Frequently Asked Questions about analyzing-dotnet-performance

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

FAQPage Schema
How do I scan C# code for performance anti-patterns?

To scan C# code for performance anti-patterns, you can automate the review process using scripts that apply grep and regex to identify over 50 known bottlenecks across areas like async, memory, strings, and LINQ. This provides a systematic audit of your codebase.

What are common .NET performance bottlenecks I should look for during code review?

Common .NET performance bottlenecks include allocation-heavy patterns in hot paths, inefficient async operations, improper string handling, suboptimal collection usage, and poorly optimized LINQ or regex operations. Identifying these anti-patterns helps resolve memory and I/O issues.

Can I automatically detect allocation-heavy patterns in my .NET hot paths?

Yes, you can automatically detect allocation-heavy patterns in .NET hot paths by running targeted analysis scripts against your source code. The automation audits specific hot-path contexts to pinpoint inefficient memory allocations and other anti-patterns.

Do I need deep C# knowledge to automate .NET performance analysis?

Yes, automating .NET performance analysis requires knowledge of C# code structure and performance bottlenecks to properly configure the source scanning, interpret the identified anti-patterns, and apply the resulting optimizations effectively.

What is the best way to audit a codebase for known anti-patterns before a release?

The best way to audit a codebase for known anti-patterns before a release is to perform a systematic automated scan using analysis scripts. This approach checks for over 50 performance issues across async, memory, collections, and I/O areas.