Agent Skills: Reviewing .NET Code

Reviewing .NET Code

Apply Microsoft's .NET coding conventions and modern C# patterns when reviewing or generating code.

Quick Reference

Naming Conventions

| Element | Style | Example | |---------|-------|---------| | Classes, Records | PascalCase | CustomerService, OrderRecord | | Interfaces | IPascalCase | IRepository, IDisposable | | Methods | PascalCase | GetCustomer(), ValidateOrder() | | Properties | PascalCase | FirstName, IsActive | | Public Fields | PascalCase | MaxRetryCount | | Parameters | camelCase | customerId, orderDate | | Local Variables | camelCase | itemCount, isValid | | Private Fields | _camelCase | _connectionString, _logger | | Constants | PascalCase | DefaultTimeout, MaxItems | | Enums | PascalCase (singular) | Color.Red, Status.Active | | Async Methods | PascalCaseAsync | GetCustomerAsync() |

Type Keywords

Always use language keywords over framework types:

// Correct
string name;
int count;
bool isActive;

// Avoid
String name;
Int32 count;
Boolean isActive;

Modern C# Patterns (C# 10+)

// File-scoped namespaces
namespace MyApp.Services;

// Target-typed new
List<Customer> customers = new();

// Collection expressions
string[] items = ["one", "two", "three"];

// Primary constructors
public class Service(ILogger logger, IRepository repo);

// Records for immutable data
public record CustomerDto(string Name, string Email);

// Raw string literals
var json = """
    { "name": "test" }
    """;

Review Workflow

Step 1: Check Naming

Scan for naming violations:

• Classes/methods not in PascalCase
• Private fields without underscore prefix
• Parameters/locals not in camelCase
• Async methods missing Async suffix

Step 2: Check Patterns

Look for outdated patterns:

• String instead of string
• new List<T>() instead of new() or []
• Block-scoped namespaces
• Manual null checks instead of ?. or ??

Step 3: Check Async/Await

Flag async anti-patterns:

• async void (except event handlers)
• .Result or .Wait() blocking calls
• Missing ConfigureAwait(false) in libraries

Step 4: Check Exception Handling

Verify exception patterns:

• Catching Exception instead of specific types
• Empty catch blocks
• Not using using for disposables

Step 5: Check LINQ Usage

Identify LINQ opportunities:

• Manual loops that could be Select/Where/Any
• Multiple enumerations (should .ToList())

When to Read Reference Files

Read REFERENCE.md when:

• User asks for detailed naming rules
• Reviewing complex class hierarchies
• Need specific async/await guidance
• Reviewing exception handling patterns

Read EXAMPLES.md when:

• Need before/after refactoring samples
• Showing concrete improvements
• User asks "how should this look?"

Anti-Patterns to Flag

Critical (Always Flag)

// async void (except event handlers)
public async void ProcessData() { }

// Blocking on async
var result = GetDataAsync().Result;
task.Wait();

// Empty catch
try { } catch { }

// Catching base Exception
catch (Exception ex) { }

Important (Flag in Reviews)

// Hungarian notation
int iCount;      // use: count
string strName;  // use: name

// Screaming caps
const int MAX_SIZE = 100;  // use: MaxSize

// System types
String name;  // use: string

Code Generation Templates

Service Class

namespace MyApp.Services;

public class CustomerService(
    ILogger<CustomerService> logger,
    ICustomerRepository repository)
{
    public async Task<Customer?> GetByIdAsync(
        int id,
        CancellationToken cancellationToken = default)
    {
        logger.LogDebug("Getting customer {Id}", id);
        return await repository.FindByIdAsync(id, cancellationToken);
    }
}

Record DTO

namespace MyApp.Models;

public record CustomerDto(
    int Id,
    string Name,
    string Email,
    DateOnly CreatedDate);

Interface

namespace MyApp.Abstractions;

public interface ICustomerRepository
{
    Task<Customer?> FindByIdAsync(int id, CancellationToken ct = default);
    Task<IReadOnlyList<Customer>> GetAllAsync(CancellationToken ct = default);
    Task AddAsync(Customer customer, CancellationToken ct = default);
}

EditorConfig Integration

If project has .editorconfig, defer to those rules for style preferences. Check before suggesting style changes.

Review Checklist

• [ ] Naming follows conventions
• [ ] Using language keywords (string, int, bool)
• [ ] Async methods have Async suffix
• [ ] No async void (except event handlers)
• [ ] No blocking calls (.Result, .Wait())
• [ ] Using statements for disposables
• [ ] Specific exception types caught
• [ ] LINQ used where appropriate
• [ ] Modern C# features applied