diff --git a/modules/openapi-generator/src/main/resources/csharp/ApiClient.mustache b/modules/openapi-generator/src/main/resources/csharp/ApiClient.mustache
index 0d826c87c9d0..1cf23cc2bc5b 100644
--- a/modules/openapi-generator/src/main/resources/csharp/ApiClient.mustache
+++ b/modules/openapi-generator/src/main/resources/csharp/ApiClient.mustache
@@ -449,10 +449,9 @@ namespace {{packageName}}.Client
         /// <param name="configuration">A per-request configuration object.
         /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
         /// <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 clientOptions = new RestClientOptions(baseUrl)
             {
                 ClientCertificates = configuration.ClientCertificates,
@@ -486,7 +485,7 @@ namespace {{packageName}}.Client
             {
                 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 (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@@ -582,21 +581,21 @@ namespace {{packageName}}.Client
                 clientOptions.CookieContainer = cookies;
             };
 
-            Func<RestClient, RestResponse<T>> getResponse = (client) =>
+            Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
             {
                 if (RetryConfiguration.RetryPolicy != null)
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
                 }
                 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}}
@@ -607,29 +606,25 @@ namespace {{packageName}}.Client
                 //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}}
-                    if (RetryConfiguration.AsyncRetryPolicy != null)
-                    {
-                        var policy = RetryConfiguration.AsyncRetryPolicy;
-                        var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
-                        return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
-                    }
-                    else
-                    {
-                    {{/supportsRetry}}
-                        return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
-                    {{#supportsRetry}}
-                    }
-                    {{/supportsRetry}}
-                };
-                return action().Result;
+                    var policy = RetryConfiguration.AsyncRetryPolicy;
+                    var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
+                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                }
+                else
+                {
+                {{/supportsRetry}}
+                    return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
+                {{#supportsRetry}}
+                }
+                {{/supportsRetry}}
             };
 
-            return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration));
+            return ExecClientAsync(getResponse, setOptions, request, options, configuration);
         }
 
         #region IAsynchronousClient
diff --git a/samples/client/echo_api/csharp-restsharp/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/echo_api/csharp-restsharp/src/Org.OpenAPITools/Client/ApiClient.cs
index 1f3056ed28e2..e3ae4e14ff07 100644
--- a/samples/client/echo_api/csharp-restsharp/src/Org.OpenAPITools/Client/ApiClient.cs
+++ b/samples/client/echo_api/csharp-restsharp/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -449,10 +449,9 @@ private ApiResponse<T> ToApiResponse<T>(RestResponse<T> response)
         /// <param name="configuration">A per-request configuration object.
         /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
         /// <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 clientOptions = new RestClientOptions(baseUrl)
             {
                 ClientCertificates = configuration.ClientCertificates,
@@ -469,7 +468,7 @@ private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getRespon
             {
                 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 (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@@ -565,21 +564,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 clientOptions.CookieContainer = cookies;
             };
 
-            Func<RestClient, RestResponse<T>> getResponse = (client) =>
+            Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
             {
                 if (RetryConfiguration.RetryPolicy != null)
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
                 }
                 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))
@@ -589,25 +588,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 //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);
-                        return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
-                    }
-                    else
-                    {
-                        return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
-                    }
-                };
-                return action().Result;
+                    var policy = RetryConfiguration.AsyncRetryPolicy;
+                    var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
+                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                }
+                else
+                {
+                    return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
+                }
             };
 
-            return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration));
+            return ExecClientAsync(getResponse, setOptions, request, options, configuration);
         }
 
         #region IAsynchronousClient
