private static async Task PublishMessageToTopic()
{
using ServiceBusMessageBatch messageBatch = await _sender.CreateMessageBatchAsync();
for (int i = 0; i < 10; i++)
{
if (!messageBatch.TryAddMessage(new ServiceBusMessage($"Message {i}")))
{
throw new Exception($"The message {i} is too large to fit in the batch");
}
}
try
{
await _sender.SendMessagesAsync(messageBatch);
Console.WriteLine("A batch of message has been sent to the topic");
}
finally
{
await _sender.DisposeAsync();
await _topicClient.DisposeAsync();
}
Console.WriteLine("Press enter to end the application");
Console.ReadKey();
}
public void Dispose()
{
_sender.DisposeAsync().GetAwaiter().GetResult();
_sender = null;
_client.DisposeAsync().GetAwaiter().GetResult();
_client = null;
}
public async Task SendMessage <T>(string queueOrTopicName, ServiceBusMessage <T> message, CancellationToken cancellationToken)
where T : class
{
ServiceBusSender publisher = null;
try
{
publisher = _client.CreateSender(queueOrTopicName);
var messageAsJson = JsonConvert.SerializeObject(message);
var serviceBusMessage = new ServiceBusMessage(messageAsJson)
.EnrichWithMetadata(message)
.SetCorrelationId(message)
.SetSessionId(message);
await publisher.SendMessageAsync(serviceBusMessage, cancellationToken);
}
catch (Exception ex)
{
_logger.LogError(ex, "Service Bus message sending error");
throw new ServiceBusPublisherOperationException("Service Bus message sending error", ex);
}
finally
{
if (publisher != null)
{
await publisher.DisposeAsync();
}
}
}
static async Task SendSalesMessageAsync()
{
await using var client = new ServiceBusClient(ServiceBusConnectionString);
await using ServiceBusSender sender = client.CreateSender(QueueName);
try
{
string messageBody = $"$10,000 order for bicycle parts from retailer Adventure Works.";
var message = new ServiceBusMessage(messageBody);
Console.WriteLine($"Sending message: {messageBody}");
await sender.SendMessageAsync(message);
}
catch (Exception exception)
{
Console.WriteLine($"{DateTime.Now} :: Exception: {exception.Message}");
}
finally
{
// Calling DisposeAsync on client types is required to ensure that network
// resources and other unmanaged objects are properly cleaned up.
await sender.DisposeAsync();
await client.DisposeAsync();
}
}
public static async Task Main(string[] args)
{
client = new ServiceBusClient(connectionString);
sender = client.CreateSender(queueName);
using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
for (int i = 1; i <= numOfMessages; i++)
{
if (!messageBatch.TryAddMessage(new ServiceBusMessage($"Message {i}")))
{
throw new Exception($"The message {i} is too large to fit in the batch.");
}
}
try
{
await sender.SendMessagesAsync(messageBatch);
Console.WriteLine($"A batch of {numOfMessages} messages has been published to the queue.");
}
finally
{
await sender.DisposeAsync();
await client.DisposeAsync();
}
}
private static async Task SendMessagesToServicebus(ServiceBusSender sender, string QueueOrTopic, string BatchOrSingle, int numMessagesToSend)
{
if (BatchOrSingle == "batch")
{
using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
for (var i = 0; i < numMessagesToSend; i++)
{
try
{
if (!messageBatch.TryAddMessage(new ServiceBusMessage($"Message {i}")))
{
throw new Exception($"Failed to add message to the batch.");
}
}
catch (ServiceBusException sbe)
{
WriteLine($"ServiceBusException: {sbe.Message}");
}
catch (Exception ex)
{
WriteLine($"{DateTime.Now} > Exception: {ex.Message}");
}
}
try
{
await sender.SendMessagesAsync(messageBatch);
}
finally
{
await sender.DisposeAsync();
}
}
else if (BatchOrSingle == "single")
{
for (int i = 0; i < numMessagesToSend; i++)
{
try
{
ServiceBusMessage message = new ServiceBusMessage($"Topic-Message-{i}-{Guid.NewGuid().ToString("N")}-{DateTime.Now.Minute}");
WriteLine($"Sending message: {message.Body}");
await sender.SendMessageAsync(message);
}
catch (ServiceBusException sbe)
{
WriteLine($"ServiceBusException: {sbe.Message}");
}
catch (Exception ex)
{
WriteLine($"{DateTime.Now} > Exception: {ex.Message}");
}
}
}
else
{
WriteLine($"0 messages sent. You entered {QueueOrTopic} instead of either 'Queue' or 'Topic'.");
}
WriteLine($"{numMessagesToSend} messages sent.");
}
public async void Dispose()
{
// stop processing
await processor.StopProcessingAsync();
await processor.DisposeAsync();
await sender.DisposeAsync();
await serviceBusClient.DisposeAsync();
}
static async Task Main()
{
// The Service Bus client types are safe to cache and use as a singleton for the lifetime
// of the application, which is best practice when messages are being published or read
// regularly.
//
// Create the clients that we'll use for sending and processing messages.
client = new ServiceBusClient(connectionString);
sender = client.CreateSender(queueName);
// create a batch
using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
for (int i = 1; i <= numOfMessages; i++)
{
// try adding a message to the batch
if (!messageBatch.TryAddMessage(new ServiceBusMessage($"Message {i} Data")))
{
// if it is too large for the batch
throw new Exception($"The message {i} is too large to fit in the batch.");
}
}
try
{
// Use the producer client to send the batch of messages to the Service Bus queue
await sender.SendMessagesAsync(messageBatch);
Console.WriteLine($"A batch of {numOfMessages} messages has been published to the queue.");
}
finally
{
// Calling DisposeAsync on client types is required to ensure that network
// resources and other unmanaged objects are properly cleaned up.
await sender.DisposeAsync();
await client.DisposeAsync();
}
Console.WriteLine("Press any key to end the application");
Console.ReadKey();
}
public async Task SendMessage(string queueOrTopicName, ServiceBusReceivedMessage message, CancellationToken cancellationToken)
{
ServiceBusSender publisher = null;
try
{
publisher = _client.CreateSender(queueOrTopicName);
var serviceBusMessage = new ServiceBusMessage(message);
await publisher.SendMessageAsync(serviceBusMessage, cancellationToken);
}
catch (Exception ex)
{
_logger.LogError(ex, "Service Bus message sending error");
throw new ServiceBusPublisherOperationException("Service Bus message sending error", ex);
}
finally
{
if (publisher != null)
{
await publisher.DisposeAsync();
}
}
}
public async Task LogsEvents()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = CreateNoRetryClient();
_listener.SingleEventById(ServiceBusEventSource.ClientCreateStartEvent, e => e.Payload.Contains(nameof(ServiceBusClient)) && e.Payload.Contains(client.FullyQualifiedNamespace));
var messageCount = 10;
ServiceBusSender sender = client.CreateSender(scope.QueueName);
_listener.EventsById(ServiceBusEventSource.ClientCreateStartEvent).Where(e => e.Payload.Contains(nameof(ServiceBusSender)) && e.Payload.Contains(sender.FullyQualifiedNamespace) && e.Payload.Contains(sender.EntityPath));
using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync();
_listener.SingleEventById(ServiceBusEventSource.CreateMessageBatchStartEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.CreateMessageBatchCompleteEvent, e => e.Payload.Contains(sender.Identifier));
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount).AsEnumerable <ServiceBusMessage>();
await sender.SendMessagesAsync(batch);
_listener.SingleEventById(ServiceBusEventSource.CreateSendLinkStartEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.RequestAuthorizationStartEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.RequestAuthorizationCompleteEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.CreateSendLinkCompleteEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.SendMessageStartEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.SendMessageCompleteEvent, e => e.Payload.Contains(sender.Identifier));
Assert.That(
async() => await client.AcceptNextSessionAsync(scope.QueueName),
Throws.InstanceOf <InvalidOperationException>());
_listener.SingleEventById(ServiceBusEventSource.ClientCreateStartEvent, e => e.Payload.Contains(nameof(ServiceBusSessionReceiver)) && e.Payload.Contains(client.FullyQualifiedNamespace) && e.Payload.Contains(scope.QueueName));
_listener.SingleEventById(ServiceBusEventSource.ClientCreateExceptionEvent, e => e.Payload.Contains(nameof(ServiceBusSessionReceiver)) && e.Payload.Contains(client.FullyQualifiedNamespace) && e.Payload.Contains(scope.QueueName));
var receiver = client.CreateReceiver(scope.QueueName);
_listener.SingleEventById(ServiceBusEventSource.ClientCreateStartEvent, e => e.Payload.Contains(nameof(ServiceBusReceiver)) && e.Payload.Contains(client.FullyQualifiedNamespace));
var messageEnum = messages.GetEnumerator();
var remainingMessages = messageCount;
while (remainingMessages > 0)
{
foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(item.DeliveryCount, 1);
}
}
_listener.SingleEventById(ServiceBusEventSource.CreateReceiveLinkStartEvent, e => e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.RequestAuthorizationStartEvent, e => e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.RequestAuthorizationCompleteEvent, e => e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.CreateReceiveLinkCompleteEvent, e => e.Payload.Contains(receiver.Identifier));
Assert.IsTrue(_listener.EventsById(ServiceBusEventSource.ReceiveMessageStartEvent).Any());
Assert.IsTrue(_listener.EventsById(ServiceBusEventSource.ReceiveMessageCompleteEvent).Any());
Assert.AreEqual(0, remainingMessages);
messageEnum.Reset();
foreach (var item in await receiver.PeekMessagesAsync(messageCount))
{
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
}
_listener.SingleEventById(ServiceBusEventSource.CreateManagementLinkStartEvent, e => e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.CreateManagementLinkCompleteEvent, e => e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.PeekMessageStartEvent, e => e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.PeekMessageCompleteEvent, e => e.Payload.Contains(receiver.Identifier));
var seq = await sender.ScheduleMessageAsync(new ServiceBusMessage(), DateTimeOffset.UtcNow.AddMinutes(1));
_listener.SingleEventById(ServiceBusEventSource.ScheduleMessageStartEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.ScheduleMessageCompleteEvent, e => e.Payload.Contains(sender.Identifier));
await sender.CancelScheduledMessageAsync(seq);
_listener.SingleEventById(ServiceBusEventSource.CancelScheduledMessageStartEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.CancelScheduledMessageCompleteEvent, e => e.Payload.Contains(sender.Identifier));
await receiver.DisposeAsync();
_listener.SingleEventById(ServiceBusEventSource.ClientCloseStartEvent, e => e.Payload.Contains(nameof(ServiceBusReceiver)) && e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.ClientCloseCompleteEvent, e => e.Payload.Contains(nameof(ServiceBusReceiver)) && e.Payload.Contains(receiver.Identifier));
// link closed event is fired asynchronously, so add a small delay
await Task.Delay(TimeSpan.FromSeconds(5));
_listener.SingleEventById(ServiceBusEventSource.ReceiveLinkClosedEvent, e => e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.ManagementLinkClosedEvent, e => e.Payload.Contains(receiver.Identifier));
Assert.IsFalse(_listener.EventsById(ServiceBusEventSource.MaxMessagesExceedsPrefetchEvent).Any());
receiver = client.CreateReceiver(scope.QueueName, new ServiceBusReceiverOptions {
PrefetchCount = 10
});
await receiver.ReceiveMessagesAsync(20, TimeSpan.FromSeconds(1));
_listener.SingleEventById(ServiceBusEventSource.MaxMessagesExceedsPrefetchEvent, e => e.Payload.Contains(receiver.Identifier));
await sender.DisposeAsync();
_listener.SingleEventById(ServiceBusEventSource.ClientCloseStartEvent, e => e.Payload.Contains(nameof(ServiceBusSender)) && e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.ClientCloseCompleteEvent, e => e.Payload.Contains(nameof(ServiceBusSender)) && e.Payload.Contains(sender.Identifier));
await client.DisposeAsync();
_listener.SingleEventById(ServiceBusEventSource.ClientCloseStartEvent, e => e.Payload.Contains(nameof(ServiceBusClient)) && e.Payload.Contains(client.Identifier));
_listener.SingleEventById(ServiceBusEventSource.ClientCloseCompleteEvent, e => e.Payload.Contains(nameof(ServiceBusClient)) && e.Payload.Contains(client.Identifier));
}
}
public async Task LogsSessionEvents()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = CreateNoRetryClient();
_listener.SingleEventById(ServiceBusEventSource.ClientCreateStartEvent, e => e.Payload.Contains(nameof(ServiceBusClient)) && e.Payload.Contains(client.FullyQualifiedNamespace));
var messageCount = 10;
ServiceBusSender sender = client.CreateSender(scope.QueueName);
_listener.SingleEventById(ServiceBusEventSource.ClientCreateStartEvent, e => e.Payload.Contains(nameof(ServiceBusSender)) && e.Payload.Contains(sender.FullyQualifiedNamespace) && e.Payload.Contains(sender.EntityPath));
using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync();
_listener.SingleEventById(ServiceBusEventSource.CreateMessageBatchStartEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.CreateMessageBatchCompleteEvent, e => e.Payload.Contains(sender.Identifier));
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, "sessionId").AsEnumerable <ServiceBusMessage>();
await sender.SendMessagesAsync(batch);
_listener.SingleEventById(ServiceBusEventSource.CreateSendLinkStartEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.RequestAuthorizationStartEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.RequestAuthorizationCompleteEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.CreateSendLinkCompleteEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.SendMessageStartEvent, e => e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.SendMessageCompleteEvent, e => e.Payload.Contains(sender.Identifier));
var receiver = client.CreateReceiver(scope.QueueName);
_listener.SingleEventById(ServiceBusEventSource.ClientCreateStartEvent, e => e.Payload.Contains(nameof(ServiceBusReceiver)) && e.Payload.Contains(client.FullyQualifiedNamespace));
// can't use a non-session receiver for session queue
Assert.That(
async() => await receiver.ReceiveMessageAsync(),
Throws.InstanceOf <InvalidOperationException>());
_listener.SingleEventById(ServiceBusEventSource.CreateReceiveLinkStartEvent, e => e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.CreateReceiveLinkExceptionEvent, e => e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.ReceiveMessageStartEvent, e => e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.ReceiveMessageExceptionEvent, e => e.Payload.Contains(receiver.Identifier));
var sessionReceiver = await client.AcceptNextSessionAsync(scope.QueueName);
_listener.EventsById(ServiceBusEventSource.ClientCreateStartEvent).Where(e => e.Payload.Contains(nameof(ServiceBusSessionReceiver)) && e.Payload.Contains(client.FullyQualifiedNamespace)).Any();
_listener.SingleEventById(ServiceBusEventSource.CreateReceiveLinkStartEvent, e => e.Payload.Contains(sessionReceiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.CreateReceiveLinkCompleteEvent, e => e.Payload.Contains(sessionReceiver.Identifier));
var msg = await sessionReceiver.ReceiveMessageAsync();
_listener.SingleEventById(ServiceBusEventSource.ReceiveMessageStartEvent, e => e.Payload.Contains(sessionReceiver.Identifier));
msg = await sessionReceiver.PeekMessageAsync();
_listener.SingleEventById(ServiceBusEventSource.CreateManagementLinkStartEvent, e => e.Payload.Contains(sessionReceiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.CreateManagementLinkCompleteEvent, e => e.Payload.Contains(sessionReceiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.PeekMessageStartEvent, e => e.Payload.Contains(sessionReceiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.PeekMessageCompleteEvent, e => e.Payload.Contains(sessionReceiver.Identifier));
await receiver.DisposeAsync();
_listener.SingleEventById(ServiceBusEventSource.ClientCloseStartEvent, e => e.Payload.Contains(nameof(ServiceBusReceiver)) && e.Payload.Contains(receiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.ClientCloseCompleteEvent, e => e.Payload.Contains(nameof(ServiceBusReceiver)) && e.Payload.Contains(receiver.Identifier));
await sessionReceiver.DisposeAsync();
_listener.SingleEventById(ServiceBusEventSource.ClientCloseStartEvent, e => e.Payload.Contains(nameof(ServiceBusSessionReceiver)) && e.Payload.Contains(sessionReceiver.Identifier));
_listener.SingleEventById(ServiceBusEventSource.ClientCloseCompleteEvent, e => e.Payload.Contains(nameof(ServiceBusSessionReceiver)) && e.Payload.Contains(sessionReceiver.Identifier));
await Task.Delay(TimeSpan.FromSeconds(2));
_listener.SingleEventById(ServiceBusEventSource.ReceiveLinkClosedEvent, e => e.Payload.Contains(sessionReceiver.Identifier) &&
e.Payload.Contains(sessionReceiver.SessionId));
await sender.DisposeAsync();
_listener.SingleEventById(ServiceBusEventSource.ClientCloseStartEvent, e => e.Payload.Contains(nameof(ServiceBusSender)) && e.Payload.Contains(sender.Identifier));
_listener.SingleEventById(ServiceBusEventSource.ClientCloseCompleteEvent, e => e.Payload.Contains(nameof(ServiceBusSender)) && e.Payload.Contains(sender.Identifier));
await client.DisposeAsync();
_listener.SingleEventById(ServiceBusEventSource.ClientCloseStartEvent, e => e.Payload.Contains(nameof(ServiceBusClient)) && e.Payload.Contains(client.Identifier));
_listener.SingleEventById(ServiceBusEventSource.ClientCloseCompleteEvent, e => e.Payload.Contains(nameof(ServiceBusClient)) && e.Payload.Contains(client.Identifier));
}
}
public async ValueTask DisposeAsync()
{
await _serviceBusProcessor.DisposeAsync();
await _serviceBusSender.DisposeAsync();
}
public async ValueTask DisposeAsync()
{
await _sender.CloseAsync();
await _sender.DisposeAsync();
}
public void Dispose()
{
_sbSender.DisposeAsync().GetAwaiter().GetResult();
}
public ValueTask DisposeAsync()
{
return(_sender?.DisposeAsync() ?? ValueTask.CompletedTask);
}
