public void Receive()
{
var conn = new GetConnection();
conn.MqHandle((connection, channel) =>
{
//声明一个名为hello的队列
QueueDeclare.QueueDeclareByName("hello", connection, channel);
//接下来我们通知服务器可以将消息从队列里发送过来了。由于服务器会异步地将消息推送给我们，所以我们这里提供一个回调方法。这就是EventingBasicConsumer.Receivedevent所做的工作。
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (conn, ea) =>
{
///Thread.Sleep(2000);
var body = ea.Body.Span;
var message = Encoding.UTF8.GetString(body);
Console.WriteLine(" [x] Received {0}", message);
};
///param1:消费哪个队列的消息 队列名称
///param2:开始消息的自动确认机制
///param3;消费时的回调接口
channel.BasicConsume(queue: "hello",
autoAck: true,
consumer: consumer);
Console.WriteLine(" Press [enter] to exit.");
Console.ReadLine();
});
}
private static async Task StartConsumer()
{
var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddConsole();
builder.SetMinimumLevel(LogLevel.Debug);
});
var builder = new RabbitMQConnectionFactoryBuilder(new DnsEndPoint(Host, 5672));
var factory = builder.AddLogger(loggerFactory.CreateLogger(string.Empty)).Build();
var connection = factory.CreateConnection();
await connection.StartAsync();
var channel = await connection.OpenChannel();
await channel.ExchangeDeclareAsync(ExchangeDeclare.Create("TestExchange", ExchangeType.Direct));
await channel.QueueDeclareAsync(QueueDeclare.Create("TestQueue"));
await channel.QueueBindAsync(QueueBind.Create("TestQueue", "TestExchange"));
var consumer = new RabbitMQConsumer(channel, ConsumeConf.CreateNoWait("TestQueue", "TestConsumer", true), PipeScheduler.ThreadPool);
consumer.Received += /*async*/ (sender, result) =>
{
if (result.Body[0] != 42)
{
throw new Exception("SHIT");
}
//await channel.Ack(AckInfo.Create(result.DeliveryTag));
};
await channel.ConsumerStartAsync(consumer);
await Task.Delay(TimeSpan.FromHours(1));
}
public void Send()
{
var conn = new GetConnection();
conn.MqHandle((connection, channel) =>
{
//声明一个名为hello的队列
QueueDeclare.QueueDeclareByName("hello", connection, channel);
for (int i = 0; i < 1000; i++)
{
var body = Encoding.UTF8.GetBytes(i.ToString());
//消息写入到hello队列中
///param1:交换机名称
///param2:队列名称
///param3:传递消息额外设置
///param4:消息具体内容
channel.BasicPublish(exchange: "",
routingKey: "hello",
basicProperties: null,
body: body);
Console.WriteLine(" [x] Sent {0}", i);
}
});
Console.WriteLine(" Press [enter] to exit.");
Console.ReadLine();
}
private static async Task Main(string[] args)
{
var builder = new RabbitMQConnectionFactoryBuilder(new DnsEndPoint(Host, 5672));
var factory = builder.Build();
var connection = factory.CreateConnection();
await connection.StartAsync();
var channel = await connection.OpenChannel();
await channel.ExchangeDeclareAsync(ExchangeDeclare.Create("TestExchange", ExchangeType.Direct));
await channel.QueueDeclareAsync(QueueDeclare.Create("TestQueue"));
await channel.QueueBindAsync(QueueBind.Create("TestQueue", "TestExchange"));
var consumer = new RabbitMQConsumer(channel, ConsumeConf.Create("TestQueue", "TestConsumer", true));
consumer.Received += /*async*/ (sender, result) =>
{
//await channel.Ack(AckInfo.Create(result.DeliveryTag));
};
await channel.ConsumerStartAsync(consumer);
await Task.Delay(TimeSpan.FromHours(1));
}
private void TryCreateExchangeAndQueue()
{
if (!_persistentConnection.IsConnected)
{
_persistentConnection.TryConnect();
}
using (var channel = _persistentConnection.CreateModel())
{
ExchangeDeclare.Declare(channel);
QueueDeclare.Declare(channel);
}
}
public void Receive()
{
var conn = new GetConnection();
conn.MqHandle((connection, channel) =>
{
//声明一个名为hello的队列
QueueDeclare.QueueDeclareByName("task_query", connection, channel);
#region BasicQos
//你可能注意到了，调度依照我们希望的方式运行。例如在有两个工作者的情况下，当所有的奇数任务都很繁重而所有的偶数任务都很轻松的时候，其中一个工作者会一直处于忙碌之中而另一个几乎无事可做。RabbitMQ并不会对此有任何察觉，仍旧会平均分配消息。
//这种情况发生的原因是由于当有消息进入队列时，RabbitMQ只负责将消息调度的工作，而不会检查某个消费者有多少未经确认的消息。它只是盲目的将第n个消息发送给第n个消费者而已。
//img
//要改变这种行为的话，我们可以在BasicQos方法中设置prefetchCount = 1。这样会告诉RabbitMQ一次不要给同一个worker提供多于一条的信息。话句话说，在一个工作者还没有处理完消息，并且返回确认标志之前，不要再给它调度新的消息。取而代之，它会将消息调度给下一个不再繁忙的工作者
#endregion
channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);
Console.WriteLine(" [*] Waiting for messages.");
//接下来我们通知服务器可以将消息从队列里发送过来了。由于服务器会异步地将消息推送给我们，所以我们这里提供一个回调方法。这就是EventingBasicConsumer.Receivedevent所做的工作。
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (conn, ea) =>
{
var body = ea.Body.Span;
var message = Encoding.UTF8.GetString(body);
Console.WriteLine(" [x] Received {0}", message);
Thread.Sleep(1000);
Console.WriteLine(" [x] Done");
//忘记使用BasicAck是一个常见的错误。虽然是个简单的错误，但是后果严重。消息会在客户端退出后重新投送（就像是随机进行的重新投送），但是由于RabbitMQ无法释放任何未经确认的消息，内存占用会越来越严重。
//手动确认消息完成
channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
};
///param1:消费哪个队列的消息 队列名称
///param2:开始消息的自动确认机制
///param3;消费时的回调接口
channel.BasicConsume(queue: "task_query",
autoAck: false,
consumer: consumer);
Console.WriteLine(" Press [enter] to exit.");
Console.ReadLine();
});
}
public static async Task RunDefault()
{
var builder = new RabbitMQConnectionFactoryBuilder(new DnsEndPoint(Host, 5672));
var factory = builder.Build();
var connection = factory.CreateConnection();
await connection.StartAsync();
var channel = await connection.OpenChannel();
await channel.ExchangeDeclareAsync(ExchangeDeclare.Create("TestExchange", ExchangeType.Direct));
await channel.ExchangeDeclareAsync(ExchangeDeclare.CreateNoWait("TestExchange2", ExchangeType.Direct));
var declareOk = await channel.QueueDeclareAsync(QueueDeclare.Create("TestQueue"));
await channel.QueueDeclareNoWaitAsync(QueueDeclare.Create("TestQueue2"));
var purgeOk = await channel.QueuePurgeAsync(QueuePurge.Create("TestQueue"));
await channel.QueuePurgeNoWaitAsync(QueuePurge.Create("TestQueue2"));
await channel.QueueBindAsync(QueueBind.Create("TestQueue", "TestExchange"));
await channel.QueueBindAsync(QueueBind.CreateNoWait("TestQueue2", "TestExchange2"));
var consumer = new RabbitMQConsumer(channel, ConsumeConf.Create("TestQueue", "TestConsumer", true));
consumer.Received += (sender, result) =>
{
//await channel.Ack(deliver.DeliveryTag, false);
//Console.WriteLine(Encoding.UTF8.GetString(result.Body));
};
await channel.ConsumerStartAsync(consumer);
await channel.Publish("TestExchange", string.Empty, false, false, new ContentHeaderProperties(), new byte[16 * 1024 * 1024 + 1]);
//await channel.QueueUnbindAsync(QueueUnbind.Create("TestQueue", "TestExchange"));
//await channel.QueueUnbindAsync(QueueUnbind.Create("TestQueue2", "TestExchange2"));
//var deleteOk = await channel.QueueDeleteAsync(QueueDelete.Create("TestQueue"));
//await channel.QueueDeleteNoWaitAsync(QueueDelete.Create("TestQueue2"));
//await channel.ExchangeDeleteAsync(ExchangeDelete.Create("TestExchange"));
//await channel.ExchangeDeleteAsync(ExchangeDelete.CreateNoWait("TestExchange2"));
await connection.CloseAsync();
await Task.Delay(TimeSpan.FromHours(2));
}
public Task BindAsync(string routingKey)
{
if (!_persistentConnection.IsConnected)
{
_persistentConnection.TryConnect();
}
using (var channel = _persistentConnection.CreateModel())
{
ExchangeDeclare.Declare(channel);
QueueDeclare.Declare(channel);
channel.QueueBind(queue: QueueDeclare.QueueName,
exchange: ExchangeDeclare.ExchangeName,
routingKey: routingKey);
BindingQueueRoutingKeys.TryAdd(routingKey, QueueDeclare.QueueName);
}
return(Task.CompletedTask);
}
private static async Task StartPublisher()
{
var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddConsole();
builder.SetMinimumLevel(LogLevel.Debug);
});
var builder = new RabbitMQConnectionFactoryBuilder(new DnsEndPoint(Host, 5672));
var factory = builder.AddLogger(loggerFactory.CreateLogger(string.Empty))
.ConnectionTimeout(TimeSpan.FromSeconds(30))
.ConnectionAttempts(100)
.Build();
var connection = factory.CreateConnection();
await connection.StartAsync();
var channel = await connection.OpenChannel();
await channel.ExchangeDeclareAsync(ExchangeDeclare.Create("TestExchange", ExchangeType.Direct));
await channel.QueueDeclareAsync(QueueDeclare.Create("TestQueue"));
await channel.QueueBindAsync(QueueBind.Create("TestQueue", "TestExchange"));
var properties = new ContentHeaderProperties();
//properties.AppId = "testapp";
var body = new byte[Size];
int i = 0;
while (true /*!channel.IsClosed*/)
{
//properties.CorrelationId = Guid.NewGuid().ToString();
var result = await channel.Publish("TestExchange", string.Empty, false, false, properties, body);
//if (!result)
//{
// break;
//}
}
//await Task.Delay(TimeSpan.FromHours(1));
}
public void Send()
{
var conn = new GetConnection();
conn.MqHandle((connection, channel) =>
{
//声明一个名为hello的队列
QueueDeclare.QueueDeclareByName("task_query", connection, channel);
//IBasicProperties.SetPersistent设置为true，用来将我们的消息标示成持久化的。
var properties = channel.CreateBasicProperties();
properties.Persistent = true;
#region 关于消息持久化的注释
//消息持久化的注释
//将消息标示为持久化并不能完全保证消息不会丢失。尽管它会告诉RabbitMQ将消息存储到硬盘上，但是在RabbitMQ接收到消息并将其进行存储两个行为之间仍旧会有一个窗口期。同样的，RabbitMQ也不会对每一条消息执行fsync(2)，所以消息获取只是存到了缓存之中，而不是硬盘上。虽然持久化的保证不强，但是应对我们简单的任务队列已经足够了
#endregion
for (int i = 0; i < 1000; i++)
{
var body = Encoding.UTF8.GetBytes(i.ToString());
//消息写入到hello队列中
///param1:交换机名称
///param2:队列名称
///param3:传递消息额外设置
///param4:消息具体内容
channel.BasicPublish(exchange: "",
routingKey: "task_query",
basicProperties: properties,
body: body);
Console.WriteLine(" [x] Sent {0}", i);
}
});
Console.WriteLine(" Press [enter] to exit.");
Console.ReadLine();
}
private static async Task Main(string[] args)
{
var builder = new RabbitMQConnectionFactoryBuilder(new DnsEndPoint(Host, 5672));
var factory = builder.Build();
var connection = factory.CreateConnection();
await connection.StartAsync();
var channel = await connection.OpenChannel();
await channel.ExchangeDeclareAsync(ExchangeDeclare.Create("TestExchange", ExchangeType.Direct));
await channel.QueueDeclareAsync(QueueDeclare.Create("TestQueue"));
await channel.QueueBindAsync(QueueBind.Create("TestQueue", "TestExchange"));
var properties = new ContentHeaderProperties();
properties.AppId = "testapp";
//var body = new byte[16 * 1024 * 1024 + 1];
var body = new byte[32];
//var body = new byte[16*1024];
//var body = new byte[128*1024];
//var body = new byte[512 * 1024];
//var body = new byte[1 * 1024 * 1024];
//var body = new byte[1024];
while (true /*!channel.IsClosed*/)
{
properties.CorrelationId = Guid.NewGuid().ToString();
await channel.Publish("TestExchange", string.Empty, false, false, properties, body);
}
//await Task.Delay(TimeSpan.FromHours(1));
}
protected virtual void OnQueueDeclare(MessageReceivedEventArgs e)
{
QueueDeclare?.Invoke(this, e);
}
public virtual void QueueDeclare(C context, QueueDeclare mystruct)
{
}
public static async ValueTask QueueDeclareNoWaitAsync(this RabbitMQSession session, RabbitMQChannel channel, QueueDeclare queue)
{
session.Channels.TryGetValue(channel.ChannelId, out var src);
var data = session.GetChannelData(channel.ChannelId);
queue.NoWait = true;
await session.Writer.SendQueueDeclareAsync(channel.ChannelId, queue).ConfigureAwait(false);
data.Queues.Add(queue.Name, queue);
}
public static async ValueTask <QueueDeclareOk> QueueDeclareAsync(this RabbitMQSession session, RabbitMQChannel channel, QueueDeclare queue)
{
session.Channels.TryGetValue(channel.ChannelId, out var src);
var data = session.GetChannelData(channel.ChannelId);
src.QueueTcs = new TaskCompletionSource <QueueDeclareOk>(TaskCreationOptions.RunContinuationsAsynchronously);
queue.NoWait = false;
await session.Writer.SendQueueDeclareAsync(channel.ChannelId, queue).ConfigureAwait(false);
var declare = await src.QueueTcs.Task.ConfigureAwait(false);
data.Queues.Add(queue.Name, queue);
return(declare);
}
public static async Task ChannelTest()
{
var loggerFactory = LoggerFactory.Create(builder =>
{
//builder.AddConsole();
builder.SetMinimumLevel(LogLevel.Information);
});
var builder = new RabbitMQConnectionFactoryBuilder(new DnsEndPoint(Host, 5672));
var factory = builder.AddLogger(loggerFactory.CreateLogger(string.Empty))
.ConnectionTimeout(TimeSpan.FromSeconds(30))
.ConnectionAttempts(100000)
.Build();
var connection = factory.CreateConnection();
await connection.StartAsync();
var channel1 = await connection.OpenChannel();
var channel2 = await connection.OpenChannel();
await channel1.ExchangeDeclareAsync(ExchangeDeclare.Create("TestExchange", ExchangeType.Direct));
await channel1.ExchangeDeclareAsync(ExchangeDeclare.CreateNoWait("TestExchange2", ExchangeType.Direct));
var declareOk = await channel1.QueueDeclareAsync(QueueDeclare.Create("TestQueue"));
await channel1.QueueDeclareNoWaitAsync(QueueDeclare.Create("TestQueue2"));
var purgeOk = await channel1.QueuePurgeAsync(QueuePurge.Create("TestQueue"));
await channel1.QueuePurgeNoWaitAsync(QueuePurge.Create("TestQueue2"));
await channel1.QueueBindAsync(QueueBind.Create("TestQueue", "TestExchange"));
await channel1.QueueBindAsync(QueueBind.CreateNoWait("TestQueue2", "TestExchange2"));
var body1 = new byte[Size];
var consumer1 = new RabbitMQConsumer(channel1, ConsumeConf.Create("TestQueue", "TestConsumer", true));
consumer1.Received += async(sender, result) =>
{
//await channel1.Ack(deliver.DeliveryTag, true);
var propertiesConsume = new ContentHeaderProperties();
propertiesConsume.AppId = "testapp2";
var published = await channel2.Publish("TestExchange2", string.Empty, false, false, propertiesConsume, body1);
};
var consumer2 = new RabbitMQConsumer(channel2, ConsumeConf.Create("TestQueue2", "TestConsumer2", true));
consumer2.Received += async(sender, result) =>
{
//await channel2.Ack(deliver.DeliveryTag, true);
var propertiesConsume = new ContentHeaderProperties();
propertiesConsume.AppId = "testapp1";
var published = await channel1.Publish("TestExchange", string.Empty, false, false, propertiesConsume, body1);
};
await channel1.ConsumerStartAsync(consumer1);
await channel2.ConsumerStartAsync(consumer2);
var firtsTask = Task.Run(async() =>
{
var properties = new ContentHeaderProperties();
properties.AppId = "testapp1";
while (true /*!channel1.IsClosed*/)
{
var published = await channel1.Publish("TestExchange", string.Empty, false, false, properties, body1);
}
});
var secondTask = Task.Run(async() =>
{
var properties = new ContentHeaderProperties();
properties.AppId = "testapp2";
while (true /*!channel2.IsClosed*/)
{
var published = await channel2.Publish("TestExchange2", string.Empty, false, false, properties, body1);
}
});
await Task.Delay(TimeSpan.FromHours(1));
}
public ValueTask QueueDeclareNoWaitAsync(QueueDeclare queue)
{
queue.NoWait = true;
return(Session.QueueDeclareNoWaitAsync(this, queue));
}
public ValueTask <QueueDeclareOk> QueueDeclareAsync(QueueDeclare queue)
{
return(Session.QueueDeclareAsync(this, queue));
}
