Put all optional client parameters into client options

Directory.Build.props

@@ -8,7 +8,7 @@
     <AzureCoreSharedSources>$(MSBuildThisFileDirectory)/src/assets/Azure.Core.Shared/</AzureCoreSharedSources>
     <ShouldUseCentralVersions Condition="'$(ShouldUseCentralVersions)' == ''">true</ShouldUseCentralVersions>
     <NoWarn Condition="'$(IsTestGenerationTestProject)' == 'true'">$(NoWarn);CS1591</NoWarn>
-    <NoWarn>$(NoWarn);NU5105</NoWarn>
+    <NoWarn>$(NoWarn);NU5105;AD0001</NoWarn>
     <!-- Test client libraries won't be in the approved namespace list -->
     <NoWarn Condition="'$(IsTestGenerationSrcProject)' == 'true'">$(NoWarn);AZC0001</NoWarn>
     <!-- Test client libraries can have single word class names -->

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

@@ -82,6 +82,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 && !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(RestClientBuilder.GetOptionalParameters(client.Parameters));
+
                 yield return client;
             }
         }

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

@@ -155,7 +155,8 @@ public static IEnumerable<LowLevelClientMethod> BuildMethods(LowLevelClient? cli
 
         private IEnumerable<ConstructorSignature> BuildPrimaryConstructors(IReadOnlyList<Parameter> requiredParameters, IReadOnlyList<Parameter> optionalParameters)
         {
-            var optionalToRequired = optionalParameters
+            var neededOptionalParameters = Configuration.KeepOptionalClientParametersInConstructor ? optionalParameters : optionalParameters.Where(p => ClientOptions.Type.EqualsIgnoreNullable(p.Type));
+            var optionalToRequired = neededOptionalParameters
                 .Select(parameter => ClientOptions.Type.EqualsIgnoreNullable(parameter.Type)
                 ? parameter with { DefaultValue = null, Validation = ValidationType.None }
                 : parameter with
@@ -191,15 +192,17 @@ private IEnumerable<ConstructorSignature> BuildSecondaryConstructors(IReadOnlyLi
                 yield return CreateMockingConstructor();
             }
 
+            var neededOptionalParameters = Configuration.KeepOptionalClientParametersInConstructor ? optionalParameters : optionalParameters.Where(p => ClientOptions.Type.EqualsIgnoreNullable(p.Type));
+
             /* Construct the parameter arguments to call primitive constructor.
              * In primitive constructor, the endpoint is the first parameter,
              * so put the endpoint as the first parameter argument if the endpoint is optional paramter.
              * */
-            var optionalParametersArguments = optionalParameters
+            var optionalParametersArguments = neededOptionalParameters
                 .Where(p => !p.Name.Equals("endpoint", StringComparison.OrdinalIgnoreCase))
                 .Select(p => p.Initializer ?? p.Type.GetParameterInitializer(p.DefaultValue!.Value)!)
                 .ToArray();
-            var optionalEndpoint = optionalParameters.Where(p => p.Name.Equals("endpoint", StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
+            var optionalEndpoint = neededOptionalParameters.Where(p => p.Name.Equals("endpoint", StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
             var arguments = new List<FormattableString>();
             if (optionalEndpoint != null)
             {

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",

src/assets/Azure.Core.Shared/RequestContentHelper.cs

@@ -96,13 +96,7 @@ public static RequestContent FromObject(object value)
         }
         public static RequestContent FromObject(BinaryData value)
         {
-            var content = new Utf8JsonRequestContent();
-#if NET6_0_OR_GREATER
-            content.JsonWriter.WriteRawValue(value);
-#else
-            JsonSerializer.Serialize(content.JsonWriter, JsonDocument.Parse(value).RootElement);
-#endif
-            return content;
+            return value;
         }
     }
 }