Add support for array encoding with @encode(ArrayEncoding.*) decorator

packages/http-client-csharp/emitter/src/lib/type-converter.ts

@@ -269,6 +269,7 @@ function fromSdkModelProperty(
     serializationOptions: sdkProperty.serializationOptions,
     // A property is defined to be metadata if it is marked `@header`, `@cookie`, `@query`, `@path`.
     isHttpMetadata: isHttpMetadata(sdkContext, sdkProperty),
+    encode: sdkProperty.encode,
   } as InputModelProperty;
 
   if (property) {

packages/http-client-csharp/emitter/src/type/input-type.ts

@@ -181,6 +181,7 @@ export interface InputModelProperty extends InputPropertyTypeBase {
   serializationOptions: SerializationOptions;
   flatten: boolean;
   isHttpMetadata: boolean;
+  encode?: string;
 }
 
 export type InputProperty = InputModelProperty | InputParameter;

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/test/Providers/MrwSerializationTypeDefinitions/ModelCustomizationTests.cs

@@ -526,5 +526,62 @@ public async Task ExplicitOperatorDoesNotPreventImplicit()
                 m.Signature.Modifiers.HasFlag(MethodSignatureModifiers.Operator));
             Assert.IsNotNull(implicitOperator, "Implicit operator should still be generated when only explicit operator is customized");
         }
+
+        // Unit test for enum array serialization - shows generated output like spector tests show behavior
+        [Test]
+        public async Task ValidateEnumArraySerializationGeneratedOutput()
+        {
+            var inputEnum = InputFactory.StringEnum("TestEnum", [("Blue", "blue"), ("Red", "red"), ("Green", "green")], isExtensible: false);
+            var props = new[]
+            {
+                InputFactory.Property("Colors", InputFactory.Array(inputEnum))
+            };
+
+            var inputModel = InputFactory.Model("mockInputModel", properties: props, usage: InputModelTypeUsage.Json);
+            var mockGenerator = await MockHelpers.LoadMockGeneratorAsync(
+                inputModels: () => [inputModel],
+                inputEnums: () => [inputEnum]);
+
+            var modelProvider = mockGenerator.Object.OutputLibrary.TypeProviders.Single(t => t is ModelProvider);
+            var serializationProvider = modelProvider.SerializationProviders.Single(t => t is MrwSerializationTypeDefinition);
+
+            var writer = new TypeProviderWriter(serializationProvider);
+            var file = writer.Write();
+
+            var generatedCode = file.Content;
+
+            Assert.IsTrue(generatedCode.Contains("writer.WriteStringValue(item.ToSerialString())"));
+            Assert.IsTrue(generatedCode.Contains("array.Add(item.GetString().ToTestEnum())"));
+            Assert.IsTrue(generatedCode.Contains("foreach"));
+            Assert.IsTrue(generatedCode.Contains("ToSerialString()"));
+        }
+
+        [Test]
+        public async Task ValidateEnumArrayDeserializationGeneratedOutput()
+        {
+            var inputEnum = InputFactory.StringEnum("TestEnum", [("Blue", "blue"), ("Red", "red"), ("Green", "green")], isExtensible: false);
+            var props = new[]
+            {
+                InputFactory.Property("Colors", InputFactory.Array(inputEnum))
+            };
+
+            var inputModel = InputFactory.Model("mockInputModel", properties: props, usage: InputModelTypeUsage.Json);
+            var mockGenerator = await MockHelpers.LoadMockGeneratorAsync(
+                inputModels: () => [inputModel],
+                inputEnums: () => [inputEnum]);
+
+            var modelProvider = mockGenerator.Object.OutputLibrary.TypeProviders.Single(t => t is ModelProvider);
+            var serializationProvider = modelProvider.SerializationProviders.Single(t => t is MrwSerializationTypeDefinition);
+
+            var writer = new TypeProviderWriter(serializationProvider);
+            var file = writer.Write();
+
+            var generatedCode = file.Content;
+
+            Assert.IsTrue(generatedCode.Contains("array.Add(item.GetString().ToTestEnum())"));
+            Assert.IsTrue(generatedCode.Contains("foreach"));
+            Assert.IsTrue(generatedCode.Contains("JsonElement"));
+            Assert.IsTrue(generatedCode.Contains("ToTestEnum()") || generatedCode.Contains(".ToEnum()"));
+        }
     }
 }

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/Extensions/ArrayKnownEncodingExtensions.cs

