Added a simple factory with opt-in

Author: alexeyzimarev

docs/v107/interfaces.md

@@ -28,9 +28,8 @@
 | `UseSerializer(Func<IRestSerializer> serializerFactory)`                                        | `RestClient`                       |
 | `UseSerializer<T>()`                                                                            | `RestClient`                       |
 | `Deserialize<T>(IRestResponse response)`                                                        | `RestClient`                       |
-| `BuildUri(IRestRequest request)`                                                                | `RestClient`                       |
-| `UseUrlEncoder(Func<string, string> encoder)`                                                   | Extension                          |
-| `UseQueryEncoder(Func<string, Encoding, string> queryEncoder)`                                  | Extension                          |
+| `UseUrlEncoder(Func<string, string> encoder)`                                                   | `RestClientOptions.Encode`         |
+| `UseQueryEncoder(Func<string, Encoding, string> queryEncoder)`                                  | `RestClientOptions.EncodeQuery`    |
 | `ExecuteAsync<T>(IRestRequest request, CancellationToken cancellationToken)`                    | `RestClient`                       |
 | `ExecuteAsync<T>(IRestRequest request, Method httpMethod, CancellationToken cancellationToken)` | Extension                          |
 | `ExecuteAsync(IRestRequest request, Method httpMethod, CancellationToken cancellationToken)`    | Extension                          |

src/RestSharp/Options/RestClientOptions.cs

@@ -36,9 +36,14 @@ public RestClientOptions() { }
 
     public RestClientOptions(string baseUrl) : this(new Uri(Ensure.NotEmptyString(baseUrl, nameof(baseUrl)))) { }
 
-    /// <inheritdoc/>
+    /// <summary>
+    /// Base URL for all requests made with this client instance
+    /// </summary>
     public Uri? BaseUrl { get; set; }
 
+    /// <summary>
+    /// Custom configuration for the underlying <seealso cref="HttpMessageHandler"/>
+    /// </summary>
     public Func<HttpMessageHandler, HttpMessageHandler>? ConfigureMessageHandler { get; set; }
 
     /// <summary>
