dotnet-solid-principles

name	dotnet-solid-principles
description	Applies SOLID and DRY principles. C# anti-patterns, fixes, SRP compliance checks.
license	MIT
targets	["*"]
category	fundamentals
subcategory	design-principles
tags	["dotnet","skill","solid","dry","design-principles"]
version	1.0.0
author	dotnet-agent-harness
invocable	true
related_skills	["dotnet-csharp-coding-standards","dotnet-csharp-api-design","dotnet-csharp-code-smells"]
claudecode	{"allowed-tools":["Read","Grep","Glob","Bash","Write","Edit"]}
codexcli	{"short-description":".NET skill guidance for design principles"}
opencode	{"allowed-tools":["Read","Grep","Glob","Bash","Write","Edit"]}
copilot	{}
geminicli	{}
antigravity	{}

dotnet-solid-principles

Foundational design principles for .NET applications. Covers each SOLID principle with concrete C# anti-patterns and fixes, plus DRY guidance with nuance on when duplication is acceptable. These principles guide class design, interface contracts, and dependency management across all .NET project types.

Scope

• SOLID principles with C# anti-patterns and fixes
• DRY guidance and when duplication is acceptable
• SRP compliance tests and class design heuristics
• Interface segregation and dependency inversion patterns

Out of scope

• Architectural patterns (vertical slices, request pipelines, caching) -- see [skill:dotnet-architecture-patterns]
• DI container mechanics (registration, lifetimes, keyed services) -- see [skill:dotnet-csharp-dependency-injection]
• Code smells and anti-pattern detection -- see [skill:dotnet-csharp-code-smells]

Cross-references: [skill:dotnet-architecture-patterns] for clean architecture and vertical slices, [skill:dotnet-csharp-dependency-injection] for DI registration patterns and lifetime management, [skill:dotnet-csharp-code-smells] for anti-pattern detection, [skill:dotnet-csharp-coding-standards] for naming and style conventions.

---

Single Responsibility Principle (SRP)

A class should have only one reason to change. Apply the "describe in one sentence" test: if you cannot describe what a class does in one sentence without using "and" or "or", it likely violates SRP.

Anti-Pattern: God Class

// WRONG -- OrderService handles validation, persistence, email, and PDF generation
public class OrderService
{
    private readonly AppDbContext _db;
    private readonly SmtpClient _smtp;

    public OrderService(AppDbContext db, SmtpClient smtp)
    {
        _db = db;
        _smtp = smtp;
    }

    public async Task<Order> CreateOrderAsync(CreateOrderRequest request)
    {
        // Validation logic (reason to change #1)
        if (.IsNullOrEmpty(request.CustomerId))
              ArgumentException();

        
         order =  Order { CustomerId = request.CustomerId };
        _db.Orders.Add(order);
         _db.SaveChangesAsync();

        
         message =  MailMessage(, request.Email,
            , );
         _smtp.SendMailAsync(message);

        
        GenerateInvoicePdf(order);

         order;
    }

     {  }
}

```text



```csharp



{
    
    {
        validator.Validate(request);

         order =  repository.AddAsync(request, ct);

         notifier.OrderCreatedAsync(order, ct);

         order;
    }
}

    : 
{
    
    {
        ArgumentException.ThrowIfNullOrEmpty(request.CustomerId);
        
    }
}


{
    
    {
         order =  Order { CustomerId = request.CustomerId };
        db.Orders.Add(order);
         db.SaveChangesAsync(ct);
         order;
    }
}

```text



```csharp


app.MapPost(,  (
    CreateOrderRequest request,
    AppDbContext db,
    ILogger<Program> logger) =>
{
    
     (request.Lines.Count == )
         Results.BadRequest();

    
     total = request.Lines.Sum(l => l.Quantity * l.Price);
     (total > _000)
         Results.BadRequest();

    
     order =  Order
    {
        CustomerId = request.CustomerId,
        Total = total,
        Lines = request.Lines.Select(l =>  OrderLine
        {
            ProductId = l.ProductId,
            Quantity = l.Quantity,
            Price = l.Price
        }).ToList()
    };

    
    db.Orders.Add(order);
     db.SaveChangesAsync();

    logger.LogInformation(, order.Id);
     Results.Created(, order);
});

```text

Move business logic to a handler; keep the endpoint thin:

```csharp

app.MapPost(,  (
    CreateOrderRequest request,
    IOrderHandler handler,
    CancellationToken ct) =>
{
     result =  handler.CreateAsync(request, ct);
     result 
    {
        { IsSuccess:  } => Results.Created(
            , result.Value),
        _ => Results.ValidationProblem(result.Errors)
    };
});

```text

---



Classes should be open  extension but closed  modification. Add  behavior  implementing  types,   editing existing / chains.



```csharp



