private string SubscribeToResponse <TRequest, TResponse>()
where TResponse : class
{
var rpcKey = new RpcKey {
Request = typeof(TRequest), Response = typeof(TResponse)
};
responseQueues.AddOrUpdate(rpcKey,
key =>
{
var queue = advancedBus.QueueDeclare(
conventions.RpcReturnQueueNamingConvention(),
passive: false,
durable: false,
exclusive: true,
autoDelete: true);
advancedBus.Consume <TResponse>(queue, (message, messageRecievedInfo) => Task.Factory.StartNew(() =>
{
ResponseAction responseAction;
if (responseActions.TryRemove(message.Properties.CorrelationId, out responseAction))
{
responseAction.OnSuccess(message);
}
}));
return(queue.Name);
},
(_, queueName) => queueName);
return(responseQueues[rpcKey]);
}
protected virtual async Task <string> SubscribeToResponseAsync <TRequest, TResponse>(
CancellationToken cancellationToken
)
{
var responseType = typeof(TResponse);
var requestType = typeof(TRequest);
var rpcKey = new RpcKey(requestType, responseType);
if (responseSubscriptions.TryGetValue(rpcKey, out var responseSubscription))
{
return(responseSubscription.QueueName);
}
using (await responseSubscriptionsLock.AcquireAsync(cancellationToken).ConfigureAwait(false))
{
if (responseSubscriptions.TryGetValue(rpcKey, out responseSubscription))
{
return(responseSubscription.QueueName);
}
var queue = await advancedBus.QueueDeclareAsync(
conventions.RpcReturnQueueNamingConvention(responseType),
c => c.AsDurable(false).AsExclusive(true).AsAutoDelete(true),
cancellationToken
).ConfigureAwait(false);
var exchangeName = conventions.RpcResponseExchangeNamingConvention(responseType);
if (exchangeName != Exchange.GetDefault().Name)
{
var exchange = await exchangeDeclareStrategy.DeclareExchangeAsync(
exchangeName,
ExchangeType.Direct,
cancellationToken
).ConfigureAwait(false);
await advancedBus.BindAsync(exchange, queue, queue.Name, cancellationToken).ConfigureAwait(false);
}
var subscription = advancedBus.Consume <TResponse>(queue, (message, messageReceivedInfo) =>
{
if (responseActions.TryRemove(message.Properties.CorrelationId, out var responseAction))
{
responseAction.OnSuccess(message);
}
});
responseSubscriptions.TryAdd(rpcKey, new ResponseSubscription(queue.Name, subscription));
return(queue.Name);
}
}
protected virtual string SubscribeToResponse <TRequest, TResponse>()
where TResponse : class
{
var responseType = typeof(TResponse);
var rpcKey = new RpcKey {
Request = typeof(TRequest), Response = responseType
};
if (responseQueues.TryGetValue(rpcKey, out ResponseQueueWithCancellation queueWithCancellation))
{
return(queueWithCancellation.QueueName);
}
lock (responseQueuesAddLock)
{
if (responseQueues.TryGetValue(rpcKey, out queueWithCancellation))
{
return(queueWithCancellation.QueueName);
}
var queue = advancedBus.QueueDeclare(
conventions.RpcReturnQueueNamingConvention(),
passive: false,
durable: false,
exclusive: true,
autoDelete: true);
var exchange = DeclareAndBindRpcExchange(
conventions.RpcResponseExchangeNamingConvention(responseType),
queue,
queue.Name);
var cancellation = advancedBus.Consume <TResponse>(queue, (message, messageReceivedInfo) => Task.Factory.StartNew(() =>
{
ResponseAction responseAction;
if (responseActions.TryRemove(message.Properties.CorrelationId, out responseAction))
{
responseAction.OnSuccess(message);
}
}));
responseQueues.TryAdd(rpcKey, new ResponseQueueWithCancellation {
QueueName = queue.Name, Cancellation = cancellation
});
return(queue.Name);
}
}
protected virtual string SubscribeToResponse()
{
var responseType = typeof(byte[]);
var rpcKey = new RpcKey {
Request = typeof(byte[]), Response = responseType
};
string queueName;
if (responseQueues.TryGetValue(rpcKey, out queueName))
{
return(queueName);
}
lock (responseQueuesAddLock)
{
if (responseQueues.TryGetValue(rpcKey, out queueName))
{
return(queueName);
}
var queue = advancedBus.QueueDeclare(
conventions.RpcReturnQueueNamingConvention(),
passive: false,
durable: false,
exclusive: true,
autoDelete: true);
advancedBus.Consume(queue, (message, messageProperties, messageReceivedInfo) => Task.Factory.StartNew(() =>
{
ResponseAction responseAction;
if (responseActions.TryRemove(messageProperties.CorrelationId, out responseAction))
{
responseAction.OnSuccessByte(message, messageProperties);
}
}));
responseQueues.TryAdd(rpcKey, queue.Name);
return(queue.Name);
}
}
