
## Introduction

Code smells are warning signs, not bugs by themselves. They indicate design debt that will slow future changes.

This post covers high-impact smells and corresponding refactors.

## 1) Long method -> Extract method

If a method exceeds one concern or one abstraction level, split it.

```csharp
public async Task PlaceOrderAsync(OrderRequest request, CancellationToken ct)
{
    ValidateRequest(request);
    var total = CalculateTotal(request.Items);
    var order = await PersistOrderAsync(request.CustomerId, total, ct);
    await SendConfirmationAsync(order, ct);
}
```

## 2) Data clumps -> Parameter object

Repeated parameter groups should become a type.

```csharp
public record Address(string Line1, string City, string ZipCode);
public record CreateUserRequest(string FirstName, string LastName, string Email, Address Address);
```

This improves consistency and reduces call-site errors.

## 3) Primitive obsession -> Value objects

Domain concepts should not always be `string`/`int`.

```csharp
public readonly record struct OrderId(int Value);
public readonly record struct CustomerId(int Value);
```

Compiler-checked types prevent ID mix-ups.

## 4) Magic numbers -> Named constants

```csharp
private const decimal BulkOrderThreshold = 500m;
private const decimal BulkDiscountRate = 0.10m;

if (order.Total > BulkOrderThreshold)
{
    order.Discount = order.Total * BulkDiscountRate;
}
```

Named constants explain intent and centralize change.

## 5) Duplicate code -> Extract shared function

```csharp
public static string FormatFullName(string? firstName, string? lastName)
    => string.IsNullOrWhiteSpace(firstName) && string.IsNullOrWhiteSpace(lastName)
        ? "Unknown"
        : $"{firstName} {lastName}".Trim();
```

Removing duplication lowers bug probability and maintenance cost.

## 6) Nested conditionals -> Guard clauses

```csharp
public decimal GetDiscount(Customer customer)
{
    if (customer is null) return 0m;
    if (!customer.IsActive) return 0m;

    return customer.OrderCount > 10 ? 0.15m : 0.05m;
}
```

Flat logic is easier to reason about and test.

## 7) Repeated type switch -> Polymorphism

If you repeatedly switch on type/enum to choose behavior, move behavior into subtype implementations.

```csharp
public abstract class PriceRule
{
    public abstract decimal Apply(decimal total);
}

public class StandardPriceRule : PriceRule
{
    public override decimal Apply(decimal total) => total;
}

public class PremiumPriceRule : PriceRule
{
    public override decimal Apply(decimal total) => total * 0.9m;
}
```

## Refactor safely checklist

- Add or update tests first
- Refactor in small commits
- Keep behavior unchanged
- Rename with intention
- Remove dead code after migration

## Summary

Refactoring is continuous, not a one-time event. Focus on smells that block change speed: long methods, duplication, primitive obsession, and nested conditionals.


Identify common C# code smells and apply practical refactoring patterns to improve readability, safety, and maintainability.

C# Clean Code


## Introduction

Most readability issues in C# code come from two places:

1. weak naming
2. methods doing too many things

If you improve only these two areas, your code quality rises quickly.

## 1) Naming conventions that scale

### Use `intention-revealing` names

A good name explains purpose without comments.

```csharp
// BAD
int d; // elapsed days

// GOOD
int elapsedTimeInDays;
```

### Follow C# casing conventions

- `PascalCase`: classes, methods, properties, constants
- `camelCase`: local variables, method parameters
- `_camelCase`: private fields

```csharp
public class OrderService
{
    private readonly IOrderRepository _orderRepository;

    public async Task<Order?> GetOrderByIdAsync(int orderId, CancellationToken ct)
    {
        var order = await _orderRepository.GetByIdAsync(orderId, ct);
        return order;
    }
}
```

### Prefer domain words over abbreviations

```csharp
// BAD
var custMgr = new CM();

// GOOD
var customerManager = new CustomerManager();
```

### Boolean names should read like questions

Good booleans: `isActive`, `hasPermission`, `canExecute`.

## 2) Method design principles

### Keep methods small and single-purpose

If a method validates input, calculates data, writes to database, and sends email, it has multiple responsibilities.

```csharp
public async Task ProcessOrderAsync(OrderRequest request, CancellationToken ct)
{
    Validate(request);
    decimal total = CalculateTotal(request.Items);
    var order = await SaveOrderAsync(request.CustomerId, total, ct);
    await NotifyCustomerAsync(order, ct);
}
```

### Keep parameter count low

When a method needs many primitives, introduce a request object.

```csharp
public record CreateUserRequest(
    string FirstName,
    string LastName,
    string Email,
    string Phone,
    Address Address);

public Task CreateUserAsync(CreateUserRequest request, CancellationToken ct);
```

### Avoid boolean flag arguments

```csharp
// BAD
RenderPage(page, true);

// GOOD
RenderPageForPrinting(page);
RenderPageForScreen(page);
```

### Use guard clauses to reduce nesting

```csharp
// BAD
public decimal GetDiscount(Customer customer)
{
    decimal discount = 0m;

    if (customer != null)
    {
        if (customer.IsActive)
        {
            if (customer.OrderCount > 10)
            {
                discount = 0.15m;
            }
            else
            {
                discount = 0.05m;
            }
        }
    }

    return discount;
}

// GOOD
public decimal GetDiscount(Customer customer)
{
    if (customer is null) return 0m;
    if (!customer.IsActive) return 0m;

    return customer.OrderCount > 10 ? 0.15m : 0.05m;
}
```

### Avoid hidden side effects

Method names must match behavior.

```csharp
// BAD
public bool CheckPassword(string password)
{
    if (Encrypt(password) == _storedHash)
    {
        Session.Initialize(); // hidden side effect
        return true;
    }
    return false;
}

// BETTER
public bool IsPasswordValid(string password) => Encrypt(password) == _storedHash;
public void InitializeSession() => Session.Initialize();
```

## Common review questions

Before merging, ask:

- Can a new developer understand each name in 5 seconds?
- Does each method do one thing at one abstraction level?
- Are there flag arguments or too many parameters?
- Are there side effects not reflected by method names?

## Summary

Clear naming and focused methods are the highest-ROI clean-code improvements in C#. Start there, then move to class design and architecture.


Practical C# naming conventions and method design rules that improve readability and reduce bugs in production code.