Classes and interfaces

Properties, records, interfaces and polymorphism — the object model that domain types and services are built from.

A class

public class Account
{
    public string Owner { get; }                 // set in the constructor only
    public decimal Balance { get; private set; }

    public Account(string owner, decimal opening)
    {
        Owner = string.IsNullOrWhiteSpace(owner)
            ? throw new ArgumentException("owner is required", nameof(owner))
            : owner;
        Balance = opening;
    }

    public void Deposit(decimal amount)
    {
        if (amount <= 0) throw new ArgumentOutOfRangeException(nameof(amount));
        Balance += amount;
    }

    public override string ToString() => $"{Owner}: {Balance:C}";
}

// init-only and required make immutable construction ergonomic
public class User
{
    public required string Email { get; init; }
    public string DisplayName { get; init; } = "";
}

var u = new User { Email = "[email protected]", DisplayName = "Ada" };

// a record gives value equality and a readable ToString for free
public record Money(decimal Amount, string Currency)
{
    public Money Add(Money other)
    {
        if (Currency != other.Currency)
            throw new InvalidOperationException("currency mismatch");
        return this with { Amount = Amount + other.Amount };   // a copy, updated
    }
}

var total = new Money(10m, "GBP").Add(new Money(2.5m, "GBP"));   // 12.5 GBP

Interfaces and inheritance

A class extends exactly one base class but may implement any number of interfaces. Depend on the interface so the implementation can be replaced, including by a test double.

public interface IShape
{
    double Area();
    string Name => GetType().Name;          // default interface member
}

public sealed class Circle(double radius) : IShape
{
    public double Area() => Math.PI * radius * radius;
}

public sealed class Rectangle(double w, double h) : IShape
{
    public double Area() => w * h;
}

public static class ShapeReport
{
    public static string Describe(IEnumerable<IShape> shapes)
    {
        var total = shapes.Sum(s => s.Area());
        return $"{shapes.Count()} shapes totalling {total:F2}";
    }
}

// pattern matching against the runtime type
static string Kind(IShape s) => s switch
{
    Circle c when c.Area() > 100 => "large circle",
    Circle                       => "circle",
    _                            => "other"
};

• sealed prevents further inheritance and is a reasonable default for small concrete types.
• abstract members have no body and force every derived class to supply one.
• virtual members have a body and may be overridden; without it a derived method hides the base member instead of replacing it.
• Interface names conventionally begin with I, and good ones describe a role (IRepository<T>) rather than mirroring a class.

Constructing an object graph

public interface IPricingService { decimal PriceFor(string sku); }

public class Checkout(IPricingService pricing, ILogger<Checkout> log)
{
    public decimal Total(IEnumerable<string> skus)
    {
        var total = skus.Sum(pricing.PriceFor);
        log.LogInformation("Priced {Count} items for {Total}", skus.Count(), total);
        return total;
    }
}

// registration in a .NET host
builder.Services.AddSingleton<IPricingService, PricingService>();
builder.Services.AddScoped<Checkout>();

FAQ

Related

Syntax and types LINQ and async/await

Last refreshed 2026-09-18.