static async Task TransactionAsync(bool commit)
{
ServiceBusSender sender = srv.CreateSender(QueueOrTopicName);
using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) {
await sender.SendMessageAsync(new ServiceBusMessage("Paso1"));
await sender.SendMessageAsync(new ServiceBusMessage("Paso2"));
await sender.SendMessageAsync(new ServiceBusMessage("Paso3"));
// ...
if (commit)
{
ts.Complete();
Console.WriteLine("Messages was sent successfully.");
}
else
{
Console.WriteLine("Messages was cancel.");
ts.Dispose();
}
}
await sender.CloseAsync();
}
static async Task SendMessageAsync()
{
ServiceBusSender sender = srv.CreateSender(QueueOrTopicName);
try {
string messageBody = $"Mensaje {DateTime.Now:mm:ss:ff}: valor {rnd.Next(1, 100)}.";
var item = new Item()
{
Id = 1, Mensaje = messageBody
};
var message = item.AsMessage();
message.To = item.Categoria;
message.Subject = item.Nivel;
message.ApplicationProperties.Add("nivel", item.Nivel);
message.MessageId = $"{DateTime.Now.Minute}-1";
message.SessionId = Guid.NewGuid().ToString();
if (TimeToLive > 0)
{
message.TimeToLive = TimeSpan.FromSeconds(TimeToLive);
}
await sender.SendMessageAsync(message);
Console.WriteLine($"Sending message: {message.MessageId} - {item}");
} catch (Exception exception) {
Console.WriteLine($"{DateTime.Now} :: Exception: {exception.Message}");
}
await sender.CloseAsync();
Console.WriteLine("Messages was sent successfully.");
}
public async Task CloseConnectionAsync()
{
await _serviceBusSender.CloseAsync();
await _serviceBusClient.DisposeAsync();
Console.WriteLine("Client connection closed");
}
static async Task MainAsync(string ServiceBusConnectionString, string QueueName, string recipientEmail, string MessageBody)
{
Console.WriteLine($"mainAsync");
var client = new ServiceBusClient(ServiceBusConnectionString);
sender = client.CreateSender(QueueName);
Console.WriteLine($"before send ansync");
// Send Messages
await SendMessagesAsync(recipientEmail, MessageBody);
await sender.CloseAsync();
}
//ServiceBusProcessor.StopProcessingAsync currently has a bug when using the AMQP protocol that prevents it from gracefully shutting down in a timely manner
//it will timeout after 1 min and eventually shutdown but we don't want to wait for that so do all shutdown waiting in an async void method.
private async void Stop()
{
await using (_sender)
await using (_processor)
{
await _processor.StopProcessingAsync();
await _processor.CloseAsync();
await _sender.CloseAsync();
}
}
public async Task <ActionResult> Send(ServiceBusMessageData messageInfo)
{
if (string.IsNullOrEmpty(messageInfo.MessageToSend))
{
return(RedirectToAction("Index"));
}
ServiceBusSender sender = client.CreateSender(Config.Queue);
ServiceBusMessage message = new ServiceBusMessage(messageInfo.MessageToSend);
await sender.SendMessageAsync(message).ConfigureAwait(false);
await sender.CloseAsync().ConfigureAwait(false);
return(RedirectToAction("Index"));
}
/// <summary>
/// Simulate the message processing of the message pump using the Service Bus.
/// </summary>
public async Task SimulateMessageProcessingAsync()
{
if (_serviceBusEventConsumerHost is null)
{
throw new InvalidOperationException(
"Cannot simulate the message pump because the service is not yet started; please start this service before simulating");
}
var operationId = Guid.NewGuid().ToString();
var transactionId = Guid.NewGuid().ToString();
string connectionString = _configuration.GetServiceBusConnectionString(_entity);
var connectionStringProperties = ServiceBusConnectionStringProperties.Parse(connectionString);
await using (var client = new ServiceBusClient(connectionString))
await using (ServiceBusSender messageSender = client.CreateSender(connectionStringProperties.EntityPath))
{
try
{
Order order = GenerateOrder();
ServiceBusMessage orderMessage = order.AsServiceBusMessage(operationId, transactionId);
await messageSender.SendMessageAsync(orderMessage);
string receivedEvent = _serviceBusEventConsumerHost.GetReceivedEvent(operationId);
Assert.NotEmpty(receivedEvent);
EventBatch <Event> eventBatch = EventParser.Parse(receivedEvent);
Assert.NotNull(eventBatch);
Event orderCreatedEvent = Assert.Single(eventBatch.Events);
Assert.NotNull(orderCreatedEvent);
var orderCreatedEventData = orderCreatedEvent.GetPayload <OrderCreatedEventData>();
Assert.NotNull(orderCreatedEventData);
Assert.NotNull(orderCreatedEventData.CorrelationInfo);
Assert.Equal(order.Id, orderCreatedEventData.Id);
Assert.Equal(order.Amount, orderCreatedEventData.Amount);
Assert.Equal(order.ArticleNumber, orderCreatedEventData.ArticleNumber);
Assert.Equal(transactionId, orderCreatedEventData.CorrelationInfo.TransactionId);
Assert.Equal(operationId, orderCreatedEventData.CorrelationInfo.OperationId);
Assert.NotEmpty(orderCreatedEventData.CorrelationInfo.CycleId);
}
finally
{
await messageSender.CloseAsync();
}
}
}
static async Task SendMessageBatchAsync()
{
ServiceBusSender sender = srv.CreateSender(QueueOrTopicName);
string[] sessionIds = { Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString() };
ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();
try {
for (int i = 0; i < NumeroDeEnvios; i++)
{
string messageBody = $"Mensaje {DateTime.Now:mm:ss:ff}: valor {rnd.Next(1, 100)}.";
var item = new Item()
{
Id = i, Mensaje = messageBody
};
var message = item.AsMessage();
message.To = item.Categoria;
message.Subject = item.Nivel;
message.ApplicationProperties.Add("nivel", item.Nivel);
message.MessageId = $"{DateTime.Now.Minute}-{i}";
message.SessionId = sessionIds[i % 3];
if (TimeToLive > 0)
{
message.TimeToLive = TimeSpan.FromSeconds(TimeToLive);
}
Console.WriteLine($"Sending message: {message.MessageId} - {item}");
if (!messageBatch.TryAddMessage(message))
{
await sender.SendMessagesAsync(messageBatch);
Console.WriteLine($"Sending Batch: {messageBatch.Count} - {messageBatch.SizeInBytes}");
messageBatch.Dispose();
messageBatch = await sender.CreateMessageBatchAsync();
messageBatch.TryAddMessage(message);
}
}
Console.WriteLine($"Sending Batch: {messageBatch.Count} - {messageBatch.SizeInBytes}");
await sender.SendMessagesAsync(messageBatch);
} catch (Exception exception) {
Console.WriteLine($"{DateTime.Now} :: Exception: {exception.Message}");
}
await sender.CloseAsync();
Console.WriteLine("Messages was sent successfully.");
}
public async Task EnviarMensajeAsync(string sesionId, string cadenaConexion, string nombreQueueRequest, T body)
{
await using (ServiceBusClient client = new ServiceBusClient(cadenaConexion))
{
// create a sender for the queue
ServiceBusSender sender = client.CreateSender(nombreQueueRequest);
// create a message that we can send
ServiceBusMessage message = new ServiceBusMessage(JsonConvert.SerializeObject(body));
message.SessionId = sesionId;
message.ContentType = "application/json";
// send the message
await sender.SendMessageAsync(message);
await sender.CloseAsync();
}
}
public async Task CloseRespectsCancellationToken()
{
var mockTransportSender = new Mock <TransportSender>();
var cts = new CancellationTokenSource();
// mutate the cancellation token to distinguish it from CancellationToken.None
cts.CancelAfter(100);
var mockConnection = CreateMockConnection();
mockConnection.Setup(
connection => connection.CreateTransportSender(
It.IsAny <string>(),
It.IsAny <ServiceBusRetryPolicy>(),
It.IsAny <string>()))
.Returns(mockTransportSender.Object);
var sender = new ServiceBusSender("fake", mockConnection.Object);
await sender.CloseAsync(cts.Token);
mockTransportSender.Verify(transportReceiver => transportReceiver.CloseAsync(It.Is <CancellationToken>(ct => ct == cts.Token)));
}
public async ValueTask DisposeAsync()
{
await _sender.CloseAsync();
await _sender.DisposeAsync();
}
private static async Task RunAsync(string fullyQualifiedNamespace, string connection)
{
if (!string.IsNullOrEmpty(connection))
{
s_client = new ServiceBusClient(Environment.GetEnvironmentVariable(connection));
s_adminClient = new ServiceBusAdministrationClient(Environment.GetEnvironmentVariable(connection));
}
else if (!string.IsNullOrEmpty(fullyQualifiedNamespace))
{
var defaultAzureCredential = new DefaultAzureCredential();
s_client = new ServiceBusClient(fullyQualifiedNamespace, defaultAzureCredential);
s_adminClient = new ServiceBusAdministrationClient(fullyQualifiedNamespace, defaultAzureCredential);
}
else
{
throw new ArgumentException(
"Either a fully qualified namespace or a connection string environment variable must be specified.");
}
Console.WriteLine($"Creating topic {TopicName}");
await s_adminClient.CreateTopicAsync(TopicName);
s_sender = s_client.CreateSender(TopicName);
// First Subscription is already created with default rule. Leave as is.
Console.WriteLine($"Creating subscription {NoFilterSubscriptionName}");
await s_adminClient.CreateSubscriptionAsync(TopicName, NoFilterSubscriptionName);
Console.WriteLine($"SubscriptionName: {NoFilterSubscriptionName}, Removing and re-adding Default Rule");
await s_adminClient.DeleteRuleAsync(TopicName, NoFilterSubscriptionName, RuleProperties.DefaultRuleName);
await s_adminClient.CreateRuleAsync(TopicName, NoFilterSubscriptionName,
new CreateRuleOptions(RuleProperties.DefaultRuleName, new TrueRuleFilter()));
// 2nd Subscription: Add SqlFilter on Subscription 2
// In this scenario, rather than deleting the default rule after creating the subscription,
// we will create the subscription along with our desired rule in a single operation.
// See https://docs.microsoft.com/en-us/azure/service-bus-messaging/topic-filters to learn more about topic filters.
Console.WriteLine($"Creating subscription {SqlFilterOnlySubscriptionName}");
await s_adminClient.CreateSubscriptionAsync(
new CreateSubscriptionOptions(TopicName, SqlFilterOnlySubscriptionName),
new CreateRuleOptions { Name = "RedSqlRule", Filter = new SqlRuleFilter("Color = 'Red'") });
// 3rd Subscription: Add the SqlFilter Rule and Action
// See https://docs.microsoft.com/en-us/azure/service-bus-messaging/topic-filters#actions to learn more about actions.
Console.WriteLine($"Creating subscription {SqlFilterWithActionSubscriptionName}");
await s_adminClient.CreateSubscriptionAsync(
new CreateSubscriptionOptions(TopicName, SqlFilterWithActionSubscriptionName),
new CreateRuleOptions
{
Name = "BlueSqlRule",
Filter = new SqlRuleFilter("Color = 'Blue'"),
Action = new SqlRuleAction("SET Color = 'BlueProcessed'")
});
// 4th Subscription: Add Correlation Filter on Subscription 4
Console.WriteLine($"Creating subscription {CorrelationFilterSubscriptionName}");
await s_adminClient.CreateSubscriptionAsync(
new CreateSubscriptionOptions(TopicName, CorrelationFilterSubscriptionName),
new CreateRuleOptions
{
Name = "ImportantCorrelationRule",
Filter = new CorrelationRuleFilter {
Subject = "Red", CorrelationId = "important"
}
});
// Get Rules on Subscription, called here only for one subscription as example
var rules = s_adminClient.GetRulesAsync(TopicName, CorrelationFilterSubscriptionName);
await foreach (var rule in rules)
{
Console.WriteLine(
$"GetRules:: SubscriptionName: {CorrelationFilterSubscriptionName}, CorrelationFilter Name: {rule.Name}, Rule: {rule.Filter}");
}
// Send messages to Topic
await SendMessagesAsync();
// Receive messages from 'NoFilterSubscription'. Should receive all 9 messages
await ReceiveMessagesAsync(NoFilterSubscriptionName);
// Receive messages from 'SqlFilterOnlySubscription'. Should receive all messages with Color = 'Red' i.e 3 messages
await ReceiveMessagesAsync(SqlFilterOnlySubscriptionName);
// Receive messages from 'SqlFilterWithActionSubscription'. Should receive all messages with Color = 'Blue'
// i.e 3 messages AND all messages should have color set to 'BlueProcessed'
await ReceiveMessagesAsync(SqlFilterWithActionSubscriptionName);
// Receive messages from 'CorrelationFilterSubscription'. Should receive all messages with Color = 'Red' and CorrelationId = "important"
// i.e 1 message
await ReceiveMessagesAsync(CorrelationFilterSubscriptionName);
Console.ResetColor();
Console.WriteLine("=======================================================================");
Console.WriteLine("Completed Receiving all messages. Disposing clients and deleting topic.");
Console.WriteLine("=======================================================================");
Console.WriteLine("Disposing sender");
await s_sender.CloseAsync();
Console.WriteLine("Disposing client");
await s_client.DisposeAsync();
Console.WriteLine("Deleting topic");
// Deleting the topic will handle deleting all the subscriptions as well.
await s_adminClient.DeleteTopicAsync(TopicName);
}
public async ValueTask StopAsync()
{
await using (_sender)
await _sender.CloseAsync();
}
public static void Cleanup()
{
Task.Run(() => queueClient.CloseAsync()).Wait();
}
public void Close()
{
_serviceBusSender.CloseAsync().Wait();
}
