coding-style

Role Definition:

• C# Language Expert
• Software Architect
• Code Quality Specialist

General: Description: > C# code should be written to maximize readability, maintainability, and correctness while minimizing complexity and coupling. Prefer functional patterns and immutable data where appropriate, and keep abstractions simple and focused. Requirements: - Write clear, self-documenting code - Keep abstractions simple and focused - Minimize dependencies and coupling - Use modern C# features appropriately

Type Definitions:

• Prefer records for data types:

  // Good: Immutable data type with value semantics
  public sealed record CustomerDto(string Name, Email Email);
  
  // Avoid: Class with mutable properties
  public class Customer
  {
      public string Name { get; set; }
      public string Email { get; set; }
  }
  

• Make classes sealed by default:

  // Good: Sealed by default
  public sealed class OrderProcessor
  {
      // Implementation
  }
  
  // Only unsealed when inheritance is specifically designed for
  public abstract class Repository<T>
  {
      // Base implementation
  }
  

• Use value objects to avoid primitive obsession:

  // Good: Strong typing with value objects
  public sealed record OrderId(Guid Value)
  {
      public static OrderId New() => new(Guid.NewGuid());
      public static OrderId From(string value) => new(Guid.Parse(value));
  }
  
  // Avoid: Primitive types for identifiers
  public class Order
  {
      public Guid Id { get; set; }  // Primitive obsession
  }
  

Functional Patterns:

• Use pattern matching effectively:

  // Good: Clear pattern matching
  public decimal CalculateDiscount(Customer customer) =>
      customer switch
      {
          { Tier: CustomerTier.Premium } => 0.2m,
          { OrderCount: > 10 } => 0.1m,
          _ => 0m
      };
  
  // Avoid: Nested if statements
  public decimal CalculateDiscount(Customer customer)
  {
      if (customer.Tier == CustomerTier.Premium)
          return 0.2m;
      if (customer.OrderCount > 10)
          return 0.1m;
      return 0m;
  }
  

• Prefer pure methods:

  // Good: Pure function
  public static decimal CalculateTotalPrice(
      IEnumerable<OrderLine> lines,
      decimal taxRate) =>
      lines.Sum(line => line.Price * line.Quantity) * (1 + taxRate);
  
  // Avoid: Method with side effects
  public void CalculateAndUpdateTotalPrice()
  {
      this.Total = this.Lines.Sum(l => l.Price * l.Quantity);
      this.UpdateDatabase();
  }
  

Code Organization:

• Separate state from behavior:

  // Good: Behavior separate from state
  public sealed record Order(OrderId Id, List<OrderLine> Lines);
  
  public static class OrderOperations
  {
      public static decimal CalculateTotal(Order order) =>
          order.Lines.Sum(line => line.Price * line.Quantity);
  }
  

• Use extension methods appropriately:

  // Good: Extension method for domain-specific operations
  public static class OrderExtensions
  {
      public static bool CanBeFulfilled(this Order order, Inventory inventory) =>
          order.Lines.All(line => inventory.HasStock(line.ProductId, line.Quantity));
  }
  

Dependency Management:

• Minimize constructor injection:

  // Good: Minimal dependencies
  public sealed class OrderProcessor
  {
      private readonly IOrderRepository _repository;
      
      public OrderProcessor(IOrderRepository repository)
      {
          _repository = repository;
      }
  }
  
  // Avoid: Too many dependencies
  public class OrderProcessor
  {
      public OrderProcessor(
          IOrderRepository repository,
          ILogger logger,
          IEmailService emailService,
          IMetrics metrics,
          IValidator validator)
      {
          // Too many dependencies indicates possible design issues
      }
  }
  

• Prefer composition with interfaces:

  // Good: Composition with interfaces
  public sealed class EnhancedLogger : ILogger
  {
      private readonly ILogger _baseLogger;
      private readonly IMetrics _metrics;
      
      public EnhancedLogger(ILogger baseLogger, IMetrics metrics)
      {
          _baseLogger = baseLogger;
          _metrics = metrics;
      }
  }