{
     (order.DiscountType)
    {
         :
             order.Total * order.DiscountValue / ;
         :
             order.DiscountValue;
         :
             order.Lines
                .Where(l => l.Quantity >= )
                .Sum(l => l.Price);
        :
             ;
    }
}

```text



```csharp

  
{
    ;
}


{
     =>
        order.Total * percentage / ;
}


{
     =>
        Math.Min(amount, order.Total);
}


    : 
{
     =>
        order.Lines
            .Where(l => l.Quantity >= )
            .Sum(l => l.Price);
}



{
     =>
        strategies.Max(s => s.Calculate(order));
}

```text



When strategies share significant behavior, use an   :

```

   
{
    
    {
        
        ArgumentNullException.ThrowIfNull(notification);
         SendCoreAsync(notification, ct);
    }

    ;
}


{
    
    {
         client.SendEmailAsync(
            notification.Recipient, notification.Subject,
            notification.Body, ct);
    }
}

```text

---



Subtypes must be substitutable  their  types without altering program correctness. A subclass must honor the behavioral contract of its parent -- preconditions cannot be strengthened, postconditions cannot be weakened.



```csharp

   : 
{
     =>
        File.OpenRead(path);
}



   : 
{
    
    {
         (!File.Exists(path))
              InvalidOperationException(
                );
         .OpenRead(path);
    }

    
}

```text



```csharp


IList<Animal> animals =  List<Dog>(); 


Animal[] animals =  Dog[];
animals[] =  Cat(); 

```csharp



```csharp


IEnumerable<Animal> animals =  List<Dog>(); 
IReadOnlyList<Animal> readOnlyAnimals =  List<Dog>(); 


List<Dog> dogs = [ Dog(),  Dog()];
ProcessAnimals(dogs); 


{
     ( animal  animals)
        animal.Speak();
}

```text



- Derived classes     exception types that the  does  declare
- 
{
    ;
    ;
    ;
    ;
    ;
    ;
}


   : 
{
     => ;
     =>   NotSupportedException(); 
     =>   NotSupportedException(); 
     => ;
     =>
          NotSupportedException(); 
     =>
          NotSupportedException(); 
}

```text



```csharp

  
{
    ;
}

  
{
    ;
    ;
}

  
{
    ;
}

  
{
    ;
}


    :
    , , , 
{
     => ;
     {  }
     {  }
     => ;
     {  }
}


    : , 
{
     => ;
     => ;
}

```text



The .NET BCL demonstrates ISP well:

| Wide Interface | Segregated Alternatives |
|---|---|
| `IList<T>` (read + write) | `IReadOnlyList<T>` (read only) |
| `ICollection<T>` | `IReadOnlyCollection<T>` |
| `IDictionary<K,V>` | `IReadOnlyDictionary<K,V>` |

Accept the narrowest     :

```


  (<> ) =>
    lines.Sum(l => l.Price * l.Quantity);


 =>
    lines.Sum(l => l.Price * l.Quantity);


 =>
    lines.Sum(l => l.Price * l.Quantity);

```text

---



High-level modules should  depend  low-level modules. Both should depend  abstractions. Abstractions should  depend  details.



```csharp


   
{
      SqlOrderRepository _repository = ();
      SmtpEmailSender _emailSender = ();

    
    {
         _repository.SaveAsync(order);      
         _emailSender.SendAsync(order.Email, 
            , );
    }
}

```text



```csharp

  
{
    ;
    Task<Order?> GetByIdAsync( id, CancellationToken ct = );
}

  
{
    ;
}



{
    
    {
         repository.SaveAsync(order, ct);
         notifier.NotifyAsync(order.Email,
            , , ct);
    }
}



{
     =>
        ;
      Task<Order?> GetByIdAsync( id, CancellationToken ct) =>
         db.Orders.FindAsync([id], ct);
}

```text



Register abstractions  Microsoft.Extensions.DependencyInjection. See [skill:dotnet-csharp-dependency-injection]  lifetime management, keyed services,  decoration patterns.

```csharp

builder.Services.AddScoped<IOrderRepository, SqlOrderRepository>();
builder.Services.AddScoped<INotificationService, SmtpNotificationService>();
builder.Services.AddScoped<OrderProcessor>();

```csharp



Apply DIP at module boundaries,  everywhere:

- **DO**  =  Dog[]` compiles but throws `ArrayTypeMismatchException` at runtime  adding non-Dog elements. Use `IReadOnlyList<T>`  `IEnumerable<T>`  covariant read-only access.
 **Accept the narrowest     .**  `<>`  , `<>`    ,  `<>`     .        .

---

##  

             :

- **  ()  ** --     .    ,     ,          . : :
- ** ' -  ** --           (     )       (     ). :      ; apply the patterns  built- mechanisms  possible. Source: https:

> **Note:** This skill applies publicly documented guidance. It does  represent  speak  the named sources.



- [SOLID Principles  C
- [Dependency Injection  .NET](https:
- [Covariance  Contravariance  Generics](https:
- [