@@ -49,15 +54,10 @@ public RestClientOptions(string baseUrl) : this(new Uri(Ensure.NotEmptyString(ba
             ? ResponseStatus.Completed
             : ResponseStatus.Error;
 
-    volatile IAuthenticator? _authenticator;
-
     /// <summary>
     /// Authenticator that will be used to populate request with necessary authentication data
     /// </summary>
-    public IAuthenticator? Authenticator {
-        get => _authenticator;
-        set => _authenticator = value;
-    }
+    public IAuthenticator? Authenticator { get; set; }
 
     /// <summary>
     /// Passed to <see cref="HttpMessageHandler"/> <code>Credentials</code> property
@@ -76,27 +76,52 @@ public IAuthenticator? Authenticator {
     /// </summary>
     public bool DisableCharset { get; set; }
 
+    /// <summary>
+    /// Set the decompression method to use when making requests
+    /// </summary>
 #if NET
     public DecompressionMethods AutomaticDecompression { get; set; } = DecompressionMethods.All;
 #else
     public DecompressionMethods AutomaticDecompression { get; set; } = DecompressionMethods.GZip;
 #endif
 
+    /// <summary>
+    /// Set the maximum number of redirects to follow
+    /// </summary>
     public int? MaxRedirects { get; set; }
 
     /// <summary>
     /// X509CertificateCollection to be sent with request
     /// </summary>
     public X509CertificateCollection? ClientCertificates { get; set; }
 
-    public IWebProxy?               Proxy             { get; set; }
-    public CacheControlHeaderValue? CachePolicy       { get; set; }
-    public bool                     FollowRedirects   { get; set; } = true;
-    public bool?                    Expect100Continue { get; set; } = null;
-    public string?                  UserAgent         { get; set; } = DefaultUserAgent;
+    /// <summary>
+    /// Set the proxy to use when making requests. Default is null, which will use the default system proxy if one is set.
+    /// </summary>
+    public IWebProxy? Proxy { get; set; }
+
+    /// <summary>
+    /// Cache policy to be used for requests using <seealso cref="CacheControlHeaderValue"/>
+    /// </summary>
+    public CacheControlHeaderValue? CachePolicy { get; set; }
+
+    /// <summary>
+    /// Instruct the client to follow redirects. Default is true.
+    /// </summary>
+    public bool FollowRedirects { get; set; } = true;
+
+    /// <summary>
+    /// Gets or sets a value that indicates if the <see langword="Expect" /> header for an HTTP request contains Continue.
+    /// </summary>
+    public bool? Expect100Continue { get; set; } = null;
 
     /// <summary>
-    /// Passed to <see cref="HttpMessageHandler"/> <code>PreAuthenticate</code> property
+    /// Value of the User-Agent header to be sent with requests. Default is "RestSharp/{version}"
+    /// </summary>
+    public string? UserAgent { get; set; } = DefaultUserAgent;
+
+    /// <summary>
+    /// Passed to <see cref="HttpMessageHandler"/> <see langword="PreAuthenticate"/> property
     /// </summary>
     public bool PreAuthenticate { get; set; }
 
@@ -106,6 +131,9 @@ public IAuthenticator? Authenticator {
     /// </summary>
     public RemoteCertificateValidationCallback? RemoteCertificateValidationCallback { get; set; }
 
+    /// <summary>
+    /// Sets the value of the Host header to be sent with requests.
+    /// </summary>
     public string? BaseHost { get; set; }
 
     /// <summary>
@@ -114,23 +142,40 @@ public IAuthenticator? Authenticator {
     /// </summary>
     public int MaxTimeout { get; set; }
 
+    /// <summary>
+    /// Default encoding to use when no encoding is specified in the content type header.
+    /// </summary>
     public Encoding Encoding { get; set; } = Encoding.UTF8;
 
-    /// <inheritdoc />>
+    /// <summary>
+    /// Set to true to throw an exception when a deserialization error occurs. Default is false.
+    /// </summary>
     public bool ThrowOnDeserializationError { get; set; }
 
-    /// <inheritdoc />>
+    /// <summary>
+    /// When set to true, the response status will be set to <see cref="ResponseStatus.Error"/>
+    /// when a deserialization error occurs. Default is true.
+    /// </summary>
     public bool FailOnDeserializationError { get; set; } = true;
 
-    /// <inheritdoc />>
+    /// <summary>
+    /// Set to true to throw an exception when <seealso cref="HttpClient"/> throws an exception when making a request.
+    /// Default is false.
+    /// </summary>
     public bool ThrowOnAnyError { get; set; }
 
-    /// <inheritdoc />>
+    /// <summary>
+    /// Set to true to allow multiple default parameters with the same name. Default is false.
+    /// </summary>
     public bool AllowMultipleDefaultParametersWithSameName { get; set; }
 
-    /// <inheritdoc />>
+    /// <summary>
+    /// Custom function to encode a string for use in a URL.
+    /// </summary>
     public Func<string, string> Encode { get; set; } = s => s.UrlEncode();
 
-    /// <inheritdoc />>
+    /// <summary>
+    /// Custom function to encode a string for use in a URL query.
+    /// </summary>
     public Func<string, Encoding, string> EncodeQuery { get; set; } = (s, encoding) => s.UrlEncode(encoding)!;
 }

src/RestSharp/RestClient.Async.cs

@@ -27,7 +27,7 @@ public async Task<RestResponse> ExecuteAsync(RestRequest request, CancellationTo
                     internalResponse.ResponseMessage!,
                     request,
                     Options.Encoding,
-                    request.CookieContainer?.GetCookies(internalResponse.Url),
+                    internalResponse.CookieContainer?.GetCookies(internalResponse.Url),
                     Options.CalculateResponseStatus,
                     cancellationToken
                 )
@@ -131,14 +131,20 @@ async Task<HttpResponse> ExecuteRequestAsync(RestRequest request, CancellationTo
 
             if (request.OnAfterRequest != null) await request.OnAfterRequest(responseMessage).ConfigureAwait(false);
 
-            return new HttpResponse(responseMessage, url, null, timeoutCts.Token);
+            return new HttpResponse(responseMessage, url, cookieContainer, null, timeoutCts.Token);
         }
         catch (Exception ex) {
-            return new HttpResponse(null, url, ex, timeoutCts.Token);
+            return new HttpResponse(null, url, null, ex, timeoutCts.Token);
         }
     }
 
-    record HttpResponse(HttpResponseMessage? ResponseMessage, Uri Url, Exception? Exception, CancellationToken TimeoutToken);
+    record HttpResponse(
+        HttpResponseMessage? ResponseMessage,
+        Uri                  Url,
+        CookieContainer?     CookieContainer,
+        Exception?           Exception,
+        CancellationToken    TimeoutToken
+    );
 
     static HttpMethod AsHttpMethod(Method method)
         => method switch {

src/RestSharp/RestClient.cs

@@ -37,7 +37,7 @@ public partial class RestClient : IRestClient {
     /// </summary>
     public string[] AcceptedContentTypes { get; set; } = null!;
 
-    HttpClient HttpClient { get; }
+    internal HttpClient HttpClient { get; }
 
     /// <inheritdoc />>
     public ReadOnlyRestClientOptions Options { get; }
@@ -55,24 +55,39 @@ public partial class RestClient : IRestClient {
     /// <param name="options">Client options</param>
     /// <param name="configureDefaultHeaders">Delegate to add default headers to the wrapped HttpClient instance</param>
     /// <param name="configureSerialization">Delegate to configure serialization</param>
+    /// <param name="useClientFactory">Set to true if you wish to reuse the <seealso cref="HttpClient"/> instance</param>
     public RestClient(
         RestClientOptions       options,
         ConfigureHeaders?       configureDefaultHeaders = null,
-        ConfigureSerialization? configureSerialization  = null
+        ConfigureSerialization? configureSerialization  = null,
+        bool                    useClientFactory        = false
     ) {
-        Serializers = new RestSerializers(ConfigureSerializers(configureSerialization));
+        if (useClientFactory && options.BaseUrl == null) {
+            throw new ArgumentException("BaseUrl must be set when using a client factory");
+        }
 
-        Options            = new ReadOnlyRestClientOptions(options);
-        _disposeHttpClient = true;
+        Serializers = new RestSerializers(ConfigureSerializers(configureSerialization));
+        Options     = new ReadOnlyRestClientOptions(options);
 
-        var handler = new HttpClientHandler();
-        ConfigureHttpMessageHandler(handler, Options);
+        if (useClientFactory) {
+            _disposeHttpClient = false;
+            HttpClient         = SimpleClientFactory.GetClient(options.BaseUrl!, GetClient);
+        }
+        else {
+            _disposeHttpClient = true;
+            HttpClient         = GetClient();
+        }
 
-        var finalHandler = options.ConfigureMessageHandler?.Invoke(handler) ?? handler;
+        HttpClient GetClient() {
+            var handler = new HttpClientHandler();
+            ConfigureHttpMessageHandler(handler, Options);
+            var finalHandler = options.ConfigureMessageHandler?.Invoke(handler) ?? handler;
 
-        HttpClient = new HttpClient(finalHandler);
-        ConfigureHttpClient();
-        configureDefaultHeaders?.Invoke(HttpClient.DefaultRequestHeaders);
+            var httpClient = new HttpClient(finalHandler);
+            ConfigureHttpClient(httpClient, options);
+            configureDefaultHeaders?.Invoke(httpClient.DefaultRequestHeaders);
+            return httpClient;
+        }
     }
 
     static RestClientOptions ConfigureOptions(RestClientOptions options, ConfigureRestClient? configureRestClient) {
@@ -86,12 +101,14 @@ static RestClientOptions ConfigureOptions(RestClientOptions options, ConfigureRe
     /// <param name="configureRestClient">Delegate to configure the client options</param>
     /// <param name="configureDefaultHeaders">Delegate to add default headers to the wrapped HttpClient instance</param>
     /// <param name="configureSerialization">Delegate to configure serialization</param>
+    /// <param name="useClientFactory">Set to true if you wish to reuse the <seealso cref="HttpClient"/> instance</param>
     public RestClient(
         ConfigureRestClient?    configureRestClient     = null,
         ConfigureHeaders?       configureDefaultHeaders = null,
-        ConfigureSerialization? configureSerialization  = null
+        ConfigureSerialization? configureSerialization  = null,
+        bool                    useClientFactory        = false
     )
-        : this(ConfigureOptions(new RestClientOptions(), configureRestClient), configureDefaultHeaders, configureSerialization) { }
+        : this(ConfigureOptions(new RestClientOptions(), configureRestClient), configureDefaultHeaders, configureSerialization, useClientFactory) { }
 
     /// <inheritdoc />
     /// <summary>
@@ -101,16 +118,19 @@ public RestClient(
     /// <param name="configureRestClient">Delegate to configure the client options</param>
     /// <param name="configureDefaultHeaders">Delegate to add default headers to the wrapped HttpClient instance</param>
     /// <param name="configureSerialization">Delegate to configure serialization</param>
+    /// <param name="useClientFactory">Set to true if you wish to reuse the <seealso cref="HttpClient"/> instance</param>
     public RestClient(
         Uri                     baseUrl,
         ConfigureRestClient?    configureRestClient     = null,
         ConfigureHeaders?       configureDefaultHeaders = null,
-        ConfigureSerialization? configureSerialization  = null
+        ConfigureSerialization? configureSerialization  = null,
+        bool                    useClientFactory        = false
     )
         : this(
             ConfigureOptions(new RestClientOptions { BaseUrl = baseUrl }, configureRestClient),
             configureDefaultHeaders,
-            configureSerialization
+            configureSerialization,
+            useClientFactory
         ) { }
 
     /// <summary>
@@ -153,7 +173,7 @@ public RestClient(
         var opt = options ?? new RestClientOptions();
         Options = new ReadOnlyRestClientOptions(opt);
 
-        if (options != null) ConfigureHttpClient();
+        if (options != null) ConfigureHttpClient(httpClient, options);
     }
 
     /// <summary>
@@ -187,14 +207,14 @@ public RestClient(
     )
         : this(new HttpClient(handler, disposeHandler), true, configureRestClient, configureSerialization) { }
 
-    void ConfigureHttpClient() {
-        if (Options.MaxTimeout > 0) HttpClient.Timeout = TimeSpan.FromMilliseconds(Options.MaxTimeout);
+    static void ConfigureHttpClient(HttpClient httpClient, RestClientOptions options) {
+        if (options.MaxTimeout > 0) httpClient.Timeout = TimeSpan.FromMilliseconds(options.MaxTimeout);
 
-        if (Options.UserAgent != null && HttpClient.DefaultRequestHeaders.UserAgent.All(x => x.Product?.Name != Options.UserAgent)) {
-            HttpClient.DefaultRequestHeaders.TryAddWithoutValidation(KnownHeaders.UserAgent, Options.UserAgent);
+        if (options.UserAgent != null && httpClient.DefaultRequestHeaders.UserAgent.All(x => x.Product?.Name != options.UserAgent)) {
+            httpClient.DefaultRequestHeaders.TryAddWithoutValidation(KnownHeaders.UserAgent, options.UserAgent);
         }
 
-        if (Options.Expect100Continue != null) HttpClient.DefaultRequestHeaders.ExpectContinue = Options.Expect100Continue;
+        if (options.Expect100Continue != null) httpClient.DefaultRequestHeaders.ExpectContinue = options.Expect100Continue;
     }
 
     static void ConfigureHttpMessageHandler(HttpClientHandler handler, ReadOnlyRestClientOptions options) {

src/RestSharp/Serializers/RestSerializers.cs

@@ -93,7 +93,7 @@ internal RestResponse<T> Deserialize<T>(RestRequest request, RestResponse raw, R
         return factory?.GetSerializer().Deserializer;
 
         ContentType? DetectContentType()
-            => response.Content[0] switch {
+            => response.Content![0] switch {
                 '<'        => ContentType.Xml,
                 '{' or '[' => ContentType.Json,
                 _          => null

src/RestSharp/NameValuePair.cs src/RestSharp/SimpleClientFactory.cssrc/RestSharp/NameValuePair.cs renamed to src/RestSharp/SimpleClientFactory.cs

@@ -1,30 +1,30 @@
 //  Copyright (c) .NET Foundation and Contributors
-// 
+//
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
-// 
+//
 // http://www.apache.org/licenses/LICENSE-2.0
-// 
+//
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+//
+
+using System.Collections.Concurrent;
 
 namespace RestSharp;
 
-[PublicAPI]
-public class NameValuePair {
-    public static NameValuePair Empty = new(null, null);
+static class SimpleClientFactory {
+    static readonly ConcurrentDictionary<string, HttpClient> CachedClients = new();
 
-    public NameValuePair(string? name, string? value) {
-        Name  = name;
-        Value = value;
+    public static HttpClient GetClient(Uri baseUrl, Func<HttpClient> getClient) {
+        var key = baseUrl.ToString();
+        if (CachedClients.TryGetValue(key, out var client)) return client;
+        client = getClient();
+        CachedClients.TryAdd(key, client);
+        return client;
     }
-
-    public string? Name  { get; }
-    public string? Value { get; }
-
-    public bool IsEmpty => Name == null;
-}
+}