Put all optional client parameters into client options

src/AutoRest.CSharp/Common/Generation/Writers/ClientOptionsWriter.cs

@@ -5,6 +5,7 @@
 using System.Linq;
 using AutoRest.CSharp.Common.Input;
 using AutoRest.CSharp.Output.Models.Types;
+using AutoRest.CSharp.Utilities;
 
 namespace AutoRest.CSharp.Generation.Writers
 {
@@ -50,6 +51,21 @@ public static void WriteClientOptions(CodeWriter writer, ClientOptionsTypeProvid
                             }
                         }
                     }
+
+                    if (clientOptions.AdditionalProperties != null && !Configuration.KeepOptionalClientParametersInConstructor)
+                    {
+                        if (clientOptions.ApiVersions is not null)
+                        {
+                            writer.Line();
+                        }
+
+                        foreach (var property in clientOptions.AdditionalProperties)
+                        {
+                            writer.WriteXmlDocumentationSummary(property.Description);
+                            writer.Line($"public {property.Type} {property.Name.FirstCharToUpperCase()} {{ get; set; }}");
+                            writer.Line();
+                        }
+                    }
                 }
             }
         }

src/AutoRest.CSharp/Common/Input/Configuration.cs

@@ -6,6 +6,7 @@
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Net.Http;
 using System.Text;
 using System.Text.Json;
 using AutoRest.CSharp.AutoRest.Communication;
@@ -42,6 +43,7 @@ public static class Options
             public const string UnreferencedTypesHandling = "unreferenced-types-handling";
             public const string UseOverloadsBetweenProtocolAndConvenience = "use-overloads-between-protocol-and-convenience";
             public const string KeepNonOverloadableProtocolSignature = "keep-non-overloadable-protocol-signature";
+            public const string KeepOptionalClientParametersInConstructor = "keep-optional-client-parameters-in-constructor";
             public const string ModelFactoryForHlc = "model-factory-for-hlc";
             public const string GenerateModelFactory = "generate-model-factory";
             public const string ModelsToTreatEmptyStringAsNull = "models-to-treat-empty-string-as-null";
