HttpEase 1.2.0

HttpEase

Simple, powerful HTTP client for .NET with retry, logging, result wrapper, typed clients, and enterprise-level Polly integration.

Install

dotnet add package HttpEase

Quick Start

Basic Usage

services.AddHttpEase("https://api.example.com");

var client = provider.GetRequiredService<HttpEaseClient>();
var user = await client.GetAsync<User>("/users/1");

Safe Calls with Result Wrapper

var result = await client.TryGetAsync<User>("/users/1");
if(result.Success) 
{
    Console.WriteLine(result.Data);
}
else
{
    Console.WriteLine($"Error: {result.Error}");
}

Typed Client Support (Major Feature)

Create strongly-typed API clients by inheriting from HttpEaseClient:

Step 1: Create Your Typed Client

public class UserApiClient : HttpEaseClient
{
    public UserApiClient(HttpClient http, ILogger<UserApiClient> logger) 
        : base(http, logger)
    {
    }

    public async Task<User?> GetUserAsync(int userId)
    {
        return await GetAsync<User>($"/users/{userId}");
    }

    public async Task<User?> CreateUserAsync(CreateUserRequest request)
    {
        return await PostAsync<CreateUserRequest, User>("/users", request);
    }
}

Step 2: Register in Dependency Injection

// Option 1: Basic typed client
services.AddHttpEaseTypedClient<UserApiClient>("https://api.example.com");

// Option 2: Typed client with Polly policies
var policy = HttpEase.Policies.PollyPolicyFactory.CreateCombinedPolicy();
services.AddHttpEaseTypedClientWithPolly<UserApiClient>(
    "https://api.example.com", 
    policy);

Step 3: Use in Your Application

var userClient = provider.GetRequiredService<UserApiClient>();
var user = await userClient.GetUserAsync(1);
var newUser = await userClient.CreateUserAsync(new CreateUserRequest 
{ 
    Name = "John", 
    Email = "john@example.com" 
});

Polly Integration (Enterprise Level)

Advanced resilience and fault-handling with Polly policies:

Step 1: Configure Policies

// Retry policy
var retryPolicy = HttpEase.Policies.PollyPolicyFactory.CreateRetryPolicy(
    retryCount: 3, 
    delayBetweenRetries: TimeSpan.FromSeconds(1));

// Circuit breaker policy
var circuitBreakerPolicy = HttpEase.Policies.PollyPolicyFactory.CreateCircuitBreakerPolicy(
    failureThreshold: 5,
    timeout: TimeSpan.FromSeconds(30));

// Timeout policy
var timeoutPolicy = HttpEase.Policies.PollyPolicyFactory.CreateTimeoutPolicy(
    timeoutDuration: TimeSpan.FromSeconds(30));

// Combined policy (recommended)
var combinedPolicy = HttpEase.Policies.PollyPolicyFactory.CreateCombinedPolicy(
    retryCount: 3,
    failureThreshold: 5,
    timeoutDuration: TimeSpan.FromSeconds(30),
    circuitBreakerTimeout: TimeSpan.FromSeconds(30),
    retryDelay: TimeSpan.FromSeconds(1));

// Bulkhead isolation policy
var bulkheadPolicy = HttpEase.Policies.PollyPolicyFactory.CreateBulkheadPolicy(
    maxParallelization: 10,
    maxQueuingActions: 5);

Step 2: Apply Policies

// Basic HttpEaseClient with Polly
services.AddHttpEaseWithPolly(
    "https://api.example.com",
    combinedPolicy);

// Typed client with Polly
services.AddHttpEaseTypedClientWithPolly<UserApiClient>(
    "https://api.example.com",
    combinedPolicy);

// Without custom policy (uses smart defaults)
services.AddHttpEaseWithPolly("https://api.example.com");

Available Policies

Real-World Example

// Startup
var productApiPolicy = HttpEase.Policies.PollyPolicyFactory.CreateCombinedPolicy(
    retryCount: 3,
    failureThreshold: 5,
    timeoutDuration: TimeSpan.FromSeconds(10));

services.AddHttpEaseTypedClientWithPolly<ProductApiClient>(
    "https://api.products.com",
    productApiPolicy);

// Usage
public class ProductService
{
    private readonly ProductApiClient _client;

    public ProductService(ProductApiClient client)
    {
        _client = client;
    }

    public async Task<Product?> FetchProductAsync(int id)
    {
        // Automatically handled by Polly policies:
        // - retries on transient failures
        // - fails fast after circuit opens
        // - enforces 10-second timeout
        return await _client.GetProductAsync(id);
    }
}

Core Features

• ✅ Typed Clients - Create strongly-typed API clients
• ✅ Polly Integration - Enterprise resilience policies
• ✅ Retry Support - Configurable retry logic
• ✅ Logging - Built-in logging for all requests
• ✅ Result Wrapper - Safe error handling with Result<T>
• ✅ JSON Serialization - Automatic JSON handling
• ✅ Clean DI - First-class dependency injection support

Examples

See the Examples/ folder for complete implementations:

• UserApiClient.cs - Simple typed client pattern
• ProductApiClient.cs - Error handling with Result<T>

License

MIT