public void Send_Receive_Message()
{
using (IBus bus = new RabbitMQBus())
{
using (IChannelFactory <ITestContract> channelFactory = new MessageBus.Core.Proxy.ChannelFactory <ITestContract>(bus))
{
ISubscriptionFactory <ITestContract> subscriptionFactory = new SubscriptionFactory <ITestContract>(bus, c => c.SetReceiveSelfPublish());
string actual = "";
ManualResetEvent ev = new ManualResetEvent(false);
using (ISubscriptionSelector <ITestContract> selector = subscriptionFactory.Subscribe())
{
selector.Subscribe <string>(contract => contract.Foo, s =>
{
actual = s;
ev.Set();
});
ITestContract channel = channelFactory.CreateChannel();
channel.Foo("boo");
ev.WaitOne(TimeSpan.FromSeconds(5));
actual.Should().Be("boo");
}
}
}
}
public EasyNetQSubscriber(IErrorHandlingStrategy errorHandlingStrategy, IAdvancedBus bus, IQueue queue, ushort prefetchcount,
ISubscriptionSelector subscriptionSelector, ISuccessHandlingStrategy successHandlingStrategy, IDisposable nameHandle)
{
_errorHandlingStrategy = errorHandlingStrategy;
_successHandlingStrategy = successHandlingStrategy;
_bus = bus;
_queue = queue;
_prefetchcount = prefetchcount;
_subscriptionSelector = subscriptionSelector;
_nameHandle = nameHandle;
}
public void Send_Receive_CustomSerializationMessage()
{
using (IBus bus = new RabbitMQBus())
{
using (IChannelFactory <ITestContract> channelFactory = new MessageBus.Core.Proxy.ChannelFactory <ITestContract>(bus, c => c.UseJsonSerializerSettings(new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto
})))
{
ISubscriptionFactory <ITestContract> subscriptionFactory = new SubscriptionFactory <ITestContract>(bus);
Data actual = null;
ManualResetEvent ev = new ManualResetEvent(false);
Data data = new Data
{
Value = "boo"
};
using (ISubscriptionSelector <ITestContract> selector = subscriptionFactory.Subscribe(c => c.SetReceiveSelfPublish().UseJsonSerializerSettings(new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto
})))
{
selector.Subscribe <Data>(contract => contract.Foo, s =>
{
actual = s;
ev.Set();
});
ITestContract channel = channelFactory.CreateChannel();
channel.Foo(data);
ev.WaitOne(TimeSpan.FromSeconds(5));
actual.ShouldBeEquivalentTo(data);
}
}
}
}
public async Task <ISubscriber> CreateSubscriberAsync(string name, IEnumerable <string> routings, int retrycount, int prefetchcount,
bool explicitAcknowledgments, ISubscriptionSelector subscriptionSelector)
{
return(await CreateSubscriberAsync(name, false, null, routings, retrycount, prefetchcount,
explicitAcknowledgments, subscriptionSelector, true));
}
public async Task <ISubscriber> CreateSubscriberAsync(string name, IEnumerable <string> routings,
int retrycount, int prefetchcount, ISubscriptionSelector subscriptionSelector, bool storedeadletter)
{
return(await CreateSubscriberAsync(name, false, null, routings,
retrycount, prefetchcount, false, new DefaultSubscriptionSelector(), storedeadletter));
}
private async Task <ISubscriber> CreateSubscriberAsync(string name, bool temporary, Action temporaryQueueDisconnected,
IEnumerable <string> routings, int retrycount, int prefetchcount, bool explicitAcknowledgments, ISubscriptionSelector subscriptionSelector, bool storedeadletter)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("name argument can not be null or empty");
}
if ((routings != null) && (routings.Any(routing => string.IsNullOrEmpty(routing)) || !routings.Any()))
{
throw new ArgumentException("routings argument can not be empty or contain empty strings");
}
if (retrycount < 0)
{
throw new ArgumentException("retrycount argument can not be less than zero");
}
if (temporaryQueueDisconnected != null)
{
_broker.RegisterDisconnectedAction(temporaryQueueDisconnected);
}
//Main subscriber queue and bindings
var queue = await _bus.QueueDeclareAsync(
_environmentNamingConventionController.GetQueueName(name), false, true, temporary);
if (routings != null)
{
foreach (var routing in routings)
{
await _bus.BindAsync(await _exchange, queue, routing);
}
}
//Retry subscriber queue and bindings
for (int i = 1; i <= retrycount; i++)
{
var retryqueueroutingkey = _environmentNamingConventionController.GetRetryRoutingKey(name, i);
var retryqueuequeuename = _environmentNamingConventionController.GetRetryQueueName(name, i);
var queueretrybinding = await _bus.BindAsync(await _exchange, queue,
retryqueueroutingkey);
var retryqueue = await _bus.QueueDeclareAsync(retryqueuequeuename,
false, true, temporary, false, _retryfactor *i, null, null, (await _exchange).Name);
var retryqueuebinding =
await _bus.BindAsync(_easyNetQPublisherToWaitExchange.Exchange,
retryqueue, retryqueueroutingkey);
}
//Dead letter subscriber queue and bindings
if (storedeadletter)
{
var deadletterqueueroutingkey = _environmentNamingConventionController
.GetDeadLetterQueueRoutingKey(name);
var deadletterqueuequeuename = _environmentNamingConventionController.
GetDeadLetterQueueName(name);
var deadletterqueue = await _bus.QueueDeclareAsync(deadletterqueuequeuename, false, true, temporary);
var deadletterqueuebinding = await
_bus.BindAsync(_easyNetQPublisherToWaitExchange.Exchange, deadletterqueue,
deadletterqueueroutingkey);
}
//Direct Routing Key binding
var directroutingkey = _environmentNamingConventionController.GetDirectRoutingKey(name);
var queuedirectroutingkeybinding = await _bus.BindAsync(await _exchange, queue,
directroutingkey);
if (_subscriberController.RegisterSubscriberName(name, out IDisposable nameHandle))
{
var executionHandler = new ExecutionHandlingStrategy(name, _easyNetQPublisherToWaitExchange,
retrycount, _environmentNamingConventionController, explicitAcknowledgments, _publisher, storedeadletter);
return(new EasyNetQSubscriber(executionHandler, _bus, queue, (ushort)prefetchcount,
subscriptionSelector, executionHandler, nameHandle));
}
else
{
throw new SubscriberAlreadyExistsException($"The subscriber " +
$"with name {name}" +
$" already exists");
}
}
public async Task <ISubscriber> CreateSubscriberAsync(string name, Action temporaryQueueDisconnected, IEnumerable <string> routings,
int retrycount, bool storedeadletter, int prefetchcount, bool explicitAcknowledgments, ISubscriptionSelector subscriptionSelector)
{
return(await CreateSubscriberAsync(name, true, temporaryQueueDisconnected, routings,
retrycount, prefetchcount, explicitAcknowledgments, new DefaultSubscriptionSelector(), storedeadletter));
}
public async Task <ISubscriber> CreateSubscriberAsync(string name, Action temporaryQueueDisconnected, IEnumerable <string> routings,
int retrycount, int prefetchcount, ISubscriptionSelector subscriptionSelector)
{
return(await CreateSubscriberAsync(name, true, temporaryQueueDisconnected, routings,
retrycount, prefetchcount, false, new DefaultSubscriptionSelector(), true));
}
public async Task <ISubscriber> CreateSubscriberAsync(string name, bool temporary, IEnumerable <string> routings,
int retrycount, int prefetchcount, bool explicitAcknowledgments, ISubscriptionSelector subscriptionSelector, bool storedeadletter)
{
return(await CreateSubscriberAsync(name, temporary, null, routings,
retrycount, prefetchcount, explicitAcknowledgments, subscriptionSelector, storedeadletter));
}
