The Most Impactful .net core interview questions

// Advanced retry policy with exponential backoff
public class ResilientHttpService
{
    private readonly HttpClient _httpClient;
    private readonly IAsyncPolicy<HttpResponseMessage> _retryPolicy;
    private readonly ILogger<ResilientHttpService> _logger;
    
    public ResilientHttpService(HttpClient httpClient, ILogger<ResilientHttpService> logger)
    {
        _httpClient = httpClient;
        _logger = logger;
        
        // Retry policy with exponential backoff and jitter
        _retryPolicy = Policy
            .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
            .Or<HttpRequestException>()
            .Or<TaskCanceledException>()
            .WaitAndRetryAsync(
                retryCount: 3,
                sleepDurationProvider: retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))
                    .Add(TimeSpan.FromMilliseconds(Random.Shared.Next(0, 1000))), // Add jitter
                onRetry: (outcome, timespan, retryCount, context) =>
                {
                    _logger.LogWarning("Retry {RetryCount} for {OperationKey} in {Delay}ms",
                    retryCount, context.OperationKey, timespan.TotalMilliseconds);
            });
    }
    
    public async Task<T> GetAsync<T>(string endpoint, CancellationToken cancellationToken = default)
    {
        var context = new Context(endpoint);
        
        var response = await _retryPolicy.ExecuteAsync(async (ctx) =>
        {
            _logger.LogInformation("Attempting HTTP GET to {Endpoint}", endpoint);
            return await _httpClient.GetAsync(endpoint, cancellationToken);
        }, context);
        
        var content = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize<T>(content);
    }
}
// Circuit breaker with retry combination
public class ResilientServiceClient
{
    private readonly HttpClient _httpClient;
    private readonly IAsyncPolicy<HttpResponseMessage> _combinedPolicy;
    
    public ResilientServiceClient(HttpClient httpClient)
    {
        _httpClient = httpClient;
        
        // Retry policy
        var retryPolicy = Policy
            .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
            .WaitAndRetryAsync(
                retryCount: 3,
                sleepDurationProvider: retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));
        
        // Circuit breaker policy
        var circuitBreakerPolicy = Policy
            .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
            .CircuitBreakerAsync(
                handledEventsAllowedBeforeBreaking: 3,
                durationOfBreak: TimeSpan.FromSeconds(30),
                onBreak: (result, timespan) =>
                {
                    Console.WriteLine($"Circuit breaker opened for {timespan}");
                },
                onReset: () =>
                {
                    Console.WriteLine("Circuit breaker reset");
                });
        
        // Timeout policy
        var timeoutPolicy = Policy.TimeoutAsync<HttpResponseMessage>(TimeSpan.FromSeconds(10));
        
        // Combine policies: Timeout -> Retry -> Circuit Breaker
        _combinedPolicy = Policy.WrapAsync(retryPolicy, circuitBreakerPolicy, timeoutPolicy);
    }
    
    public async Task<ApiResponse<T>> CallServiceAsync<T>(string endpoint)
    {
        try
        {
            var response = await _combinedPolicy.ExecuteAsync(async () =>
            {
                return await _httpClient.GetAsync(endpoint);
            });
            
            var content = await response.Content.ReadAsStringAsync();
            var data = JsonSerializer.Deserialize<T>(content);
            
            return new ApiResponse<T>
            {
                IsSuccess = true,
                Data = data
            };
        }
        catch (CircuitBreakerOpenException)
        {
            return new ApiResponse<T>
            {
                IsSuccess = false,
                ErrorMessage = "Service temporarily unavailable"
            };
        }
        catch (TimeoutRejectedException)
        {
            return new ApiResponse<T>
            {
                IsSuccess = false,
                ErrorMessage = "Request timeout"
            };
        }
    }
}
// Polly registry for centralized policy management
public static class PolicyRegistry
{
    public static IAsyncPolicy<HttpResponseMessage> GetRetryPolicy(string policyName)
    {
        return policyName switch
        {
            "aggressive-retry" => Policy
                .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
                .WaitAndRetryAsync(5, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))),
                
            "gentle-retry" => Policy
                .HandleResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
                .WaitAndRetryAsync(2, retryAttempt => TimeSpan.FromSeconds(retryAttempt)),
                
            _ => Policy.NoOpAsync<HttpResponseMessage>()
        };
    }
}
// Dependency injection setup
services.AddHttpClient<ResilientHttpService>()
    .AddPolicyHandler(PolicyRegistry.GetRetryPolicy("aggressive-retry"));