// Example of using RabbitMQ with RabbitMQ.Client in C#
using RabbitMQ.Client;
class RabbitMQService {
    public void SendMessageToQueue(string queueName, string message) {
        var factory = new ConnectionFactory(){HostName="localhost"};
        using var connection = factory.CreateConnection();
        using var channel = connection.CreateModel;
        channel.QueueDeclare(queue:queueName,durable:false,exclusive:false,autoDelete:false,arguments:null);
        var body=Encoding.UTF8.GetBytes(message);
        channel.BasicPublish(exchange:"",routingKey:queueName,basicProperties:null,body:body);
        Console.WriteLines($"Message sent to {queueName}:{message}");
    }
}

// Example of using RabbitMQ for Publish-Subscribe
public class Publisher
{
    public void Publish(string exchangeName, string message)
    {
        var factory = new ConnectionFactory() { HostName = "localhost" };
        using var connection = factory.CreateConnection();
        using var channel = connection.CreateModel();
        channel.ExchangeDeclare(exchange: exchangeName, type: ExchangeType.Fanout);
        var body = Encoding.UTF8.GetBytes(message);
        channel.BasicPublish(exchange: exchangeName, routingKey: "", basicProperties: null, body: body);
        Console.WriteLine($"Message published to {exchangeName}: {message}");
    }
}

// Example of Command and Query models in C#
public class Command {
    public string Id {get;set;}
    public object Payload{get;set}
}
public class Query {
    public string Id(get;set;)
}
// Command Handler
public class CommandHandler {
    public void HandleCommand(Command command) {
        // Logic to process and update the system state based on the command
    }
}
// Query Handler
public class QueryHandler {
    public object HandleQuery(Query query) {
        // Logic to retrieve and return data without altering the system state
        return null;
    }
}

// Command Handler
public class CommandHandler {
    public void HandleCommand(Command command){
        // Logic to process and update the system state based on the command
    }
}
// Query handler
public class QueryHandler{
    public object HandlerQuery(Query query) {
        // Logic to retrieve and return data without altering the system state
        return null;
    }
}

