loafle/openapi-generator-original
3
0
Fork 1
mirror of https://github.com/OpenAPITools/openapi-generator.git synced 2025-05-12 12:40:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master-fix#19176' of https://github.com/filipe-silva/openapi-generator into filipe-silva-master-fix#19176b

Browse Source
This commit is contained in:
William Cheng 2024-08-04 18:07:36 +08:00
commit 88ce2cb070
12 changed files with 208 additions and 268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
modules/openapi-generator/src/main/resources/csharp/ApiClient.mustache vendored
View File

@ -449,10 +449,9 @@ namespace {{packageName}}.Client
/// <param name="configuration">A per-request configuration object. /// <param name="configuration">A per-request configuration object.
/// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param> /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
/// <returns>A new ApiResponse instance.</returns> /// <returns>A new ApiResponse instance.</returns>
private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration) private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<RestResponse<T>>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration)
{ {
var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl; var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl;
var clientOptions = new RestClientOptions(baseUrl) var clientOptions = new RestClientOptions(baseUrl)
{ {
ClientCertificates = configuration.ClientCertificates, ClientCertificates = configuration.ClientCertificates,
@ -486,7 +485,7 @@ namespace {{packageName}}.Client
{ {
InterceptRequest(request); InterceptRequest(request);
RestResponse<T> response = getResponse(client); RestResponse<T> response = await getResponse(client);
// if the response type is oneOf/anyOf, call FromJSON to deserialize the data // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T))) if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@ -582,21 +581,21 @@ namespace {{packageName}}.Client
clientOptions.CookieContainer = cookies; clientOptions.CookieContainer = cookies;
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
{ {
if (RetryConfiguration.RetryPolicy != null) if (RetryConfiguration.RetryPolicy != null)
{ {
var policy = RetryConfiguration.RetryPolicy; var policy = RetryConfiguration.RetryPolicy;
var policyResult = policy.ExecuteAndCapture(() => client.Execute(request)); var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
} }
else else
{ {
return client.Execute<T>(request); return Task.FromResult(client.Execute<T>(request));
} }
}; };
return ExecClient(getResponse, setOptions, request, options, configuration); return ExecClientAsync(getResponse, setOptions, request, options, configuration).GetAwaiter().GetResult();
} }
{{#supportsAsync}} {{#supportsAsync}}
@ -607,29 +606,25 @@ namespace {{packageName}}.Client
//no extra options //no extra options
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = async (client) =>
{ {
Func<Task<RestResponse<T>>> action = async () => {{#supportsRetry}}
if (RetryConfiguration.AsyncRetryPolicy != null)
{ {
{{#supportsRetry}} var policy = RetryConfiguration.AsyncRetryPolicy;
if (RetryConfiguration.AsyncRetryPolicy != null) var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
{ return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
var policy = RetryConfiguration.AsyncRetryPolicy; }
var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false); else
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); {
} {{/supportsRetry}}
else return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
{ {{#supportsRetry}}
{{/supportsRetry}} }
return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false); {{/supportsRetry}}
{{#supportsRetry}}
}
{{/supportsRetry}}
};
return action().Result;
}; };
return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration)); return ExecClientAsync(getResponse, setOptions, request, options, configuration);
} }
#region IAsynchronousClient #region IAsynchronousClient

39
samples/client/echo_api/csharp-restsharp/src/Org.OpenAPITools/Client/ApiClient.cs
View File

@ -449,10 +449,9 @@ namespace Org.OpenAPITools.Client
/// <param name="configuration">A per-request configuration object. /// <param name="configuration">A per-request configuration object.
/// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param> /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
/// <returns>A new ApiResponse instance.</returns> /// <returns>A new ApiResponse instance.</returns>
private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration) private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<RestResponse<T>>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration)
{ {
var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl; var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl;
var clientOptions = new RestClientOptions(baseUrl) var clientOptions = new RestClientOptions(baseUrl)
{ {
ClientCertificates = configuration.ClientCertificates, ClientCertificates = configuration.ClientCertificates,
@ -469,7 +468,7 @@ namespace Org.OpenAPITools.Client
{ {
InterceptRequest(request); InterceptRequest(request);
RestResponse<T> response = getResponse(client); RestResponse<T> response = await getResponse(client);
// if the response type is oneOf/anyOf, call FromJSON to deserialize the data // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T))) if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@ -565,21 +564,21 @@ namespace Org.OpenAPITools.Client
clientOptions.CookieContainer = cookies; clientOptions.CookieContainer = cookies;
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
{ {
if (RetryConfiguration.RetryPolicy != null) if (RetryConfiguration.RetryPolicy != null)
{ {
var policy = RetryConfiguration.RetryPolicy; var policy = RetryConfiguration.RetryPolicy;
var policyResult = policy.ExecuteAndCapture(() => client.Execute(request)); var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
} }
else else
{ {
return client.Execute<T>(request); return Task.FromResult(client.Execute<T>(request));
} }
}; };
return ExecClient(getResponse, setOptions, request, options, configuration); return ExecClientAsync(getResponse, setOptions, request, options, configuration).GetAwaiter().GetResult();
} }
private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken)) private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken))
@ -589,25 +588,21 @@ namespace Org.OpenAPITools.Client
//no extra options //no extra options
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = async (client) =>
{ {
Func<Task<RestResponse<T>>> action = async () => if (RetryConfiguration.AsyncRetryPolicy != null)
{ {
if (RetryConfiguration.AsyncRetryPolicy != null) var policy = RetryConfiguration.AsyncRetryPolicy;
{ var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
var policy = RetryConfiguration.AsyncRetryPolicy; return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false); }
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); else
} {
else return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
{ }
return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
}
};
return action().Result;
}; };
return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration)); return ExecClientAsync(getResponse, setOptions, request, options, configuration);
} }
#region IAsynchronousClient #region IAsynchronousClient

