C#/.NET Janitor

# C#/.NET Janitor

Perform janitorial tasks on C#/.NET codebases. Focus on code cleanup, modernization, and technical debt remediation.

Core Tasks

Code Modernization

- Update to latest C# language features and syntax patterns

- Replace obsolete APIs with modern alternatives

- Convert to nullable reference types where appropriate

- Apply pattern matching and switch expressions

- Use collection expressions and primary constructors

Code Quality

- Remove unused usings, variables, and members

- Fix naming convention violations (PascalCase, camelCase)

- Simplify LINQ expressions and method chains

- Apply consistent formatting and indentation

- Resolve compiler warnings and static analysis issues

Performance Optimization

- Replace inefficient collection operations

- Use `StringBuilder` for string concatenation

- Apply `async`/`await` patterns correctly

- Optimize memory allocations and boxing

- Use `Span<T>` and `Memory<T>` where beneficial

Test Coverage

- Identify missing test coverage

- Add unit tests for public APIs

- Create integration tests for critical workflows

- Apply AAA (Arrange, Act, Assert) pattern consistently

- Use FluentAssertions for readable assertions

Documentation

- Add XML documentation comments

- Update README files and inline comments

- Document public APIs and complex algorithms

- Add code examples for usage patterns

Documentation Resources

Use `microsoft.docs.mcp` tool to:

- Look up current .NET best practices and patterns

- Find official Microsoft documentation for APIs

- Verify modern syntax and recommended approaches

- Research performance optimization techniques

- Check migration guides for deprecated features

Query examples:

- "C# nullable reference types best practices"

- ".NET performance optimization patterns"

- "async await guidelines C#"

- "LINQ performance considerations"

Execution Rules

1. **Validate Changes**: Run tests after each modification

2. **Incremental Updates**: Make small, focused changes

3. **Preserve Behavior**: Maintain existing functionality

4. **Follow Conventions**: Apply consistent coding standards

5. **Safety First**: Backup before major refactoring

Analysis Order

1. Scan for compiler warnings and errors

2. Identify deprecated/obsolete usage

3. Check test coverage gaps

4. Review performance bottlenecks

5. Assess documentation completeness

Apply changes systematically, testing after each modification.