What does fail fast mean in .NET, and how do you apply it without making the system fragile?

1. Origin

Jim Shore's Fail Fast (IEEE Software, 2004) argued that code which fails immediately and visibly is more robust, not less, because defects are found and fixed instead of hiding. The same idea appears in Erlang's "let it crash" philosophy, paired with supervision: fail fast locally, recover at a higher level.

2. Why late failures are expensive

Controller (null customerId accepted)
  → Service (passes it along)
    → Repository (builds a query)
      → Mapper → NullReferenceException in an unrelated place, minutes or hours later

The stack trace points at the symptom, not the cause; logs lack the original context. A guard at the controller or service boundary would have produced ArgumentNullException: customerId immediately.

3. Throw helpers

They use [CallerArgumentExpression] to fill in the parameter name automatically and keep the throwing code out of the hot path (better inlining).

4. Options validation in depth

builder.Services.AddOptions<PaymentOptions>()
    .BindConfiguration("Payments")
    .ValidateDataAnnotations()
    .Validate(o => o.TimeoutSeconds < o.TotalBudgetSeconds, "Timeout must be below the total budget")
    .ValidateOnStart();

• ValidateOnStart runs validators during host startup (before requests).
• Custom IValidateOptions<T> handles cross-field rules.
• .NET 8 adds a source-generated options validator ([OptionsValidator]) that's trimming/AOT-friendly.

5. Value objects: fail fast at creation

public readonly record struct Email
{
    public string Value { get; }
    public Email(string value)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(value);
        if (!value.Contains('@')) throw new ArgumentException("Invalid email", nameof(value));
        Value = value.Trim();
    }
}

Once an Email exists it's valid everywhere, so downstream code needs no re-checks.

6. Don't swallow exceptions

try { ProcessPayment(); }
catch (Exception) { }          // the opposite of fail fast: bad state continues silently

Catch only exceptions you can handle meaningfully, add context, and let the rest reach the global handler (IExceptionHandler, BackgroundService exception behaviour).

7. Environment.FailFast

• Terminates the process immediately, logs the message to the event log/stderr and can produce a crash dump.
• Skips finally blocks, finalisers and graceful shutdown.
• Use when continuing could corrupt data (e.g. detected memory/state corruption in a critical component), never for ordinary errors.

8. Try it yourself

1. Run the code example without Payments:BaseUrl and observe the startup failure.
2. Register a service that depends on an unregistered type with ValidateOnBuild on, and see Build() fail.
3. Replace manual if (x == null) throw ... checks with ThrowIfNull and compare messages.
4. Introduce a value object for one primitive (email, ABN) and delete downstream re-validation.
5. Search for empty catch blocks and decide what each should really do.

using System.ComponentModel.DataAnnotations;
using Microsoft.Extensions.Options;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddOptions<PaymentOptions>()
    .BindConfiguration("Payments")
    .ValidateDataAnnotations()
    .ValidateOnStart(); // misconfiguration stops startup, not the first payment

builder.Host.UseDefaultServiceProvider(o =>
{
    o.ValidateScopes = true;
    o.ValidateOnBuild = true; // missing registrations fail at Build()
});

builder.Services.AddSingleton<RefundCalculator>();
var app = builder.Build();

app.MapGet("/refund/{amount:decimal}", (decimal amount, RefundCalculator calc, IOptions<PaymentOptions> opt) =>
    Results.Ok(new { refund = calc.Refund(amount, 0.1m), gateway = opt.Value.BaseUrl }));

app.Run();

public sealed class PaymentOptions
{
    [Required, Url] public string BaseUrl { get; set; } = "";
    [Range(1, 60)] public int TimeoutSeconds { get; set; } = 10;
}

public sealed class RefundCalculator
{
    public decimal Refund(decimal amount, decimal feeRate)
    {
        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(amount);
        ArgumentOutOfRangeException.ThrowIfNegative(feeRate);
        ArgumentOutOfRangeException.ThrowIfGreaterThan(feeRate, 1m);
        return Math.Round(amount * (1 - feeRate), 2);
    }
}

Run without a Payments:BaseUrl setting and the host throws OptionsValidationException at startup.