39
samples/client/others/csharp-complex-files/src/Org.OpenAPITools/Client/ApiClient.cs
View File

@ -449,10 +449,9 @@ namespace Org.OpenAPITools.Client
/// <param name="configuration">A per-request configuration object. /// <param name="configuration">A per-request configuration object.
/// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param> /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
/// <returns>A new ApiResponse instance.</returns> /// <returns>A new ApiResponse instance.</returns>
private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration) private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<RestResponse<T>>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration)
{ {
var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl; var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl;
var clientOptions = new RestClientOptions(baseUrl) var clientOptions = new RestClientOptions(baseUrl)
{ {
ClientCertificates = configuration.ClientCertificates, ClientCertificates = configuration.ClientCertificates,
@ -469,7 +468,7 @@ namespace Org.OpenAPITools.Client
{ {
InterceptRequest(request); InterceptRequest(request);
RestResponse<T> response = getResponse(client); RestResponse<T> response = await getResponse(client);
// if the response type is oneOf/anyOf, call FromJSON to deserialize the data // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T))) if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@ -565,21 +564,21 @@ namespace Org.OpenAPITools.Client
clientOptions.CookieContainer = cookies; clientOptions.CookieContainer = cookies;
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
{ {
if (RetryConfiguration.RetryPolicy != null) if (RetryConfiguration.RetryPolicy != null)
{ {
var policy = RetryConfiguration.RetryPolicy; var policy = RetryConfiguration.RetryPolicy;
var policyResult = policy.ExecuteAndCapture(() => client.Execute(request)); var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
} }
else else
{ {
return client.Execute<T>(request); return Task.FromResult(client.Execute<T>(request));
} }
}; };
return ExecClient(getResponse, setOptions, request, options, configuration); return ExecClientAsync(getResponse, setOptions, request, options, configuration).GetAwaiter().GetResult();
} }
private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken)) private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken))
@ -589,25 +588,21 @@ namespace Org.OpenAPITools.Client
//no extra options //no extra options
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = async (client) =>
{ {
Func<Task<RestResponse<T>>> action = async () => if (RetryConfiguration.AsyncRetryPolicy != null)
{ {
if (RetryConfiguration.AsyncRetryPolicy != null) var policy = RetryConfiguration.AsyncRetryPolicy;
{ var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
var policy = RetryConfiguration.AsyncRetryPolicy; return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false); }
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); else
} {
else return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
{ }
return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
}
};
return action().Result;
}; };
return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration)); return ExecClientAsync(getResponse, setOptions, request, options, configuration);
} }
#region IAsynchronousClient #region IAsynchronousClient

