github-copilot-rules: Instructions file for GitHub Copilot

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

Code Organization:

• Use meaningful names:

  // Good: Clear intent
  public async Task<Result<Order>> ProcessOrderAsync(OrderRequest request, CancellationToken cancellationToken)
  
  // Avoid: Unclear abbreviations
  public async Task<Result<T>> ProcAsync<T>(ReqDto r, CancellationToken ct)
  

• 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);
  }
  

• 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();
  }
  

• 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));
  }
  

• Design for testability:

  // Good: Easy to test pure functions
  public static class PriceCalculator
  {
      public static decimal CalculateDiscount(
          decimal price,
          int quantity,
          CustomerTier tier) =>
          // Pure calculation
  }
  
  // Avoid: Hard to test due to hidden dependencies
  public decimal CalculateDiscount()
  {
      var user = _userService.GetCurrentUser();  // Hidden dependency
      var settings = _configService.GetSettings(); // Hidden dependency
      // Calculation
  }