@@ -0,0 +1,68 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+
+namespace Microsoft.TypeSpec.Generator.Input.Extensions
+{
+    public static class ArrayKnownEncodingExtensions
+    {
+        /// <summary>
+        /// Converts a string representation to ArrayKnownEncoding.
+        /// </summary>
+        public static bool TryParse(string? value, out ArrayKnownEncoding encoding)
+        {
+            encoding = default;
+            if (value == null) return false;
+
+            return value switch
+            {
+                "ArrayEncoding.commaDelimited" or "commaDelimited" =>
+                    SetEncodingAndReturnTrue(out encoding, ArrayKnownEncoding.CommaDelimited),
+                "ArrayEncoding.spaceDelimited" or "spaceDelimited" =>
+                    SetEncodingAndReturnTrue(out encoding, ArrayKnownEncoding.SpaceDelimited),
+                "ArrayEncoding.pipeDelimited" or "pipeDelimited" =>
+                    SetEncodingAndReturnTrue(out encoding, ArrayKnownEncoding.PipeDelimited),
+                "ArrayEncoding.newlineDelimited" or "newlineDelimited" =>
+                    SetEncodingAndReturnTrue(out encoding, ArrayKnownEncoding.NewlineDelimited),
+                _ => false
+            };
+        }
+
+        /// <summary>
+        /// Converts ArrayKnownEncoding to SerializationFormat.
+        /// </summary>
+        public static SerializationFormat ToSerializationFormat(this ArrayKnownEncoding encoding)
+        {
+            return encoding switch
+            {
+                ArrayKnownEncoding.CommaDelimited => SerializationFormat.Array_CommaDelimited,
+                ArrayKnownEncoding.SpaceDelimited => SerializationFormat.Array_SpaceDelimited,
+                ArrayKnownEncoding.PipeDelimited => SerializationFormat.Array_PipeDelimited,
+                ArrayKnownEncoding.NewlineDelimited => SerializationFormat.Array_NewlineDelimited,
+                _ => throw new ArgumentOutOfRangeException(nameof(encoding), encoding, "Unknown array encoding")
+            };
+        }
+
+        /// <summary>
+        /// Gets the delimiter string for array serialization format.
+        /// </summary>
+        public static string GetDelimiter(SerializationFormat format)
+        {
+            return format switch
+            {
+                SerializationFormat.Array_CommaDelimited => ",",
+                SerializationFormat.Array_SpaceDelimited => " ",
+                SerializationFormat.Array_PipeDelimited => "|",
+                SerializationFormat.Array_NewlineDelimited => "\n",
+                _ => throw new ArgumentOutOfRangeException(nameof(format), format, "Unsupported array serialization format")
+            };
+        }
+
+        private static bool SetEncodingAndReturnTrue(out ArrayKnownEncoding encoding, ArrayKnownEncoding value)
+        {
+            encoding = value;
+            return true;
+        }
+    }
+}

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/ArrayKnownEncoding.cs

@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+namespace Microsoft.TypeSpec.Generator.Input
+{
+    /// <summary>
+    /// Represents the known encoding formats for arrays.
+    /// </summary>
+    public enum ArrayKnownEncoding
+    {
+        /// <summary>
+        /// Comma-delimited array encoding
+        /// </summary>
+        CommaDelimited,
+
+        /// <summary>
+        /// Space-delimited array encoding
+        /// </summary>
+        SpaceDelimited,
+
+        /// <summary>
+        /// Pipe-delimited array encoding
+        /// </summary>
+        PipeDelimited,
+
+        /// <summary>
+        /// Newline-delimited array encoding
+        /// </summary>
+        NewlineDelimited
+    }
+}

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/InputModelProperty.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+using Microsoft.TypeSpec.Generator.Input.Extensions;
+
 namespace Microsoft.TypeSpec.Generator.Input
 {
     public class InputModelProperty : InputProperty
@@ -18,7 +20,8 @@ public InputModelProperty(
             bool isHttpMetadata,
             bool isApiVersion,
             InputConstant? defaultValue,
-            InputSerializationOptions serializationOptions)
+            InputSerializationOptions serializationOptions,
+            string? encode = null)
             : base(name, summary, doc, type, isRequired, isReadOnly, access, serializedName, isApiVersion, defaultValue)
         {
             Name = name;
@@ -30,11 +33,13 @@ public InputModelProperty(
             IsDiscriminator = isDiscriminator;
             IsHttpMetadata = isHttpMetadata;
             SerializationOptions = serializationOptions;
+            Encode = encode;
         }
 
         public bool IsDiscriminator { get; internal set; }
         public InputSerializationOptions? SerializationOptions { get; internal set; }
         public bool IsHttpMetadata { get; internal set; }
+        public string? Encode { get; internal set; }
 
         /// <summary>
         /// Updates the properties of the input model property.
@@ -117,5 +122,14 @@ public void Update(
                 SerializationOptions = serializationOptions;
             }
         }