diff --git a/samples/client/others/csharp-complex-files/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/others/csharp-complex-files/src/Org.OpenAPITools/Client/ApiClient.cs
index 789c14ac264c..556ac5015243 100644
--- a/samples/client/others/csharp-complex-files/src/Org.OpenAPITools/Client/ApiClient.cs
+++ b/samples/client/others/csharp-complex-files/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -449,10 +449,9 @@ private ApiResponse<T> ToApiResponse<T>(RestResponse<T> response)
         /// <param name="configuration">A per-request configuration object.
         /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
         /// <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 clientOptions = new RestClientOptions(baseUrl)
             {
                 ClientCertificates = configuration.ClientCertificates,
@@ -469,7 +468,7 @@ private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getRespon
             {
                 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 (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@@ -565,21 +564,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 clientOptions.CookieContainer = cookies;
             };
 
-            Func<RestClient, RestResponse<T>> getResponse = (client) =>
+            Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
             {
                 if (RetryConfiguration.RetryPolicy != null)
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
                 }
                 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))
@@ -589,25 +588,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 //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);
-                        return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
-                    }
-                    else
-                    {
-                        return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
-                    }
-                };
-                return action().Result;
+                    var policy = RetryConfiguration.AsyncRetryPolicy;
+                    var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
+                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                }
+                else
+                {
+                    return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
+                }
             };
 
-            return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration));
+            return ExecClientAsync(getResponse, setOptions, request, options, configuration);
         }
 
         #region IAsynchronousClient
diff --git a/samples/client/petstore/csharp/restsharp/net4.7/MultipleFrameworks/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/restsharp/net4.7/MultipleFrameworks/src/Org.OpenAPITools/Client/ApiClient.cs
index 7d3e7d96adf3..1fcf07903a62 100644
--- a/samples/client/petstore/csharp/restsharp/net4.7/MultipleFrameworks/src/Org.OpenAPITools/Client/ApiClient.cs
+++ b/samples/client/petstore/csharp/restsharp/net4.7/MultipleFrameworks/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -450,10 +450,9 @@ private ApiResponse<T> ToApiResponse<T>(RestResponse<T> response)
         /// <param name="configuration">A per-request configuration object.
         /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
         /// <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 clientOptions = new RestClientOptions(baseUrl)
             {
                 ClientCertificates = configuration.ClientCertificates,
@@ -485,7 +484,7 @@ private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getRespon
             {
                 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 (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@@ -581,21 +580,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 clientOptions.CookieContainer = cookies;
             };
 
-            Func<RestClient, RestResponse<T>> getResponse = (client) =>
+            Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
             {
                 if (RetryConfiguration.RetryPolicy != null)
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
                 }
                 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))
@@ -605,25 +604,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 //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);
-                        return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
-                    }
-                    else
-                    {
-                        return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
-                    }
-                };
-                return action().Result;
+                    var policy = RetryConfiguration.AsyncRetryPolicy;
+                    var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
+                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                }
+                else
+                {
+                    return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
+                }
             };
 
-            return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration));
+            return ExecClientAsync(getResponse, setOptions, request, options, configuration);
         }
 
         #region IAsynchronousClient
diff --git a/samples/client/petstore/csharp/restsharp/net4.7/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/restsharp/net4.7/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
index a55d7f34afc6..e383b0f70fed 100644
--- a/samples/client/petstore/csharp/restsharp/net4.7/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
+++ b/samples/client/petstore/csharp/restsharp/net4.7/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -450,10 +450,9 @@ private ApiResponse<T> ToApiResponse<T>(RestResponse<T> response)
         /// <param name="configuration">A per-request configuration object.
         /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
         /// <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 clientOptions = new RestClientOptions(baseUrl)
             {
                 ClientCertificates = configuration.ClientCertificates,
@@ -485,7 +484,7 @@ private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getRespon
             {
                 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 (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@@ -581,21 +580,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 clientOptions.CookieContainer = cookies;
             };
 
-            Func<RestClient, RestResponse<T>> getResponse = (client) =>
+            Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
             {
                 if (RetryConfiguration.RetryPolicy != null)
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
                 }
                 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))
