Install-Package Monq.Core.HttpClientExtensions

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigBasicHttpService()
        .ConfigureWebHostDefaults(webBuilder => webBuilder.UseStartup<Startup>());

hostBuilder.ConfigBasicHttpService(opts =>
{
    var headerOptions = new RestHttpClientHeaderOptions();
    headerOptions.AddForwardedHeader(MicroserviceConstants.EventIdHeader);
    headerOptions.AddForwardedHeader(MicroserviceConstants.UserspaceIdHeader);

    opts.ConfigHeaders(headerOptions);
});

{
	public void ConfigureServices(IServiceCollection services)
    {
		....
		RestHttpClientSerializer.UseSystemTextJson(options => options.PropertyNamingPolicy = System.Text.Json.JsonNamingPolicy.CamelCase); // Use System.Text.Json with options.
        RestHttpClientSerializer.UseNewtonsoftJson(); // Use NewtonsoftJson. Default.
	}
}

new Newtonsoft.Json.JsonSerializerSettings() { ContractResolver = new Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver
{
    NamingStrategy = new Newtonsoft.Json.Serialization.CamelCaseNamingStrategy
    {
        ProcessDictionaryKeys = true
    }
}};

new System.Text.Json.JsonSerializerOptions
{
    PropertyNamingPolicy = System.Text.Json.JsonNamingPolicy.CamelCase,
    DictionaryKeyPolicy = System.Text.Json.JsonNamingPolicy.CamelCase,
    PropertyNameCaseInsensitive = true
};

hostBuilder.ConfigureStaticAuthentication();

{
  "Authentication": {
    "AuthenticationEndpoint": "https://smon.monq.ru",
    "Client": {
        "Login": "idp-client",
        "Password": "idp-client-secret"
    },
    "RequireHttpsMetadata": false
  }
}

using IdentityModel.Client;
using Monq.Core.HttpClientExtensions.Exceptions;
using System.Net.Http;
using System.Threading.Tasks;

...

RestHttpClient.AuthorizationRequest += RestHttpClientAuthorizationRequest;

static async Task<TokenResponse> RestHttpClientAuthorizationRequest(HttpClient client)
{
    var authEndpoint = "";
    var requireHttps = true;
    var clientId = "";
    var clientSecret = "";
    var scope = "scope1 scope2";

    var discoveryDocumentRequest = new DiscoveryDocumentRequest
    {
        Address = authEndpoint,
        Policy = new DiscoveryPolicy { RequireHttps = requireHttps }
    };
    var disco = await client.GetDiscoveryDocumentAsync(discoveryDocumentRequest);
    if (disco.IsError) throw new DiscoveryEndpointException(disco.Error, disco.Exception);

    var request = new ClientCredentialsTokenRequest
    {
        Address = disco.TokenEndpoint,
        ClientId = clientId,
        ClientSecret = clientSecret,
        Scope = scope
    };

    var response = await client.RequestClientCredentialsTokenAsync(request);
    return response;
}

public class ServiceUriOptions
{
    public string ServiceUri { get; set; } = default!;
}

public class RemoteServiceModel
{
    public int UserId { get; set; }
    public int Id { get; set; }
    public string Title { get; set; } = default!;
    public string Body { get; set; } = default!;
}

public interface IRemoteServiceApiHttpService
{
    Task<IList<RemoteServiceModel>> GetAllInstances();
}

public class DefaultRemoteServiceApiHttpService : RestHttpClientFromOptions<ServiceUriOptions>, IRemoteServiceApiHttpService
{
    public DefaultRemoteServiceApiHttpService(IOptions<ServiceUriOptions> optionsAccessor,
            HttpClient httpClient,
            ILoggerFactory loggerFactory,
            RestHttpClientOptions configuration,
            IHttpContextAccessor httpContextAccessor)
        : base(optionsAccessor,
                httpClient,
                loggerFactory,
                configuration,
                httpContextAccessor,
                optionsAccessor.Value.ServiceUri)
    {
    }

    public async Task<IList<RemoteServiceModel>> GetAllInstances()
    {
        var uri = "api/instances";
        var result = await Get<IList<RemoteServiceModel>>(uri, TimeSpan.FromSeconds(10));

        return result.ResultObject;
    }
}

public class Startup
{
	public void ConfigureServices(IServiceCollection services)
    {
		....
		services.AddOptions();
        services.Configure<ServiceUriOptions>(Configuration.GetSection("Services"));

		services.AddHttpClient<IRemoteServiceApiHttpService, DefaultRemoteServiceApiHttpService>();
	}
}

