‫برنامه‌نویسی با الهام از هوش مصنوعی: ساخت کلاینت‌های HTTP تاب‌آور در دات‌نت

• سیستم باید موجودی موز را از سیستم انبار خارجی دریافت کند.
• سیستم باید بیش از ۱۰۰ آیتم موجودی موز را در هر صفحه نمایش دهد.
• سیستم باید محتوای موجودی موز را در سمت سرور رندر کند.
• سیستم باید وضعیت موجودی را برای هر SKU موز (Stock Keeping Unit - واحد نگهداری موجودی) به درستی نمایش دهد (موجود، ناموجود، نامعلوم).

• موجود (Available)
• ناموجود (Unavailable)
• نامعلوم (Unknown)
• خطاهای جزئی (Partial Errors)
• صفحه‌بندی (Pagination)
• SKUs موز گمشده (Missing Banana SKUs)

• استفاده از درخواست‌های دسته‌ای (Batched SKU-based Requests): برای کاهش تعداد فراخوانی‌های شبکه خارجی.
• به تعویق انداختن بازیابی داده‌های در دسترس بودن (Defer Availability Data Retrieval): تا پس از فاز هیدراسیون (Hydration) React، با استفاده از یک نقطه پایانی /api/availability اختصاصی.
• حفظ سرعت و مقاومت رندر سمت سرور (SSR): با انتقال بارگذاری داده‌های بلادرنگ به سمت کلاینت.
• پیاده‌سازی تخریب تدریجی (Graceful Degradation): برای جلوگیری از مسدود شدن رندر صفحه.

• تلاش مجدد (Retry): برای خطاهای موقتی که ممکن است با تکرار عملیات برطرف شوند.
• مدارشکن (Circuit Breaker): برای جلوگیری از اضافه بار سیستم هنگامی که سرویس خارجی غیرقابل دسترس می‌شود. این الگو از ارسال درخواست‌های بیشتر به یک سرویس ناسالم جلوگیری می‌کند.
• مهلت زمانی (Timeout): برای کنترل فراخوانی‌های طولانی‌مدت و جلوگیری از آویزان شدن برنامه.
• ایزولاسیون بالک‌هد (Bulkhead Isolation): برای محدود کردن تعداد درخواست‌های هم‌زمان (Concurrent Requests) و جلوگیری از اتمام رشته‌ها (Thread Exhaustion) و ایزولاسیون خطاها.
• کش کوتاه‌مدت (Short-lived Caching): برای جذب بارهای ناگهانی (Load Bursts) و در عین حال حفظ تازگی داده‌ها.

• یکپارچگی با HttpClientFactory: برای ایجاد نمونه‌های HttpClient به منظور ارتباط با سیستم خارجی.
• کش توزیع‌شده (Distributed Caching): برای ذخیره و بازیابی کارآمد داده‌ها (با استفاده از IDistributedCache و گزینه InMemory برای تست).
• الگوی مدارشکن (Circuit Breaker Pattern): با استفاده از Polly برای نظارت بر در دسترس بودن سیستم خارجی. هنگامی که سیستم خارجی غیرقابل پاسخ می‌شود، مدار باید باز شود تا از فراخوانی‌های بیشتر جلوگیری شود.
• بازگشت به کش (Fallback to Cache): هنگامی که مدارشکن باز است، کلاینت باید پاسخ‌ها را از کش توزیع‌شده ارائه دهد و از برقراری تماس با سیستم خارجی تا زمان سالم شدن مجدد آن خودداری کند.
• ابطال کش (Cache Invalidation): اگر سیستم خارجی برای مدت زمان پیکربندی شده‌ای غیرقابل پاسخ بماند، داده‌های کش شده باطل شوند تا از ارائه پاسخ‌های منقضی شده جلوگیری شود.
• ایزولاسیون بالک‌هد (Bulkhead Isolation): با استفاده از Polly برای محدود کردن تعداد درخواست‌های هم‌زمان و ایزولاسیون خطاها.
• استفاده از WireMock.Net: برای شبیه‌سازی (Mock) سیستم خارجی در تست‌ها.

// Required NuGet Packages (Example for .NET 8)
// <ItemGroup>
//   <PackageReference Include="Microsoft.Extensions.Http.Polly" Version="8.0.6" />
//   <PackageReference Include="Microsoft.Extensions.Caching.Distributed" Version="8.0.6" />
//   <PackageReference Include="Microsoft.Extensions.Caching.InMemory" Version="8.0.6" />
//   <PackageReference Include="Polly.Extensions.Http" Version="3.0.0" />
//   <PackageReference Include="Polly.Contrib.Bulkhead" Version="0.2.1-alpha" /> // Consider a more recent and stable Bulkhead library if available or use a custom implementation
//   <PackageReference Include="xunit" Version="2.9.0" />
//   <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />
//   <PackageReference Include="WireMock.Net" Version="1.5.47" />
// </ItemGroup>