@@ -605,25 +604,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 //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);
-                        return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
-                    }
-                    else
-                    {
-                        return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
-                    }
-                };
-                return action().Result;
+                    var policy = RetryConfiguration.AsyncRetryPolicy;
+                    var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
+                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                }
+                else
+                {
+                    return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
+                }
             };
 
-            return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration));
+            return ExecClientAsync(getResponse, setOptions, request, options, configuration);
         }
 
         #region IAsynchronousClient
diff --git a/samples/client/petstore/csharp/restsharp/net4.8/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/restsharp/net4.8/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
index a55d7f34afc6..e383b0f70fed 100644
--- a/samples/client/petstore/csharp/restsharp/net4.8/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
+++ b/samples/client/petstore/csharp/restsharp/net4.8/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -450,10 +450,9 @@ private ApiResponse<T> ToApiResponse<T>(RestResponse<T> response)
         /// <param name="configuration">A per-request configuration object.
         /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
         /// <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 clientOptions = new RestClientOptions(baseUrl)
             {
                 ClientCertificates = configuration.ClientCertificates,
@@ -485,7 +484,7 @@ private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getRespon
             {
                 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 (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@@ -581,21 +580,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 clientOptions.CookieContainer = cookies;
             };
 
-            Func<RestClient, RestResponse<T>> getResponse = (client) =>
+            Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
             {
                 if (RetryConfiguration.RetryPolicy != null)
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
                 }
                 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))
@@ -605,25 +604,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 //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);
-                        return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
-                    }
-                    else
-                    {
-                        return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
-                    }
-                };
-                return action().Result;
+                    var policy = RetryConfiguration.AsyncRetryPolicy;
+                    var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
+                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                }
+                else
+                {
+                    return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
+                }
             };
 
-            return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration));
+            return ExecClientAsync(getResponse, setOptions, request, options, configuration);
         }
 
         #region IAsynchronousClient
diff --git a/samples/client/petstore/csharp/restsharp/net6/ParameterMappings/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/restsharp/net6/ParameterMappings/src/Org.OpenAPITools/Client/ApiClient.cs
index fe40f39ad5b3..e66ebeceeb22 100644
--- a/samples/client/petstore/csharp/restsharp/net6/ParameterMappings/src/Org.OpenAPITools/Client/ApiClient.cs
+++ b/samples/client/petstore/csharp/restsharp/net6/ParameterMappings/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -448,10 +448,9 @@ private ApiResponse<T> ToApiResponse<T>(RestResponse<T> response)
         /// <param name="configuration">A per-request configuration object.
         /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
         /// <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 clientOptions = new RestClientOptions(baseUrl)
             {
                 ClientCertificates = configuration.ClientCertificates,
@@ -468,7 +467,7 @@ private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getRespon
             {
                 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 (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@@ -564,21 +563,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 clientOptions.CookieContainer = cookies;
             };
 
-            Func<RestClient, RestResponse<T>> getResponse = (client) =>
+            Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
             {
                 if (RetryConfiguration.RetryPolicy != null)
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
                 }
                 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))
@@ -588,25 +587,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 //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);
-                        return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
-                    }
-                    else
-                    {
-                        return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
-                    }
-                };
-                return action().Result;
+                    var policy = RetryConfiguration.AsyncRetryPolicy;
+                    var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
+                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                }
+                else
+                {
+                    return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
+                }
             };
 
-            return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration));
+            return ExecClientAsync(getResponse, setOptions, request, options, configuration);
         }
 
         #region IAsynchronousClient