+
+        public ArrayKnownEncoding? GetArrayEncoding()
+        {
+            if (ArrayKnownEncodingExtensions.TryParse(Encode, out var encoding))
+            {
+                return encoding;
+            }
+            return null;
+        }
     }
 }

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/Serialization/InputModelPropertyConverter.cs

@@ -46,7 +46,8 @@ internal static InputModelProperty ReadInputModelProperty(ref Utf8JsonReader rea
                 isHttpMetadata: false,
                 isApiVersion: false,
                 defaultValue: null,
-                serializationOptions: null!);
+                serializationOptions: null!,
+                encode: null);
             resolver.AddReference(id, property);
 
             string? kind = null;
@@ -63,6 +64,7 @@ internal static InputModelProperty ReadInputModelProperty(ref Utf8JsonReader rea
             bool isDiscriminator = false;
             IReadOnlyList<InputDecoratorInfo>? decorators = null;
             InputSerializationOptions? serializationOptions = null;
+            string? encode = null;
 
             while (reader.TokenType != JsonTokenType.EndObject)
             {
@@ -81,7 +83,8 @@ internal static InputModelProperty ReadInputModelProperty(ref Utf8JsonReader rea
                     || reader.TryReadString("serializedName", ref serializedName)
                     || reader.TryReadBoolean("isApiVersion", ref isApiVersion)
                     || reader.TryReadComplexType("defaultValue", options, ref defaultValue)
-                    || reader.TryReadComplexType("serializationOptions", options, ref serializationOptions);
+                    || reader.TryReadComplexType("serializationOptions", options, ref serializationOptions)
+                    || reader.TryReadString("encode", ref encode);
 
                 if (!isKnownProperty)
                 {
@@ -103,6 +106,7 @@ internal static InputModelProperty ReadInputModelProperty(ref Utf8JsonReader rea
             property.SerializedName = serializedName ?? serializationOptions?.Json?.Name ?? name;
             property.IsApiVersion = isApiVersion;
             property.DefaultValue = defaultValue;
+            property.Encode = encode;
 
             return property;
         }

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.Input/src/InputTypes/Serialization/SerializationFormat.cs

@@ -28,5 +28,9 @@ public enum SerializationFormat
         Bytes_Base64Url,
         Bytes_Base64,
         Int_String,
+        Array_CommaDelimited,
+        Array_SpaceDelimited,
+        Array_PipeDelimited,
+        Array_NewlineDelimited,
     }
 }

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

@@ -39,6 +39,7 @@ public class PropertyProvider
         public FieldProvider? BackingField { get; set; }
         public PropertyProvider? BaseProperty { get; set; }
         public bool IsRef { get; private set; }
+        public SerializationFormat SerializationFormat => _serializationFormat;
 
         /// <summary>
         /// Converts this property to a parameter.
@@ -91,7 +92,7 @@ private PropertyProvider(InputProperty inputProperty, CSharpType propertyType, T
             }
 
             EnclosingType = enclosingType;
-            _serializationFormat = CodeModelGenerator.Instance.TypeFactory.GetSerializationFormat(inputProperty.Type);
+            _serializationFormat = GetSerializationFormat(inputProperty);
             _isRequiredNonNullableConstant = inputProperty.IsRequired && propertyType is { IsLiteral: true, IsNullable: false };
             var propHasSetter = PropertyHasSetter(propertyType, inputProperty);
             MethodSignatureModifiers setterModifier = propHasSetter ? MethodSignatureModifiers.Public : MethodSignatureModifiers.None;
@@ -334,5 +335,21 @@ public void Update(
                 BuildDocs();
             }
         }
+
+        private SerializationFormat GetSerializationFormat(InputProperty inputProperty)
+        {
+            // Handle array encoding from InputModelProperty
+            if (inputProperty is InputModelProperty modelProperty &&
+                inputProperty.Type is InputArrayType)
+            {
+                var arrayEncoding = modelProperty.GetArrayEncoding();
+                if (arrayEncoding.HasValue)
+                {
+                    return arrayEncoding.Value.ToSerializationFormat();
+                }
+            }
+
+            return CodeModelGenerator.Instance.TypeFactory.GetSerializationFormat(inputProperty.Type);
+        }
     }
 }

packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator/src/Snippets/StringSnippets.cs