public class OrderCommandHandler
{
    private readonly string commandQueueName = "order_commands";
    public void SendOrderCommand(OrderCommand command)
    {
        var factory = new ConnectionFactory() { HostName = "localhost" };
        using var connection = factory.CreateConnection();
        using var channel = connection.CreateModel();
        channel.QueueDeclare(queue: commandQueueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
        var body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(command));
        channel.BasicPublish(exchange: "", routingKey: commandQueueName, basicProperties: null, body: body);
        Console.WriteLine($"Order command sent: {JsonConvert.SerializeObject(command)}");
    }
    public void ConsumeOrderCommands()
    {
        var factory = new ConnectionFactory() { HostName = "localhost" };
        using var connection = factory.CreateConnection();
        using var channel = connection.CreateModel();
        channel.QueueDeclare(queue: commandQueueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
        var consumer = new EventingBasicConsumer(channel);
        consumer.Received += (model, ea) =>
        {
            var body = ea.Body.ToArray();
            var commandMessage = Encoding.UTF8.GetString(body);
            var orderCommand = JsonConvert.DeserializeObject<OrderCommand>(commandMessage);
            // 處理訂單命令
            Task.Run(() => ProcessOrderCommand(orderCommand));
            // 確認(rèn)消息
            channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
        };
        channel.BasicConsume(queue: commandQueueName, autoAck: false, consumer: consumer);
    }
    private void ProcessOrderCommand(OrderCommand orderCommand)
    {
        // 異步處理訂單命令的邏輯
        Console.WriteLine($"Processing order command: {JsonConvert.SerializeObject(orderCommand)}");
        // 下訂單，執(zhí)行驗(yàn)證
        // 如果成功，發(fā)布一個(gè)訂單處理事件
        var orderEvent = new OrderEvent { OrderId = orderCommand.OrderId, Status = "Processed" };
        SendOrderProcessedEvent(orderEvent);
    }
    private void SendOrderProcessedEvent(OrderEvent orderEvent)
    {
        var eventQueueName = "order_events";
        var factory = new ConnectionFactory() { HostName = "localhost" };
        using var connection = factory.CreateConnection();
        using var channel = connection.CreateModel();
        channel.QueueDeclare(queue: eventQueueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
        var body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(orderEvent));
        channel.BasicPublish(exchange: "", routingKey: eventQueueName, basicProperties: null, body: body);
        Console.WriteLine($"Order processed event sent: {JsonConvert.SerializeObject(orderEvent)}");
    }
}

public class OrderEventConsumer
{
    private readonly string eventQueueName = "order_events";
    public void ConsumeOrderEvents()
    {
        var factory = new ConnectionFactory() { HostName = "localhost" };
        using var connection = factory.CreateConnection();
        using var channel = connection.CreateModel();
        channel.QueueDeclare(queue: eventQueueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
        var consumer = new EventingBasicConsumer(channel);
        consumer.Received += (model, ea) =>
        {
            var body = ea.Body.ToArray();
            var eventMessage = Encoding.UTF8.GetString(body);
            var orderEvent = JsonConvert.DeserializeObject<OrderEvent>(eventMessage);
            Console.WriteLine($"Received order processed event: {JsonConvert.SerializeObject(orderEvent)}");
            // 處理已處理訂單事件的邏輯
        };
        channel.BasicConsume(queue: eventQueueName, autoAck: true, consumer: consumer);
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        var orderCommandHandler = new OrderCommandHandler();
        var orderEventConsumer = new OrderEventConsumer();
        // 舉例:發(fā)送訂單命令
        var orderCommand = new OrderCommand { OrderId = Guid.NewGuid(), Product = "Product A", Quantity = 2 };
        orderCommandHandler.SendOrderCommand(orderCommand);
        // 異步使用訂單命令和事件
        Task.Run(() => orderCommandHandler.ConsumeOrderCommands());
        Task.Run(() => orderEventConsumer.ConsumeOrderEvents());
        Console.ReadLine(); // 保持應(yīng)用程序運(yùn)行
    }
}

// 處理命令(下訂單)
public class OrderCommandService
{
    private readonly string commandQueueName = "order_commands";
    public void SendOrderCommand(OrderCommand command)
    {
        // 向RabbitMQ隊(duì)列發(fā)送order命令的代碼（具體可以參考前面SendOrderCommand的代碼）
    }
    public void ConsumeOrderCommands()
    {
        // 從RabbitMQ隊(duì)列中消費(fèi)訂單命令的代碼（具體可以參考前面的ConsumeOrderCommands代碼）
        // 異步處理接收到的命令并相應(yīng)地觸發(fā)事件
    }
}

// 處理查詢(獲取訂單)
public class OrderQueryService
{
    private readonly string queryQueueName = "order_queries";
    public void SendOrderQuery(Query query)
    {
        // 向RabbitMQ隊(duì)列發(fā)送order命令的代碼（具體可以參考前面SendOrderCommand的代碼）
    }
    public void ConsumeOrderQueries()
    {
        // 從RabbitMQ隊(duì)列中接受消費(fèi)訂單命令的代碼（具體可以參考前面的ConsumeOrderCommands代碼）
        // 異步處理接收到的查詢并檢索訂單數(shù)據(jù)
    }
}

// 命令模型
public class OrderCommand
{
    public string OrderId { get; set; }
    // 其他與訂單相關(guān)的字段（省略）
}
// 查詢模型
public class OrderQuery
{
    public string QueryId { get; set; }
    // 其他與訂單相關(guān)的字段（省略）
}

// 發(fā)送訂單命令
OrderCommandService orderCommandService = new OrderCommandService();
OrderCommand orderCommand = new OrderCommand { OrderId = "123", /* 其他訂單屬性 */ };
orderCommandService.SendOrderCommand(orderCommand);
// 消費(fèi)訂單命令
orderCommandService.ConsumeOrderCommands();

// 發(fā)送訂單查詢
OrderQueryService orderQueryService = new OrderQueryService();
OrderQuery orderQuery = new OrderQuery { QueryId = "456", /* 其他訂單屬性 */ };
orderQueryService.SendOrderQuery(orderQuery);
// 消費(fèi)訂單查詢
orderQueryService.ConsumeOrderQueries();