[.NET Generator] Auto-generate ClientSettings class and IConfiguration-enabled constructors

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel.StubLibrary/src/StubLibraryVisitor.cs

@@ -46,6 +46,7 @@ internal class StubLibraryVisitor : ScmLibraryVisitor
             if (!IsCallingBaseCtor(constructor) &&
                 !IsEffectivelyPublic(constructor.Signature.Modifiers) &&
                 !IsParameterlessInternalCtorOnMrwSerializationType(constructor) &&
+                !IsInternalClientConstructor(constructor) &&
                 (constructor.EnclosingType is not ModelProvider model || model.DerivedModels.Count == 0))
                 return null;
 
@@ -57,6 +58,14 @@ internal class StubLibraryVisitor : ScmLibraryVisitor
             return constructor;
         }
 
+        private static bool IsInternalClientConstructor(ConstructorProvider constructor)
+        {
+            if (!constructor.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Internal))
+                return false;
+
+            return constructor.EnclosingType is ClientProvider;
+        }
+
         private static bool IsParameterlessInternalCtorOnMrwSerializationType(ConstructorProvider constructor)
         {
             if (constructor.Signature.Parameters.Count != 0)
@@ -78,7 +87,13 @@ private static bool IsCallingBaseCtor(ConstructorProvider constructor)
         protected override FieldProvider? VisitField(FieldProvider field)
         {
             // For ClientOptions, keep the non-public field as this currently represents the latest service version for a client.
-            return (field.Modifiers.HasFlag(FieldModifiers.Public) || field.EnclosingType.BaseType?.Equals(typeof(ClientPipelineOptions)) == true)
+            // For ClientProvider, keep const and static fields as they are referenced by stub constructor initializers
+            // (e.g. AuthorizationHeader const used in this() API key ctor, _flows static used in this() OAuth2 ctor).
+            return (field.Modifiers.HasFlag(FieldModifiers.Public)
+                || field.EnclosingType.BaseType?.Equals(typeof(ClientPipelineOptions)) == true
+                || (field.EnclosingType is ClientProvider
+                    && (field.Modifiers.HasFlag(FieldModifiers.Const)
+                        || field.Modifiers.HasFlag(FieldModifiers.Static))))
                 ? field
                 : null;
         }

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Microsoft.TypeSpec.Generator.ClientModel.csproj

@@ -9,6 +9,7 @@
 
   <ItemGroup>
     <PackageReference Include="System.ClientModel" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" />
   </ItemGroup>
 
   <ItemGroup>

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/BinaryContentProvider.cs

@@ -3,10 +3,10 @@
 
 using System.ClientModel;
 using Microsoft.TypeSpec.Generator.ClientModel.Snippets;
-using static Microsoft.TypeSpec.Generator.Snippets.Snippet;
 using Microsoft.TypeSpec.Generator.Expressions;
-using Microsoft.TypeSpec.Generator.Statements;
 using Microsoft.TypeSpec.Generator.Primitives;
+using Microsoft.TypeSpec.Generator.Statements;
+using static Microsoft.TypeSpec.Generator.Snippets.Snippet;
 
 namespace Microsoft.TypeSpec.Generator.ClientModel.Providers
 {

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ClientOptionsProvider.cs

@@ -11,6 +11,7 @@
 using Microsoft.TypeSpec.Generator.Primitives;
 using Microsoft.TypeSpec.Generator.Providers;
 using Microsoft.TypeSpec.Generator.Shared;
+using Microsoft.TypeSpec.Generator.Snippets;
 using Microsoft.TypeSpec.Generator.Statements;
 using Microsoft.TypeSpec.Generator.Utilities;
 using static Microsoft.TypeSpec.Generator.Snippets.Snippet;
@@ -230,9 +231,15 @@ protected override TypeProvider[] BuildNestedTypes()
 
         protected override ConstructorProvider[] BuildConstructors()
         {
+            var configSectionCtor = BuildConfigurationSectionConstructor();
+
             if (LatestVersionsFields is null)
             {
-                return [];
+                var defaultCtor = new ConstructorProvider(
+                    new ConstructorSignature(Type, $"Initializes a new instance of {_clientProvider.Name}Options.", MethodSignatureModifiers.Public, []),
+                    MethodBodyStatement.Empty,
+                    this);
+                return [defaultCtor, configSectionCtor];
             }
 
             var constructorBody = new List<MethodBodyStatement>();
@@ -281,7 +288,85 @@ protected override ConstructorProvider[] BuildConstructors()
                 new ConstructorSignature(Type, $"Initializes a new instance of {_clientProvider.Name}Options.", MethodSignatureModifiers.Public, constructorParameters),
                 constructorBody,
                 this);
-            return [constructor];
+            return [constructor, configSectionCtor];
+        }
+
+        private ConstructorProvider BuildConfigurationSectionConstructor()
+        {
+            var sectionParam = new ParameterProvider(
+                "section",
+                $"The configuration section.",
+                ClientSettingsProvider.IConfigurationSectionType);
+
+            var experimentalAttr = new AttributeStatement(
+                typeof(System.Diagnostics.CodeAnalysis.ExperimentalAttribute),
+                [Literal(ClientSettingsProvider.ClientSettingsDiagnosticId)]);
+
+            // Set version to latest version before the guard so it is always initialized
+            var body = new List<MethodBodyStatement>();
+            if (LatestVersionsFields != null && VersionProperties != null)
+            {
+                foreach (var (_, serviceVersionEnum) in LatestVersionsFields.OrderBy(kvp => kvp.Key.Name))
+                {
+                    if (VersionProperties.TryGetValue(serviceVersionEnum, out var versionProperty))
+                    {
+                        var latestVersion = serviceVersionEnum.EnumValues[^1];
+                        body.Add(versionProperty.Assign(Literal(latestVersion.Value)).Terminate());
+                    }
+                }
+            }
+
+            // if (section is null || !section.Exists()) { return; }
+            var guardCondition = sectionParam.Is(Null).Or(Not(sectionParam.Invoke("Exists")));
+            var guardStatement = new IfStatement(guardCondition) { Return() };
+
+            body.Add(guardStatement);
+
+            // Bind version properties from configuration (after guard, default already set before guard)
+            if (LatestVersionsFields != null && VersionProperties != null)
+            {
+                foreach (var (_, serviceVersionEnum) in LatestVersionsFields.OrderBy(kvp => kvp.Key.Name))
+                {
+                    if (VersionProperties.TryGetValue(serviceVersionEnum, out var versionProperty))
+                    {
+                        // if (section["VersionPropertyName"] is string version) { Version = version; }
+                        var versionVarDecl = Declare(versionProperty.Name.ToVariableName(), new CSharpType(typeof(string)), out var versionVar);
+                        var ifVersionStatement = new IfStatement(new IndexerExpression(sectionParam, Literal(versionProperty.Name)).Is(versionVarDecl));
+                        ifVersionStatement.Add(This.Property(versionProperty.Name).Assign(versionVar).Terminate());
+                        body.Add(ifVersionStatement);
+                    }
+                }
+            }
+
+            // Build a set of version property names for O(1) lookup
+            var versionPropertyNames = VersionProperties?.Values.Select(vp => vp.Name).ToHashSet();
+
+            // Bind non-version properties from configuration using type-aware binding
+            foreach (var property in Properties)
+            {
+                if (versionPropertyNames?.Contains(property.Name) == true)
+                {
+                    continue;
+                }
+
+                ClientSettingsProvider.AppendBindingForProperty(
+                    body,
+                    sectionParam,
+                    property.Name,
+                    property.Name.ToVariableName(),
+                    property.Type);
+            }
+
+            return new ConstructorProvider(
+                new ConstructorSignature(
+                    Type,
+                    $"Initializes a new instance of {_clientProvider.Name}Options from configuration.",
+                    MethodSignatureModifiers.Internal,
+                    [sectionParam],
+                    attributes: [experimentalAttr],
+                    initializer: new ConstructorInitializer(true, [sectionParam])),
+                new MethodBodyStatements([.. body]),
+                this);
         }
 
         protected override PropertyProvider[] BuildProperties()