public void Dispose()
{
_processor.DisposeAsync().GetAwaiter().GetResult();
_processor = null;
_client.DisposeAsync().GetAwaiter().GetResult();
_client = null;
}
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();
}
}
//private static string _subscriptionName = "demosubscription2";
static async Task Main(string[] args)
{
var connStr = "";
var topicName = "demotopic1";
_topicClient = new ServiceBusClient(connStr);
_processor = _topicClient.CreateProcessor(topicName, _subscriptionName, new ServiceBusProcessorOptions());
try
{
_processor.ProcessMessageAsync += MessageHandler;
_processor.ProcessErrorAsync += ErrorHandler;
await _processor.StartProcessingAsync();
Console.WriteLine("Wait for a minute and then press any key to end the processing");
Console.ReadKey();
Console.WriteLine("Stopping");
await _processor.StopProcessingAsync();
Console.WriteLine("Stopped");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message.ToString());
}
finally
{
await _processor.DisposeAsync();
await _topicClient.DisposeAsync();
}
}
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();
}
static async Task MainAsync()
{
serviceBusClient = new ServiceBusClient(ServiceBusConnectionString);
serviceBusProcessor = serviceBusClient.CreateProcessor(TopicName, SubscriptionName, RegisterOptions());
//serviceBusProcessor = serviceBusClient.CreateProcessor(QueueName, RegisterOptions());
serviceBusProcessor.ProcessErrorAsync += ExceptionReceivedHandler;
serviceBusProcessor.ProcessMessageAsync += ProcessMessagesAsync;
Console.WriteLine("======================================================");
Console.WriteLine("Press ENTER key to exit after receiving all the messages.");
Console.WriteLine("======================================================");
// Register the queue message handler and receive messages in a loop
try
{
serviceBusProcessor.StartProcessingAsync();
}
catch (ServiceBusException e)
{
System.Console.WriteLine("OH SNAP!: " + e.Message);
}
Console.ReadLine();
await serviceBusProcessor.StopProcessingAsync();
await serviceBusProcessor.CloseAsync();
await serviceBusClient.DisposeAsync();
}
public async Task MetricsInstanceIsNotMutated()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString, new ServiceBusClientOptions { EnableTransportMetrics = true });
ServiceBusSender sender = client.CreateSender(scope.QueueName);
await sender.SendMessageAsync(new ServiceBusMessage());
var metrics = client.GetTransportMetrics();
var firstHeartBeat = metrics.LastHeartBeat;
var firstOpen = metrics.LastConnectionOpen;
Assert.GreaterOrEqual(firstOpen, firstHeartBeat);
SimulateNetworkFailure(client);
await sender.SendMessageAsync(new ServiceBusMessage());
Assert.AreEqual(firstOpen, metrics.LastConnectionOpen);
await client.DisposeAsync();
// The close frame does not come back from the service before the DisposeAsync
// call is returned.
await Task.Delay(500);
Assert.IsNull(metrics.LastConnectionClose);
}
}
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();
}
}
public void Dispose()
{
_sender.DisposeAsync().GetAwaiter().GetResult();
_sender = null;
_client.DisposeAsync().GetAwaiter().GetResult();
_client = null;
}
static async Task Main()
{
client = new ServiceBusClient(connectionString);
processor = client.CreateProcessor(queueName, new ServiceBusProcessorOptions());
try
{
processor.ProcessMessageAsync += MessageHandler;
processor.ProcessErrorAsync += ErrorHandler;
await processor.StartProcessingAsync();
Console.WriteLine("Wait for a minute and then press any key to end the processing");
Console.ReadKey();
Console.WriteLine("\nStopping the receiver...");
await processor.StopProcessingAsync();
Console.WriteLine("Stopped receiving messages");
}
finally
{
await processor.DisposeAsync();
await client.DisposeAsync();
}
}
protected virtual async Task DisposeInternal()
{
// Hmmm... why does StopProcessingAsync take so long?
_ = Task.Run(() => { try { _processor.StopProcessingAsync().Wait(); } catch { } });
try { await DeleteSubscription(_connectionString, _topic, _subscription); } catch { }
try { await _client.DisposeAsync().AsTask(); } catch { }
}
static async Task ReceiveMessagesAsync()
{
ServiceBusClient client = new ServiceBusClient(connectionString);
// create a processor that we can use to process the messages
ServiceBusProcessor processor = client.CreateProcessor(queueName, new ServiceBusProcessorOptions());
// add handler to process messages
processor.ProcessMessageAsync += MessageHandler;
// add handler to process any errors
processor.ProcessErrorAsync += ErrorHandler;
// start processing
await processor.StartProcessingAsync();
Console.WriteLine("Wait for a minute and then press any key to end the processing");
Console.ReadKey();
// stop processing
Console.WriteLine("\nStopping the receiver...");
await processor.StopProcessingAsync();
await client.DisposeAsync();
Console.WriteLine("Stopped receiving messages");
}
public override async Task StopAsync(CancellationToken cancellationToken)
{
await processor.DisposeAsync();
await serviceBusClient.DisposeAsync();
await base.StopAsync(cancellationToken);
}
public async Task CloseConnectionAsync()
{
await _serviceBusSender.CloseAsync();
await _serviceBusClient.DisposeAsync();
Console.WriteLine("Client connection closed");
}
public async ValueTask DisposeAsync()
{
if (!(_client is null))
{
await _client.DisposeAsync().ConfigureAwait(false);
}
GC.SuppressFinalize(this);
}
public async Task CancelScheduledMessagesAsyncValidatesClientIsNotDisposed()
{
await using var client = new ServiceBusClient("not.real.com", Mock.Of <TokenCredential>());
await using var sender = client.CreateSender("fake");
await client.DisposeAsync();
Assert.That(async() => await sender.CancelScheduledMessagesAsync(new[] { 12345L, 678910L }),
Throws.InstanceOf <ObjectDisposedException>().And.Property(nameof(ObjectDisposedException.ObjectName)).EqualTo(nameof(ServiceBusConnection)));
}
public async Task RenewMessageLockValidatesClientIsNotDisposed()
{
await using var client = new ServiceBusClient("not.real.com", Mock.Of <TokenCredential>());
await using var receiver = client.CreateReceiver("fake");
await client.DisposeAsync();
Assert.That(async() => await receiver.RenewMessageLockAsync(new ServiceBusReceivedMessage()),
Throws.InstanceOf <ObjectDisposedException>().And.Property(nameof(ObjectDisposedException.ObjectName)).EqualTo(nameof(ServiceBusConnection)));
}
public async Task CloseConnectionAsync()
{
await _serviceBusProcessor.StopProcessingAsync();
await _serviceBusProcessor.CloseAsync();
await _serviceBusClient.DisposeAsync();
Console.WriteLine("Client connection closed");
}
public async Task ScheduleMessagesAsyncValidatesClientIsNotDisposed()
{
await using var client = new ServiceBusClient("not.real.com", Mock.Of <TokenCredential>());
await using var sender = client.CreateSender("fake");
await client.DisposeAsync();
Assert.That(async() => await sender.ScheduleMessagesAsync(new[] { new ServiceBusMessage("one"), new ServiceBusMessage("two") }, new DateTimeOffset(2015, 10, 27, 12, 0, 0, TimeSpan.Zero)),
Throws.InstanceOf <ObjectDisposedException>().And.Property(nameof(ObjectDisposedException.ObjectName)).EqualTo(nameof(ServiceBusConnection)));
}
public void Dispose()
{
if (_disposed)
{
return;
}
_disposed = true;
_topicClient.DisposeAsync().GetAwaiter().GetResult();
}
public async ValueTask DisposeAsync()
{
if (_disposed)
{
return;
}
_disposed = true;
await _topicClient.DisposeAsync();
}
public async void Dispose()
{
// stop processing
await processor.StopProcessingAsync();
await processor.DisposeAsync();
await sender.DisposeAsync();
await serviceBusClient.DisposeAsync();
}
public async Task SendMessagesAsyncValidatesClientIsNotDisposed()
{
await using var client = new ServiceBusClient("not.real.com", Mock.Of <TokenCredential>());
await using var sender = client.CreateSender("fake");
using var batch = ServiceBusModelFactory.ServiceBusMessageBatch(4096, new List <ServiceBusMessage> { new ServiceBusMessage("test") });
await client.DisposeAsync();
Assert.That(async() => await sender.SendMessagesAsync(batch),
Throws.InstanceOf <ObjectDisposedException>().And.Property(nameof(ObjectDisposedException.ObjectName)).EqualTo(nameof(ServiceBusConnection)));
}
private static async Task MainServiceBusAsync(string[] args)
{
WriteLine("Enter your Service Bus connection string:");
var ServiceBusConnectionString = ReadLine();
while (ServiceBusConnectionString.Length == 0)
{
WriteLine("Try again, this value must have a length > 0");
WriteLine("Enter your Service Bus connection string:");
ServiceBusConnectionString = ReadLine();
}
WriteLine("Send message(s) to a Queue or Topic?");
var QueueOrTopic = ReadLine();
while (QueueOrTopic.Length == 0)
{
WriteLine("Try again, enter either 'Queue' or 'Topic'");
WriteLine("Enter your Queue name:");
QueueOrTopic = ReadLine();
}
WriteLine("Enter your Queue/Topic name:");
var QueueName = ReadLine();
while (QueueName.Length == 0)
{
WriteLine("Try again, this value must have a length > 0");
WriteLine("Enter your Queue/Topic name:");
QueueName = ReadLine();
}
WriteLine("Send messages in 'batch' or 'single'?");
var BatchOrSingle = ReadLine();
while (BatchOrSingle.Length == 0)
{
WriteLine("Try again, this value must have a length > 0");
WriteLine("'batch' messages together or send 'single', one by one:");
BatchOrSingle = ReadLine();
}
WriteLine("Enter number of messages to add: ");
int ServiceBusMessagesToSend = 0;
while (!int.TryParse(ReadLine(), out ServiceBusMessagesToSend))
{
WriteLine("Try again, this value must be numeric.");
}
await using var client = new ServiceBusClient(ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(QueueName);
await SendMessagesToServicebus(sender, QueueOrTopic.ToLower(), BatchOrSingle, ServiceBusMessagesToSend);
await client.DisposeAsync();
}
/// <summary>
/// Unsubscribe from messagebus and closes connection.
/// </summary>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public virtual async Task UnSubscribeFromMessageBusAsync(CancellationToken cancellationToken = default)
{
if (_serviceBusProcessor is not null)
{
await _serviceBusProcessor.DisposeAsync();
}
if (_serviceBusClient is not null)
{
await _serviceBusClient.DisposeAsync();
}
}
public async Task StopAsync()
{
if (string.IsNullOrWhiteSpace(_subscriptionName))
{
return;
}
var tskStopProcessing = _sbProcessor.StopProcessingAsync();
var tskDeleteSub = DeleteSubscriptionAsync();
await _sbClient.DisposeAsync();
await Task.WhenAll(tskStopProcessing, tskDeleteSub);
_subscriptionName = null;
}
public async Task PublishMessage(BaseMessage message, string topicName)
{
await using var client = new ServiceBusClient(connectionString);
ServiceBusSender sender = client.CreateSender(topicName);
var jsonMessage = JsonConvert.SerializeObject(message);
ServiceBusMessage finalMessage = new ServiceBusMessage(Encoding.UTF8.GetBytes(jsonMessage))
{
CorrelationId = Guid.NewGuid().ToString()
};
await sender.SendMessageAsync(finalMessage);
await client.DisposeAsync();
}
public async Task CreateBatchReactsToClosingTheClient()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
await using var sender = client.CreateSender(scope.QueueName);
using var batch = await sender.CreateMessageBatchAsync();
// Close the client and attempt to create another batch.
await client.DisposeAsync();
Assert.That(async() => await sender.CreateMessageBatchAsync(),
Throws.InstanceOf <ObjectDisposedException>().And.Property(nameof(ObjectDisposedException.ObjectName)).EqualTo(nameof(ServiceBusConnection)));
}
}
public async Task GetChildClientFromClosedParentClientThrows(bool useSessions)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: true, enableSession: useSessions))
{
var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var sender = client.CreateSender(scope.QueueName);
var message = GetMessage(useSessions ? "sessionId" : null);
await sender.SendMessageAsync(message);
await sender.DisposeAsync();
ServiceBusReceiver receiver;
if (!useSessions)
{
receiver = client.CreateReceiver(scope.QueueName);
}
else
{
receiver = await client.CreateSessionReceiverAsync(scope.QueueName);
}
var receivedMessage = await receiver.ReceiveMessageAsync().ConfigureAwait(false);
Assert.AreEqual(message.Body.ToString(), receivedMessage.Body.ToString());
await client.DisposeAsync();
Assert.IsTrue(client.IsClosed);
if (!useSessions)
{
Assert.Throws <ObjectDisposedException>(() => client.CreateReceiver(scope.QueueName));
Assert.Throws <ObjectDisposedException>(() => client.CreateReceiver(scope.QueueName, scope.QueueName));
Assert.Throws <ObjectDisposedException>(() => client.CreateSender(scope.QueueName));
}
else
{
Assert.ThrowsAsync <ObjectDisposedException>(async() => await client.CreateSessionReceiverAsync(scope.QueueName));
Assert.ThrowsAsync <ObjectDisposedException>(async() => await client.CreateSessionReceiverAsync(
scope.QueueName,
new ServiceBusSessionReceiverOptions {
SessionId = "sessionId"
}));
}
Assert.Throws <ObjectDisposedException>(() => client.CreateProcessor(scope.QueueName));
}
}
public async Task ScheduleMessagesReactsToClosingTheClient()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
var scheduleTime = DateTimeOffset.UtcNow.AddHours(10);
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
await using var sender = client.CreateSender(scope.QueueName);
await sender.ScheduleMessagesAsync(ServiceBusTestUtilities.GetMessages(5), scheduleTime);
// Close the client and attempt to schedule another set of messages.
await client.DisposeAsync();
Assert.That(async() => await sender.ScheduleMessagesAsync(ServiceBusTestUtilities.GetMessages(5), scheduleTime),
Throws.InstanceOf <ObjectDisposedException>().And.Property(nameof(ObjectDisposedException.ObjectName)).EqualTo(nameof(ServiceBusConnection)));
}
}
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();
}