using Xunit;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Caching.Distributed;
using Microsoft.Extensions.Caching.InMemory;
using System.Net.Http;
using Polly;
using Polly.CircuitBreaker;
using Polly.Timeout;
using System.Threading.Tasks;
using System;
using WireMock.RequestBuilders;
using WireMock.ResponseBuilders;
using WireMock.Server;
using Microsoft.Extensions.Logging;
using System.Collections.Generic;
using System.Text.Json;
using System.Text;

// --- Test Class ---
public class InventoryClientTests : IDisposable
{
    private readonly IWireMockServer _server;
    private readonly ServiceProvider _serviceProvider;
    private readonly ILogger<InventoryClient> _logger;

    public InventoryClientTests()
    {
        // Setup WireMock server
        _server = WireMockServer.Start();
        _server
            .Given(Request.Create().WithPath("/inventory").UsingGet())
            .RespondWith(Response.Create()
                .WithStatusCode(200)
                .WithBody("{\"bananaId1\":10,\"bananaId2\":5}")
                .WithHeader("Content-Type", "application/json"));

        _server
            .Given(Request.Create().WithPath("/inventory-unhealthy").UsingGet())
            .RespondWith(Response.Create()
                .WithStatusCode(500)); // Simulate an unhealthy service

        // Setup DI container with Polly and Caching
        var services = new ServiceCollection();
        services.AddLogging(builder => builder.AddConsole());
        _logger = services.BuildServiceProvider().GetRequiredService<ILogger<InventoryClient>>();

        services.AddDistributedMemoryCache(); // In-memory distributed cache for testing

        // Configure Polly policies
        var retryPolicy = Policy
            .Handle<HttpRequestException>()
            .OrResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
            .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
                onRetry: (exception, timeSpan, retryCount, context) =>
                {
                    _logger.LogWarning($"Retry {retryCount} due to {exception.Exception?.Message ?? exception.Result?.StatusCode.ToString()}. Waiting {timeSpan.TotalSeconds}s.");
                });

        var circuitBreakerPolicy = Policy
            .Handle<HttpRequestException>()
            .OrResult<HttpResponseMessage>(r => !r.IsSuccessStatusCode)
            .CircuitBreakerAsync(2, TimeSpan.FromSeconds(5),
                onBreak: (exception, breakDelay) =>
                {
                    _logger.LogError($"Circuit opened for {breakDelay.TotalSeconds}s due to {exception.Exception?.Message ?? exception.Result?.StatusCode.ToString()}.");
                },
                onReset: () => _logger.LogInformation("Circuit reset."),
                onHalfOpen: () => _logger.LogInformation("Circuit half-opened."));

        // Bulkhead policy for capping concurrent requests
        // Note: For real-world scenarios, consider a more robust bulkhead implementation or library.
        // This is a simple example for demonstration.
        var bulkheadPolicy = Policy.BulkheadAsync(10, 2); // 10 concurrent executions, 2 queued

        services.AddHttpClient("InventoryClient", client =>
        {
            client.BaseAddress = new Uri(_server.Url);
            client.Timeout = TimeSpan.FromSeconds(3); // Global timeout for HttpClient
        })
        .AddPolicyHandler(retryPolicy)
        .AddPolicyHandler(circuitBreakerPolicy)
        .AddPolicyHandler(bulkheadPolicy); // Adding bulkhead policy directly to HttpClient

        services.AddSingleton<InventoryClient>();

        _serviceProvider = services.BuildServiceProvider();
    }

    [Fact]
    public async Task GetInventoryDataAsync_ReturnsData_WhenExternalServiceIsAvailable()
    {
        // Arrange
        var client = _serviceProvider.GetRequiredService<InventoryClient>();
        var bananaSkus = new List<string> { "bananaId1", "bananaId2" };

        // Act
        var inventoryData = await client.GetInventoryDataAsync(bananaSkus);

        // Assert
        Assert.NotNull(inventoryData);
        Assert.True(inventoryData.ContainsKey("bananaId1"));
        Assert.Equal(10, inventoryData["bananaId1"]);
    }

    [Fact]
    public async Task GetInventoryDataAsync_ReturnsCachedData_WhenCircuitBreakerIsOpen()
    {
        // Arrange
        var client = _serviceProvider.GetRequiredService<InventoryClient>();
        var distributedCache = _serviceProvider.GetRequiredService<IDistributedCache>();
        var bananaSkus = new List<string> { "bananaId1" };
        var cachedData = new Dictionary<string, int> { { "bananaId1", 99 } };
        var serializedData = JsonSerializer.Serialize(cachedData);
        await distributedCache.SetStringAsync("InventoryClient_bananaId1", serializedData, new DistributedCacheEntryOptions
        {
            AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(1)
        });

        // Simulate service going down to open the circuit
        _server.Stop(); // Stop the server to simulate unreachability

        // Trigger calls to open the circuit breaker
        for (int i = 0; i < 3; i++) // Number of failures to open circuit
        {
            await Assert.ThrowsAnyAsync<Exception>(() => client.GetInventoryDataAsync(bananaSkus));
        }

        // Act
        var inventoryData = await client.GetInventoryDataAsync(bananaSkus);

        // Assert
        // The client should return data from cache because the circuit is open
        Assert.NotNull(inventoryData);
        Assert.True(inventoryData.ContainsKey("bananaId1"));
        Assert.Equal(99, inventoryData["bananaId1"]); // Should be from cache
    }


    public void Dispose()
    {
        _server.Stop();
        _server.Dispose();
        _serviceProvider.Dispose();
    }
}