39
samples/client/petstore/csharp/restsharp/net4.7/MultipleFrameworks/src/Org.OpenAPITools/Client/ApiClient.cs
View File

@ -450,10 +450,9 @@ namespace Org.OpenAPITools.Client
/// <param name="configuration">A per-request configuration object. /// <param name="configuration">A per-request configuration object.
/// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param> /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
/// <returns>A new ApiResponse instance.</returns> /// <returns>A new ApiResponse instance.</returns>
private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration) private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<RestResponse<T>>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration)
{ {
var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl; var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl;
var clientOptions = new RestClientOptions(baseUrl) var clientOptions = new RestClientOptions(baseUrl)
{ {
ClientCertificates = configuration.ClientCertificates, ClientCertificates = configuration.ClientCertificates,
@ -485,7 +484,7 @@ namespace Org.OpenAPITools.Client
{ {
InterceptRequest(request); InterceptRequest(request);
RestResponse<T> response = getResponse(client); RestResponse<T> response = await getResponse(client);
// if the response type is oneOf/anyOf, call FromJSON to deserialize the data // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T))) if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@ -581,21 +580,21 @@ namespace Org.OpenAPITools.Client
clientOptions.CookieContainer = cookies; clientOptions.CookieContainer = cookies;
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
{ {
if (RetryConfiguration.RetryPolicy != null) if (RetryConfiguration.RetryPolicy != null)
{ {
var policy = RetryConfiguration.RetryPolicy; var policy = RetryConfiguration.RetryPolicy;
var policyResult = policy.ExecuteAndCapture(() => client.Execute(request)); var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
} }
else else
{ {
return client.Execute<T>(request); return Task.FromResult(client.Execute<T>(request));
} }
}; };
return ExecClient(getResponse, setOptions, request, options, configuration); return ExecClientAsync(getResponse, setOptions, request, options, configuration).GetAwaiter().GetResult();
} }
private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken)) private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken))
@ -605,25 +604,21 @@ namespace Org.OpenAPITools.Client
//no extra options //no extra options
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = async (client) =>
{ {
Func<Task<RestResponse<T>>> action = async () => if (RetryConfiguration.AsyncRetryPolicy != null)
{ {
if (RetryConfiguration.AsyncRetryPolicy != null) var policy = RetryConfiguration.AsyncRetryPolicy;
{ var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
var policy = RetryConfiguration.AsyncRetryPolicy; return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false); }
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); else
} {
else return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
{ }
return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
}
};
return action().Result;
}; };
return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration)); return ExecClientAsync(getResponse, setOptions, request, options, configuration);
} }
#region IAsynchronousClient #region IAsynchronousClient

39
samples/client/petstore/csharp/restsharp/net4.7/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
View File

