diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Abstractions/ClientPipelineApi.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Abstractions/ClientPipelineApi.cs
index c06c53292a0..65b5c1795de 100644
--- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Abstractions/ClientPipelineApi.cs
+++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/Abstractions/ClientPipelineApi.cs
@@ -2,6 +2,7 @@
// Licensed under the MIT License.
using System;
+using Microsoft.TypeSpec.Generator.ClientModel.Snippets;
using Microsoft.TypeSpec.Generator.Expressions;
using Microsoft.TypeSpec.Generator.Primitives;
using Microsoft.TypeSpec.Generator.Snippets;
@@ -37,6 +38,21 @@ public abstract MethodBodyStatement[] CreateMessage(
public abstract ValueExpression KeyAuthorizationPolicy(ValueExpression credential, ValueExpression headerName, ValueExpression? keyPrefix = null);
public abstract ValueExpression TokenAuthorizationPolicy(ValueExpression credential, ValueExpression scopes);
public virtual ValueExpression? UserAgentPolicy(CSharpType clientType) => null;
+
+ ///
+ /// Gets whether the client options of this pipeline carry model proxies. When true, generated clients store
+ /// the options returned by and pass them to every model
+ /// they read and write in their operations. Pipelines whose client options don't carry model proxies keep the
+ /// default (false), and their clients use the shared wire options.
+ ///
+ public virtual bool SupportsModelProxies => false;
+
+ ///
+ /// Gets the ModelReaderWriterOptions a generated client uses to read and write models in its operations,
+ /// built from its client options. Only called when is true.
+ ///
+ /// The client options expression.
+ public virtual ValueExpression GetModelReaderWriterOptions(ValueExpression clientOptions) => ModelSerializationExtensionsSnippets.Wire;
public abstract ClientPipelineApi FromExpression(ValueExpression expression);
public abstract ClientPipelineApi ToExpression();
}
diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/BinaryContentHelperDefinition.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/BinaryContentHelperDefinition.cs
index 9118211f1a6..82382572e9f 100644
--- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/BinaryContentHelperDefinition.cs
+++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/BinaryContentHelperDefinition.cs
@@ -3,6 +3,7 @@
using System;
using System.ClientModel;
+using System.ClientModel.Primitives;
using System.Collections.Generic;
using System.IO;
using System.Xml;
@@ -35,6 +36,25 @@ public class BinaryContentHelperDefinition : InternalHelperProvider
protected override IReadOnlyList BuildBodyDependencyTypes() =>
[ScmCodeModelGenerator.Instance.ModelSerializationExtensionsDefinition.Type];
+ // Clients whose options carry model proxies pass their options so the proxies apply to the items written here.
+ // The parameter is optional so existing callers, such as custom code, keep writing with the wire options.
+ private static ParameterProvider? CreateOptionsParameter()
+ => ScmCodeModelGenerator.Instance.TypeFactory.ClientPipelineApi.ToExpression().SupportsModelProxies
+ ? new ParameterProvider("options", FormattableStringHelpers.Empty, typeof(ModelReaderWriterOptions), defaultValue: Null)
+ : null;
+
+ private static ScopedApi GetOptions(ParameterProvider? optionsParameter)
+ => optionsParameter?.As() ?? ModelSerializationExtensionsSnippets.Wire;
+
+ // options ??= ModelSerializationExtensions.WireOptions;
+ private static MethodBodyStatement DefaultOptions(ParameterProvider? optionsParameter)
+ => optionsParameter is null
+ ? MethodBodyStatement.Empty
+ : optionsParameter.Assign(ModelSerializationExtensionsSnippets.Wire, nullCoalesce: true).Terminate();
+
+ private static ParameterProvider[] WithOptions(ParameterProvider? optionsParameter, params ParameterProvider[] parameters)
+ => optionsParameter is null ? parameters : [.. parameters, optionsParameter];
+
protected override MethodProvider[] BuildMethods()
{
var methods = new List
@@ -61,10 +81,11 @@ private MethodProvider BuildFromEnumerableTMethod()
var enumerableTType = typeof(IEnumerable<>);
CSharpType tType = enumerableTType.GetGenericArguments()[0];
var enumerableParameter = new ParameterProvider("enumerable", FormattableStringHelpers.Empty, enumerableTType);
+ var optionsParameter = CreateOptionsParameter();
var signature = new MethodSignature(
Name: _fromEnumerableName,
Modifiers: _methodModifiers,
- Parameters: [enumerableParameter],
+ Parameters: WithOptions(optionsParameter, enumerableParameter),
ReturnType: _requestBodyType,
GenericArguments: [tType],
GenericParameterConstraints: [Where.NotNull(tType)],
@@ -73,6 +94,7 @@ private MethodProvider BuildFromEnumerableTMethod()
var body = new List
{
+ DefaultOptions(optionsParameter),
Declare("content", New.Instance(), out var content)
};
var writer = content.JsonWriter();
@@ -81,7 +103,7 @@ private MethodProvider BuildFromEnumerableTMethod()
writer.WriteStartArray(),
new ForEachStatement("item", enumerableParameter.As(enumerableParameter.Type), out var item)
{
- writer.WriteObjectValue(item.As(tType), ModelSerializationExtensionsSnippets.Wire)
+ writer.WriteObjectValue(item.As(tType), GetOptions(optionsParameter))
},
writer.WriteEndArray(),
MethodBodyStatement.EmptyLine,
@@ -130,10 +152,11 @@ private MethodProvider BuildFromReadOnlySpanMethod()
var spanType = typeof(ReadOnlySpan<>);
CSharpType tType = spanType.GetGenericArguments()[0];
var spanParameter = new ParameterProvider("span", FormattableStringHelpers.Empty, spanType);
+ var optionsParameter = CreateOptionsParameter();
var signature = new MethodSignature(
Name: _fromEnumerableName,
Modifiers: _methodModifiers,
- Parameters: [spanParameter],
+ Parameters: WithOptions(optionsParameter, spanParameter),
ReturnType: _requestBodyType,
GenericArguments: [tType],
GenericParameterConstraints: [Where.NotNull(tType)],
@@ -142,6 +165,7 @@ private MethodProvider BuildFromReadOnlySpanMethod()
var body = new List
{
+ DefaultOptions(optionsParameter),
Declare("content", New.Instance(), out var content)
};
var writer = content.JsonWriter();
@@ -151,7 +175,7 @@ private MethodProvider BuildFromReadOnlySpanMethod()
Declare("i", Int(0), out var i),
new ForStatement(null, i.LessThan(spanParameter.Property(nameof(ReadOnlySpan.Length))), i.Increment())
{
- writer.WriteObjectValue(new IndexerExpression(spanParameter, i).As(tType), ModelSerializationExtensionsSnippets.Wire)
+ writer.WriteObjectValue(new IndexerExpression(spanParameter, i).As(tType), GetOptions(optionsParameter))
},
writer.WriteEndArray(),
MethodBodyStatement.EmptyLine,
@@ -166,10 +190,11 @@ private MethodProvider BuildFromDictionaryTMethod()
var dictionaryTType = typeof(IDictionary<,>);
CSharpType valueType = dictionaryTType.GetGenericArguments()[1];
var dictionaryParameter = new ParameterProvider("dictionary", FormattableStringHelpers.Empty, new CSharpType(dictionaryTType, typeof(string), valueType));
+ var optionsParameter = CreateOptionsParameter();
var signature = new MethodSignature(
Name: _fromDictionaryName,
Modifiers: _methodModifiers,
- Parameters: [dictionaryParameter],
+ Parameters: WithOptions(optionsParameter, dictionaryParameter),
ReturnType: _requestBodyType,
GenericArguments: [valueType],
GenericParameterConstraints: [Where.NotNull(valueType)],
@@ -178,6 +203,7 @@ private MethodProvider BuildFromDictionaryTMethod()
var body = new List
{
+ DefaultOptions(optionsParameter),
Declare("content", New.Instance(), out var content)
};
var writer = content.JsonWriter();
@@ -187,7 +213,7 @@ private MethodProvider BuildFromDictionaryTMethod()
new ForEachStatement("item", dictionaryParameter.As(dictionaryParameter.Type), out var item)
{
writer.WritePropertyName(item.Property("Key")),
- writer.WriteObjectValue(item.Property("Value").As(valueType), ModelSerializationExtensionsSnippets.Wire)
+ writer.WriteObjectValue(item.Property("Value").As(valueType), GetOptions(optionsParameter))
},
writer.WriteEndObject(),
MethodBodyStatement.EmptyLine,
@@ -285,10 +311,11 @@ private MethodProvider BuildFromEnumerableXmlMethod()
var enumerableParameter = new ParameterProvider("enumerable", FormattableStringHelpers.Empty, enumerableTType);
var rootNameHintParameter = new ParameterProvider("rootNameHint", FormattableStringHelpers.Empty, typeof(string));
var childNameHintParameter = new ParameterProvider("childNameHint", FormattableStringHelpers.Empty, typeof(string));
+ var optionsParameter = CreateOptionsParameter();
var signature = new MethodSignature(
Name: _fromEnumerableName,
Modifiers: _methodModifiers,
- Parameters: [enumerableParameter, rootNameHintParameter, childNameHintParameter],
+ Parameters: WithOptions(optionsParameter, enumerableParameter, rootNameHintParameter, childNameHintParameter),
ReturnType: _requestBodyType,
GenericArguments: [tType],
GenericParameterConstraints: [Where.NotNull(tType)],
@@ -304,7 +331,7 @@ private MethodProvider BuildFromEnumerableXmlMethod()
xmlWriter.WriteStartElement(rootNameHintParameter),
new ForEachStatement("item", enumerableParameter.As(enumerableParameter.Type), out var item)
{
- xmlWriter.WriteObjectValue(item.As(tType), ModelSerializationExtensionsSnippets.Wire, childNameHintParameter)
+ xmlWriter.WriteObjectValue(item.As(tType), GetOptions(optionsParameter), childNameHintParameter)
},
xmlWriter.WriteEndElement(),
]);
@@ -319,7 +346,7 @@ private MethodProvider BuildFromEnumerableXmlMethod()
[Int(0), streamVar.Property(nameof(MemoryStream.Position)).CastTo(typeof(int))])))))
]);
- var body = new MethodBodyStatement[] { outerUsing };
+ var body = new MethodBodyStatement[] { DefaultOptions(optionsParameter), outerUsing };
return new MethodProvider(signature, body, this);
}
diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ClientPipelineProvider.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ClientPipelineProvider.cs
index 6a93b77942e..2b9abe0b512 100644
--- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ClientPipelineProvider.cs
+++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ClientPipelineProvider.cs
@@ -3,6 +3,7 @@
using System.ClientModel;
using System.ClientModel.Primitives;
+using Microsoft.TypeSpec.Generator.ClientModel.Snippets;
using Microsoft.TypeSpec.Generator.Expressions;
using Microsoft.TypeSpec.Generator.Primitives;
using Microsoft.TypeSpec.Generator.Snippets;
@@ -33,6 +34,12 @@ public ClientPipelineProvider(ValueExpression original) : base(typeof(ClientPipe
public override ValueExpression Create(ValueExpression options, ValueExpression perRetryPolicies)
=> Static().Invoke(nameof(ClientPipeline.Create), [options, New.Array(ScmCodeModelGenerator.Instance.TypeFactory.ClientPipelineApi.PipelinePolicyType), perRetryPolicies, New.Array(ScmCodeModelGenerator.Instance.TypeFactory.ClientPipelineApi.PipelinePolicyType)]).As();
+ public override bool SupportsModelProxies => true;
+
+ // Copies ClientPipelineOptions.ModelProxies into the client's options; creating the pipeline freezes them.
+ public override ValueExpression GetModelReaderWriterOptions(ValueExpression clientOptions)
+ => ModelSerializationExtensionsSnippets.ToWireOptions(clientOptions.Property(nameof(ClientPipelineOptions.ModelProxies)));
+
public override MethodBodyStatement[] CreateMessage(
HttpRequestOptionsApi requestOptions,
ValueExpression uri,
diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ClientProvider.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ClientProvider.cs
index 391b2bbe5ff..20584b13688 100644
--- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ClientProvider.cs
+++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ClientProvider.cs
@@ -10,6 +10,7 @@
using System.Linq;
using System.Threading;
using Microsoft.TypeSpec.Generator.ClientModel.Primitives;
+using Microsoft.TypeSpec.Generator.ClientModel.Snippets;
using Microsoft.TypeSpec.Generator.ClientModel.Utilities;
using Microsoft.TypeSpec.Generator.EmitterRpc;
using Microsoft.TypeSpec.Generator.Expressions;
@@ -41,6 +42,7 @@ private record ApiVersionFields(FieldProvider Field, PropertyProvider? Correspon
private const string TokenProviderFieldName = "_tokenProvider";
private const string TokenCredentialFieldName = "_tokenCredential";
private const string EndpointFieldName = "_endpoint";
+ private const string ModelReaderWriterOptionsFieldName = "_modelReaderWriterOptions";
private const string CredentialParamName = "credential";
private const string SettingsParamName = "settings";
private const string ClientSuffix = "Client";
@@ -182,6 +184,16 @@ public ClientProvider(InputClient inputClient)
typeof(Uri),
EndpointFieldName,
this);
+ // Clients created through the mocking constructor skip the constructors that copy the client options' proxies,
+ // so the field starts with the shared wire options to keep their convenience methods working.
+ ModelReaderWriterOptionsField = ScmCodeModelGenerator.Instance.TypeFactory.ClientPipelineApi.ToExpression().SupportsModelProxies
+ ? new FieldProvider(
+ FieldModifiers.Private | FieldModifiers.ReadOnly,
+ typeof(ModelReaderWriterOptions),
+ ModelReaderWriterOptionsFieldName,
+ this,
+ initializationValue: ModelSerializationExtensionsSnippets.Wire)
+ : null;
PipelineProperty = new(
description: $"The HTTP pipeline for sending and receiving REST requests and responses.",
modifiers: MethodSignatureModifiers.Public,
@@ -515,6 +527,12 @@ private IReadOnlyList GetSubClientInternalConstructorParamete
PipelineProperty.AsParameter
};
+ // The parent passes the options it built from its client options so subclient operations use the same proxies.
+ if (ModelReaderWriterOptionsField != null)
+ {
+ subClientParameters.Add(ModelReaderWriterOptionsField.AsParameter);
+ }
+
// Auth credentials are NOT included here — the parent passes its authenticated
// pipeline, so the sub-client doesn't need separate credential parameters.
subClientParameters.Add(_subClientEndpointParameter);
@@ -624,6 +642,12 @@ private IReadOnlyList GetClientParameters()
public PropertyProvider PipelineProperty { get; }
public FieldProvider EndpointField { get; }
+ ///
+ /// Gets the field holding the the client uses to read and write models, or
+ /// null when the client pipeline options don't carry model proxies.
+ ///
+ public FieldProvider? ModelReaderWriterOptionsField { get; }
+
public IReadOnlyList SubClients => _subClients.Value;
protected override string BuildRelativeFilePath() => Path.Combine("src", "Generated", $"{Name}.cs");
@@ -750,6 +774,11 @@ protected override FieldProvider[] BuildFields()
{
List fields = [EndpointField];
+ if (ModelReaderWriterOptionsField != null)
+ {
+ fields.Add(ModelReaderWriterOptionsField);
+ }
+
if (_apiKeyAuthFields != null)
{
// No longer add AuthField (_keyCredential) — auth is handled via AuthenticationPolicy parameter in the internal constructor
@@ -1361,6 +1390,13 @@ private MethodBodyStatement[] BuildPrimaryConstructorBody(IReadOnlyList().Create(clientOptionsParameter, perRetryPolicies)).Terminate());
}
+ // Creating the pipeline freezes the client options, so the options built here can't change afterwards.
+ if (ModelReaderWriterOptionsField != null)
+ {
+ body.Add(ModelReaderWriterOptionsField.Assign(
+ This.ToApi().GetModelReaderWriterOptions(clientOptionsParameter)).Terminate());
+ }
+
foreach (var f in Fields)
{
var fieldInfo = _apiVersionFields?.FirstOrDefault(fieldInfo => fieldInfo.Field == f);
diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/CollectionResultDefinition.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/CollectionResultDefinition.cs
index 5b636e56dc5..cb3e17d6a45 100644
--- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/CollectionResultDefinition.cs
+++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/CollectionResultDefinition.cs
@@ -29,6 +29,12 @@ public class CollectionResultDefinition : TypeProvider
protected ClientProvider Client { get; }
protected FieldProvider ClientField { get; }
+ ///
+ /// Gets the field holding the client's , or null when the client
+ /// doesn't carry model proxies.
+ ///
+ protected FieldProvider? ModelReaderWriterOptionsField { get; }
+
protected InputOperation Operation { get; }
protected InputPagingServiceMetadata Paging { get; }
@@ -76,6 +82,13 @@ public CollectionResultDefinition(ClientProvider client, InputPagingServiceMetho
Client.Type,
"_client",
this);
+ ModelReaderWriterOptionsField = Client.ModelReaderWriterOptionsField != null
+ ? new FieldProvider(
+ FieldModifiers.Private | FieldModifiers.ReadOnly,
+ typeof(ModelReaderWriterOptions),
+ "_modelReaderWriterOptions",
+ this)
+ : null;
Operation = serviceMethod.Operation;
Paging = serviceMethod.PagingMetadata;
IsAsync = isAsync;
@@ -237,7 +250,10 @@ protected override IReadOnlyList BuildBodyDependencyTypes()
return dependencies;
}
- protected override FieldProvider[] BuildFields() => [ClientField, .. RequestFields];
+ protected override FieldProvider[] BuildFields()
+ => ModelReaderWriterOptionsField != null
+ ? [ClientField, ModelReaderWriterOptionsField, .. RequestFields]
+ : [ClientField, .. RequestFields];
protected override CSharpType[] BuildImplements() =>
(_modelType: ItemModelType, IsAsync) switch
@@ -254,6 +270,12 @@ protected override ConstructorProvider[] BuildConstructors()
"client",
$"The {Client.Type.Name} client used to send requests.",
Client.Type);
+ var modelReaderWriterOptionsParameter = ModelReaderWriterOptionsField != null
+ ? new ParameterProvider(
+ "modelReaderWriterOptions",
+ $"The options used to read the pages, including the model proxies configured on the client options.",
+ typeof(ModelReaderWriterOptions))
+ : null;
return
[
new ConstructorProvider(
@@ -261,30 +283,39 @@ protected override ConstructorProvider[] BuildConstructors()
Type,
$"Initializes a new instance of {Name}, which is used to iterate over the pages of a collection.",
MethodSignatureModifiers.Public,
- [
- clientParameter,
- .. CreateRequestParameters
- ]),
- BuildConstructorBody(clientParameter),
+ modelReaderWriterOptionsParameter != null
+ ? [clientParameter, modelReaderWriterOptionsParameter, .. CreateRequestParameters]
+ : [clientParameter, .. CreateRequestParameters]),
+ BuildConstructorBody(clientParameter, modelReaderWriterOptionsParameter),
this)
];
}
private ValueExpression GetPropertyExpression(IReadOnlyList segments, ValueExpression response)
{
- return BuildGetPropertyExpression(segments, response.CastTo(ResponseModelType));
+ return BuildGetPropertyExpression(segments, ToResponseModel(response));
}
+ // The cast operator can't take the client's options, so it would skip the configured model proxies.
+ private ValueExpression ToResponseModel(ValueExpression response)
+ => ModelReaderWriterOptionsField != null && MrwSerializationTypeDefinition.HasResponseConversion(ResponseModelType)
+ ? Static(ResponseModelType).Invoke(MrwSerializationTypeDefinition.FromResponseMethodName, [response, ModelReaderWriterOptionsField])
+ : response.CastTo(ResponseModelType);
+
protected ValueExpression BuildGetPropertyExpression(IReadOnlyList segments, ValueExpression responseModel)
{
return ResponseModel.GetPropertyExpression(responseModel, segments);
}
- private MethodBodyStatement[] BuildConstructorBody(ParameterProvider clientParameter)
+ private MethodBodyStatement[] BuildConstructorBody(ParameterProvider clientParameter, ParameterProvider? modelReaderWriterOptionsParameter)
{
- var statements = new List(CreateRequestParameters.Count + 1);
+ var statements = new List(CreateRequestParameters.Count + 2);
statements.Add(ClientField.Assign(clientParameter).Terminate());
+ if (ModelReaderWriterOptionsField != null && modelReaderWriterOptionsParameter != null)
+ {
+ statements.Add(ModelReaderWriterOptionsField.Assign(modelReaderWriterOptionsParameter).Terminate());
+ }
for (int parameterNumber = 0; parameterNumber < CreateRequestParameters.Count; parameterNumber++)
{
@@ -502,7 +533,7 @@ private MethodBodyStatement[] BuildGetRawPagesForNextLink()
MethodBodyStatement.EmptyLine,
// Assign nextLinkUri from the result and check if it is null
- AssignAndCheckNextPageVariable(result, result.CastTo(ResponseModelType), nextPageVariable),
+ AssignAndCheckNextPageVariable(result, ToResponseModel(result), nextPageVariable),
// Update message for next iteration
message.Assign(InvokeCreateRequestForNextLink(nextPageVariable)).Terminate()
@@ -537,7 +568,7 @@ private MethodBodyStatement[] BuildGetRawPagesForContinuationToken()
MethodBodyStatement.EmptyLine,
// Assign nextLinkUri from the result and check if it is null
- AssignAndCheckNextPageVariable(result, result.CastTo(ResponseModelType), nextTokenVariable),
+ AssignAndCheckNextPageVariable(result, ToResponseModel(result), nextTokenVariable),
// Update message for next iteration
message.Assign(InvokeCreateRequestForContinuationToken(nextTokenVariable)).Terminate()
diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/DiscriminatedUnionSerialization.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/DiscriminatedUnionSerialization.cs
index f03b2d24cce..59a54d3fae6 100644
--- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/DiscriminatedUnionSerialization.cs
+++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/DiscriminatedUnionSerialization.cs
@@ -67,9 +67,9 @@ internal static MethodProvider[] BuildMethods(InputUnionType union, TypeProvider
.Or(payload.ValueKind().NotEqual(FrameworkEnumValue(JsonValueKind.Object)));
var cases = subtypes.Select(entry => new SwitchCaseStatement(
Literal(entry.Key),
- Return(MrwSerializationTypeDefinition.GetDeserializationMethodInvocationForType(
+ Return(MrwSerializationTypeDefinition.GetProxyAwareDeserializationMethodInvocation(
GetModelType(entry.Value),
- payload, payload.GetUtf8Bytes(), options)))).ToList();
+ payload, payload.GetUtf8Bytes(), options.As())))).ToList();
cases.Add(SwitchCaseStatement.Default(Throw(New.Instance(
Literal($"Unknown discriminator value for union '{union.Name}'.")))));
diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ModelSerializationExtensionsDefinition.ModelProxies.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ModelSerializationExtensionsDefinition.ModelProxies.cs
new file mode 100644
index 00000000000..e2fa78b6b58
--- /dev/null
+++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ModelSerializationExtensionsDefinition.ModelProxies.cs
@@ -0,0 +1,145 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System.ClientModel.Primitives;
+using System.Collections.Generic;
+using Microsoft.TypeSpec.Generator.ClientModel.Snippets;
+using Microsoft.TypeSpec.Generator.Expressions;
+using Microsoft.TypeSpec.Generator.Primitives;
+using Microsoft.TypeSpec.Generator.Providers;
+using Microsoft.TypeSpec.Generator.Snippets;
+using Microsoft.TypeSpec.Generator.Statements;
+using static Microsoft.TypeSpec.Generator.Snippets.Snippet;
+
+namespace Microsoft.TypeSpec.Generator.ClientModel.Providers
+{
+ public sealed partial class ModelSerializationExtensionsDefinition
+ {
+ private const string IsBuildableMethodName = "IsBuildable";
+ internal const string ToWireOptionsMethodName = "ToWireOptions";
+
+ private ProxyReadEligibilityDefinition? _proxyReadEligibility;
+ private ProxyReadEligibilityDefinition ProxyReadEligibility => _proxyReadEligibility ??= new(this, _t);
+
+ protected override TypeProvider[] BuildNestedTypes() => [ProxyReadEligibility];
+
+ private MethodProvider[] BuildModelProxyMethods()
+ {
+ MethodProvider shouldReadThroughProxy = BuildShouldReadThroughProxyMethodProvider();
+ return ScmCodeModelGenerator.Instance.TypeFactory.ClientPipelineApi.ToExpression().SupportsModelProxies
+ ? [shouldReadThroughProxy, BuildToWireOptionsMethodProvider()]
+ : [shouldReadThroughProxy];
+ }
+
+ // Clients keep the shared wire options when no proxies are configured so model reads and writes keep their fast paths.
+ private MethodProvider BuildToWireOptionsMethodProvider()
+ {
+ var modelProxiesParameter = new ParameterProvider("modelProxies", FormattableStringHelpers.Empty, typeof(IList));
+ var signature = new MethodSignature(
+ Name: ToWireOptionsMethodName,
+ Modifiers: _methodModifiers,
+ Parameters: [modelProxiesParameter],
+ ReturnType: typeof(ModelReaderWriterOptions),
+ Description: null,
+ ReturnDescription: null);
+
+ var body = new MethodBodyStatement[]
+ {
+ new IfStatement(modelProxiesParameter.Property(nameof(ICollection.Count)).Equal(Int(0)))
+ {
+ Return(WireOptionsField)
+ },
+ Declare("options", typeof(ModelReaderWriterOptions), New.Instance(typeof(ModelReaderWriterOptions), ModelReaderWriterOptionsSnippets.WireFormat), out var options),
+ new ForEachStatement(typeof(ModelProxy), "proxy", modelProxiesParameter, false, out var proxy)
+ {
+ options.Property(nameof(ModelReaderWriterOptions.Proxies)).Invoke(nameof(IList.Add), proxy).Terminate()
+ },
+ Return(options)
+ };
+
+ return new MethodProvider(signature, body, this, XmlDocProvider.Empty);
+ }
+
+ // ShouldReadThroughProxy(this ModelReaderWriterOptions options, ModelReaderWriterContext context)
+ // => options.Proxies.Count > 0 && ProxyReadEligibility.IsBuildable(context);
+ private MethodProvider BuildShouldReadThroughProxyMethodProvider()
+ {
+ var optionsParameter = new ParameterProvider("options", FormattableStringHelpers.Empty, typeof(ModelReaderWriterOptions));
+ var contextParameter = new ParameterProvider("context", FormattableStringHelpers.Empty, typeof(ModelReaderWriterContext));
+ var signature = new MethodSignature(
+ Name: ModelSerializationExtensionsSnippets.ShouldReadThroughProxyMethodName,
+ Modifiers: _methodModifiers,
+ Parameters: [optionsParameter, contextParameter],
+ ReturnType: typeof(bool),
+ Description: null,
+ ReturnDescription: null,
+ GenericArguments: [_t]);
+
+ var isBuildable = Static(ProxyReadEligibility.Type).Invoke(IsBuildableMethodName, [contextParameter]);
+ var body = Return(optionsParameter.As().ProxiesCount().GreaterThan(Int(0)).And(isBuildable));
+
+ return new MethodProvider(signature, body, this, XmlDocProvider.Empty);
+ }
+
+ ///
+ /// Caches, per model type, whether the generated can build the type so
+ /// nested reads don't repeat the context lookup. Generated code only passes the library's own context, so the
+ /// result for a type never changes.
+ ///
+ private sealed class ProxyReadEligibilityDefinition : TypeProvider
+ {
+ private readonly ModelSerializationExtensionsDefinition _declaringType;
+ private readonly CSharpType _t;
+ private readonly FieldProvider _stateField;
+
+ public ProxyReadEligibilityDefinition(ModelSerializationExtensionsDefinition declaringType, CSharpType t)
+ {
+ _declaringType = declaringType;
+ _t = t;
+ // 0 = unknown, 1 = buildable, 2 = not buildable. An int keeps the cached value tear-free.
+ _stateField = new FieldProvider(FieldModifiers.Private | FieldModifiers.Static, typeof(int), "s_state", this);
+ }
+
+ protected override TypeProvider? BuildDeclaringTypeProvider() => _declaringType;
+
+ protected override string BuildRelativeFilePath() => _declaringType.RelativeFilePath;
+
+ protected override string BuildName() => "ProxyReadEligibility";
+
+ protected override TypeSignatureModifiers BuildDeclarationModifiers()
+ => TypeSignatureModifiers.Private | TypeSignatureModifiers.Static | TypeSignatureModifiers.Class;
+
+ protected override CSharpType[] GetTypeArguments() => [_t];
+
+ protected override FieldProvider[] BuildFields() => [_stateField];
+
+ protected override MethodProvider[] BuildMethods()
+ {
+ var contextParameter = new ParameterProvider("context", FormattableStringHelpers.Empty, typeof(ModelReaderWriterContext));
+ var signature = new MethodSignature(
+ Name: IsBuildableMethodName,
+ Modifiers: MethodSignatureModifiers.Public | MethodSignatureModifiers.Static,
+ Parameters: [contextParameter],
+ ReturnType: typeof(bool),
+ Description: null,
+ ReturnDescription: null);
+
+ var tryGetTypeBuilder = contextParameter.Invoke(
+ nameof(ModelReaderWriterContext.TryGetTypeBuilder),
+ [TypeOf(_t), Identifier("_").AsArgument(isOut: true)]);
+ var body = new MethodBodyStatement[]
+ {
+ Declare("state", typeof(int), _stateField, out var state),
+ new IfStatement(state.Equal(Int(0)))
+ {
+ state.Assign(new TernaryConditionalExpression(tryGetTypeBuilder, Int(1), Int(2))).Terminate(),
+ _stateField.Assign(state).Terminate()
+ },
+ Return(state.Equal(Int(1)))
+ };
+
+ return [new MethodProvider(signature, body, this, XmlDocProvider.Empty)];
+ }
+ }
+ }
+}
diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ModelSerializationExtensionsDefinition.Xml.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ModelSerializationExtensionsDefinition.Xml.cs
index d18f64512ad..e97bcd31e65 100644
--- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ModelSerializationExtensionsDefinition.Xml.cs
+++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ModelSerializationExtensionsDefinition.Xml.cs
@@ -55,6 +55,8 @@ private MethodProvider[] BuildXmlExtensionMethods()
BuildXmlGetDateTimeOffsetMethodProvider(),
BuildXmlGetTimeSpanMethodProvider(),
BuildXmlGetBytesFromBase64MethodProvider(),
+ BuildXmlGetUtf8BytesMethodProvider(),
+ BuildToXmlOptionsMethodProvider(),
BuildXmlWriteStringValueDateTimeOffsetMethodProvider(),
BuildXmlWriteStringValueTimeSpanMethodProvider(),
BuildXmlWriteBase64StringValueMethodProvider(),
@@ -62,6 +64,55 @@ private MethodProvider[] BuildXmlExtensionMethods()
];
}
+ // Re-serializes a nested element, including inherited namespace declarations, so it can be read through ModelReaderWriter.
+ private MethodProvider BuildXmlGetUtf8BytesMethodProvider()
+ {
+ var signature = new MethodSignature(
+ Name: ModelSerializationExtensionsSnippets.GetUtf8BytesMethodName,
+ Modifiers: _methodModifiers,
+ Parameters: [_xElementParameter],
+ ReturnType: typeof(BinaryData),
+ Description: null,
+ ReturnDescription: null);
+
+ var element = _xElementParameter.As();
+ var body = BinaryDataSnippets.FromString(
+ element.Invoke(nameof(XElement.ToString), FrameworkEnumValue(SaveOptions.DisableFormatting)));
+
+ return new MethodProvider(signature, body, this, XmlDocProvider.Empty);
+ }
+
+ // A model that also supports JSON reports "J" for the wire format. When an XML-only parent reads it with "W",
+ // its proxy-aware read must request XML explicitly while keeping the registered proxies.
+ private MethodProvider BuildToXmlOptionsMethodProvider()
+ {
+ var optionsParameter = new ParameterProvider("options", FormattableStringHelpers.Empty, typeof(ModelReaderWriterOptions));
+ var signature = new MethodSignature(
+ Name: ModelSerializationExtensionsSnippets.ToXmlOptionsMethodName,
+ Modifiers: _methodModifiers,
+ Parameters: [optionsParameter],
+ ReturnType: typeof(ModelReaderWriterOptions),
+ Description: null,
+ ReturnDescription: null);
+
+ var options = optionsParameter.As();
+ var body = new MethodBodyStatement[]
+ {
+ new IfStatement(options.Format().Equal(ModelReaderWriterOptionsSnippets.XmlFormat))
+ {
+ Return(options)
+ },
+ Declare("xmlOptions", typeof(ModelReaderWriterOptions), New.Instance(typeof(ModelReaderWriterOptions), ModelReaderWriterOptionsSnippets.XmlFormat), out var xmlOptions),
+ new ForEachStatement(typeof(ModelProxy), "proxy", options.Property(nameof(ModelReaderWriterOptions.Proxies)), false, out var proxy)
+ {
+ xmlOptions.Property(nameof(ModelReaderWriterOptions.Proxies)).Invoke(nameof(IList.Add), proxy).Terminate()
+ },
+ Return(xmlOptions)
+ };
+
+ return new MethodProvider(signature, body, this, XmlDocProvider.Empty);
+ }
+
private MethodProvider BuildXmlGetDateTimeOffsetMethodProvider()
{
var signature = new MethodSignature(
diff --git a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ModelSerializationExtensionsDefinition.cs b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ModelSerializationExtensionsDefinition.cs
index f21d993f23c..fb1c921634b 100644
--- a/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ModelSerializationExtensionsDefinition.cs
+++ b/packages/http-client-csharp/generator/Microsoft.TypeSpec.Generator.ClientModel/src/Providers/ModelSerializationExtensionsDefinition.cs
@@ -191,6 +191,7 @@ protected override MethodProvider[] BuildMethods()
BuildWriteObjectValueMethodGeneric(),
BuildWriteObjectValueMethodProvider(),
BuildGetUtf8BytesMethodProvider(),
+ .. BuildModelProxyMethods(),
.. BuildDynamicModelHelpers(),
.. BuildXmlExtensionMethods(),
];
@@ -673,11 +674,19 @@ private MethodProvider BuildWriteObjectValueMethodGeneric()
};
cases.Add(
BuildWriteObjectValueSwitchCase(new CSharpType(typeof(IJsonModel<>), _t), "jsonModel",
- jsonModel => new MethodBodyStatement[]
+ jsonModel =>
{
- jsonModel.Invoke(nameof(IJsonModel