diff --git a/samples/client/petstore/csharp/restsharp/net7/EnumMappings/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/restsharp/net7/EnumMappings/src/Org.OpenAPITools/Client/ApiClient.cs
index 05e2ddb4de86..3b6edaa8b48c 100644
--- a/samples/client/petstore/csharp/restsharp/net7/EnumMappings/src/Org.OpenAPITools/Client/ApiClient.cs
+++ b/samples/client/petstore/csharp/restsharp/net7/EnumMappings/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -449,10 +449,9 @@ private ApiResponse<T> ToApiResponse<T>(RestResponse<T> response)
         /// <param name="configuration">A per-request configuration object.
         /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
         /// <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 clientOptions = new RestClientOptions(baseUrl)
             {
                 ClientCertificates = configuration.ClientCertificates,
@@ -484,7 +483,7 @@ private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getRespon
             {
                 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 (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@@ -580,21 +579,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 clientOptions.CookieContainer = cookies;
             };
 
-            Func<RestClient, RestResponse<T>> getResponse = (client) =>
+            Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
             {
                 if (RetryConfiguration.RetryPolicy != null)
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
                 }
                 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))
@@ -604,25 +603,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 //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);
-                        return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
-                    }
-                    else
-                    {
-                        return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
-                    }
-                };
-                return action().Result;
+                    var policy = RetryConfiguration.AsyncRetryPolicy;
+                    var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
+                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                }
+                else
+                {
+                    return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
+                }
             };
 
-            return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration));
+            return ExecClientAsync(getResponse, setOptions, request, options, configuration);
         }
 
         #region IAsynchronousClient
diff --git a/samples/client/petstore/csharp/restsharp/net7/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/restsharp/net7/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
index 05e2ddb4de86..3b6edaa8b48c 100644
--- a/samples/client/petstore/csharp/restsharp/net7/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
+++ b/samples/client/petstore/csharp/restsharp/net7/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -449,10 +449,9 @@ private ApiResponse<T> ToApiResponse<T>(RestResponse<T> response)
         /// <param name="configuration">A per-request configuration object.
         /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
         /// <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 clientOptions = new RestClientOptions(baseUrl)
             {
                 ClientCertificates = configuration.ClientCertificates,
@@ -484,7 +483,7 @@ private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getRespon
             {
                 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 (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@@ -580,21 +579,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 clientOptions.CookieContainer = cookies;
             };
 
-            Func<RestClient, RestResponse<T>> getResponse = (client) =>
+            Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
             {
                 if (RetryConfiguration.RetryPolicy != null)
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
                 }
                 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))
@@ -604,25 +603,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 //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);
-                        return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
-                    }
-                    else
-                    {
-                        return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
-                    }
-                };
-                return action().Result;
+                    var policy = RetryConfiguration.AsyncRetryPolicy;
+                    var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
+                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                }
+                else
+                {
+                    return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
+                }
             };
 
-            return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration));
+            return ExecClientAsync(getResponse, setOptions, request, options, configuration);
         }
 
         #region IAsynchronousClient
diff --git a/samples/client/petstore/csharp/restsharp/net7/UseDateTimeForDate/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/restsharp/net7/UseDateTimeForDate/src/Org.OpenAPITools/Client/ApiClient.cs
index 9190dbea600a..c98004a0527b 100644
--- a/samples/client/petstore/csharp/restsharp/net7/UseDateTimeForDate/src/Org.OpenAPITools/Client/ApiClient.cs
+++ b/samples/client/petstore/csharp/restsharp/net7/UseDateTimeForDate/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -448,10 +448,9 @@ private ApiResponse<T> ToApiResponse<T>(RestResponse<T> response)
         /// <param name="configuration">A per-request configuration object.
         /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
         /// <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 clientOptions = new RestClientOptions(baseUrl)
             {
                 ClientCertificates = configuration.ClientCertificates,
@@ -468,7 +467,7 @@ private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getRespon
             {
                 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 (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@@ -564,21 +563,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 clientOptions.CookieContainer = cookies;
             };
 
-            Func<RestClient, RestResponse<T>> getResponse = (client) =>
+            Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
             {
                 if (RetryConfiguration.RetryPolicy != null)
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
                 }
                 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))
@@ -588,25 +587,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 //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);
-                        return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
-                    }
-                    else
-                    {
-                        return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
-                    }
-                };
-                return action().Result;
+                    var policy = RetryConfiguration.AsyncRetryPolicy;
+                    var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
+                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                }
+                else
+                {
+                    return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
+                }
             };
 
