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

#19176 fix Task.Result directly blocks thread

Browse Source 
- async should never be blocked on the ApiClient
 To fix we invert the logic and use Task as base and keep consistency, we expect and wait result only on synchronous calls.
This commit is contained in:
filipe 2024-07-20 11:01:58 +01:00
parent e542b06869
commit 2fd7c41b3d
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,
@ -485,7 +484,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)))
@ -581,21 +580,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}}
@ -606,29 +605,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,
@ -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/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,
@ -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/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,
@ -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/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,
@ -483,7 +482,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)))
@ -579,21 +578,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))
@ -603,25 +602,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,
@ -483,7 +482,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)))
@ -579,21 +578,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))
@ -603,25 +602,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,
@ -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/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,
@ -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