public class CachedRemoteServiceApiHttpService : RestHttpClientFromOptions<ServiceUriOptions>, IRemoteServiceApiHttpService
{
    readonly IMemoryCache _memoryCache;

    public CachedRemoteServiceApiHttpService(IOptions<ServiceUriOptions> optionsAccessor,
            HttpClient httpClient,
            ILoggerFactory loggerFactory,
            RestHttpClientOptions configuration,
            IHttpContextAccessor httpContextAccessor 
            IMemoryCache memoryCache)
        : base(optionsAccessor,
                httpClient,
                loggerFactory,
                configuration,
                httpContextAccessor,
                optionsAccessor.Value.ServiceUri)
    {
        _memoryCache = memoryCache;
    }
	..........
}

ILogger<DefaultRemoteServiceApiHttpService> log

public async Task<RestHttpResponseMessage<IList<RemoteServiceModel>> GetAllInstances()
{
    var uri = "api/instances";
    var result = await Get<IList<RemoteServiceModel>>(uri, TimeSpan.FromSeconds(10));

    return result;
}

using Monq.Core.HttpClientExtensions.Extensions;

public async Task<RestHttpResponseMessage<IList<RemoteServiceModel>> FilterInstances(RemoteServiceFilter filter)
{
    if (filter is null || filter.Prop is null)
        return RestHttpResponseMessageWrapper.Empty<IEnumerable<ConnectorMinimalViewModel>>(); // using the response wrapper.

    var uri = "api/instances";
    var result = await Get<IList<RemoteServiceModel>>(uri, TimeSpan.FromSeconds(10));

    return result;
}

public async Task<TestModel> TestApi(string auth)
{
    var headers = new HeaderDictionary();
    headers.Add("Authorization", $"Bearer {auth}");

    var result = await Get<TestModel>("posts/1", TimeSpan.FromSeconds(10), headers);

    return result.ResultObject!;
}

using Polly;
using Polly.Extensions.Http;

public class Startup
{
	public void ConfigureServices(IServiceCollection services)
    {
		....
		services.AddHttpClient<IRemoteServiceApiHttpService, DefaultRemoteServiceApiHttpService>()
            .AddPolicyHandler(GetCircuitBreakerPolicy());
	}

    static IAsyncPolicy<HttpResponseMessage> GetCircuitBreakerPolicy()
    {
        return HttpPolicyExtensions
            .HandleTransientHttpError()
            .CircuitBreakerAsync(2, TimeSpan.FromSeconds(30));
    }
}

public class DefaultRemoteServiceApiHttpServiceTests
{
	readonly ILogger<DefaultRemoteServiceApiHttpService> _logger;
	readonly Mock<IOptions<ServiceUriOptions>> _serviceUriOptionsMock;

	public DefaultRemoteServiceApiHttpServiceTests()
    {
        _logger = new StubLogger<DefaultRemoteServiceApiHttpService>();

        _serviceUriOptionsMock = new Mock<IOptions<ServiceUriOptions>>();
        _serviceUriOptionsMock.Setup(x => x.Value)
            .Returns(new ServiceUriOptions() {
                ServiceUri = "https://jsonplaceholder.typicode.com"
            });
    }

    [Fact]
	public async Task ShouldProperlyGetAllInstances()
	{
		var model = new RemoteServiceModel() { UserId = 1532 };
		var modelJson = JsonConvert.SerializeObject(new List<RemoteServiceModel>() { model });

        var mockHttpMessageHandler = new Mock<HttpMessageHandler>();

        mockHttpMessageHandler.Protected()
            .Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(), ItExpr.IsAny<CancellationToken>())
            .ReturnsAsync(new HttpResponseMessage
            {
                StatusCode = HttpStatusCode.OK,
                Content = new StringContent(modelJson),
            });

        var client = new HttpClient(mockHttpMessageHandler.Object);

		var apiService = CreateApiService(client);

		var instances = await apiService.GetAllInstances();

        Assert.Equal(1, instances.Count())
        var firstInstance = instances.First();
		Assert.Equal(model.UserId, firstInstance.UserId);
	}

	DefaultRemoteServiceApiHttpService CreateApiService(HttpClient httpClient, HttpContext? httpContext, IOptions<ServiceOptions> optionsAccessor)
	{
		return new DefaultRemoteServiceApiHttpService(optionsAccessor ?? _optionsMoq.Object,
                       httpClient,
                       _loggerFactory,
                       null,
                       new HttpContextAccessorStub(httpContext ?? new DefaultHttpContext()),
                       optionsAccessor.Value.ServiceUri);
	}
}