-            return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration));
+            return ExecClientAsync(getResponse, setOptions, request, options, configuration);
         }
 
         #region IAsynchronousClient
diff --git a/samples/client/petstore/csharp/restsharp/standard2.0/ConditionalSerialization/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/restsharp/standard2.0/ConditionalSerialization/src/Org.OpenAPITools/Client/ApiClient.cs
index a55d7f34afc6..e383b0f70fed 100644
--- a/samples/client/petstore/csharp/restsharp/standard2.0/ConditionalSerialization/src/Org.OpenAPITools/Client/ApiClient.cs
+++ b/samples/client/petstore/csharp/restsharp/standard2.0/ConditionalSerialization/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -450,10 +450,9 @@ private ApiResponse<T> ToApiResponse<T>(RestResponse<T> response)
         /// <param name="configuration">A per-request configuration object.
         /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
         /// <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 clientOptions = new RestClientOptions(baseUrl)
             {
                 ClientCertificates = configuration.ClientCertificates,
@@ -485,7 +484,7 @@ private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getRespon
             {
                 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 (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@@ -581,21 +580,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 clientOptions.CookieContainer = cookies;
             };
 
-            Func<RestClient, RestResponse<T>> getResponse = (client) =>
+            Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
             {
                 if (RetryConfiguration.RetryPolicy != null)
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
                 }
                 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))
@@ -605,25 +604,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 //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);
-                        return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
-                    }
-                    else
-                    {
-                        return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
-                    }
-                };
-                return action().Result;
+                    var policy = RetryConfiguration.AsyncRetryPolicy;
+                    var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
+                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                }
+                else
+                {
+                    return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
+                }
             };
 
-            return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration));
+            return ExecClientAsync(getResponse, setOptions, request, options, configuration);
         }
 
         #region IAsynchronousClient
diff --git a/samples/client/petstore/csharp/restsharp/standard2.0/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/restsharp/standard2.0/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
index a55d7f34afc6..e383b0f70fed 100644
--- a/samples/client/petstore/csharp/restsharp/standard2.0/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
+++ b/samples/client/petstore/csharp/restsharp/standard2.0/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -450,10 +450,9 @@ private ApiResponse<T> ToApiResponse<T>(RestResponse<T> response)
         /// <param name="configuration">A per-request configuration object.
         /// It is assumed that any merge with GlobalConfiguration has been done before calling this method.</param>
         /// <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 clientOptions = new RestClientOptions(baseUrl)
             {
                 ClientCertificates = configuration.ClientCertificates,
@@ -485,7 +484,7 @@ private ApiResponse<T> ExecClient<T>(Func<RestClient, RestResponse<T>> getRespon
             {
                 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 (typeof(AbstractOpenAPISchema).IsAssignableFrom(typeof(T)))
@@ -581,21 +580,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 clientOptions.CookieContainer = cookies;
             };
 
-            Func<RestClient, RestResponse<T>> getResponse = (client) =>
+            Func<RestClient, Task<RestResponse<T>>> getResponse = (client) =>
             {
                 if (RetryConfiguration.RetryPolicy != null)
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
                 }
                 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))
@@ -605,25 +604,21 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 //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);
-                        return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
-                    }
-                    else
-                    {
-                        return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
-                    }
-                };
-                return action().Result;
+                    var policy = RetryConfiguration.AsyncRetryPolicy;
+                    var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
+                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                }
+                else
+                {
+                    return await client.ExecuteAsync<T>(request, cancellationToken).ConfigureAwait(false);
+                }
             };
 
-            return Task.FromResult<ApiResponse<T>>(ExecClient(getResponse, setOptions, request, options, configuration));
+            return ExecClientAsync(getResponse, setOptions, request, options, configuration);
         }
 
         #region IAsynchronousClient