[csharp] do not use deprecated HttpRequestMessage.Properties (#20737)

ffabss · web-flow · commit 00d16496c850 · 2025-10-21T10:58:47.000+08:00
diff --git a/modules/openapi-generator/src/main/resources/csharp-functions/libraries/httpclient/ApiClient.mustache b/modules/openapi-generator/src/main/resources/csharp-functions/libraries/httpclient/ApiClient.mustache
@@ -167,6 +167,9 @@ namespace {{packageName}}.Client
     /// </remarks>
     {{>visibility}} partial class ApiClient : IDisposable, ISynchronousClient{{#supportsAsync}}, IAsynchronousClient{{/supportsAsync}}
     {
+    {{#net60OrLater}}
+        private static readonly HttpRequestOptionsKey<List<Cookie>> _httpOptionsCookieContainerKey = new("CookieContainer");
+    {{/net60OrLater}}
         private readonly string _baseUrl;
 
         private readonly HttpClientHandler _httpClientHandler;
@@ -382,12 +385,15 @@ namespace {{packageName}}.Client
                 }
             }
 
-
-
             // TODO provide an alternative that allows cookies per request instead of per API client
             if (options.Cookies != null && options.Cookies.Count > 0)
             {
+            {{#net60OrLater}}
+                request.Options.Set(_httpOptionsCookieContainerKey, options.Cookies);
+            {{/net60OrLater}}
+            {{^net60OrLater}}
                 request.Properties["CookieContainer"] = options.Cookies;
+            {{/net60OrLater}}
             }
 
             return request;
@@ -474,9 +480,16 @@ namespace {{packageName}}.Client
                     _httpClientHandler.ClientCertificates.AddRange(configuration.ClientCertificates);
                 }
 
+            {{^net60OrLater}}
                 var cookieContainer = req.Properties.ContainsKey("CookieContainer") ? req.Properties["CookieContainer"] as List<Cookie> : null;
+            {{/net60OrLater}}
 
+            {{#net60OrLater}}
+                if (req.Options.TryGetValue(_httpOptionsCookieContainerKey, out var cookieContainer))
+            {{/net60OrLater}}
+            {{^net60OrLater}}
                 if (cookieContainer != null)
+            {{/net60OrLater}}
                 {
                     if(_httpClientHandler == null) throw new InvalidOperationException("Request property `CookieContainer` not supported when the client is explicitly created without an HttpClientHandler, use the proper constructor.");
                     foreach (var cookie in cookieContainer)
diff --git a/modules/openapi-generator/src/main/resources/csharp/libraries/httpclient/ApiClient.mustache b/modules/openapi-generator/src/main/resources/csharp/libraries/httpclient/ApiClient.mustache
@@ -79,7 +79,7 @@ namespace {{packageName}}.Client
 
         public async Task<T> Deserialize<T>(HttpResponseMessage response)
         {
-            var result = (T) await Deserialize(response, typeof(T)).ConfigureAwait(false);
+            var result = (T)await Deserialize(response, typeof(T)).ConfigureAwait(false);
             return result;
         }
 
@@ -95,13 +95,13 @@ namespace {{packageName}}.Client
             // process response headers, e.g. Access-Control-Allow-Methods
             foreach (var responseHeader in response.Headers)
             {
-                headers.Add(responseHeader.Key + "=" +  ClientUtils.ParameterToString(responseHeader.Value));
+                headers.Add(responseHeader.Key + "=" + ClientUtils.ParameterToString(responseHeader.Value));
             }
 
             // process response content headers, e.g. Content-Type
             foreach (var responseHeader in response.Content.Headers)
             {
-                headers.Add(responseHeader.Key + "=" +  ClientUtils.ParameterToString(responseHeader.Value));
+                headers.Add(responseHeader.Key + "=" + ClientUtils.ParameterToString(responseHeader.Value));
             }
 
             // RFC 2183 & RFC 2616
@@ -112,7 +112,8 @@ namespace {{packageName}}.Client
             }
             else if (type == typeof(FileParameter))
             {
-                if (headers != null) {
+                if (headers != null)
+                {
                     foreach (var header in headers)
                     {
                         var match = fileNameRegex.Match(header.ToString());
@@ -191,6 +192,9 @@ namespace {{packageName}}.Client
     /// </remarks>
     {{>visibility}} partial class ApiClient : IDisposable, ISynchronousClient{{#supportsAsync}}, IAsynchronousClient{{/supportsAsync}}
     {
+    {{#net60OrLater}}
+        private static readonly HttpRequestOptionsKey<List<Cookie>> _httpOptionsCookieContainerKey = new("CookieContainer");
+    {{/net60OrLater}}
         private readonly string _baseUrl;
 
         private readonly HttpClientHandler _httpClientHandler;
@@ -283,7 +287,8 @@ namespace {{packageName}}.Client
         /// </summary>
         public void Dispose()
         {
-            if(_disposeClient) {
+            if(_disposeClient)
+            {
                 _httpClient.Dispose();
             }
         }
@@ -413,7 +418,12 @@ namespace {{packageName}}.Client
             // TODO provide an alternative that allows cookies per request instead of per API client
             if (options.Cookies != null && options.Cookies.Count > 0)
             {
+            {{#net60OrLater}}
+                request.Options.Set(_httpOptionsCookieContainerKey, options.Cookies);
+            {{/net60OrLater}}
+            {{^net60OrLater}}
                 request.Properties["CookieContainer"] = options.Cookies;
+            {{/net60OrLater}}
             }
 
             return request;
@@ -424,7 +434,7 @@ namespace {{packageName}}.Client
 
         private async Task<ApiResponse<T>> ToApiResponse<T>(HttpResponseMessage response, object responseData, Uri uri)
         {
-            T result = (T) responseData;
+            T result = (T)responseData;
             string rawContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
 
             var transformed = new ApiResponse<T>(response.StatusCode, new Multimap<string, string>({{#caseInsensitiveResponseHeaders}}StringComparer.OrdinalIgnoreCase{{/caseInsensitiveResponseHeaders}}), result, rawContent)
@@ -459,7 +469,7 @@ namespace {{packageName}}.Client
                         transformed.Cookies.Add(cookie);
                     }
                 }
-                catch (PlatformNotSupportedException) {}
+                catch (PlatformNotSupportedException) { }
             }
 
             return transformed;
@@ -496,15 +506,22 @@ namespace {{packageName}}.Client
 
                 if (configuration.ClientCertificates != null)
                 {
-                    if(_httpClientHandler == null) throw new InvalidOperationException("Configuration `ClientCertificates` not supported when the client is explicitly created without an HttpClientHandler, use the proper constructor.");
+                    if (_httpClientHandler == null) throw new InvalidOperationException("Configuration `ClientCertificates` not supported when the client is explicitly created without an HttpClientHandler, use the proper constructor.");
                     _httpClientHandler.ClientCertificates.AddRange(configuration.ClientCertificates);
                 }
 
+            {{^net60OrLater}}
                 var cookieContainer = req.Properties.ContainsKey("CookieContainer") ? req.Properties["CookieContainer"] as List<Cookie> : null;
+            {{/net60OrLater}}
 
+            {{#net60OrLater}}
+                if (req.Options.TryGetValue(_httpOptionsCookieContainerKey, out var cookieContainer))
+            {{/net60OrLater}}
+            {{^net60OrLater}}
                 if (cookieContainer != null)
+            {{/net60OrLater}}
                 {
-                    if(_httpClientHandler == null) throw new InvalidOperationException("Request property `CookieContainer` not supported when the client is explicitly created without an HttpClientHandler, use the proper constructor.");
+                    if (_httpClientHandler == null) throw new InvalidOperationException("Request property `CookieContainer` not supported when the client is explicitly created without an HttpClientHandler, use the proper constructor.");
                     foreach (var cookie in cookieContainer)
                     {
                         _httpClientHandler.CookieContainer.Add(cookie);
@@ -546,11 +563,11 @@ namespace {{packageName}}.Client
                 // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
                 if (typeof({{{packageName}}}.{{modelPackage}}.AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
                 {
-                    responseData = (T) typeof(T).GetMethod("FromJson").Invoke(null, new object[] { response.Content });
+                    responseData = (T)typeof(T).GetMethod("FromJson").Invoke(null, new object[] { response.Content });
                 }
                 else if (typeof(T).Name == "Stream") // for binary response
                 {
-                    responseData = (T) (object) await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
+                    responseData = (T)(object) await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
                 }
 
                 InterceptResponse(req, response);
diff --git a/samples/client/petstore/csharp/httpclient/net9/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/httpclient/net9/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -83,7 +83,7 @@ public string Serialize(object obj)
 
         public async Task<T> Deserialize<T>(HttpResponseMessage response)
         {
-            var result = (T) await Deserialize(response, typeof(T)).ConfigureAwait(false);
+            var result = (T)await Deserialize(response, typeof(T)).ConfigureAwait(false);
             return result;
         }
 
@@ -99,13 +99,13 @@ internal async Task<object> Deserialize(HttpResponseMessage response, Type type)
             // process response headers, e.g. Access-Control-Allow-Methods
             foreach (var responseHeader in response.Headers)
             {
-                headers.Add(responseHeader.Key + "=" +  ClientUtils.ParameterToString(responseHeader.Value));
+                headers.Add(responseHeader.Key + "=" + ClientUtils.ParameterToString(responseHeader.Value));
             }
 
             // process response content headers, e.g. Content-Type
             foreach (var responseHeader in response.Content.Headers)
             {
-                headers.Add(responseHeader.Key + "=" +  ClientUtils.ParameterToString(responseHeader.Value));
+                headers.Add(responseHeader.Key + "=" + ClientUtils.ParameterToString(responseHeader.Value));
             }
 
             // RFC 2183 & RFC 2616
@@ -116,7 +116,8 @@ internal async Task<object> Deserialize(HttpResponseMessage response, Type type)
             }
             else if (type == typeof(FileParameter))
             {
-                if (headers != null) {
+                if (headers != null)
+                {
                     foreach (var header in headers)
                     {
                         var match = fileNameRegex.Match(header.ToString());
@@ -195,6 +196,7 @@ public string ContentType
     /// </remarks>
     public partial class ApiClient : IDisposable, ISynchronousClient, IAsynchronousClient
     {
+        private static readonly HttpRequestOptionsKey<List<Cookie>> _httpOptionsCookieContainerKey = new("CookieContainer");
         private readonly string _baseUrl;
 
         private readonly HttpClientHandler _httpClientHandler;
@@ -287,7 +289,8 @@ public ApiClient(HttpClient client, string basePath, HttpClientHandler handler =
         /// </summary>
         public void Dispose()
         {
-            if(_disposeClient) {
+            if(_disposeClient)
+            {
                 _httpClient.Dispose();
             }
         }
@@ -415,7 +418,7 @@ private HttpRequestMessage NewRequest(
             // TODO provide an alternative that allows cookies per request instead of per API client
             if (options.Cookies != null && options.Cookies.Count > 0)
             {
-                request.Properties["CookieContainer"] = options.Cookies;
+                request.Options.Set(_httpOptionsCookieContainerKey, options.Cookies);
             }
 
             return request;
@@ -426,7 +429,7 @@ private HttpRequestMessage NewRequest(
 
         private async Task<ApiResponse<T>> ToApiResponse<T>(HttpResponseMessage response, object responseData, Uri uri)
         {
-            T result = (T) responseData;
+            T result = (T)responseData;
             string rawContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
 
             var transformed = new ApiResponse<T>(response.StatusCode, new Multimap<string, string>(), result, rawContent)
@@ -461,7 +464,7 @@ private async Task<ApiResponse<T>> ToApiResponse<T>(HttpResponseMessage response
                         transformed.Cookies.Add(cookie);
                     }
                 }
-                catch (PlatformNotSupportedException) {}
+                catch (PlatformNotSupportedException) { }
             }
 
             return transformed;
@@ -498,15 +501,14 @@ private async Task<ApiResponse<T>> ExecAsync<T>(HttpRequestMessage req,
 
                 if (configuration.ClientCertificates != null)
                 {
-                    if(_httpClientHandler == null) throw new InvalidOperationException("Configuration `ClientCertificates` not supported when the client is explicitly created without an HttpClientHandler, use the proper constructor.");
+                    if (_httpClientHandler == null) throw new InvalidOperationException("Configuration `ClientCertificates` not supported when the client is explicitly created without an HttpClientHandler, use the proper constructor.");
                     _httpClientHandler.ClientCertificates.AddRange(configuration.ClientCertificates);
                 }
 
-                var cookieContainer = req.Properties.ContainsKey("CookieContainer") ? req.Properties["CookieContainer"] as List<Cookie> : null;
 
-                if (cookieContainer != null)
+                if (req.Options.TryGetValue(_httpOptionsCookieContainerKey, out var cookieContainer))
                 {
-                    if(_httpClientHandler == null) throw new InvalidOperationException("Request property `CookieContainer` not supported when the client is explicitly created without an HttpClientHandler, use the proper constructor.");
+                    if (_httpClientHandler == null) throw new InvalidOperationException("Request property `CookieContainer` not supported when the client is explicitly created without an HttpClientHandler, use the proper constructor.");
                     foreach (var cookie in cookieContainer)
                     {
                         _httpClientHandler.CookieContainer.Add(cookie);
@@ -544,11 +546,11 @@ private async Task<ApiResponse<T>> ExecAsync<T>(HttpRequestMessage req,
                 // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
                 if (typeof(Org.OpenAPITools.Model.AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
                 {
-                    responseData = (T) typeof(T).GetMethod("FromJson").Invoke(null, new object[] { response.Content });
+                    responseData = (T)typeof(T).GetMethod("FromJson").Invoke(null, new object[] { response.Content });
                 }
                 else if (typeof(T).Name == "Stream") // for binary response
                 {
-                    responseData = (T) (object) await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
+                    responseData = (T)(object) await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
                 }
 
                 InterceptResponse(req, response);
diff --git a/samples/client/petstore/csharp/httpclient/standard2.0/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/httpclient/standard2.0/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs

Original file line number	Diff line number	Diff line change
`@@ -167,6 +167,9 @@ namespace {{packageName}}.Client`
`167`	`167`	`/// </remarks>`
`168`	`168`	`{{>visibility}} partial class ApiClient : IDisposable, ISynchronousClient{{#supportsAsync}}, IAsynchronousClient{{/supportsAsync}}`
`169`	`169`	`{`
	`170`	`+ {{#net60OrLater}}`
	`171`	`+ private static readonly HttpRequestOptionsKey<List<Cookie>> _httpOptionsCookieContainerKey = new("CookieContainer");`
	`172`	`+ {{/net60OrLater}}`
`170`	`173`	`private readonly string _baseUrl;`
`171`	`174`
`172`	`175`	`private readonly HttpClientHandler _httpClientHandler;`
`@@ -382,12 +385,15 @@ namespace {{packageName}}.Client`
`382`	`385`	`}`
`383`	`386`	`}`
`384`	`387`
`385`		`-`
`386`		`-`
`387`	`388`	`// TODO provide an alternative that allows cookies per request instead of per API client`
`388`	`389`	`if (options.Cookies != null && options.Cookies.Count > 0)`
`389`	`390`	`{`
	`391`	`+ {{#net60OrLater}}`
	`392`	`+ request.Options.Set(_httpOptionsCookieContainerKey, options.Cookies);`
	`393`	`+ {{/net60OrLater}}`
	`394`	`+ {{^net60OrLater}}`
`390`	`395`	`request.Properties["CookieContainer"] = options.Cookies;`
	`396`	`+ {{/net60OrLater}}`
`391`	`397`	`}`
`392`	`398`
`393`	`399`	`return request;`
`@@ -474,9 +480,16 @@ namespace {{packageName}}.Client`
`474`	`480`	`_httpClientHandler.ClientCertificates.AddRange(configuration.ClientCertificates);`
`475`	`481`	`}`
`476`	`482`
	`483`	`+ {{^net60OrLater}}`
`477`	`484`	`var cookieContainer = req.Properties.ContainsKey("CookieContainer") ? req.Properties["CookieContainer"] as List<Cookie> : null;`
	`485`	`+ {{/net60OrLater}}`
`478`	`486`
	`487`	`+ {{#net60OrLater}}`
	`488`	`+ if (req.Options.TryGetValue(_httpOptionsCookieContainerKey, out var cookieContainer))`
	`489`	`+ {{/net60OrLater}}`
	`490`	`+ {{^net60OrLater}}`
`479`	`491`	`if (cookieContainer != null)`
	`492`	`+ {{/net60OrLater}}`
`480`	`493`	`{`
`481`	`494`	if(_httpClientHandler == null) throw new InvalidOperationException("Request property `CookieContainer` not supported when the client is explicitly created without an HttpClientHandler, use the proper constructor.");
`482`	`495`	`foreach (var cookie in cookieContainer)`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ namespace {{packageName}}.Client`
`79`	`79`
`80`	`80`	`public async Task<T> Deserialize<T>(HttpResponseMessage response)`
`81`	`81`	`{`
`82`		`- var result = (T) await Deserialize(response, typeof(T)).ConfigureAwait(false);`
	`82`	`+ var result = (T)await Deserialize(response, typeof(T)).ConfigureAwait(false);`
`83`	`83`	`return result;`
`84`	`84`	`}`
`85`	`85`
`@@ -95,13 +95,13 @@ namespace {{packageName}}.Client`
`95`	`95`	`// process response headers, e.g. Access-Control-Allow-Methods`
`96`	`96`	`foreach (var responseHeader in response.Headers)`
`97`	`97`	`{`
`98`		`- headers.Add(responseHeader.Key + "=" + ClientUtils.ParameterToString(responseHeader.Value));`
	`98`	`+ headers.Add(responseHeader.Key + "=" + ClientUtils.ParameterToString(responseHeader.Value));`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`// process response content headers, e.g. Content-Type`
`102`	`102`	`foreach (var responseHeader in response.Content.Headers)`
`103`	`103`	`{`
`104`		`- headers.Add(responseHeader.Key + "=" + ClientUtils.ParameterToString(responseHeader.Value));`
	`104`	`+ headers.Add(responseHeader.Key + "=" + ClientUtils.ParameterToString(responseHeader.Value));`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`// RFC 2183 & RFC 2616`
`@@ -112,7 +112,8 @@ namespace {{packageName}}.Client`
`112`	`112`	`}`
`113`	`113`	`else if (type == typeof(FileParameter))`
`114`	`114`	`{`
`115`		`- if (headers != null) {`
	`115`	`+ if (headers != null)`
	`116`	`+ {`
`116`	`117`	`foreach (var header in headers)`
`117`	`118`	`{`
`118`	`119`	`var match = fileNameRegex.Match(header.ToString());`
`@@ -191,6 +192,9 @@ namespace {{packageName}}.Client`
`191`	`192`	`/// </remarks>`
`192`	`193`	`{{>visibility}} partial class ApiClient : IDisposable, ISynchronousClient{{#supportsAsync}}, IAsynchronousClient{{/supportsAsync}}`
`193`	`194`	`{`
	`195`	`+ {{#net60OrLater}}`
	`196`	`+ private static readonly HttpRequestOptionsKey<List<Cookie>> _httpOptionsCookieContainerKey = new("CookieContainer");`
	`197`	`+ {{/net60OrLater}}`
`194`	`198`	`private readonly string _baseUrl;`
`195`	`199`
`196`	`200`	`private readonly HttpClientHandler _httpClientHandler;`
`@@ -283,7 +287,8 @@ namespace {{packageName}}.Client`
`283`	`287`	`/// </summary>`
`284`	`288`	`public void Dispose()`
`285`	`289`	`{`
`286`		`- if(_disposeClient) {`
	`290`	`+ if(_disposeClient)`
	`291`	`+ {`
`287`	`292`	`_httpClient.Dispose();`
`288`	`293`	`}`
`289`	`294`	`}`
`@@ -413,7 +418,12 @@ namespace {{packageName}}.Client`
`413`	`418`	`// TODO provide an alternative that allows cookies per request instead of per API client`
`414`	`419`	`if (options.Cookies != null && options.Cookies.Count > 0)`
`415`	`420`	`{`
	`421`	`+ {{#net60OrLater}}`
	`422`	`+ request.Options.Set(_httpOptionsCookieContainerKey, options.Cookies);`
	`423`	`+ {{/net60OrLater}}`
	`424`	`+ {{^net60OrLater}}`
`416`	`425`	`request.Properties["CookieContainer"] = options.Cookies;`
	`426`	`+ {{/net60OrLater}}`
`417`	`427`	`}`
`418`	`428`
`419`	`429`	`return request;`
`@@ -424,7 +434,7 @@ namespace {{packageName}}.Client`
`424`	`434`
`425`	`435`	`private async Task<ApiResponse<T>> ToApiResponse<T>(HttpResponseMessage response, object responseData, Uri uri)`
`426`	`436`	`{`
`427`		`- T result = (T) responseData;`
	`437`	`+ T result = (T)responseData;`
`428`	`438`	`string rawContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);`
`429`	`439`
`430`	`440`	`var transformed = new ApiResponse<T>(response.StatusCode, new Multimap<string, string>({{#caseInsensitiveResponseHeaders}}StringComparer.OrdinalIgnoreCase{{/caseInsensitiveResponseHeaders}}), result, rawContent)`
`@@ -459,7 +469,7 @@ namespace {{packageName}}.Client`
`459`	`469`	`transformed.Cookies.Add(cookie);`
`460`	`470`	`}`
`461`	`471`	`}`
`462`		`- catch (PlatformNotSupportedException) {}`
	`472`	`+ catch (PlatformNotSupportedException) { }`
`463`	`473`	`}`
`464`	`474`
`465`	`475`	`return transformed;`
`@@ -496,15 +506,22 @@ namespace {{packageName}}.Client`
`496`	`506`
`497`	`507`	`if (configuration.ClientCertificates != null)`
`498`	`508`	`{`
`499`		- if(_httpClientHandler == null) throw new InvalidOperationException("Configuration `ClientCertificates` not supported when the client is explicitly created without an HttpClientHandler, use the proper constructor.");
	`509`	+ if (_httpClientHandler == null) throw new InvalidOperationException("Configuration `ClientCertificates` not supported when the client is explicitly created without an HttpClientHandler, use the proper constructor.");
`500`	`510`	`_httpClientHandler.ClientCertificates.AddRange(configuration.ClientCertificates);`
`501`	`511`	`}`
`502`	`512`
	`513`	`+ {{^net60OrLater}}`
`503`	`514`	`var cookieContainer = req.Properties.ContainsKey("CookieContainer") ? req.Properties["CookieContainer"] as List<Cookie> : null;`
	`515`	`+ {{/net60OrLater}}`
`504`	`516`
	`517`	`+ {{#net60OrLater}}`
	`518`	`+ if (req.Options.TryGetValue(_httpOptionsCookieContainerKey, out var cookieContainer))`
	`519`	`+ {{/net60OrLater}}`
	`520`	`+ {{^net60OrLater}}`
`505`	`521`	`if (cookieContainer != null)`
	`522`	`+ {{/net60OrLater}}`
`506`	`523`	`{`
`507`		- if(_httpClientHandler == null) throw new InvalidOperationException("Request property `CookieContainer` not supported when the client is explicitly created without an HttpClientHandler, use the proper constructor.");
	`524`	+ if (_httpClientHandler == null) throw new InvalidOperationException("Request property `CookieContainer` not supported when the client is explicitly created without an HttpClientHandler, use the proper constructor.");
`508`	`525`	`foreach (var cookie in cookieContainer)`
`509`	`526`	`{`
`510`	`527`	`_httpClientHandler.CookieContainer.Add(cookie);`
`@@ -546,11 +563,11 @@ namespace {{packageName}}.Client`
`546`	`563`	`// if the response type is oneOf/anyOf, call FromJSON to deserialize the data`
`547`	`564`	`if (typeof({{{packageName}}}.{{modelPackage}}.AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))`
`548`	`565`	`{`
`549`		`- responseData = (T) typeof(T).GetMethod("FromJson").Invoke(null, new object[] { response.Content });`
	`566`	`+ responseData = (T)typeof(T).GetMethod("FromJson").Invoke(null, new object[] { response.Content });`
`550`	`567`	`}`
`551`	`568`	`else if (typeof(T).Name == "Stream") // for binary response`
`552`	`569`	`{`
`553`		`- responseData = (T) (object) await response.Content.ReadAsStreamAsync().ConfigureAwait(false);`
	`570`	`+ responseData = (T)(object) await response.Content.ReadAsStreamAsync().ConfigureAwait(false);`
`554`	`571`	`}`
`555`	`572`
`556`	`573`	`InterceptResponse(req, response);`
Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ public string Serialize(object obj)`
`83`	`83`
`84`	`84`	`public async Task<T> Deserialize<T>(HttpResponseMessage response)`
`85`	`85`	`{`
`86`		`- var result = (T) await Deserialize(response, typeof(T)).ConfigureAwait(false);`
	`86`	`+ var result = (T)await Deserialize(response, typeof(T)).ConfigureAwait(false);`
`87`	`87`	`return result;`
`88`	`88`	`}`
`89`	`89`
`@@ -99,13 +99,13 @@ internal async Task<object> Deserialize(HttpResponseMessage response, Type type)`
`99`	`99`	`// process response headers, e.g. Access-Control-Allow-Methods`
`100`	`100`	`foreach (var responseHeader in response.Headers)`
`101`	`101`	`{`
`102`		`- headers.Add(responseHeader.Key + "=" + ClientUtils.ParameterToString(responseHeader.Value));`
	`102`	`+ headers.Add(responseHeader.Key + "=" + ClientUtils.ParameterToString(responseHeader.Value));`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`// process response content headers, e.g. Content-Type`
`106`	`106`	`foreach (var responseHeader in response.Content.Headers)`
`107`	`107`	`{`
`108`		`- headers.Add(responseHeader.Key + "=" + ClientUtils.ParameterToString(responseHeader.Value));`
	`108`	`+ headers.Add(responseHeader.Key + "=" + ClientUtils.ParameterToString(responseHeader.Value));`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`// RFC 2183 & RFC 2616`
`@@ -116,7 +116,8 @@ internal async Task<object> Deserialize(HttpResponseMessage response, Type type)`
`116`	`116`	`}`
`117`	`117`	`else if (type == typeof(FileParameter))`
`118`	`118`	`{`
`119`		`- if (headers != null) {`
	`119`	`+ if (headers != null)`
	`120`	`+ {`
`120`	`121`	`foreach (var header in headers)`
`121`	`122`	`{`
`122`	`123`	`var match = fileNameRegex.Match(header.ToString());`
`@@ -195,6 +196,7 @@ public string ContentType`
`195`	`196`	`/// </remarks>`
`196`	`197`	`public partial class ApiClient : IDisposable, ISynchronousClient, IAsynchronousClient`
`197`	`198`	`{`
	`199`	`+ private static readonly HttpRequestOptionsKey<List<Cookie>> _httpOptionsCookieContainerKey = new("CookieContainer");`
`198`	`200`	`private readonly string _baseUrl;`
`199`	`201`
`200`	`202`	`private readonly HttpClientHandler _httpClientHandler;`
`@@ -287,7 +289,8 @@ public ApiClient(HttpClient client, string basePath, HttpClientHandler handler =`
`287`	`289`	`/// </summary>`
`288`	`290`	`public void Dispose()`
`289`	`291`	`{`
`290`		`- if(_disposeClient) {`
	`292`	`+ if(_disposeClient)`
	`293`	`+ {`
`291`	`294`	`_httpClient.Dispose();`
`292`	`295`	`}`
`293`	`296`	`}`
`@@ -415,7 +418,7 @@ private HttpRequestMessage NewRequest(`
`415`	`418`	`// TODO provide an alternative that allows cookies per request instead of per API client`
`416`	`419`	`if (options.Cookies != null && options.Cookies.Count > 0)`
`417`	`420`	`{`
`418`		`- request.Properties["CookieContainer"] = options.Cookies;`
	`421`	`+ request.Options.Set(_httpOptionsCookieContainerKey, options.Cookies);`
`419`	`422`	`}`
`420`	`423`
`421`	`424`	`return request;`
`@@ -426,7 +429,7 @@ private HttpRequestMessage NewRequest(`
`426`	`429`
`427`	`430`	`private async Task<ApiResponse<T>> ToApiResponse<T>(HttpResponseMessage response, object responseData, Uri uri)`
`428`	`431`	`{`
`429`		`- T result = (T) responseData;`
	`432`	`+ T result = (T)responseData;`
`430`	`433`	`string rawContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);`
`431`	`434`
`432`	`435`	`var transformed = new ApiResponse<T>(response.StatusCode, new Multimap<string, string>(), result, rawContent)`
`@@ -461,7 +464,7 @@ private async Task<ApiResponse<T>> ToApiResponse<T>(HttpResponseMessage response`
`461`	`464`	`transformed.Cookies.Add(cookie);`
`462`	`465`	`}`
`463`	`466`	`}`
`464`		`- catch (PlatformNotSupportedException) {}`
	`467`	`+ catch (PlatformNotSupportedException) { }`
`465`	`468`	`}`
`466`	`469`
`467`	`470`	`return transformed;`
`@@ -498,15 +501,14 @@ private async Task<ApiResponse<T>> ExecAsync<T>(HttpRequestMessage req,`
`498`	`501`
`499`	`502`	`if (configuration.ClientCertificates != null)`
`500`	`503`	`{`
`501`		- if(_httpClientHandler == null) throw new InvalidOperationException("Configuration `ClientCertificates` not supported when the client is explicitly created without an HttpClientHandler, use the proper constructor.");
	`504`	+ if (_httpClientHandler == null) throw new InvalidOperationException("Configuration `ClientCertificates` not supported when the client is explicitly created without an HttpClientHandler, use the proper constructor.");
`502`	`505`	`_httpClientHandler.ClientCertificates.AddRange(configuration.ClientCertificates);`
`503`	`506`	`}`
`504`	`507`
`505`		`- var cookieContainer = req.Properties.ContainsKey("CookieContainer") ? req.Properties["CookieContainer"] as List<Cookie> : null;`
`506`	`508`
`507`		`- if (cookieContainer != null)`
	`509`	`+ if (req.Options.TryGetValue(_httpOptionsCookieContainerKey, out var cookieContainer))`
`508`	`510`	`{`
`509`		- if(_httpClientHandler == null) throw new InvalidOperationException("Request property `CookieContainer` not supported when the client is explicitly created without an HttpClientHandler, use the proper constructor.");
	`511`	+ if (_httpClientHandler == null) throw new InvalidOperationException("Request property `CookieContainer` not supported when the client is explicitly created without an HttpClientHandler, use the proper constructor.");
`510`	`512`	`foreach (var cookie in cookieContainer)`
`511`	`513`	`{`
`512`	`514`	`_httpClientHandler.CookieContainer.Add(cookie);`
`@@ -544,11 +546,11 @@ private async Task<ApiResponse<T>> ExecAsync<T>(HttpRequestMessage req,`
`544`	`546`	`// if the response type is oneOf/anyOf, call FromJSON to deserialize the data`
`545`	`547`	`if (typeof(Org.OpenAPITools.Model.AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))`
`546`	`548`	`{`
`547`		`- responseData = (T) typeof(T).GetMethod("FromJson").Invoke(null, new object[] { response.Content });`
	`549`	`+ responseData = (T)typeof(T).GetMethod("FromJson").Invoke(null, new object[] { response.Content });`
`548`	`550`	`}`
`549`	`551`	`else if (typeof(T).Name == "Stream") // for binary response`
`550`	`552`	`{`
`551`		`- responseData = (T) (object) await response.Content.ReadAsStreamAsync().ConfigureAwait(false);`
	`553`	`+ responseData = (T)(object) await response.Content.ReadAsStreamAsync().ConfigureAwait(false);`
`552`	`554`	`}`
`553`	`555`
`554`	`556`	`InterceptResponse(req, response);`