@ -450,10 +450,9 @@ namespace Org.OpenAPITools.Client
/// <param name="configuration">A per-request configuration object. /// <param name="configuration">A per-request configuration object.
/// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param> /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
/// <returns>A new ApiResponse instance.</returns> /// <returns>A new ApiResponse instance.</returns>
private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration) private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<RestResponse<T>>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration)
{ {
var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl; var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl;
var clientOptions = new RestClientOptions(baseUrl) var clientOptions = new RestClientOptions(baseUrl)
{ {
ClientCertificates = configuration.ClientCertificates, ClientCertificates = configuration.ClientCertificates,
@ -485,7 +484,7 @@ namespace Org.OpenAPITools.Client
{ {
InterceptRequest(request); InterceptRequest(request);
RestResponse<T> response = getResponse(client); RestResponse<T> response = await getResponse(client);
// if the response type is oneOf/anyOf, call FromJSON to deserialize the data // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T))) if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@ -581,21 +580,21 @@ namespace Org.OpenAPITools.Client
clientOptions.CookieContainer = cookies; clientOptions.CookieContainer = cookies;
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
{ {
if (RetryConfiguration.RetryPolicy != null) if (RetryConfiguration.RetryPolicy != null)
{ {
var policy = RetryConfiguration.RetryPolicy; var policy = RetryConfiguration.RetryPolicy;
var policyResult = policy.ExecuteAndCapture(() => client.Execute(request)); var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
} }
else else
{ {
return client.Execute<T>(request); return Task.FromResult(client.Execute<T>(request));
} }
}; };
return ExecClient(getResponse, setOptions, request, options, configuration); return ExecClientAsync(getResponse, setOptions, request, options, configuration).GetAwaiter().GetResult();
} }
private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken)) private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken))
@ -605,25 +604,21 @@ namespace Org.OpenAPITools.Client
//no extra options //no extra options
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = async (client) =>
{ {
Func<Task<RestResponse<T>>> action = async () => if (RetryConfiguration.AsyncRetryPolicy != null)
{ {
if (RetryConfiguration.AsyncRetryPolicy != null) var policy = RetryConfiguration.AsyncRetryPolicy;
{ var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
var policy = RetryConfiguration.AsyncRetryPolicy; return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false); }
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); else
} {
else return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
{ }
return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
}
};
return action().Result;
}; };
return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration)); return ExecClientAsync(getResponse, setOptions, request, options, configuration);
} }
#region IAsynchronousClient #region IAsynchronousClient

39
samples/client/petstore/csharp/restsharp/net4.8/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
View File

@ -450,10 +450,9 @@ namespace Org.OpenAPITools.Client
/// <param name="configuration">A per-request configuration object. /// <param name="configuration">A per-request configuration object.
/// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param> /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
/// <returns>A new ApiResponse instance.</returns> /// <returns>A new ApiResponse instance.</returns>
private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration) private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<RestResponse<T>>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration)
{ {
var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl; var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl;
var clientOptions = new RestClientOptions(baseUrl) var clientOptions = new RestClientOptions(baseUrl)
{ {
ClientCertificates = configuration.ClientCertificates, ClientCertificates = configuration.ClientCertificates,
@ -485,7 +484,7 @@ namespace Org.OpenAPITools.Client
{ {
InterceptRequest(request); InterceptRequest(request);
RestResponse<T> response = getResponse(client); RestResponse<T> response = await getResponse(client);
// if the response type is oneOf/anyOf, call FromJSON to deserialize the data // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T))) if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@ -581,21 +580,21 @@ namespace Org.OpenAPITools.Client
clientOptions.CookieContainer = cookies; clientOptions.CookieContainer = cookies;
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
{ {
if (RetryConfiguration.RetryPolicy != null) if (RetryConfiguration.RetryPolicy != null)
{ {
var policy = RetryConfiguration.RetryPolicy; var policy = RetryConfiguration.RetryPolicy;
var policyResult = policy.ExecuteAndCapture(() => client.Execute(request)); var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
} }
else else
{ {
return client.Execute<T>(request); return Task.FromResult(client.Execute<T>(request));
} }
}; };
return ExecClient(getResponse, setOptions, request, options, configuration); return ExecClientAsync(getResponse, setOptions, request, options, configuration).GetAwaiter().GetResult();
} }
private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken)) private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken))
@ -605,25 +604,21 @@ namespace Org.OpenAPITools.Client
//no extra options //no extra options
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = async (client) =>
{ {
Func<Task<RestResponse<T>>> action = async () => if (RetryConfiguration.AsyncRetryPolicy != null)
{ {
if (RetryConfiguration.AsyncRetryPolicy != null) var policy = RetryConfiguration.AsyncRetryPolicy;
{ var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
var policy = RetryConfiguration.AsyncRetryPolicy; return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false); }
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); else
} {
else return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
{ }
return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
}
};
return action().Result;
}; };
return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration)); return ExecClientAsync(getResponse, setOptions, request, options, configuration);
} }
#region IAsynchronousClient #region IAsynchronousClient

