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/MrwSerializationTypeDefinitionTests.cs

@@ -1259,5 +1259,75 @@ public void TestSerializationTypeNameMatchesModelProviderName()
             Assert.AreEqual($"Deserialize{model.Name}", deserializationMethod.Signature.Name,
                 "Deserialization method name should use ModelProvider name");
         }
+
+        [TestCase("commaDelimited", ",")]
+        [TestCase("spaceDelimited", " ")]
+        [TestCase("pipeDelimited", "|")]
+        [TestCase("newlineDelimited", "\\n")]
+        public void TestArrayEncodingSerializationStatement(string encoding, string expectedDelimiter)
+        {
+            Enum.TryParse<ArrayKnownEncoding>(encoding, ignoreCase: true, out var arrayEncoding);
+            var arrayType = new InputArrayType("TestArray", "TypeSpec.Array", InputPrimitiveType.String);
+            var arrayProperty = new InputModelProperty(
+                "TestArray", 
+                "Test array property summary",
+                "Test array property", 
+                arrayType, 
+                true, 
+                false, 
+                null, 
+                false, 
+                "testArray", 
+                false, 
+                false, 
+                null, 
+                new(json: new("testArray")),
+                arrayEncoding);
+
+            var properties = new List<InputModelProperty> { arrayProperty };
+            var inputModel = new InputModelType("TestModel", "TestNamespace", "TestModel", "public", null, null, "Test model.", InputModelTypeUsage.Input, properties, null, Array.Empty<InputModelType>(), null, null, new Dictionary<string, InputModelType>(), null, false, new(), false);
+
+            var (_, serialization) = CreateModelAndSerialization(inputModel);
+            var writeMethod = serialization.BuildJsonModelWriteCoreMethod();
+            var methodBody = writeMethod.BodyStatements!.ToDisplayString();
+
+            Assert.IsTrue(methodBody.Contains($"string.Join(\"{expectedDelimiter}\", TestArray)"), 
+                $"Expected serialization to use string.Join with delimiter '{expectedDelimiter}', but got: {methodBody}");
+        }
+
+        [TestCase("commaDelimited", ",")]
+        [TestCase("spaceDelimited", " ")]
+        [TestCase("pipeDelimited", "|")]
+        [TestCase("newlineDelimited", "\\n")]
+        public void TestArrayEncodingDeserializationStatement(string encoding, string expectedDelimiter)
+        {
+            Enum.TryParse<ArrayKnownEncoding>(encoding, ignoreCase: true, out var arrayEncoding);
+            var arrayType = new InputArrayType("TestArray", "TypeSpec.Array", InputPrimitiveType.String);
+            var arrayProperty = new InputModelProperty(
+                "TestArray", 
+                "Test array property summary",
+                "Test array property", 
+                arrayType, 
+                true, 
+                false, 
+                null, 
+                false, 
+                "testArray", 
+                false, 
+                false, 
+                null, 
+                new(json: new("testArray")),
+                arrayEncoding);
+
+            var properties = new List<InputModelProperty> { arrayProperty };
+            var inputModel = new InputModelType("TestModel", "TestNamespace", "TestModel", "public", null, null, "Test model.", InputModelTypeUsage.Input, properties, null, Array.Empty<InputModelType>(), null, null, new Dictionary<string, InputModelType>(), null, false, new(), false);
+
+            var (_, serialization) = CreateModelAndSerialization(inputModel);
+            var deserializeMethod = serialization.BuildDeserializationMethod();
+            var methodBody = deserializeMethod.BodyStatements!.ToDisplayString();
+
+            Assert.IsTrue(methodBody.Contains($".Split('{expectedDelimiter}')") || methodBody.Contains($".Split(\"{expectedDelimiter}\")"), 
+                $"Expected deserialization to use Split with delimiter '{expectedDelimiter}', but got: {methodBody}");
+        }
     }
 }

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

@@ -0,0 +1,41 @@
+// 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 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>
+        /// Get the delimiter string for array serialization format.
+        /// </summary>
+        public static bool TryGetDelimiter(SerializationFormat format, out string? delimiter)
+        {
+            delimiter = format switch
+            {
+                SerializationFormat.Array_CommaDelimited => ",",
+                SerializationFormat.Array_SpaceDelimited => " ",
+                SerializationFormat.Array_PipeDelimited => "|",
+                SerializationFormat.Array_NewlineDelimited => "\n",
+                _ => null
+            };
+            return delimiter != null;
+        }
+    }
+}

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,
+            ArrayKnownEncoding? 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 ArrayKnownEncoding? Encode { get; internal set; }
 
         /// <summary>
         /// Updates the properties of the input model property.

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? encodeString = 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 encodeString);
 
                 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 = Enum.TryParse<ArrayKnownEncoding>(encodeString, ignoreCase: true, out var encode) ? encode : null;
 
             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.Encode;
+                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" />