@@ -86,6 +88,7 @@ public static void Initialize(
             UnreferencedTypesHandlingOption unreferencedTypesHandling,
             bool useOverloadsBetweenProtocolAndConvenience,
             bool keepNonOverloadableProtocolSignature,
+            bool keepOptionalClientParametersInConstructor,
             string? projectFolder,
             string? existingProjectFolder,
             IReadOnlyList<string> protocolMethodList,
@@ -117,6 +120,7 @@ public static void Initialize(
             UnreferencedTypesHandling = unreferencedTypesHandling;
             UseOverloadsBetweenProtocolAndConvenience = useOverloadsBetweenProtocolAndConvenience;
             KeepNonOverloadableProtocolSignature = keepNonOverloadableProtocolSignature;
+            KeepOptionalClientParametersInConstructor = keepOptionalClientParametersInConstructor;
             ShouldTreatBase64AsBinaryData = !azureArm && !generation1ConvenienceClient ? shouldTreatBase64AsBinaryData : false;
             UseCoreDataFactoryReplacements = useCoreDataFactoryReplacements;
             projectFolder ??= ProjectFolderDefault;
@@ -264,6 +268,7 @@ internal static (string AbsoluteProjectFolder, string RelativeProjectFolder) Par
         public static bool DeserializeNullCollectionAsNullValue { get; private set; }
         public static bool UseOverloadsBetweenProtocolAndConvenience { get; private set; }
         public static bool KeepNonOverloadableProtocolSignature { get; private set; }
+        public static bool KeepOptionalClientParametersInConstructor { get; private set; }
 
         private static IReadOnlyList<string>? _oldModelFactoryEntries;
         /// <summary>
@@ -318,6 +323,7 @@ public static void Initialize(IPluginCommunication autoRest, string defaultNames
                 unreferencedTypesHandling: GetOptionEnumValue<UnreferencedTypesHandlingOption>(autoRest, Options.UnreferencedTypesHandling),
                 useOverloadsBetweenProtocolAndConvenience: GetOptionBoolValue(autoRest, Options.UseOverloadsBetweenProtocolAndConvenience),
                 keepNonOverloadableProtocolSignature: GetOptionBoolValue(autoRest, Options.KeepNonOverloadableProtocolSignature),
+                keepOptionalClientParametersInConstructor: GetOptionBoolValue(autoRest, Options.KeepOptionalClientParametersInConstructor),
                 useCoreDataFactoryReplacements: GetOptionBoolValue(autoRest, Options.UseCoreDataFactoryReplacements),
                 projectFolder: GetProjectFolderOption(autoRest),
                 existingProjectFolder: autoRest.GetValue<string?>(Options.ExistingProjectfolder).GetAwaiter().GetResult(),
@@ -393,6 +399,8 @@ private static bool GetOptionBoolValue(IPluginCommunication autoRest, string opt
                     return true;
                 case Options.KeepNonOverloadableProtocolSignature:
                     return false;
+                case Options.KeepOptionalClientParametersInConstructor:
+                    return false;
                 case Options.ShouldTreatBase64AsBinaryData:
                     return true;
                 case Options.DeserializeNullCollectionAsNullValue:
@@ -478,6 +486,7 @@ internal static void LoadConfiguration(JsonElement root, string? projectPath, st
                 ReadEnumOption<UnreferencedTypesHandlingOption>(root, Options.UnreferencedTypesHandling),
                 ReadOption(root, Options.UseOverloadsBetweenProtocolAndConvenience),
                 ReadOption(root, Options.KeepNonOverloadableProtocolSignature),
+                ReadOption(root, Options.KeepOptionalClientParametersInConstructor),
                 projectPath ?? ReadStringOption(root, Options.ProjectFolder),
                 existingProjectFolder,
                 protocolMethods,

src/AutoRest.CSharp/Common/Output/Models/Shared/Parameter.cs

@@ -20,6 +20,7 @@ internal record Parameter(string Name, FormattableString? Description, CSharpTyp
     {
         public CSharpAttribute[] Attributes { get; init; } = Array.Empty<CSharpAttribute>();
         public bool IsOptionalInSignature => DefaultValue != null;
+        public bool IsEndpoint => Type.Equals(typeof(Uri)) && Name == KnownParameters.Endpoint.Name;
 
         public Parameter ToRequired()
         {
@@ -82,6 +83,7 @@ public static Parameter FromInputParameter(in InputParameter operationParameter,
 
         private static Constant? GetDefaultValue(InputParameter operationParameter, TypeFactory typeFactory) => operationParameter switch
         {
+            { Name: "$host", DefaultValue.Value: ""} => (Constant?)null, // In M4, when endpoint is not set, its default value is an empty string instead of null
             { NameInRequest: var nameInRequest } when RequestHeader.ClientRequestIdHeaders.Contains(nameInRequest) => Constant.FromExpression($"message.{Configuration.ApiTypes.HttpMessageRequestName}.ClientRequestId", new CSharpType(typeof(string))),
             { NameInRequest: var nameInRequest } when RequestHeader.ReturnClientRequestIdResponseHeaders.Contains(nameInRequest) => new Constant("true", new CSharpType(typeof(string))),
             { DefaultValue: not null } => BuilderHelpers.ParseConstant(operationParameter.DefaultValue.Value, typeFactory.CreateType(operationParameter.DefaultValue.Type)),

src/AutoRest.CSharp/Common/Output/Models/Types/ClientOptionsTypeProvider.cs

@@ -7,6 +7,7 @@
 using System.Linq;
 using System.Text;
 using AutoRest.CSharp.Input.Source;
+using AutoRest.CSharp.Output.Models.Shared;
 
 namespace AutoRest.CSharp.Output.Models.Types
 {
@@ -16,6 +17,7 @@ internal sealed class ClientOptionsTypeProvider : TypeProvider
 
         public FormattableString Description { get; }
         public IReadOnlyList<ApiVersion>? ApiVersions { get; }
+        public IList<Parameter>? AdditionalProperties { get; private set; }
         protected override string DefaultName { get; }
         protected override string DefaultAccessibility { get; }
 
@@ -29,6 +31,18 @@ public ClientOptionsTypeProvider(IReadOnlyList<string>? versions, string name, s
                 ApiVersions = ConvertApiVersions(versions);
         }
 
+        public void AddAdditionalProperty(IEnumerable<Parameter> parameters)
+        {
+            AdditionalProperties ??= new List<Parameter>();
+            foreach (var parameter in parameters)
+            {
+                if (!AdditionalProperties.Any(property => property.Name == parameter.Name))
+                {
+                    AdditionalProperties.Add(parameter);
+                }
+            }
+        }
+
         private static ApiVersion[] ConvertApiVersions(IReadOnlyList<string> versions) =>
             versions.Select((v, i) => new ApiVersion(NormalizeVersion(v), $"Service version \"{v}\"", i + 1, v)).ToArray();
 

src/AutoRest.CSharp/LowLevel/Generation/DpgClientWriter.cs

@@ -252,6 +252,10 @@ private void WritePrimaryPublicConstructor(ConstructorSignature signature)
                         {
                             _writer.Line($"{field.Name:I} = {clientOptionsParameter.Name:I}.Version;");
                         }
+                        else if (parameter.IsOptionalInSignature && !parameter.IsEndpoint && !Configuration.KeepOptionalClientParametersInConstructor)
+                        {
+                            _writer.Line($"{field.Name:I} = {clientOptionsParameter.Name:I}.{parameter.Name.FirstCharToUpperCase()};");
+                        }
                         else
                         {
                             _writer.Line($"{field.Name:I} = {parameter.Name:I};");

src/AutoRest.CSharp/LowLevel/Output/DpgOutputLibraryBuilder.cs

@@ -675,6 +675,8 @@ private IEnumerable<LowLevelClient> CreateClients(IEnumerable<ClientInfo> client
 
                 subClients.AddRange(CreateClients(clientInfo.Children, typeFactory, clientOptions, client));
 
+                clientOptions.AddAdditionalProperty(client.GetOptionalParametersInOptions());
+
                 yield return client;
             }
         }

src/AutoRest.CSharp/LowLevel/Output/LowLevelClient.cs

@@ -140,7 +140,7 @@ public static IEnumerable<LowLevelClientMethod> BuildMethods(LowLevelClient? cli
             if (!IsSubClient)
             {
                 var requiredParameters = RestClientBuilder.GetRequiredParameters(orderedParameters).ToArray();
-                var optionalParameters = RestClientBuilder.GetOptionalParameters(orderedParameters).Append(CreateOptionsParameter()).ToArray();
+                var optionalParameters = GetOptionalParametersInConstructor(RestClientBuilder.GetOptionalParameters(orderedParameters).Append(CreateOptionsParameter())).ToArray();
 
                 return (
                     BuildPrimaryConstructors(requiredParameters, optionalParameters).ToArray(),
@@ -153,6 +153,17 @@ public static IEnumerable<LowLevelClientMethod> BuildMethods(LowLevelClient? cli
             }
         }
 
+        private IEnumerable<Parameter> GetOptionalParametersInConstructor(IEnumerable<Parameter> optionalParameters)
+        {
+            return Configuration.KeepOptionalClientParametersInConstructor? optionalParameters : optionalParameters.Where(
+                p => ClientOptions.Type.EqualsIgnoreNullable(p.Type) || p.IsEndpoint); // Endpoint is an exception, even it is optional, still need to be the parameter of constructor
+        }
+
+        public IEnumerable<Parameter> GetOptionalParametersInOptions()
+        {
+            return RestClientBuilder.GetOptionalParameters(Parameters).Where(p => !p.IsEndpoint);
+        }
+
         private IEnumerable<ConstructorSignature> BuildPrimaryConstructors(IReadOnlyList<Parameter> requiredParameters, IReadOnlyList<Parameter> optionalParameters)
         {
             var optionalToRequired = optionalParameters

src/TypeSpec.Extension/Emitter.Csharp/src/emitter.ts

@@ -127,6 +127,8 @@ export async function $onEmit(context: EmitContext<NetEmitterOptions>) {
                     options["use-overloads-between-protocol-and-convenience"],
                 "keep-non-overloadable-protocol-signature":
                     options["keep-non-overloadable-protocol-signature"],
+                "keep-optional-client-parameters-in-constructor":
+                    options["keep-optional-client-parameters-in-constructor"],
                 "model-namespace": options["model-namespace"],
                 "models-to-treat-empty-string-as-null":
                     options["models-to-treat-empty-string-as-null"],

src/TypeSpec.Extension/Emitter.Csharp/src/options.ts

@@ -23,6 +23,7 @@ export type NetEmitterOptions = {
     "existing-project-folder"?: string;
     "use-overloads-between-protocol-and-convenience"?: boolean;
     "keep-non-overloadable-protocol-signature"?: boolean;
+    "keep-optional-client-parameters-in-constructor"?: boolean;
     debug?: boolean;
     "models-to-treat-empty-string-as-null"?: string[];
     "additional-intrinsic-types-to-treat-empty-string-as-null"?: string[];
@@ -72,6 +73,10 @@ export const NetEmitterOptionsSchema: JSONSchemaType<NetEmitterOptions> = {
             type: "boolean",
             nullable: true
         },
+        "keep-optional-client-parameters-in-constructor": {
+            type: "boolean",
+            nullable: true
+        },
         debug: { type: "boolean", nullable: true },
         "models-to-treat-empty-string-as-null": {
             type: "array",

test/AutoRest.TestServer.Tests/Common/Utilities/NamedTypeSymbolExtensionsTests.cs

@@ -97,6 +97,7 @@ public void Method(int? nullableInt, List<int> intList, List<int?> nullableIntLi
                 unreferencedTypesHandling: Configuration.UnreferencedTypesHandlingOption.RemoveOrInternalize,
                 useOverloadsBetweenProtocolAndConvenience: true,
                 keepNonOverloadableProtocolSignature: false,
+                keepOptionalClientParametersInConstructor: false,
                 projectFolder: "/..",
                 existingProjectFolder: null,
                 protocolMethodList: Array.Empty<string>(),

test/AutoRest.TestServer.Tests/Mgmt/Unit/MgmtRestOperationTests.cs

@@ -73,6 +73,7 @@ public void Setup()
                 unreferencedTypesHandling: Configuration.UnreferencedTypesHandlingOption.RemoveOrInternalize,
                 useOverloadsBetweenProtocolAndConvenience: true,
                 keepNonOverloadableProtocolSignature: false,
+                keepOptionalClientParametersInConstructor: false,
                 useCoreDataFactoryReplacements: true,
                 projectFolder: "/..",
                 existingProjectFolder: null,

test/AutoRest.TestServerLowLevel.Tests/LowLevel/Generation/ModelGenerationTestBase.cs

@@ -56,6 +56,7 @@ public void Initialize()
                 unreferencedTypesHandling: Configuration.UnreferencedTypesHandlingOption.RemoveOrInternalize,
                 useOverloadsBetweenProtocolAndConvenience: true,
                 keepNonOverloadableProtocolSignature: false,
+                keepOptionalClientParametersInConstructor: false,
                 projectFolder: ".",
                 existingProjectFolder: null,
                 protocolMethodList: Array.Empty<string>(),

test/AutoRest.TestServerLowLevel.Tests/url-path-items.cs

@@ -12,55 +12,68 @@ public class UrlPathItemsTests : TestServerLowLevelTestBase
     {
         [Test]
         public Task UrlPathItemGetAll() => TestStatus(async (host) =>
-            await new PathItemsClient(globalStringPath: "globalStringPath",
-                    globalStringQuery: "globalStringQuery",
+        {
+            var options = new AutoRestUrlTestServiceClientOptions();
+            options.GlobalStringQuery = "globalStringQuery";
+            return await new PathItemsClient(globalStringPath: "globalStringPath",
                     credential: Key,
                     endpoint: host,
-                    options: null)
+                    options: options)
                 .GetAllWithValuesAsync(
                     pathItemStringPath: "pathItemStringPath",
                     pathItemStringQuery: "pathItemStringQuery",
                     localStringPath: "localStringPath",
-                    localStringQuery: "localStringQuery"));
+                    localStringQuery: "localStringQuery");
+        });
 
         [Test]
         public Task UrlPathItemGetPathItemAndLocalNull() => TestStatus(async (host) =>
-            await new PathItemsClient(globalStringPath: "globalStringPath",
-                    globalStringQuery: "globalStringQuery",
+        {
+            var options = new AutoRestUrlTestServiceClientOptions();
+            options.GlobalStringQuery = "globalStringQuery";
+            return await new PathItemsClient(globalStringPath: "globalStringPath",
                     credential: Key,
                     endpoint: host,
-                    options: null)
+                    options: options)
                 .GetLocalPathItemQueryNullAsync(
                     pathItemStringPath: "pathItemStringPath",
                     pathItemStringQuery: null,
                     localStringPath: "localStringPath",
-                    localStringQuery: null));
+                    localStringQuery: null);
+        });
+
 
         [Test]
         public Task UrlPathItemGetGlobalNull() => TestStatus(async (host) =>
-            await new PathItemsClient(globalStringPath: "globalStringPath",
-                    endpoint: host,
-                    credential: Key,
-                    globalStringQuery: null,
-                    options: null)
-                .GetGlobalQueryNullAsync(
-                    pathItemStringPath: "pathItemStringPath",
-                    pathItemStringQuery: "pathItemStringQuery",
-                    localStringPath: "localStringPath",
-                    localStringQuery: "localStringQuery"));
+        {
+            var options = new AutoRestUrlTestServiceClientOptions();
+            options.GlobalStringQuery = null;
+            return await new PathItemsClient(globalStringPath: "globalStringPath",
+                        endpoint: host,
+                        credential: Key,
+                        options: options)
+                    .GetGlobalQueryNullAsync(
+                        pathItemStringPath: "pathItemStringPath",
+                        pathItemStringQuery: "pathItemStringQuery",
+                        localStringPath: "localStringPath",
+                        localStringQuery: "localStringQuery");
+        });
 
         [Test]
         public Task UrlPathItemGetGlobalAndLocalNull() => TestStatus(async (host) =>
-            await new PathItemsClient(
-                    globalStringPath: "globalStringPath",
-                    endpoint: host,
-                    credential: Key,
-                    globalStringQuery: null,
-                    options: null)
-                .GetGlobalAndLocalQueryNullAsync(
-                pathItemStringPath: "pathItemStringPath",
-                pathItemStringQuery: "pathItemStringQuery",
-                localStringPath: "localStringPath",
-                localStringQuery: null));
+        {
+            var options = new AutoRestUrlTestServiceClientOptions();
+            options.GlobalStringQuery = null;
+            return await new PathItemsClient(
+                        globalStringPath: "globalStringPath",
+                        endpoint: host,
+                        credential: Key,
+                        options: options)
+                    .GetGlobalAndLocalQueryNullAsync(
+                    pathItemStringPath: "pathItemStringPath",
+                    pathItemStringQuery: "pathItemStringQuery",
+                    localStringPath: "localStringPath",
+                    localStringQuery: null);
+        });
     }
 }