@@ -21,9 +21,15 @@ public static ScopedApi<string> Format(ScopedApi<string> format, params ValueExp
         public static ScopedApi<bool> IsNullOrWhiteSpace(ScopedApi<string> value, params ValueExpression[] args)
             => Static<string>().Invoke(nameof(string.IsNullOrWhiteSpace), args.Prepend(value).ToArray()).As<bool>();
 
+        public static ScopedApi<bool> IsNullOrEmpty(ScopedApi<string> value)
+            => Static<string>().Invoke(nameof(string.IsNullOrEmpty), [value]).As<bool>();
+
         public static ScopedApi<string> Join(ValueExpression separator, ValueExpression values)
             => Static<string>().Invoke(nameof(string.Join), [separator, values]).As<string>();
 
+        public static ValueExpression Split(this ScopedApi<string> stringExpression, ValueExpression separator)
+            => stringExpression.Invoke(nameof(string.Split), [separator], null, false);
+
         public static ScopedApi<string> Substring(this ScopedApi<string> stringExpression, ValueExpression startIndex)
             => stringExpression.Invoke(nameof(string.Substring), [startIndex], null, false).As<string>();
 

packages/http-client-csharp/generator/TestProjects/Spector.Tests/Http/Encode/Array/EncodeArrayTests.cs

@@ -0,0 +1,62 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.ClientModel;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Encode._Array;
+using Encode._Array._Property;
+using NUnit.Framework;
+
+namespace TestProjects.Spector.Tests.Http.Encode.Array
+{
+    public class EncodeArrayTests : SpectorTestBase
+    {
+        [SpectorTest]
+        public Task CommaDelimited() => Test(async (host) =>
+        {
+            var testData = new List<string> { "blue", "red", "green" };
+            var body = new CommaDelimitedArrayProperty(testData);
+
+            ClientResult<CommaDelimitedArrayProperty> result = await new ArrayClient(host, null).GetPropertyClient().CommaDelimitedAsync(body);
+            Assert.AreEqual(200, result.GetRawResponse().Status);
+            Assert.AreEqual(testData, result.Value.Value);
+        });
+
+        [SpectorTest]
+        public Task SpaceDelimited() => Test(async (host) =>
+        {
+            var testData = new List<string> { "blue", "red", "green" };
+            var body = new SpaceDelimitedArrayProperty(testData);
+
+            ClientResult<SpaceDelimitedArrayProperty> result = await new ArrayClient(host, null).GetPropertyClient().SpaceDelimitedAsync(body);
+            Assert.AreEqual(200, result.GetRawResponse().Status);
+            Assert.AreEqual(testData, result.Value.Value);
+        });
+
+        [SpectorTest]
+        public Task PipeDelimited() => Test(async (host) =>
+        {
+            var testData = new List<string> { "blue", "red", "green" };
+            var body = new PipeDelimitedArrayProperty(testData);
+
+            ClientResult<PipeDelimitedArrayProperty> result = await new ArrayClient(host, null).GetPropertyClient().PipeDelimitedAsync(body);
+            Assert.AreEqual(200, result.GetRawResponse().Status);
+            Assert.AreEqual(testData, result.Value.Value);
+        });
+
+        [SpectorTest]
+        public Task NewlineDelimited() => Test(async (host) =>
+        {
+            var testData = new List<string> { "blue", "red", "green" };
+            var body = new NewlineDelimitedArrayProperty(testData);
+
+            ClientResult<NewlineDelimitedArrayProperty> result = await new ArrayClient(host, null).GetPropertyClient().NewlineDelimitedAsync(body);
+            Assert.AreEqual(200, result.GetRawResponse().Status);
+            Assert.AreEqual(testData, result.Value.Value);
+        });
+
+
+    }
+}

packages/http-client-csharp/generator/TestProjects/Spector.Tests/TestProjects.Spector.Tests.csproj

@@ -32,6 +32,7 @@
     <ProjectReference Include="$(RepoRoot)\TestProjects\Spector\http\client\structure\multi-client\src\Client.Structure.Service.Multi.Client.csproj" Aliases="ClientStructureMultiClient" />
     <ProjectReference Include="$(RepoRoot)\TestProjects\Spector\http\client\structure\renamed-operation\src\Client.Structure.Service.Renamed.Operation.csproj" Aliases="ClientStructureRenamedOperation" />
     <ProjectReference Include="$(RepoRoot)\TestProjects\Spector\http\client\structure\two-operation-group\src\Client.Structure.Service.TwoOperationGroup.csproj" Aliases="ClientStructureTwoOperationGroup" />
+    <ProjectReference Include="$(RepoRoot)\TestProjects\Spector\http\encode\array\src\Encode.Array.csproj" />
     <ProjectReference Include="$(RepoRoot)\TestProjects\Spector\http\documentation\src\Documentation.csproj" />
     <ProjectReference Include="$(RepoRoot)\TestProjects\Spector\http\encode\bytes\src\Encode.Bytes.csproj" />
     <ProjectReference Include="$(RepoRoot)\TestProjects\Spector\http\encode\datetime\src\Encode.Datetime.csproj" />