39
samples/client/petstore/csharp/restsharp/net6/ParameterMappings/src/Org.OpenAPITools/Client/ApiClient.cs
View File

@ -448,10 +448,9 @@ namespace Org.OpenAPITools.Client
/// <param name="configuration">A per-request configuration object. /// <param name="configuration">A per-request configuration object.
/// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param> /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
/// <returns>A new ApiResponse instance.</returns> /// <returns>A new ApiResponse instance.</returns>
private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration) private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<RestResponse<T>>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration)
{ {
var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl; var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl;
var clientOptions = new RestClientOptions(baseUrl) var clientOptions = new RestClientOptions(baseUrl)
{ {
ClientCertificates = configuration.ClientCertificates, ClientCertificates = configuration.ClientCertificates,
@ -468,7 +467,7 @@ namespace Org.OpenAPITools.Client
{ {
InterceptRequest(request); InterceptRequest(request);
RestResponse<T> response = getResponse(client); RestResponse<T> response = await getResponse(client);
// if the response type is oneOf/anyOf, call FromJSON to deserialize the data // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T))) if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@ -564,21 +563,21 @@ namespace Org.OpenAPITools.Client
clientOptions.CookieContainer = cookies; clientOptions.CookieContainer = cookies;
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
{ {
if (RetryConfiguration.RetryPolicy != null) if (RetryConfiguration.RetryPolicy != null)
{ {
var policy = RetryConfiguration.RetryPolicy; var policy = RetryConfiguration.RetryPolicy;
var policyResult = policy.ExecuteAndCapture(() => client.Execute(request)); var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
} }
else else
{ {
return client.Execute<T>(request); return Task.FromResult(client.Execute<T>(request));
} }
}; };
return ExecClient(getResponse, setOptions, request, options, configuration); return ExecClientAsync(getResponse, setOptions, request, options, configuration).GetAwaiter().GetResult();
} }
private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken)) private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken))
@ -588,25 +587,21 @@ namespace Org.OpenAPITools.Client
//no extra options //no extra options
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = async (client) =>
{ {
Func<Task<RestResponse<T>>> action = async () => if (RetryConfiguration.AsyncRetryPolicy != null)
{ {
if (RetryConfiguration.AsyncRetryPolicy != null) var policy = RetryConfiguration.AsyncRetryPolicy;
{ var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
var policy = RetryConfiguration.AsyncRetryPolicy; return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false); }
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); else
} {
else return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
{ }
return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
}
};
return action().Result;
}; };
return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration)); return ExecClientAsync(getResponse, setOptions, request, options, configuration);
} }
#region IAsynchronousClient #region IAsynchronousClient

39
samples/client/petstore/csharp/restsharp/net7/EnumMappings/src/Org.OpenAPITools/Client/ApiClient.cs
View File

@ -449,10 +449,9 @@ namespace Org.OpenAPITools.Client
/// <param name="configuration">A per-request configuration object. /// <param name="configuration">A per-request configuration object.
/// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param> /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
/// <returns>A new ApiResponse instance.</returns> /// <returns>A new ApiResponse instance.</returns>
private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration) private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<RestResponse<T>>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration)
{ {
var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl; var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl;
var clientOptions = new RestClientOptions(baseUrl) var clientOptions = new RestClientOptions(baseUrl)
{ {
ClientCertificates = configuration.ClientCertificates, ClientCertificates = configuration.ClientCertificates,
@ -484,7 +483,7 @@ namespace Org.OpenAPITools.Client
{ {
InterceptRequest(request); InterceptRequest(request);
RestResponse<T> response = getResponse(client); RestResponse<T> response = await getResponse(client);
// if the response type is oneOf/anyOf, call FromJSON to deserialize the data // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T))) if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@ -580,21 +579,21 @@ namespace Org.OpenAPITools.Client
clientOptions.CookieContainer = cookies; clientOptions.CookieContainer = cookies;
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
{ {
if (RetryConfiguration.RetryPolicy != null) if (RetryConfiguration.RetryPolicy != null)
{ {
var policy = RetryConfiguration.RetryPolicy; var policy = RetryConfiguration.RetryPolicy;
var policyResult = policy.ExecuteAndCapture(() => client.Execute(request)); var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
} }
else else
{ {
return client.Execute<T>(request); return Task.FromResult(client.Execute<T>(request));
} }
}; };
return ExecClient(getResponse, setOptions, request, options, configuration); return ExecClientAsync(getResponse, setOptions, request, options, configuration).GetAwaiter().GetResult();
} }
private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken)) private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken))
@ -604,25 +603,21 @@ namespace Org.OpenAPITools.Client
//no extra options //no extra options
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = async (client) =>
{ {
Func<Task<RestResponse<T>>> action = async () => if (RetryConfiguration.AsyncRetryPolicy != null)
{ {
if (RetryConfiguration.AsyncRetryPolicy != null) var policy = RetryConfiguration.AsyncRetryPolicy;
{ var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
var policy = RetryConfiguration.AsyncRetryPolicy; return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false); }
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); else
} {
else return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
{ }
return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
}
};
return action().Result;
}; };
return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration)); return ExecClientAsync(getResponse, setOptions, request, options, configuration);
} }
#region IAsynchronousClient #region IAsynchronousClient

