What is high cohesion, how do you recognise low cohesion in C# code, and how do you improve it?

1. Origin

Larry Constantine and Ed Yourdon introduced cohesion and coupling in Structured Design (1970s), including the cohesion scale above. The ideas carried over directly to object-oriented design: GRASP lists High Cohesion and Low Coupling as core patterns.

2. Measuring cohesion

Use metrics to find candidates; decide with judgement.

3. Field clusters, concretely

class CustomerManager
  fields: _db, _smtp, _templates, _pdf, _taxRates
  methods:
    GetCustomer()        uses _db
    UpdateCustomer()     uses _db
    SendWelcomeEmail()   uses _smtp, _templates
    SendStatement()      uses _smtp, _templates, _pdf
    CalculateTax()       uses _taxRates

Clusters → CustomerRepository(_db), CustomerEmails(_smtp,_templates,_pdf), TaxPolicy(_taxRates)

4. Feature envy → rich model

// Feature envy: the service reaches into the order's data
public decimal TotalWithDiscount(Order o) =>
    o.Lines.Sum(l => l.Price * l.Quantity) * (o.Customer.IsGold ? 0.9m : 1m);

// Cohesive: the order owns its total
public sealed class Order
{
    public decimal Total(DiscountPolicy policy) => policy.Apply(Lines.Sum(l => l.Subtotal), Customer);
}

5. Feature folders

A feature change then touches one folder.

6. Cohesion at architecture scale

• Modules/services should own a business capability and its data; a "shared" service everyone changes has low cohesion.
• Shared libraries should be small and focused; a Company.Common package is coincidental cohesion at package level and forces everyone to upgrade together.
• Cohesive modules reduce chatty cross-module calls, which matters for performance in distributed systems.

7. Try it yourself

1. Find the largest *Helper/*Utils class; group its methods by caller and concept.
2. Draw a field-usage matrix for a large service class; look for clusters.
3. Move one feature-envious method onto the entity it uses.
4. Reorganise one feature into a feature folder and compare the diff of a typical change.
5. Run an LCOM-style analysis (NDepend trial) and review the worst classes.

using System.Globalization;

// Low cohesion: unrelated concepts in one grab-bag that every project references.
public static class CommonHelpers
{
    public static string FormatAud(decimal amount) => amount.ToString("C", new CultureInfo("en-AU"));
    public static bool IsValidAbn(string abn) => abn.Length == 11 && abn.All(char.IsDigit);
    public static decimal AddGst(decimal amount) => amount * 1.10m;
    public static bool Overlaps(DateOnly s1, DateOnly e1, DateOnly s2, DateOnly e2) => s1 <= e2 && s2 <= e1;
}

// High cohesion: each type owns one concept, its data and its behaviour.
public readonly record struct Money(decimal Amount)
{
    private static readonly CultureInfo AuCulture = new("en-AU");
    public Money WithGst() => new(Amount * 1.10m);
    public override string ToString() => Amount.ToString("C", AuCulture);
}

public readonly record struct Abn
{
    public string Value { get; }
    private Abn(string value) => Value = value;

    public static bool TryCreate(string input, out Abn abn)
    {
        var digits = new string(input.Where(char.IsDigit).ToArray());
        abn = digits.Length == 11 ? new Abn(digits) : default;
        return digits.Length == 11; // format check only; the ABN checksum rule would live here too
    }
}

public readonly record struct DateRange(DateOnly Start, DateOnly End)
{
    public bool Overlaps(DateRange other) => Start <= other.End && other.Start <= End;
}

public static class Demo
{
    public static void Main()
    {
        Console.WriteLine(new Money(100m).WithGst());
        Console.WriteLine(Abn.TryCreate("51 824 753 556", out var abn) ? abn.Value : "invalid");
        var a = new DateRange(new(2026, 11, 1), new(2026, 11, 10));
        var b = new DateRange(new(2026, 11, 8), new(2026, 11, 20));
        Console.WriteLine(a.Overlaps(b));
    }
}