C# generator exposes discriminator parameter on concrete model due to ApiCompatVersion

[ArcturusZhang]

Summary

When ApiCompatVersion is set, the C# generator appears to preserve a discriminator base model as concrete to match the previous contract, but it still includes the required discriminator property as a public constructor parameter.

This exposes a discriminator value in the public API even though the discriminator property itself is internal.

Repro context

Repository/package: Azure.ResourceManager.Monitor
Generator package: @azure-typespec/http-client-csharp-mgmt / Microsoft.TypeSpec.Generator 1.0.0-alpha.20260612.4

Relevant TypeSpec:

@discriminator("odata.type")
model MetricAlertCriteria {
  ...Record<unknown>;

  #suppress "@azure-tools/typespec-azure-core/casing-style" "FIXME: Update justification, follow aka.ms/tsp/conversion-fix for details"
  `odata.type`: Odatatype;
}

@discriminator("criterionType")
model MultiMetricCriteria {
  ...Record<unknown>;

  criterionType: CriterionType;
  name: string;
  metricName: string;
  metricNamespace?: string;
  timeAggregation: AggregationTypeEnum;
  @identifiers(#["name"])
  dimensions?: MetricDimension[];
  skipMetricValidation?: boolean;
}

Actual behavior with ApiCompatVersion set

The generated public API has concrete classes with public constructors that expose discriminator parameters:

public partial class MetricAlertCriteria
{
    public MetricAlertCriteria(Odatatype odataType) { ... }
    internal Odatatype OdataType { get; set; }
}

public partial class MultiMetricCriteria
{
    public MultiMetricCriteria(
        CriterionType criterionType,
        string name,
        string metricName,
        MetricCriteriaTimeAggregationType timeAggregation) { ... }

    internal CriterionType CriterionType { get; set; }
}

The discriminator property is correctly not public, but its value is still required as a public constructor parameter.

Expected behavior

Discriminator values should not appear in public model constructors. If the generator makes the discriminator base concrete for back-compat, it should still avoid exposing discriminator parameters in public constructors, likely by restoring/keeping the previous public constructor shape and handling discriminator defaults internally.

Evidence this is tied to ApiCompat/back-compat behavior

As an experiment, I temporarily removed ApiCompatVersion from sdk/monitor/Azure.ResourceManager.Monitor/src/Azure.ResourceManager.Monitor.csproj and regenerated.

Without ApiCompatVersion, both models became abstract and the discriminator constructors became private protected, which matches the normal discriminator-base pattern:

public abstract partial class MetricAlertCriteria
{
    private protected MetricAlertCriteria(Odatatype odataType) { ... }
    internal Odatatype OdataType { get; set; }
}

public abstract partial class MultiMetricCriteria
{
    private protected MultiMetricCriteria(
        CriterionType criterionType,
        string name,
        string metricName,
        MetricCriteriaTimeAggregationType timeAggregation) { ... }

    internal CriterionType CriterionType { get; set; }
}

This suggests the back-compat feature reads the previous contract, sees the model was non-abstract, preserves concreteness, and unintentionally exposes required discriminator parameters in the public constructor.

Related normal case

The existing generator test/project for a normal discriminator base (Plant) generates an abstract base model:

public abstract partial class Plant
{
    private protected Plant(string species, string id, int height) { ... }
    internal string Species { get; set; }
}

That does not expose the discriminator in public API because the base model remains abstract. The issue appears specific to concrete discriminator bases produced/preserved for back compatibility.

[github-actions]

🎯 Issue Triage

When ApiCompatVersion is set, the C# generator preserves discriminator base models as concrete classes for back-compat but incorrectly exposes the discriminator property as a public constructor parameter, even though the discriminator property itself is internal.

Category: Bug

Area: emitter:client:csharp

📋 Reproduction code

`@discriminator`("odata.type")
model MetricAlertCriteria {
  ...Record<unknown>;

  #suppress "`@azure-tools/typespec-azure-core`/casing-style" "FIXME"
  `odata.type`: Odatatype;
}

`@discriminator`("criterionType")
model MultiMetricCriteria {
  ...Record<unknown>;

  criterionType: CriterionType;
  name: string;
  metricName: string;
  metricNamespace?: string;
  timeAggregation: AggregationTypeEnum;
  `@identifiers`(#["name"])
  dimensions?: MetricDimension[];
  skipMetricValidation?: boolean;
}

Note: The bug manifests in C# code generation when ApiCompatVersion is set in the .csproj. A playground link is not applicable here since it requires the C# emitter with ApiCompatVersion configured.

🔍 Analysis

Root cause: When ApiCompatVersion is active, the generator reads the previous public API contract, sees the discriminator base model was non-abstract (concrete), and preserves that concreteness. However, the constructor generation logic doesn't account for this special case — it follows the same path as a regular (non-discriminator) concrete model and includes all required properties (including the discriminator) as public constructor parameters.

In the normal flow (no ApiCompatVersion), discriminator base models are abstract, so their constructors are private protected and the discriminator parameter is never exposed publicly.

Affected components:

• @typespec/http-client-csharp (specifically the back-compat/ApiCompatVersion code path for discriminator model constructor generation)
• Observed in: Azure.ResourceManager.Monitor, generator version 1.0.0-alpha.20260612.4

Fix direction: When generating a constructor for a concrete discriminator base (preserved via ApiCompatVersion), the generator should omit discriminator parameters from the public constructor signature and handle the discriminator value internally (e.g., hardcoding/defaulting it).

📝 Suggested next steps

• Identify the back-compat constructor generation code path for discriminator models in http-client-csharp
• Add a test case: a discriminator base model that was previously concrete (non-abstract) with ApiCompatVersion set
• Fix: skip discriminator properties when building the public constructor parameter list for back-compat concrete discriminator bases

Generated by Agentic Triage