39
samples/client/petstore/csharp/restsharp/net7/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
View File

@ -449,10 +449,9 @@ namespace Org.OpenAPITools.Client
/// <param name="configuration">A per-request configuration object. /// <param name="configuration">A per-request configuration object.
/// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param> /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
/// <returns>A new ApiResponse instance.</returns> /// <returns>A new ApiResponse instance.</returns>
private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration) private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<RestResponse<T>>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration)
{ {
var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl; var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl;
var clientOptions = new RestClientOptions(baseUrl) var clientOptions = new RestClientOptions(baseUrl)
{ {
ClientCertificates = configuration.ClientCertificates, ClientCertificates = configuration.ClientCertificates,
@ -484,7 +483,7 @@ namespace Org.OpenAPITools.Client
{ {
InterceptRequest(request); InterceptRequest(request);
RestResponse<T> response = getResponse(client); RestResponse<T> response = await getResponse(client);
// if the response type is oneOf/anyOf, call FromJSON to deserialize the data // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T))) if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@ -580,21 +579,21 @@ namespace Org.OpenAPITools.Client
clientOptions.CookieContainer = cookies; clientOptions.CookieContainer = cookies;
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
{ {
if (RetryConfiguration.RetryPolicy != null) if (RetryConfiguration.RetryPolicy != null)
{ {
var policy = RetryConfiguration.RetryPolicy; var policy = RetryConfiguration.RetryPolicy;
var policyResult = policy.ExecuteAndCapture(() => client.Execute(request)); var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
} }
else else
{ {
return client.Execute<T>(request); return Task.FromResult(client.Execute<T>(request));
} }
}; };
return ExecClient(getResponse, setOptions, request, options, configuration); return ExecClientAsync(getResponse, setOptions, request, options, configuration).GetAwaiter().GetResult();
} }
private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken)) private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken))
@ -604,25 +603,21 @@ namespace Org.OpenAPITools.Client
//no extra options //no extra options
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = async (client) =>
{ {
Func<Task<RestResponse<T>>> action = async () => if (RetryConfiguration.AsyncRetryPolicy != null)
{ {
if (RetryConfiguration.AsyncRetryPolicy != null) var policy = RetryConfiguration.AsyncRetryPolicy;
{ var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
var policy = RetryConfiguration.AsyncRetryPolicy; return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false); }
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); else
} {
else return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
{ }
return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
}
};
return action().Result;
}; };
return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration)); return ExecClientAsync(getResponse, setOptions, request, options, configuration);
} }
#region IAsynchronousClient #region IAsynchronousClient

39
samples/client/petstore/csharp/restsharp/net7/UseDateTimeForDate/src/Org.OpenAPITools/Client/ApiClient.cs
View File

