public class KafkaPublisher
{
    private readonly IProducer<Null, string> _producer;

    public KafkaPublisher(string bootstrapServers)
    {
        var config = new ProducerConfig { BootstrapServers = bootstrapServers };
        _producer = new ProducerBuilder<Null, string>(config).Build();
    }

    public async Task PublishOrderPlacedAsync(OrderPlacedEvent orderPlaced)
    {
        var message = JsonSerializer.Serialize(orderPlaced);
        await _producer.ProduceAsync("order-events", new Message<Null, string> { Value = message });
    }
}

var retryPolicy = Policy
    .Handle<HttpRequestException>()
    .WaitAndRetryAsync(3, attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)), (ex, time, count, context) =>
    {
        Console.WriteLine($"Retry {count} after {time.TotalSeconds}s due to: {ex.Message}");
    });

var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreakerAsync(2, TimeSpan.FromSeconds(30), (ex, breakDelay) =>
    {
        Console.WriteLine($"Circuit broken! Delay: {breakDelay.TotalSeconds}s");
    }, () =>
    {
        Console.WriteLine("Circuit closed, operations resumed.");
    });

var policyWrap = Policy.WrapAsync(retryPolicy, circuitBreakerPolicy);

var response = await policyWrap.ExecuteAsync(() => httpClient.GetAsync("https://inventory-service/api/check-stock"));

public interface IInventoryService
{
    Task<string> CheckStockAsync(string productId);
}

public class PrimaryInventoryService : IInventoryService
{
    public async Task<string> CheckStockAsync(string productId)
    {
        throw new HttpRequestException("Primary service unavailable");
    }
}

public class BackupInventoryService : IInventoryService
{
    public async Task<string> CheckStockAsync(string productId)
    {
        return await Task.FromResult("Stock from backup service: 10 units");
    }
}

var backupService = new BackupInventoryService();
var primaryService = new PrimaryInventoryService();

var fallbackPolicy = Policy<string>
    .Handle<HttpRequestException>()
    .FallbackAsync(async cancellationToken =>
    {
        Console.WriteLine("Primary service failed. Using backup...");
        return await backupService.CheckStockAsync("P123");
    });

var result = await fallbackPolicy.ExecuteAsync(() => primaryService.CheckStockAsync("P123"));
Console.WriteLine(result);