// --- InventoryClient Implementation ---
public class InventoryClient
{
    private readonly HttpClient _httpClient;
    private readonly IDistributedCache _cache;
    private readonly ILogger<InventoryClient> _logger;

    public InventoryClient(IHttpClientFactory httpClientFactory, IDistributedCache cache, ILogger<InventoryClient> logger)
    {
        // HttpClientFactory Integration: Ensures efficient management of HttpClient instances.
        // It handles connection pooling, DNS changes, and reduces socket exhaustion, leading to better performance and reliability.
        _httpClient = httpClientFactory.CreateClient("InventoryClient");
        _cache = cache;
        _logger = logger;
    }

    public async Task<Dictionary<string, int>> GetInventoryDataAsync(List<string> bananaSkus)
    {
        var cacheKey = $"InventoryClient_{string.Join("_", bananaSkus)}";
        Dictionary<string, int>? data = null;

        try
        {
            // Circuit Breaker Pattern: If the circuit is open, this call will fail fast,
            // preventing cascading failures and allowing the external system to recover.
            // Bulkhead Isolation: This implicitly works with the HttpClientFactory policy configuration,
            // limiting concurrent calls to the external service, thus protecting internal resources (threads).
            var response = await _httpClient.GetAsync("/inventory");
            response.EnsureSuccessStatusCode();
            var jsonString = await response.Content.ReadAsStringAsync();
            data = JsonSerializer.Deserialize<Dictionary<string, int>>(jsonString);

            // Distributed Caching: Store fresh data in cache.
            // This absorbs load bursts and improves response times for subsequent requests.
            await _cache.SetStringAsync(cacheKey, JsonSerializer.Serialize(data), new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5) // Cache for 5 minutes
            });
            _logger.LogInformation($"Successfully fetched data from external service and updated cache for key: {cacheKey}");
        }
        catch (BrokenCircuitException ex)
        {
            // Fallback to Cache: When the circuit breaker is open, attempt to serve from cache.
            // This provides graceful degradation, allowing the application to function with stale data
            // during external service downtime.
            _logger.LogWarning($"Circuit breaker is open. Falling back to cache for key: {cacheKey}. Exception: {ex.Message}");
            var cachedJson = await _cache.GetStringAsync(cacheKey);
            if (!string.IsNullOrEmpty(cachedJson))
            {
                data = JsonSerializer.Deserialize<Dictionary<string, int>>(cachedJson);
                _logger.LogInformation($"Served data from cache for key: {cacheKey}");
            }
            else
            {
                // Cache Invalidation: If the circuit is open and cache is empty/stale (due to
                // a configured duration after which it gets invalidated), this indicates
                // no fresh data is available. This prevents serving indefinitely stale data.
                _logger.LogWarning($"Cache empty for key: {cacheKey} while circuit is open. Cannot serve stale data.");
                throw; // Or return an empty dictionary, depending on desired behavior
            }
        }
        catch (TimeoutRejectedException ex)
        {
            _logger.LogError($"Request timed out. Falling back to cache for key: {cacheKey}. Exception: {ex.Message}");
            var cachedJson = await _cache.GetStringAsync(cacheKey);
            if (!string.IsNullOrEmpty(cachedJson))
            {
                data = JsonSerializer.Deserialize<Dictionary<string, int>>(cachedJson);
                _logger.LogInformation($"Served data from cache for key: {cacheKey}");
            }
            else
            {
                _logger.LogWarning($"Cache empty for key: {cacheKey} during timeout. Cannot serve stale data.");
                throw;
            }
        }
        catch (Exception ex)
        {
            _logger.LogError($"An error occurred while fetching inventory data: {ex.Message}");
            // General error handling, could also fall back to cache here if desired
            throw;
        }

        return data ?? new Dictionary<string, int>();
    }
}

• با یک داستان کاربری خوب آغاز کنید.
• هوش مصنوعی را با دستورات هوشمندانه راهنمایی کنید.
• شیوه‌های مهندسی اثبات شده را به کار ببرید.
• از تکرار و بهبود تا رسیدن به نتیجه مطلوب نترسید.