@ -448,10 +448,9 @@ namespace Org.OpenAPITools.Client
/// <param name="configuration">A per-request configuration object. /// <param name="configuration">A per-request configuration object.
/// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param> /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
/// <returns>A new ApiResponse instance.</returns> /// <returns>A new ApiResponse instance.</returns>
private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration) private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<RestResponse<T>>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration)
{ {
var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl; var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl;
var clientOptions = new RestClientOptions(baseUrl) var clientOptions = new RestClientOptions(baseUrl)
{ {
ClientCertificates = configuration.ClientCertificates, ClientCertificates = configuration.ClientCertificates,
@ -468,7 +467,7 @@ namespace Org.OpenAPITools.Client
{ {
InterceptRequest(request); InterceptRequest(request);
RestResponse<T> response = getResponse(client); RestResponse<T> response = await getResponse(client);
// if the response type is oneOf/anyOf, call FromJSON to deserialize the data // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T))) if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@ -564,21 +563,21 @@ namespace Org.OpenAPITools.Client
clientOptions.CookieContainer = cookies; clientOptions.CookieContainer = cookies;
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
{ {
if (RetryConfiguration.RetryPolicy != null) if (RetryConfiguration.RetryPolicy != null)
{ {
var policy = RetryConfiguration.RetryPolicy; var policy = RetryConfiguration.RetryPolicy;
var policyResult = policy.ExecuteAndCapture(() => client.Execute(request)); var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
} }
else else
{ {
return client.Execute<T>(request); return Task.FromResult(client.Execute<T>(request));
} }
}; };
return ExecClient(getResponse, setOptions, request, options, configuration); return ExecClientAsync(getResponse, setOptions, request, options, configuration).GetAwaiter().GetResult();
} }
private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken)) private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken))
@ -588,25 +587,21 @@ namespace Org.OpenAPITools.Client
//no extra options //no extra options
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = async (client) =>
{ {
Func<Task<RestResponse<T>>> action = async () => if (RetryConfiguration.AsyncRetryPolicy != null)
{ {
if (RetryConfiguration.AsyncRetryPolicy != null) var policy = RetryConfiguration.AsyncRetryPolicy;
{ var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
var policy = RetryConfiguration.AsyncRetryPolicy; return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false); }
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); else
} {
else return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
{ }
return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
}
};
return action().Result;
}; };
return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration)); return ExecClientAsync(getResponse, setOptions, request, options, configuration);
} }
#region IAsynchronousClient #region IAsynchronousClient

39
samples/client/petstore/csharp/restsharp/standard2.0/ConditionalSerialization/src/Org.OpenAPITools/Client/ApiClient.cs
View File

@ -450,10 +450,9 @@ namespace Org.OpenAPITools.Client
/// <param name="configuration">A per-request configuration object. /// <param name="configuration">A per-request configuration object.
/// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param> /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
/// <returns>A new ApiResponse instance.</returns> /// <returns>A new ApiResponse instance.</returns>
private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration) private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<RestResponse<T>>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration)
{ {
var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl; var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl;
var clientOptions = new RestClientOptions(baseUrl) var clientOptions = new RestClientOptions(baseUrl)
{ {
ClientCertificates = configuration.ClientCertificates, ClientCertificates = configuration.ClientCertificates,
@ -485,7 +484,7 @@ namespace Org.OpenAPITools.Client
{ {
InterceptRequest(request); InterceptRequest(request);
RestResponse<T> response = getResponse(client); RestResponse<T> response = await getResponse(client);
// if the response type is oneOf/anyOf, call FromJSON to deserialize the data // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T))) if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@ -581,21 +580,21 @@ namespace Org.OpenAPITools.Client
clientOptions.CookieContainer = cookies; clientOptions.CookieContainer = cookies;
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
{ {
if (RetryConfiguration.RetryPolicy != null) if (RetryConfiguration.RetryPolicy != null)
{ {
var policy = RetryConfiguration.RetryPolicy; var policy = RetryConfiguration.RetryPolicy;
var policyResult = policy.ExecuteAndCapture(() => client.Execute(request)); var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
} }
else else
{ {
return client.Execute<T>(request); return Task.FromResult(client.Execute<T>(request));
} }
}; };
return ExecClient(getResponse, setOptions, request, options, configuration); return ExecClientAsync(getResponse, setOptions, request, options, configuration).GetAwaiter().GetResult();
} }
private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken)) private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken))
@ -605,25 +604,21 @@ namespace Org.OpenAPITools.Client
//no extra options //no extra options
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = async (client) =>
{ {
Func<Task<RestResponse<T>>> action = async () => if (RetryConfiguration.AsyncRetryPolicy != null)
{ {
if (RetryConfiguration.AsyncRetryPolicy != null) var policy = RetryConfiguration.AsyncRetryPolicy;
{ var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
var policy = RetryConfiguration.AsyncRetryPolicy; return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false); }
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); else
} {
else return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
{ }
return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
}
};
return action().Result;
}; };
return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration)); return ExecClientAsync(getResponse, setOptions, request, options, configuration);
} }
#region IAsynchronousClient #region IAsynchronousClient

