F# Discriminated Union ↔ C# Interoperability: Exhaustiveness Checking via Generated IsCaseName Properties

Direct Answer

No. The Is<CaseName> boolean properties generated by the F# compiler cannot give you compile-time exhaustiveness in a C# switch expression. They are ordinary runtime properties; the C# compiler treats each as an independent bool and cannot prove mutual exclusivity or that every union case is covered. A switch expression over these booleans will always require a default fallback or discard pattern, and the compiler will not emit CS8509 for missing cases.

Why the Generated Properties Fall Short

F# compiles a discriminated union (DU) to an abstract base class with a concrete subclass per case. For each case it emits a read-only Is<CaseName> property that returns true only for that subclass. From C# you can write:

if (du.IsCaseA) { ... }
else if (du.IsCaseB) { ... }
else { /* fallback required */ }

But a switch expression like:

var result = du switch {
    { IsCaseA: true } => HandleA(),
    { IsCaseB: true } => HandleB(),
    _ => Throw() // compiler forces this
};

does not let the compiler verify that IsCaseA and IsCaseB cover all possibilities. The properties are not a single discriminant, so exhaustiveness checking is impossible.

Exposing a Stable Discriminator for Exhaustiveness

The reliable way to get CS8509 when a case is missing is to expose an explicit enum discriminator from the F# type and switch on that in C#.

F# side (add a member)

type Shape =
    | Circle of radius: float
    | Rectangle of width: float * height: float
    member this.Tag =
        match this with
        | Circle _ -> ShapeTag.Circle
        | Rectangle _ -> ShapeTag.Rectangle

and ShapeTag =
    | Circle = 0
    | Rectangle = 1

C# side (switch expression)

var area = shape.Tag switch {
    ShapeTag.Circle => Math.PI * GetRadius(shape) * GetRadius(shape),
    ShapeTag.Rectangle => GetWidth(shape) * GetHeight(shape),
    // missing case -> CS8509
};

With every enum value handled and no _ or default, the C# compiler guarantees exhaustiveness.

Binary Compatibility Impact

• Adding a DU case is binary-compatible for existing C# callers that only use Is<CaseName> properties—the new property simply appears and old code continues to load.
• Adding a case breaks F# exhaustive pattern matches (source-breaking for F# consumers).
• Relying on the hidden integer Tag field is unsafe: it is an F# compiler implementation detail, may change between compiler versions, and is not guaranteed public or stable.
• Adding the explicit enum discriminator is a source change on the F# side but preserves binary compatibility for callers that already use Is<CaseName> properties. Serialization and reflection consumers must be reviewed because the new member appears in the public API.

Verification Steps

1. Compile the F# DU and inspect the assembly (ILSpy, dotnet-ildasm, or reflection) to confirm exact Is<CaseName> property names and whether a public Tag property exists.
2. Write a C# switch expression using only Is<CaseName> booleans; confirm the compiler requires a fallback.
3. Add the enum discriminator, switch on it in C#, omit a case, and verify CS8509 is emitted.
4. Build a C# client against v1 of the DU, add a new case in v2, and confirm the v1 client loads and calls existing Is<CaseName> properties without recompilation.

One Diagnostic Detail Needed

Which F# compiler version and --targetframework are you targeting? The visibility and naming of any generated Tag member can vary, so confirming the exact compiled output for your toolchain avoids relying on undocumented behavior.