سوالات مصاحبه Async/Await در .NET

مثال استفاده از LogicalCallContext (از طریق AsyncLocal<T>):

// در .NET Core و نسخه‌های جدیدتر، AsyncLocal<T> جایگزین LogicalCallContext شده است
public class Program
{
    private static readonly AsyncLocal<string> _correlationId = new AsyncLocal<string>();

    public static async Task Main(string[] args)
    {
        _correlationId.Value = Guid.NewGuid().ToString();
        Console.WriteLine($"Main thread: Correlation ID = {_correlationId.Value}");

        await ProcessRequestAsync();

        Console.WriteLine($"Main thread after async call: Correlation ID = {_correlationId.Value}");
        Console.ReadKey();
    }

    public static async Task ProcessRequestAsync()
    {
        Console.WriteLine($"ProcessRequestAsync: Correlation ID = {_correlationId.Value}");
        await Task.Delay(1000);
        Console.WriteLine($"ProcessRequestAsync after delay: Correlation ID = {_correlationId.Value}");
    }
}

مثال در Azure Functions (C#):

public static class MyHttpTrigger
{
    [FunctionName("MyHttpTrigger")]
    public static async Task<IActionResult> Run(
        [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
        ILogger log)
    {
        log.LogInformation("C# HTTP trigger function processed a request.");

        string name = req.Query["name"];

        // شبیه‌سازی عملیات طولانی مدت I/O-bound
        string responseMessage = await CallExternalApiAsync(name);

        return new OkObjectResult(responseMessage);
    }

    private static async Task<string> CallExternalApiAsync(string name)
    {
        // در اینجا می‌توانید یک فراخوانی واقعی به یک API خارجی یا دیتابیس داشته باشید
        await Task.Delay(2000); // شبیه‌سازی تاخیر شبکه
        return $"Hello, {name ?? "World"}. This HTTP triggered function executed successfully asynchronously.";
    }
}

مثال در یک سیستم صف پیام (Message Queue):

public class MessageProcessor
{
    public async Task ProcessMessageAsync(Message message)
    {
        Console.WriteLine($"Processing message {message.Id} on thread {Thread.CurrentThread.ManagedThreadId}");

        // شبیه‌سازی عملیات طولانی مدت (مثلاً فراخوانی API خارجی)
        await CallExternalServiceAsync(message.Payload);

        Console.WriteLine($"Finished processing message {message.Id} on thread {Thread.CurrentThread.ManagedThreadId}");
    }

    private async Task CallExternalServiceAsync(string payload)
    {
        // فرض کنید این یک فراخوانی HTTP به یک سرویس خارجی است
        using (var client = new HttpClient())
        {
            await client.PostAsync("http://external.service/api/process", new StringContent(payload));
        }
    }

    // متدی که پیام‌ها را از صف دریافت می‌کند و پردازشگر را فراخوانی می‌کند
    public async Task StartListeningToQueueAsync()
    {
        // شبیه‌سازی دریافت پیام از صف
        await foreach (var message in GetMessagesFromQueueAsync())
        {
            // هر پیام را به صورت ناهمزمان پردازش می‌کنیم
            await ProcessMessageAsync(message);
        }
    }

    private async IAsyncEnumerable<Message> GetMessagesFromQueueAsync()
    {
        for (int i = 0; i < 5; i++)
        {
            await Task.Delay(500); // شبیه‌سازی تاخیر در دریافت پیام
            yield return new Message { Id = i + 1, Payload = $"Data for message {i + 1}" };
        }
    }
}

public class Message
{
    public int Id { get; set; }
    public string Payload { get; set; }
}

مثال در یک میکروسرویس (ASP.NET Core Web API):

public class OrderService : ControllerBase
{
    private readonly ProductService _productService;
    private readonly InventoryService _inventoryService;

    public OrderService(ProductService productService, InventoryService inventoryService)
    {
        _productService = productService;
        _inventoryService = inventoryService;
    }

    [HttpPost("createOrder")]
    public async Task<IActionResult> CreateOrder([FromBody] OrderRequest request)
    {
        // فراخوانی‌های ناهمزمان به سرویس‌های دیگر به صورت موازی
        var productTask = _productService.GetProductDetailsAsync(request.ProductId);
        var inventoryTask = _inventoryService.CheckInventoryAsync(request.ProductId, request.Quantity);

        await Task.WhenAll(productTask, inventoryTask);

        var product = await productTask;
        var inventory = await inventoryTask;

        if (product == null || !inventory.IsAvailable)
        {
            return BadRequest("Product not available or out of stock.");
        }

        // ادامه منطق ایجاد سفارش
        return Ok("Order created successfully.");
    }
}

public class ProductService
{
    public async Task<Product> GetProductDetailsAsync(string productId)
    {
        // شبیه‌سازی فراخوانی HTTP به سرویس محصول
        using (var client = new HttpClient())
        {
            var response = await client.GetAsync($"http://product.service/api/products/{productId}");
            response.EnsureSuccessStatusCode();
            return await response.Content.ReadFromJsonAsync<Product>();
        }
    }
}

public class InventoryService
{
    public async Task<InventoryStatus> CheckInventoryAsync(string productId, int quantity)
    {
        // شبیه‌سازی فراخوانی HTTP به سرویس موجودی
        using (var client = new HttpClient())
        {
            var response = await client.GetAsync($"http://inventory.service/api/inventory/{productId}/{quantity}");
            response.EnsureSuccessStatusCode();
            return await response.Content.ReadFromJsonAsync<InventoryStatus>();
        }
    }
}

public class OrderRequest
{
    public string ProductId { get; set; }
    public int Quantity { get; set; }
}

public class Product { /* ... */ }
public class InventoryStatus { public bool IsAvailable { get; set; } }

مثال در DDD:

// Application Layer
public class OrderApplicationService
{
    private readonly IOrderRepository _orderRepository;
    private readonly IProductService _productService;

    public OrderApplicationService(IOrderRepository orderRepository, IProductService productService)
    {
        _orderRepository = orderRepository;
        _productService = productService;
    }

    public async Task CreateOrderAsync(CreateOrderCommand command)
    {
        // فراخوانی ناهمزمان به سرویس محصول (Infrastructure Layer)
        var product = await _productService.GetProductByIdAsync(command.ProductId);
        if (product == null)
        {
            throw new ProductNotFoundException(command.ProductId);
        }

        // ایجاد Aggregate ریشه (Domain Model)
        var order = Order.CreateNew(command.CustomerId, product.Id, command.Quantity);

        // ذخیره ناهمزمان Aggregate (Infrastructure Layer)
        await _orderRepository.AddAsync(order);
        await _orderRepository.UnitOfWork.SaveEntitiesAsync();
    }
}

// Domain Model (مثال ساده)
public class Order : Entity, IAggregateRoot
{
    public Guid CustomerId { get; private set; }
    public Guid ProductId { get; private set; }
    public int Quantity { get; private set; }

    private Order() { } // برای ORM

    public static Order CreateNew(Guid customerId, Guid productId, int quantity)
    {
        // منطق دامنه
        return new Order { CustomerId = customerId, ProductId = productId, Quantity = quantity };
    }
}

// Infrastructure Layer (مثال ساده)
public interface IOrderRepository : IRepository<Order>
{
    Task AddAsync(Order order);
    Task<Order> GetByIdAsync(Guid id);
}

public interface IProductService
{
    Task<Product> GetProductByIdAsync(Guid productId);
}

public class ProductService : IProductService
{
    public async Task<Product> GetProductByIdAsync(Guid productId)
    {
        // شبیه‌سازی فراخوانی API خارجی
        await Task.Delay(500);
        return new Product { Id = productId, Name = "Sample Product" };
    }
}

مثال در Clean Architecture:

// Domain Layer - Use Case
public class CreateOrderUseCase : ICreateOrderUseCase
{
    private readonly IOrderGateway _orderGateway;
    private readonly IProductGateway _productGateway;

    public CreateOrderUseCase(IOrderGateway orderGateway, IProductGateway productGateway)
    {
        _m_orderGateway = orderGateway;
        _productGateway = productGateway;
    }

    public async Task<OrderResponse> ExecuteAsync(CreateOrderRequest request)
    {
        var product = await _productGateway.GetProductByIdAsync(request.ProductId);
        if (product == null)
        {
            throw new ProductNotFoundException(request.ProductId);
        }

        var order = new Order(request.CustomerId, product.Id, request.Quantity);
        await _orderGateway.SaveOrderAsync(order);

        return new OrderResponse { OrderId = order.Id };
    }
}

// Domain Layer - Gateway Interface
public interface IOrderGateway
{
    Task SaveOrderAsync(Order order);
}

public interface IProductGateway
{
    Task<Product> GetProductByIdAsync(Guid productId);
}

// Infrastructure Layer - Gateway Implementation
public class OrderDatabaseGateway : IOrderGateway
{
    private readonly ApplicationDbContext _dbContext;

    public OrderDatabaseGateway(ApplicationDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public async Task SaveOrderAsync(Order order)
    {
        _dbContext.Orders.Add(order);
        await _dbContext.SaveChangesAsync();
    }
}

public class ProductApiGateway : IProductGateway
{
    private readonly HttpClient _httpClient;

    public ProductApiGateway(HttpClient httpClient)
    {
        _httpClient = httpClient;
    }

    public async Task<Product> GetProductByIdAsync(Guid productId)
    {
        var response = await _httpClient.GetAsync($"api/products/{productId}");
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadFromJsonAsync<Product>();
    }
}

// Application Layer - Controller
[ApiController]
[Route("api/[controller]")]
public class OrdersController : ControllerBase
{
    private readonly ICreateOrderUseCase _createOrderUseCase;

    public OrdersController(ICreateOrderUseCase createOrderUseCase)
    {
        _createOrderUseCase = createOrderUseCase;
    }

    [HttpPost]
    public async Task<IActionResult> Create([FromBody] CreateOrderRequest request)
    {
        var response = await _createOrderUseCase.ExecuteAsync(request);
        return Ok(response);
    }
}

مثال در CQRS (با استفاده از MediatR):

// Command
public class CreateProductCommand : IRequest<Guid>
{
    public string Name { get; set; }
    public decimal Price { get; set; }
}

// Command Handler
public class CreateProductCommandHandler : IRequestHandler<CreateProductCommand, Guid>
{
    private readonly ApplicationDbContext _dbContext;

    public CreateProductCommandHandler(ApplicationDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public async Task<Guid> Handle(CreateProductCommand request, CancellationToken cancellationToken)
    {
        var product = new Product { Name = request.Name, Price = request.Price };
        _dbContext.Products.Add(product);
        await _dbContext.SaveChangesAsync(cancellationToken);
        return product.Id;
    }
}

// Query
public class GetProductByIdQuery : IRequest<ProductDto>
{
    public Guid Id { get; set; }
}

// Query Handler
public class GetProductByIdQueryHandler : IRequestHandler<GetProductByIdQuery, ProductDto>
{
    private readonly ApplicationDbContext _dbContext;

    public GetProductByIdQueryHandler(ApplicationDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public async Task<ProductDto> Handle(GetProductByIdQuery request, CancellationToken cancellationToken)
    {
        var product = await _dbContext.Products
            .AsNoTracking()
            .FirstOrDefaultAsync(p => p.Id == request.Id, cancellationToken);

        if (product == null)
        {
            return null;
        }

        return new ProductDto { Id = product.Id, Name = product.Name, Price = product.Price };
    }
}

// Controller
[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    private readonly IMediator _mediator;

    public ProductsController(IMediator mediator)
    {
        _mediator = mediator;
    }

    [HttpPost]
    public async Task<IActionResult> Create([FromBody] CreateProductCommand command)
    {
        var productId = await _mediator.Send(command);
        return Ok(productId);
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> GetById(Guid id)
    {
        var product = await _mediator.Send(new GetProductByIdQuery { Id = id });
        if (product == null)
        {
            return NotFound();
        }
        return Ok(product);
    }
}

مثال در Event Sourcing:

// Aggregate Root
public class Account : AggregateRoot
{
    public Guid AccountId { get; private set; }
    public decimal Balance { get; private set; }

    public Account() { }

    public Account(Guid accountId)
    {
        ApplyChange(new AccountCreatedEvent(accountId));
    }

    public void Deposit(decimal amount)
    {
        if (amount <= 0) throw new ArgumentException("Deposit amount must be positive.");
        ApplyChange(new FundsDepositedEvent(AccountId, amount));
    }

    protected override void Apply(DomainEvent @event)
    {
        switch (@event)
        {
            case AccountCreatedEvent ace: AccountId = ace.AccountId;
                break;
            case FundsDepositedEvent fde: Balance += fde.Amount;
                break;
        }
    }
}

// Event Store Interface
public interface IEventStore
{
    Task SaveEventsAsync(Guid aggregateId, IEnumerable<DomainEvent> events, int expectedVersion);
    Task<IEnumerable<DomainEvent>> GetEventsForAggregateAsync(Guid aggregateId);
}

// Event Store Implementation (مثال ساده)
public class InMemoryEventStore : IEventStore
{
    private readonly Dictionary<Guid, List<DomainEvent>> _events = new Dictionary<Guid, List<DomainEvent>>();

    public Task SaveEventsAsync(Guid aggregateId, IEnumerable<DomainEvent> events, int expectedVersion)
    {
        if (!_events.ContainsKey(aggregateId))
        {
            _events.Add(aggregateId, new List<DomainEvent>());
        }

        // منطق بررسی نسخه و Conflict Resolution

        _events[aggregateId].AddRange(events);
        return Task.CompletedTask;
    }

    public Task<IEnumerable<DomainEvent>> GetEventsForAggregateAsync(Guid aggregateId)
    {
        return Task.FromResult<IEnumerable<DomainEvent>>(_events.GetValueOrDefault(aggregateId, new List<DomainEvent>()));
    }
}

// Application Service
public class AccountApplicationService
{
    private readonly IEventStore _eventStore;

    public AccountApplicationService(IEventStore eventStore)
    {
        _eventStore = eventStore;
    }

    public async Task CreateAccount(Guid accountId)
    {
        var account = new Account(accountId);
        await _eventStore.SaveEventsAsync(accountId, account.GetUncommittedChanges(), -1);
    }

    public async Task DepositFunds(Guid accountId, decimal amount)
    {
        var events = await _eventStore.GetEventsForAggregateAsync(accountId);
        var account = new Account();
        account.LoadsFromHistory(events);

        account.Deposit(amount);
        await _eventStore.SaveEventsAsync(accountId, account.GetUncommittedChanges(), account.Version);
    }
}

مثال در Akka.NET:

public class MyActor : ReceiveActor
{
    private readonly IHttpClientFactory _httpClientFactory;

    public MyActor(IHttpClientFactory httpClientFactory)
    {
        _httpClientFactory = httpClientFactory;
        ReceiveAsync<string>(async message =>
        {
            Console.WriteLine($"Actor received: {message} on thread {Thread.CurrentThread.ManagedThreadId}");
            await ProcessMessageAsync(message);
            Console.WriteLine($"Actor finished processing: {message} on thread {Thread.CurrentThread.ManagedThreadId}");
        });
    }

    private async Task ProcessMessageAsync(string message)
    {
        // شبیه‌سازی عملیات I/O-bound
        using (var client = _httpClientFactory.CreateClient())
        {
            var response = await client.GetStringAsync("http://example.com");
            Console.WriteLine($"Downloaded data: {response.Length} bytes");
        }
    }
}

// نحوه ایجاد و ارسال پیام به Actor
public class Program
{
    public static async Task Main(string[] args)
    {
        var system = ActorSystem.Create("MyActorSystem");
        var actor = system.ActorOf(Props.Create(() => new MyActor(new HttpClientFactory())), "myActor");

        actor.Tell("Hello from Main!");
        actor.Tell("Another message!");

        await Task.Delay(5000); // منتظر می‌مانیم تا Actor پیام‌ها را پردازش کند
        await system.Terminate();
    }

    // یک پیاده‌سازی ساده از IHttpClientFactory برای مثال
    public class HttpClientFactory : IHttpClientFactory
    {
        public HttpClient CreateClient(string name = null)
        {
            return new HttpClient();
        }
    }
}

مثال در F# (که از async/await پشتیبانی می‌کند):

open System
open System.Net.Http

// یک تابع خالص ناهمزمان
let downloadContentAsync (url: string) : Async<string> =
    async {
        use client = new HttpClient()
        let! content = client.GetStringAsync(url) |> Async.AwaitTask
        return content
    }

// ترکیب توابع ناهمزمان
let processUrlsAsync (urls: string list) : Async<string list> =
    async {
        let! contents = urls
                       |> List.map downloadContentAsync
                       |> Async.Parallel
                       |> Async.RunSynchronously // در اینجا برای سادگی از RunSynchronously استفاده شده است
        return contents |> List.map (fun s -> s.Substring(0, 50))
    }

// نحوه استفاده
[]
let main argv =
    let urls = ["http://example.com"; "http://google.com"]
    let! results = processUrlsAsync urls

    results |> List.iter (printfn "%s")

    0

مثال ترکیب Rx و async/await:

public class DataService
{
    public async Task<string> GetRemoteDataAsync(int id)
    {
        await Task.Delay(1000); // شبیه‌سازی فراخوانی شبکه
        return $"Data from remote service for ID: {id}";
    }
}

public class Program
{
    public static async Task Main(string[] args)
    {
        var service = new DataService();

        // 1. تبدیل Task به Observable
        var observableFromTask = Observable.FromAsync(() => service.GetRemoteDataAsync(1));
        observableFromTask.Subscribe(data => Console.WriteLine($"Observable from Task: {data}"));

        // 2. استفاده از await در داخل Subscribe
        var ids = new[] { 2, 3, 4 };
        var observableIds = ids.ToObservable();

        observableIds.SelectMany(async id => await service.GetRemoteDataAsync(id))
                     .Subscribe(data => Console.WriteLine($"Observable with await in SelectMany: {data}"));

        // 3. تبدیل Observable به Task
        var lastDataTask = observableIds.SelectMany(async id => await service.GetRemoteDataAsync(id))
                                        .ToTask();
        var result = await lastDataTask;
        Console.WriteLine($"Last data from Observable to Task: {result}");

        Console.ReadKey();
    }
}

مثال در Hot Chocolate (GraphQL for .NET):

public class Query
{
    public async Task<Book> GetBook(Guid id, [Service] IBookRepository bookRepository)
    {
        // فراخوانی ناهمزمان به دیتابیس یا سرویس دیگر
        return await bookRepository.GetBookByIdAsync(id);
    }

    public async Task<IEnumerable<Author>> GetAuthors([Service] IAuthorRepository authorRepository)
    {
        return await authorRepository.GetAllAuthorsAsync();
    }
}

public class Book
{
    public Guid Id { get; set; }
    public string Title { get; set; }
    public Guid AuthorId { get; set; }

    // Resolver برای فیلد Author
    public async Task<Author> GetAuthor([Parent] Book book, [Service] IAuthorRepository authorRepository)
    {
        // این فراخوانی می‌تواند منجر به N+1 Problem شود اگر به درستی مدیریت نشود
        return await authorRepository.GetAuthorByIdAsync(book.AuthorId);
    }
}

// Repository Interfaces
public interface IBookRepository
{
    Task<Book> GetBookByIdAsync(Guid id);
}

public interface IAuthorRepository
{
    Task<Author> GetAuthorByIdAsync(Guid id);
    Task<IEnumerable<Author>> GetAllAuthorsAsync();
}

// Repository Implementations (مثال ساده)
public class BookRepository : IBookRepository
{
    public async Task<Book> GetBookByIdAsync(Guid id)
    {
        await Task.Delay(100); // شبیه‌سازی دسترسی به دیتابیس
        return new Book { Id = id, Title = $"Book {id}", AuthorId = Guid.NewGuid() };
    }
}

public class AuthorRepository : IAuthorRepository
{
    public async Task<Author> GetAuthorByIdAsync(Guid id)
    {
        await Task.Delay(100); // شبیه‌سازی دسترسی به دیتابیس
        return new Author { Id = id, Name = $"Author {id}" };
    }

    public async Task<IEnumerable<Author>> GetAllAuthorsAsync()
    {
        await Task.Delay(200); // شبیه‌سازی دسترسی به دیتابیس
        return new List<Author>
        {
            new Author { Id = Guid.NewGuid(), Name = "Author 1" },
            new Author { Id = Guid.NewGuid(), Name = "Author 2" }
        };
    }
}

مثال در gRPC (C#):

// Service Definition (in .proto file)
// service Greeter {
//   rpc SayHello (HelloRequest) returns (HelloReply);
//   rpc SayHelloStream (HelloRequest) returns (stream HelloReply);
// }

// Server Implementation
public class GreeterService : Greeter.GreeterBase
{
    private readonly ILogger<GreeterService> _logger;

    public GreeterService(ILogger<GreeterService> logger)
    {
        _logger = logger;
    }

    public override async Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context)
    {
        _logger.LogInformation($"SayHello received: {request.Name}");
        await Task.Delay(100); // شبیه‌سازی عملیات I/O
        return new HelloReply { Message = $"Hello {request.Name}" };
    }

    public override async Task SayHelloStream(HelloRequest request, IServerStreamWriter<HelloReply> responseStream, ServerCallContext context)
    {
        _logger.LogInformation($"SayHelloStream received: {request.Name}");
        for (int i = 0; i < 5; i++)
        {
            await responseStream.WriteAsync(new HelloReply { Message = $"Hello {request.Name} ({i + 1})" });
            await Task.Delay(500); // شبیه‌سازی تاخیر
        }
    }
}

// Client Usage
public class GrpcClient
{
    public static async Task RunAsync()
    {
        using var channel = GrpcChannel.ForAddress("https://localhost:5001");
        var client = new Greeter.GreeterClient(channel);

        // Unary Call
        var reply = await client.SayHelloAsync(new HelloRequest { Name = "World" });
        Console.WriteLine($"Greeting: {reply.Message}");

        // Server Streaming Call
        using var call = client.SayHelloStream(new HelloRequest { Name = "Streamer" });
        await foreach (var message in call.ResponseStream.ReadAllAsync())
        {
            Console.WriteLine($"Streamed Greeting: {message.Message}");
        }
    }
}

مثال در ASP.NET Core WebSockets:

// Startup.cs (Configure method)
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // ...
    app.UseWebSockets();
    app.Use(async (context, next) =>
    {
        if (context.Request.Path == "/ws")
        {
            if (context.WebSockets.IsWebSocketRequest)
            {
                using var webSocket = await context.WebSockets.AcceptWebSocketAsync();
                await Echo(webSocket);
            }
            else
            {
                context.Response.StatusCode = StatusCodes.Status400BadRequest;
            }
        }
        else
        {
            await next();
        }
    });
    // ...
}

private async Task Echo(WebSocket webSocket)
{
    var buffer = new byte[1024 * 4];
    var receiveResult = await webSocket.ReceiveAsync(
        new ArraySegment<byte>(buffer), CancellationToken.None);

    while (!receiveResult.CloseStatus.HasValue)
    {
        await webSocket.SendAsync(
            new ArraySegment<byte>(buffer, 0, receiveResult.Count),
            receiveResult.MessageType,
            receiveResult.EndOfMessage,
            CancellationToken.None);

        receiveResult = await webSocket.ReceiveAsync(
            new ArraySegment<byte>(buffer), CancellationToken.None);
    }

    await webSocket.CloseAsync(
        receiveResult.CloseStatus.Value,
        receiveResult.CloseStatusDescription,
        CancellationToken.None);
}

مثال در SignalR Hub (C#):

public class ChatHub : Hub
{
    public async Task SendMessage(string user, string message)
    {
        // شبیه‌سازی ذخیره پیام در دیتابیس
        await Task.Delay(100);
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }

    public override async Task OnConnectedAsync()
    {
        await Clients.All.SendAsync("UserConnected", Context.ConnectionId);
        await base.OnConnectedAsync();
    }

    public override async Task OnDisconnectedAsync(Exception exception)
    {
        await Clients.All.SendAsync("UserDisconnected", Context.ConnectionId);
        await base.OnDisconnectedAsync(exception);
    }
}

مثال با RabbitMQ (با استفاده از RabbitMQ.Client):

// Producer
public class RabbitMqProducer
{
    private readonly IConnection _connection;
    private readonly IModel _channel;

    public RabbitMqProducer(string hostname)
    {
        var factory = new ConnectionFactory() { HostName = hostname };
        _connection = factory.CreateConnection();
        _channel = _connection.CreateModel();
        _channel.QueueDeclare(queue: "hello", durable: false, exclusive: false, autoDelete: false, arguments: null);
    }

    public async Task PublishMessageAsync(string message)
    {
        var body = Encoding.UTF8.GetBytes(message);
        // PublishAsync یک متد ناهمزمان است
        await Task.Run(() => _channel.BasicPublish(exchange: "", routingKey: "hello", basicProperties: null, body: body));
        Console.WriteLine($" [x] Sent {message}");
    }

    public void Close()
    {
        _channel.Close();
        _connection.Close();
    }
}

// Consumer
public class RabbitMqConsumer
{
    private readonly IConnection _connection;
    private readonly IModel _channel;

    public RabbitMqConsumer(string hostname)
    {
        var factory = new ConnectionFactory() { HostName = hostname };
        _connection = factory.CreateConnection();
        _channel = _connection.CreateModel();
        _channel.QueueDeclare(queue: "hello", durable: false, exclusive: false, autoDelete: false, arguments: null);
    }

    public void StartConsuming()
    {
        var consumer = new EventingBasicConsumer(_channel);
        consumer.Received += async (model, ea) =>
        {
            var body = ea.Body.ToArray();
            var message = Encoding.UTF8.GetString(body);
            Console.WriteLine($" [x] Received {message}");

            // پردازش پیام به صورت ناهمزمان
            await ProcessMessageAsync(message);

            _channel.BasicAck(ea.DeliveryTag, false);
        };
        _channel.BasicConsume(queue: "hello", autoAck: false, consumer: consumer);
    }

    private async Task ProcessMessageAsync(string message)
    {
        // شبیه‌سازی عملیات طولانی مدت (مثلاً ذخیره در دیتابیس)
        await Task.Delay(1000);
        Console.WriteLine($"Processed message: {message}");
    }

    public void Close()
    {
        _channel.Close();
        _connection.Close();
    }
}

// Main Program
public class Program
{
    public static async Task Main(string[] args)
    {
        var producer = new RabbitMqProducer("localhost");
        var consumer = new RabbitMqConsumer("localhost");

        consumer.StartConsuming();

        await producer.PublishMessageAsync("Message 1");
        await producer.PublishMessageAsync("Message 2");

        Console.WriteLine("Press [enter] to exit.");
        Console.ReadLine();

        producer.Close();
        consumer.Close();
    }
}

مثال با Saga Pattern (مفهومی):

// Order Saga Orchestrator
public class OrderSaga : IHandle<CreateOrderCommand>, IHandle<ProductReservedEvent>, IHandle<PaymentProcessedEvent>
{
    private readonly IMessageBus _messageBus;

    public OrderSaga(IMessageBus messageBus)
    {
        _messageBus = messageBus;
    }

    public async Task Handle(CreateOrderCommand command)
    {
        // شروع Saga: ارسال دستور رزرو محصول
        await _messageBus.PublishAsync(new ReserveProductCommand(command.ProductId, command.Quantity));
    }

    public async Task Handle(ProductReservedEvent @event)
    {
        // محصول رزرو شد: ارسال دستور پردازش پرداخت
        await _messageBus.PublishAsync(new ProcessPaymentCommand(@event.OrderId, @event.Amount));
    }

    public async Task Handle(PaymentProcessedEvent @event)
    {
        // پرداخت انجام شد: ارسال دستور نهایی کردن سفارش
        await _messageBus.PublishAsync(new FinalizeOrderCommand(@event.OrderId));
    }

    // متدهای مدیریت خطای جبرانی (Compensation) نیز باید پیاده‌سازی شوند
}

// Message Bus Interface
public interface IMessageBus
{
    Task PublishAsync<T>(T message);
}

// Message Bus Implementation (مثال ساده)
public class InMemoryMessageBus : IMessageBus
{
    public Task PublishAsync<T>(T message)
    {
        Console.WriteLine($"Publishing message: {message.GetType().Name}");
        // در اینجا پیام به Handlers مربوطه ارسال می‌شود
        return Task.CompletedTask;
    }
}

مثال در AWS Lambda (C#):

public class Function
{
    public async Task<APIGatewayProxyResponse> FunctionHandler(APIGatewayProxyRequest apigProxyEvent, ILambdaContext context)
    {
        context.Logger.LogInformation("Processing a request.");

        string name = apigProxyEvent.QueryStringParameters?["name"];

        // شبیه‌سازی عملیات طولانی مدت I/O-bound
        string responseMessage = await CallExternalServiceAsync(name);

        return new APIGatewayProxyResponse
        {
            StatusCode = (int)HttpStatusCode.OK,
            Body = responseMessage,
            Headers = new Dictionary<string, string> { { "Content-Type", "text/plain" } }
        };
    }

    private async Task<string> CallExternalServiceAsync(string name)
    {
        // در اینجا می‌توانید یک فراخوانی واقعی به یک API خارجی یا دیتابیس داشته باشید
        await Task.Delay(1500); // شبیه‌سازی تاخیر شبکه
        return $"Hello, {name ?? "World"}. This Lambda function executed successfully asynchronously.";
    }
}

مثال در یک دستگاه Edge (مفهومی):

public class SensorDataProcessor
{
    private readonly ISensor _sensor;
    private readonly ICloudSyncService _cloudSyncService;

    public SensorDataProcessor(ISensor sensor, ICloudSyncService cloudSyncService)
    {
        _sensor = sensor;
        _cloudSyncService = cloudSyncService;
    }

    public async Task StartProcessingAsync()
    {
        await foreach (var data in _sensor.ReadDataStreamAsync())
        {
            var processedData = ProcessLocal(data);
            await _cloudSyncService.UploadDataAsync(processedData);
        }
    }

    private ProcessedData ProcessLocal(RawData data)
    {
        // انجام پردازش محلی (CPU-bound)
        return new ProcessedData { /* ... */ };
    }
}

public interface ISensor
{
    IAsyncEnumerable<RawData> ReadDataStreamAsync();
}

public interface ICloudSyncService
{
    Task UploadDataAsync(ProcessedData data);
}