39
samples/client/petstore/csharp/restsharp/standard2.0/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
View File

@ -450,10 +450,9 @@ namespace Org.OpenAPITools.Client
/// <param name="configuration">A per-request configuration object. /// <param name="configuration">A per-request configuration object.
/// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param> /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
/// <returns>A new ApiResponse instance.</returns> /// <returns>A new ApiResponse instance.</returns>
private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration) private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<RestResponse<T>>> getResponse, Action<RestClientOptions> setOptions, RestRequest request, RequestOptions options, IReadableConfiguration configuration)
{ {
var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl; var baseUrl = configuration.GetOperationServerUrl(options.Operation, options.OperationIndex) ?? _baseUrl;
var clientOptions = new RestClientOptions(baseUrl) var clientOptions = new RestClientOptions(baseUrl)
{ {
ClientCertificates = configuration.ClientCertificates, ClientCertificates = configuration.ClientCertificates,
@ -485,7 +484,7 @@ namespace Org.OpenAPITools.Client
{ {
InterceptRequest(request); InterceptRequest(request);
RestResponse<T> response = getResponse(client); RestResponse<T> response = await getResponse(client);
// if the response type is oneOf/anyOf, call FromJSON to deserialize the data // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T))) if (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@ -581,21 +580,21 @@ namespace Org.OpenAPITools.Client
clientOptions.CookieContainer = cookies; clientOptions.CookieContainer = cookies;
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
{ {
if (RetryConfiguration.RetryPolicy != null) if (RetryConfiguration.RetryPolicy != null)
{ {
var policy = RetryConfiguration.RetryPolicy; var policy = RetryConfiguration.RetryPolicy;
var policyResult = policy.ExecuteAndCapture(() => client.Execute(request)); var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
} }
else else
{ {
return client.Execute<T>(request); return Task.FromResult(client.Execute<T>(request));
} }
}; };
return ExecClient(getResponse, setOptions, request, options, configuration); return ExecClientAsync(getResponse, setOptions, request, options, configuration).GetAwaiter().GetResult();
} }
private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken)) private Task<ApiResponse<T>> ExecAsync<T>(RestRequest request, RequestOptions options, IReadableConfiguration configuration, CancellationToken cancellationToken = default(CancellationToken))
@ -605,25 +604,21 @@ namespace Org.OpenAPITools.Client
//no extra options //no extra options
}; };
Func<RestClient, RestResponse<T>> getResponse = (client) => Func<RestClient, Task<RestResponse<T>>> getResponse = async (client) =>
{ {
Func<Task<RestResponse<T>>> action = async () => if (RetryConfiguration.AsyncRetryPolicy != null)
{ {
if (RetryConfiguration.AsyncRetryPolicy != null) var policy = RetryConfiguration.AsyncRetryPolicy;
{ var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
var policy = RetryConfiguration.AsyncRetryPolicy; return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false); }
return DeserializeRestResponseFromPolicy<T>(client, request, policyResult); else
} {
else return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
{ }
return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
}
};
return action().Result;
}; };
return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration)); return ExecClientAsync(getResponse, setOptions, request, options, configuration);
} }
#region IAsynchronousClient #region IAsynchronousClient