public static IObservable<IBusMessage<T>> CreateObervableBatch<T>(this SubscriptionClient client, int messageCount, CancellationToken cancellationToken)
{
Func<IObserver<ServiceBusBusMessage<T>>, Task> t = async (observer) => {
try
{
while (!client.IsClosed)
{
cancellationToken.ThrowIfCancellationRequested();
var messages = await client.ReceiveBatchAsync(messageCount);
if (messages == null)
{
observer.OnCompleted();
break;
}
foreach (var message in messages)
{
observer.OnNext(new ServiceBusBusMessage<T>(message));
}
}
}
catch (Exception e)
{
observer.OnError(e);
}
};
return Observable
.Create<ServiceBusBusMessage<T>>(t)
.Publish()
.RefCount();
}
public async Task <IEnumerable <IMessage <T> > > ReceiveBatchAsAsync(int batchSize)
{
return(await _executionPolicy.ExecuteAsync(async() =>
{
try
{
if (!_clientOpen)
{
OpenClient();
}
var messages = new List <IMessage <T> >();
var brokeredMessages = await _client.ReceiveBatchAsync(batchSize);
foreach (var brokeredMessage in brokeredMessages)
{
var message = await DeserialiseAzureBrokeredMessage(brokeredMessage);
if (message != null)
{
messages.Add(message);
}
}
return messages;
}
catch (SessionLockLostException)
{
RefreshClient();
throw;
}
}));
}
/// <summary>
/// Retrieves the given number of messages
/// </summary>
/// <param name="numberOfMessages">Number of messages to retrieve</param>
/// <param name="seconds">Waiting time</param>
/// <returns>The messages retrieved</returns>
public async Task<IEnumerable<IBrokeredMessage>> RetrieveAsync(
int numberOfMessages = 1, int seconds = 1)
{
var messages = await _client.ReceiveBatchAsync(
numberOfMessages, new TimeSpan(0, 0, seconds));
return Transform(messages);
}
public async Task <ICollection <BrokeredMessage> > GetMessagesAsync(string subscriptionName)
{
if (string.IsNullOrEmpty(subscriptionName))
{
throw new DSWException(SUBSCRIPTION_NOT_INITIALIZE, null, DSWExceptionCode.SS_Mapper);
}
SubscriptionClient client = SubscriptionClient.Create(TopicName, subscriptionName, ReceiveMode.ReceiveAndDelete);
return((await client.ReceiveBatchAsync(1)).ToList());
}
public async Task when_forwarding_multiple_messages_all_lock_tokens_are_returned_and_the_messages_are_forwarded()
{
var forwarder = new TopicMessageForwarder(topicClient, null);
var messagesToForward = new List <BrokeredMessage>();
messagesToForward.Add(await MessageFactory.CreateMessageWithJsonBody());
messagesToForward.Add(await MessageFactory.CreateMessageWithJsonBody());
await topicClient.SendBatchAsync(messagesToForward);
var receivedMessages = await subscriptionClient.ReceiveBatchAsync(100);
returnedLockTokens = await forwarder.ForwardMessages(receivedMessages);
forwardedMessages = await subscriptionClient.ReceiveBatchAsync(100);
Assert.That(returnedLockTokens.Count(), Is.EqualTo(2));
CollectionAssert.AllItemsAreUnique(returnedLockTokens);
Assert.That(forwardedMessages.Count(), Is.EqualTo(2));
}
private Task <IEnumerable <BrokeredMessage> > ReceiveBatchAsync(int messageCount, TimeSpan serverWaitTime)
{
return(_subscriptionClient.ReceiveBatchAsync(messageCount, serverWaitTime));
}
public async Task <IEnumerable <BrokeredMessage> > ReceiveAsync(string connectionString, string topic, string subscription, ReceiveMode receiveMode, int batchSize, int timeoutMilliSeconds)
{
SubscriptionClient subscribeClient = ServiceBusConnectionsFactory.GetSubscriptionClient(connectionString, topic, subscription);
return(await subscribeClient.ReceiveBatchAsync(1000, new TimeSpan(0, 0, 0, 0, timeoutMilliSeconds)));
}
public Task <IEnumerable <BrokeredMessage> > ReceieveMessages(int batchSize)
{
return(client.ReceiveBatchAsync(batchSize));
}
public Task <IEnumerable <BrokeredMessage> > ReceiveBatchAsync(int messageCount, TimeSpan serverWaitTime) => _client.ReceiveBatchAsync(messageCount, serverWaitTime);