C# Code Validation and Best Practices Skill

Overview

This skill provides comprehensive C# code validation, static analysis, and best practices verification for .NET applications based on senior developer standards.

Tools and Validation Methods

1. Roslyn Analyzers - Primary Validation Tool

Installation: ```bash

Install via NuGet

dotnet add package Microsoft.CodeAnalysis.NetAnalyzers dotnet add package StyleCop.Analyzers dotnet add package SonarAnalyzer.CSharp dotnet add package Roslynator.Analyzers ```

2. .editorconfig Configuration

Create an `.editorconfig` file at project root with naming conventions, code style rules, and formatting standards.

3. Code Analysis Configuration

Enable all analyzers in `Directory.Build.props`:

```xml <PropertyGroup> <AnalysisMode>All</AnalysisMode> <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild> <Nullable>enable</Nullable> <TreatWarningsAsErrors Condition="'$(Configuration)' == 'Release'">true</TreatWarningsAsErrors> </PropertyGroup> ```

Senior Developer Standards

1. SOLID Principles

Single Responsibility Principle

✅ Good: ```csharp public class UserService { private readonly IUserRepository _repository; private readonly IUserValidator _validator; private readonly INotificationService _notificationService;

public async Task<Result<User>> CreateUserAsync(User user, CancellationToken cancellationToken = default)
{
    var validationResult = await _validator.ValidateAsync(user, cancellationToken);
    if (!validationResult.IsValid)
        return Result<User>.Failure(validationResult.Errors);

    var createdUser = await _repository.AddAsync(user, cancellationToken);
    await _notificationService.SendWelcomeEmailAsync(createdUser.Email, cancellationToken);
    
    return Result<User>.Success(createdUser);
}

} ```

2. Nullable Reference Types

Always enable and properly use nullable reference types:

```csharp public class UserService { private readonly ILogger<UserService> _logger; // Non-nullable private string? _cachedUserName; // Nullable

public async Task<User?> GetUserAsync(int? userId)
{
    if (userId is null)
        return null;
    return await _repository.GetByIdAsync(userId.Value);
}

} ```

3. Async/Await Best Practices

• Always use Async suffix for async methods
• Always pass CancellationToken
• Avoid async void except for event handlers
• Use ConfigureAwait(false) in library code

4. Entity Framework Core

• Use AsNoTracking for read-only queries
• Avoid N+1 query problems with Include
• Use projections to limit data

Validation Process

When validating C# code:

1. Check for analyzer packages in the project
2. Run dotnet build with TreatWarningsAsErrors
3. Review for SOLID violations especially SRP and DIP
4. Verify nullable reference types are enabled and used correctly
5. Check async/await patterns including CancellationToken usage
6. Look for security issues like SQL injection, missing validation
7. Verify exception handling is appropriate
8. Check for performance issues like N+1 queries
9. Ensure proper DI usage and avoid service locator pattern
10. Validate test coverage and quality

Manual Review Checklist

1. Architecture & Design

   • SOLID principles followed
   • Proper separation of concerns
   • Dependency injection used correctly

2. Code Quality

   • Meaningful variable and method names
   • Methods under 50 lines
   • No code duplication (DRY)

3. Async/Await

   • All async methods have Async suffix
   • CancellationToken passed through
   • No async void (except event handlers)
   • No blocking calls (.Result, .Wait())

4. Null Safety

   • Nullable reference types enabled
   • Proper null checking
   • ArgumentNullException for public APIs

5. Security

   • Input validation on all public methods
   • Parameterized queries only
   • Sensitive data protected

6. Testing

   • Unit tests for business logic (80%+ coverage)
   • Tests follow AAA pattern
   • Edge cases covered