public async Task GetUpdateDeleteQueue()
{
string queueName = Guid.NewGuid().ToString("D").Substring(0, 8);
string connectionString = TestEnvironment.ServiceBusConnectionString;
var client = new ServiceBusAdministrationClient(connectionString);
var qd = new CreateQueueOptions(queueName);
await client.CreateQueueAsync(qd);
#region Snippet:GetQueue
QueueProperties queue = await client.GetQueueAsync(queueName);
#endregion
#region Snippet:UpdateQueue
queue.LockDuration = TimeSpan.FromSeconds(60);
QueueProperties updatedQueue = await client.UpdateQueueAsync(queue);
#endregion
Assert.AreEqual(TimeSpan.FromSeconds(60), updatedQueue.LockDuration);
#region Snippet:DeleteQueue
await client.DeleteQueueAsync(queueName);
#endregion
Assert.That(
async() =>
await client.GetQueueAsync(queueName),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusFailureReason.MessagingEntityNotFound));
}
private async Task CreateQueueIfNotExistsAsync(string name, CancellationToken cancellationToken)
{
// if entity creation is not enabled, just return
if (!TransportOptions.EnableEntityCreation)
{
Logger.LogTrace("Entity creation is diabled. Queue creation skipped");
return;
}
// If the queue does not exist, create it
Logger.LogDebug("Checking if queue '{QueueName}' exists", name);
if (!await managementClient.QueueExistsAsync(name: name, cancellationToken: cancellationToken))
{
Logger.LogTrace("Queue '{QueueName}' does not exist, preparing creation.", name);
var options = new CreateQueueOptions(name: name)
{
// set the defaults for a queue here
Status = EntityStatus.Active,
MaxDeliveryCount = 10,
};
// Allow for the defaults to be overriden
TransportOptions.SetupQueueOptions?.Invoke(options);
Logger.LogInformation("Creating queue '{QueueName}'", name);
_ = await managementClient.CreateQueueAsync(options : options, cancellationToken : cancellationToken);
}
}
private static async Task ReceiveTextMessage()
{
const string queueName = "sbq-text-message";
var managementClient = new ServiceBusAdministrationClient(Config.Namespace, Config.Credential);
if (!await managementClient.QueueExistsAsync(queueName))
{
await managementClient.CreateQueueAsync(queueName);
}
Console.WriteLine($"Receiving messages for {nameof(ReceiveTextMessage)}...");
await using var client = new ServiceBusClient(Config.Namespace, Config.Credential);
// get the options to use for configuring the processor
var options = new ServiceBusProcessorOptions
{
// By default after the message handler returns, the processor will complete the message
// If we want more fine-grained control over settlement, we can set this to false.
AutoCompleteMessages = false,
// I can also allow for multi-threading
MaxConcurrentCalls = 2
};
// create a processor that we can use to process the messages
var processor = client.CreateProcessor(queueName, options);
processor.ProcessMessageAsync += MessageHandler;
processor.ProcessErrorAsync += ErrorHandler;
public static async Task <QueueScope> CreateWithQueue(ServiceBusAdministrationClient adminClient)
{
var queueName = Guid.NewGuid().ToString("D");
var response = await adminClient.CreateQueueAsync(queueName).ConfigureAwait(false);
return(new QueueScope(adminClient, queueName, response.Value));
}
public static async Task Stage(string connectionString, string inputQueue, string destinationQueue)
{
var client = new ServiceBusAdministrationClient(connectionString);
if (await client.QueueExistsAsync(inputQueue))
{
await client.DeleteQueueAsync(inputQueue);
}
await client.CreateQueueAsync(new CreateQueueOptions(inputQueue) { MaxDeliveryCount = 1 });
if (await client.QueueExistsAsync(destinationQueue))
{
await client.DeleteQueueAsync(destinationQueue);
}
await client.CreateQueueAsync(destinationQueue);
}
private static async Task <ServiceBusAdministrationClient> Cleanup(string connectionString, string inputQueue,
string topicName, string rushSubscription, string currencySubscription)
{
var client = new ServiceBusAdministrationClient(connectionString);
if (await client.SubscriptionExistsAsync(topicName, rushSubscription))
{
await client.DeleteSubscriptionAsync(topicName, rushSubscription);
}
if (await client.SubscriptionExistsAsync(topicName, currencySubscription))
{
await client.DeleteSubscriptionAsync(topicName, currencySubscription);
}
if (await client.TopicExistsAsync(topicName))
{
await client.DeleteTopicAsync(topicName);
}
var topicDescription = new CreateTopicOptions(topicName);
await client.CreateTopicAsync(topicDescription);
if (await client.QueueExistsAsync(inputQueue))
{
await client.DeleteQueueAsync(inputQueue);
}
var queueDescription = new CreateQueueOptions(inputQueue);
await client.CreateQueueAsync(queueDescription);
return(client);
}
private static async Task SendTextMessage()
{
const string queueName = "sbq-text-message";
var managementClient = new ServiceBusAdministrationClient(Config.Namespace, Config.Credential);
if (!await managementClient.QueueExistsAsync(queueName))
{
await managementClient.CreateQueueAsync(queueName);
}
await using var client = new ServiceBusClient(Config.Namespace, Config.Credential);
var sender = client.CreateSender(queueName);
var message = new ServiceBusMessage(Encoding.UTF8.GetBytes("This is a simple test message"));
Console.WriteLine("Press any key to send a message. Press Enter to exit.");
while (Console.ReadKey(true).Key != ConsoleKey.Enter)
{
await sender.SendMessageAsync(message);
Console.WriteLine($"Message Sent for {nameof(SendTextMessage)}");
}
Console.ReadLine();
await managementClient.DeleteQueueAsync(queueName);
}
public static async Task <QueueProperties> CreateQueueAsync(string connectionString, string queueName, bool requiresSession = false)
{
var client = new ServiceBusAdministrationClient(connectionString);
var options = new CreateQueueOptions(queueName)
{
DefaultMessageTimeToLive = TimeSpan.FromDays(2),
DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(1),
EnableBatchedOperations = true,
DeadLetteringOnMessageExpiration = true,
EnablePartitioning = false,
ForwardDeadLetteredMessagesTo = null,
ForwardTo = null,
LockDuration = TimeSpan.FromSeconds(45),
MaxDeliveryCount = 8,
MaxSizeInMegabytes = 2048,
UserMetadata = "some metadata"
};
options.RequiresSession = requiresSession;
options.AuthorizationRules.Add(new SharedAccessAuthorizationRule(
"allClaims",
new[] { AccessRights.Manage, AccessRights.Send, AccessRights.Listen }));
return(await client.CreateQueueAsync(options));
}
private static async Task SendRequestMessageWithResponse()
{
const string requestQueue = "sbq-request-queue";
const string responseQueue = "sbq-response-queue";
var managementClient = new ServiceBusAdministrationClient(Config.Namespace, Config.Credential);
if (!await managementClient.QueueExistsAsync(requestQueue))
{
await managementClient.CreateQueueAsync(requestQueue);
}
if (!await managementClient.QueueExistsAsync(responseQueue))
{
var createQueueOptions = new CreateQueueOptions(responseQueue)
{
RequiresSession = true
};
await managementClient.CreateQueueAsync(createQueueOptions);
}
var responseSessionId = Guid.NewGuid().ToString();
await using var requestClient = new ServiceBusClient(Config.Namespace, Config.Credential);
var sender = requestClient.CreateSender(requestQueue);
var message = new ServiceBusMessage(Encoding.UTF8.GetBytes("This is a simple test message"))
{
ReplyToSessionId = responseSessionId
};
Console.WriteLine("Press any key to send a message. Press Enter to exit.");
await using var responseClient = new ServiceBusClient(Config.Namespace, Config.Credential);
var serviceBusSessionProcessorOptions = new ServiceBusSessionProcessorOptions();
serviceBusSessionProcessorOptions.SessionIds.Add(responseSessionId);
var sessionProcessor = responseClient.CreateSessionProcessor(responseQueue, serviceBusSessionProcessorOptions);
sessionProcessor.ProcessMessageAsync += MessageHandler;
sessionProcessor.ProcessErrorAsync += ErrorHandler;
public async Task StartAsync(CancellationToken cancellationToken)
{
_cancellationToken = cancellationToken;
_client = await _clientFactory.GetReceiverClient <T>(new ServiceBusProcessorOptions
{
AutoCompleteMessages = false,
MaxAutoLockRenewalDuration = Settings.MessageLockTimeout,
MaxConcurrentCalls = Settings.MaxConcurrentCalls,
PrefetchCount = Settings.PrefetchCount,
ReceiveMode = ServiceBusReceiveMode.PeekLock
}).ConfigureAwait(false);
var queueName = AutoMessageMapper.GetQueueName <T>();
if (!await _managementClient.QueueExistsAsync(queueName, _cancellationToken).ConfigureAwait(false))
{
try
{
var serviceBusCreationOptions = GetServiceBusCreationOptions();
await _managementClient.CreateQueueAsync(new CreateQueueOptions(queueName)
{
EnablePartitioning = serviceBusCreationOptions.EnablePartitioning,
EnableBatchedOperations = serviceBusCreationOptions.EnableBatchedOperations
}, cancellationToken).ConfigureAwait(false);
}
catch (ServiceBusException e)
{
_log.Error(e, "Failed to create queue {QueueName}", queueName);
throw;
}
}
_deadLetterLimit = Settings.DeadLetterDeliveryLimit;
_client.ProcessMessageAsync += ClientOnProcessMessageAsync;
_client.ProcessErrorAsync += ClientOnProcessErrorAsync;
await _client.StartProcessingAsync(cancellationToken);
#pragma warning disable 4014
// ReSharper disable once MethodSupportsCancellation
Task.Run(async() =>
{
_cancellationToken.WaitHandle.WaitOne();
//Cancellation requested
try
{
_log.Information($"Closing ServiceBus channel receiver for {typeof(T).Name}");
await _client.CloseAsync(CancellationToken.None);
}
catch (Exception)
{
//Swallow
}
});
#pragma warning restore 4014
}
private void CreateServiceBusQueue(string serviceBusQueueName)
{
var busAdmin = new ServiceBusAdministrationClient(Connections.ServiceBusConnectionString);
if (!busAdmin.QueueExistsAsync(serviceBusQueueName).Result.Value)
{
busAdmin.CreateQueueAsync(serviceBusQueueName).Wait();
}
}
private async Task EnsureQueueExistsAsync(string queueName, CancellationToken cancellationToken)
{
if (await _administrationClient.QueueExistsAsync(queueName, cancellationToken))
{
return;
}
await _administrationClient.CreateQueueAsync(queueName, cancellationToken);
}
public static async Task <IAsyncDisposable> Stage(string connectionString, string destination)
{
var client = new ServiceBusAdministrationClient(connectionString);
if (!await client.QueueExistsAsync(destination))
{
await client.CreateQueueAsync(destination);
}
return(new Leave(connectionString, destination));
}
public static async Task Stage(string connectionString, string destination)
{
var client = new ServiceBusAdministrationClient(connectionString);
if (await client.QueueExistsAsync(destination))
{
await client.DeleteQueueAsync(destination);
}
await client.CreateQueueAsync(destination);
}
public static Task Create(ServiceBusAdministrationClient client, CommandArgument name, CommandOption <int> size, CommandOption partitioning)
{
var queueDescription = new CreateQueueOptions(name.Value)
{
EnableBatchedOperations = true,
LockDuration = TimeSpan.FromMinutes(5),
MaxDeliveryCount = int.MaxValue,
MaxSizeInMegabytes = (size.HasValue() ? size.ParsedValue : 5) * 1024,
EnablePartitioning = partitioning.HasValue()
};
return(client.CreateQueueAsync(queueDescription));
}
public async Task CreateQueue()
{
string adminQueueName = Guid.NewGuid().ToString("D").Substring(0, 8);
string adminConnectionString = TestEnvironment.ServiceBusConnectionString;
try
{
#region Snippet:CreateQueue
#if SNIPPET
string connectionString = "<connection_string>";
string queueName = "<queue_name>";
#else
string queueName = adminQueueName;
string connectionString = adminConnectionString;
#endif
var client = new ServiceBusAdministrationClient(connectionString);
var options = new CreateQueueOptions(queueName)
{
AutoDeleteOnIdle = TimeSpan.FromDays(7),
DefaultMessageTimeToLive = TimeSpan.FromDays(2),
DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(1),
EnableBatchedOperations = true,
DeadLetteringOnMessageExpiration = true,
EnablePartitioning = false,
ForwardDeadLetteredMessagesTo = null,
ForwardTo = null,
LockDuration = TimeSpan.FromSeconds(45),
MaxDeliveryCount = 8,
MaxSizeInMegabytes = 2048,
RequiresDuplicateDetection = true,
RequiresSession = true,
UserMetadata = "some metadata"
};
options.AuthorizationRules.Add(new SharedAccessAuthorizationRule(
"allClaims",
new[] { AccessRights.Manage, AccessRights.Send, AccessRights.Listen }));
QueueProperties createdQueue = await client.CreateQueueAsync(options);
#endregion
Assert.AreEqual(options, new CreateQueueOptions(createdQueue)
{
MaxMessageSizeInKilobytes = options.MaxMessageSizeInKilobytes
});
}
finally
{
await new ServiceBusAdministrationClient(adminConnectionString).DeleteQueueAsync(adminQueueName);
}
}
public ServiceBusQueue(string connectionString, string queueName, ServiceBusReceiveMode receiveMode = ServiceBusReceiveMode.PeekLock, bool createQueueIfItDoesNotExist = true)
: base(connectionString)
{
this.connectionString = connectionString;
this.queueName = queueName;
this.receiveMode = receiveMode;
this.SubQueue = SubQueue.None;
busAdmin = new ServiceBusAdministrationClient(this.connectionString);
if (createQueueIfItDoesNotExist && !busAdmin.QueueExistsAsync(queueName).Result.Value)
{
busAdmin.CreateQueueAsync(queueName).Wait();
}
}
public async Task CreateQueues(string[] queues, CancellationToken cancellationToken = default)
{
await namespacePermissions.CanManage(cancellationToken).ConfigureAwait(false);
var topic = new CreateTopicOptions(transportSettings.TopicName)
{
EnableBatchedOperations = true,
EnablePartitioning = transportSettings.EnablePartitioning,
MaxSizeInMegabytes = maxSizeInMb
};
try
{
await administrativeClient.CreateTopicAsync(topic, cancellationToken).ConfigureAwait(false);
}
catch (ServiceBusException sbe) when(sbe.Reason == ServiceBusFailureReason.MessagingEntityAlreadyExists)
{
Logger.Info($"Topic {topic.Name} already exists");
}
catch (ServiceBusException sbe) when(sbe.IsTransient) // An operation is in progress.
{
Logger.Info($"Topic creation for {topic.Name} is already in progress");
}
foreach (var address in queues)
{
var queue = new CreateQueueOptions(address)
{
EnableBatchedOperations = true,
LockDuration = TimeSpan.FromMinutes(5),
MaxDeliveryCount = int.MaxValue,
MaxSizeInMegabytes = maxSizeInMb,
EnablePartitioning = transportSettings.EnablePartitioning
};
try
{
await administrativeClient.CreateQueueAsync(queue, cancellationToken).ConfigureAwait(false);
}
catch (ServiceBusException sbe) when(sbe.Reason == ServiceBusFailureReason.MessagingEntityAlreadyExists)
{
Logger.Debug($"Queue {queue.Name} already exists");
}
catch (ServiceBusException sbe) when(sbe.IsTransient) // An operation is in progress.
{
Logger.Info($"Queue creation for {queue.Name} is already in progress");
}
}
}
private static async Task <int> Main(string[] args)
{
if (args.Length == 0)
{
Console.Error.WriteLine("An Azure Service Bus connection string must be passed as the first argument");
return(1);
}
Agent.Subscribe(new AzureMessagingServiceBusDiagnosticsSubscriber());
var connectionString = args[0];
var adminClient = new ServiceBusAdministrationClient(connectionString);
var client = new ServiceBusClient(connectionString);
var queueName = Guid.NewGuid().ToString("D");
Console.WriteLine($"Creating queue {queueName}");
var response = await adminClient.CreateQueueAsync(queueName).ConfigureAwait(false);
var sender = client.CreateSender(queueName);
Console.WriteLine("Sending messages to queue");
await Agent.Tracer.CaptureTransaction("Send AzureServiceBus Messages", "messaging", async() =>
{
for (var i = 0; i < 10; i++)
{
await sender.SendMessageAsync(new ServiceBusMessage($"test message {i}")).ConfigureAwait(false);
}
});
var receiver = client.CreateReceiver(queueName);
Console.WriteLine("Receiving messages from queue");
var messages = await receiver.ReceiveMessagesAsync(9)
.ConfigureAwait(false);
Console.WriteLine("Receiving message from queue");
var message = await receiver.ReceiveMessageAsync()
.ConfigureAwait(false);
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
return(0);
}
public async Task RunBeforeAllTests()
{
var connectionString = Environment.GetEnvironmentVariable(ServiceBusTriggeredEndpointConfiguration.DefaultServiceBusConnectionName);
Assert.IsNotNull(connectionString, $"Environment variable '{ServiceBusTriggeredEndpointConfiguration.DefaultServiceBusConnectionName}' should be defined to run tests.");
var client = new ServiceBusAdministrationClient(connectionString);
const string errorQueueName = "error";
if (!await client.QueueExistsAsync(errorQueueName))
{
await client.CreateQueueAsync(errorQueueName);
}
}
public async Task EnsureQueue(string queueName, CancellationToken cancellationToken = default)
{
if (!await _administrationClient.QueueExistsAsync(queueName, cancellationToken))
{
var options = new CreateQueueOptions(queueName)
{
Status = EntityStatus.Active,
MaxSizeInMegabytes = 1024,
DefaultMessageTimeToLive = TimeSpan.FromDays(10000),
RequiresSession = queueName.Contains("response", StringComparison.OrdinalIgnoreCase)
};
await _administrationClient.CreateQueueAsync(options, cancellationToken);
}
}
public static async Task Stage(string connectionString, string destination)
{
var client = new ServiceBusAdministrationClient(connectionString);
if (await client.QueueExistsAsync(destination))
{
await client.DeleteQueueAsync(destination);
}
var queueDescription = new CreateQueueOptions(destination)
{
RequiresSession = true
};
await client.CreateQueueAsync(queueDescription);
}
public static async Task Stage(string connectionString, string destination)
{
var client = new ServiceBusAdministrationClient(connectionString);
if (await client.QueueExistsAsync(destination))
{
await client.DeleteQueueAsync(destination);
}
var description = new CreateQueueOptions(destination)
{
MaxDeliveryCount = int.MaxValue
};
await client.CreateQueueAsync(description);
}
public static async Task Stage(string connectionString, string destination)
{
var client = new ServiceBusAdministrationClient(connectionString);
if (await client.QueueExistsAsync(destination))
{
await client.DeleteQueueAsync(destination);
}
var queueDescription = new CreateQueueOptions(destination)
{
RequiresDuplicateDetection = true,
DuplicateDetectionHistoryTimeWindow = TimeSpan.FromSeconds(20)
};
await client.CreateQueueAsync(queueDescription);
}
public static async Task Stage(string connectionString, string destination)
{
var client = new ServiceBusAdministrationClient(connectionString);
if (await client.QueueExistsAsync(destination))
{
await client.DeleteQueueAsync(destination);
}
var description = new CreateQueueOptions(destination)
{
DeadLetteringOnMessageExpiration = true, // default false
MaxDeliveryCount = 1
};
await client.CreateQueueAsync(description);
}
public static async Task Stage(string connectionString)
{
var client = new ServiceBusAdministrationClient(connectionString);
async Task DeleteIfExists(string queueName)
{
if (await client.QueueExistsAsync(queueName))
{
await client.DeleteQueueAsync(queueName);
}
}
await Task.WhenAll(
DeleteIfExists("Hop4"),
DeleteIfExists("Hop3"),
DeleteIfExists("Hop2"),
DeleteIfExists("Hop1"),
DeleteIfExists("Hop0"),
DeleteIfExists("Hop")
);
var description = new CreateQueueOptions("Hop");
await client.CreateQueueAsync(description);
description = new CreateQueueOptions("Hop0");
await client.CreateQueueAsync(description);
description = new CreateQueueOptions("Hop1")
{
ForwardTo = "Hop0"
};
await client.CreateQueueAsync(description);
description = new CreateQueueOptions("Hop2")
{
ForwardTo = "Hop1"
};
await client.CreateQueueAsync(description);
description = new CreateQueueOptions("Hop3")
{
ForwardTo = "Hop2"
};
await client.CreateQueueAsync(description);
description = new CreateQueueOptions("Hop4")
{
ForwardTo = "Hop3"
};
await client.CreateQueueAsync(description);
}
private static async Task SendTextMessageWithProperties()
{
const string queueName = "sbq-text-message-with-properties";
var managementClient = new ServiceBusAdministrationClient(Config.Namespace, Config.Credential);
if (!await managementClient.QueueExistsAsync(queueName))
{
await managementClient.CreateQueueAsync(queueName);
}
await using var client = new ServiceBusClient(Config.Namespace, Config.Credential);
var sender = client.CreateSender(queueName);
var message = new ServiceBusMessage
{
Body = new BinaryData("This is a simple test message"),
ContentType = "text/plain",
CorrelationId = Guid.NewGuid().ToString(),
MessageId = Guid.NewGuid().ToString(),
TimeToLive = TimeSpan.FromMinutes(10),
ScheduledEnqueueTime = DateTime.UtcNow,
ApplicationProperties = { { "custom-property", "Custom Value" } }
};
Console.WriteLine("Press any key to send a message. Press Enter to exit.");
while (Console.ReadKey(true).Key != ConsoleKey.Enter)
{
await sender.SendMessageAsync(message);
Console.WriteLine($"Message Sent for {nameof(SendTextMessageWithProperties)}");
}
Console.ReadLine();
await managementClient.DeleteQueueAsync(queueName);
}
private static async Task SendComplexObjectMessage()
{
const string queueName = "sbq-complex-object-message";
var managementClient = new ServiceBusAdministrationClient(Config.Namespace, Config.Credential);
if (!await managementClient.QueueExistsAsync(queueName))
{
await managementClient.CreateQueueAsync(queueName);
}
await using var client = new ServiceBusClient(Config.Namespace, Config.Credential);
var sender = client.CreateSender(queueName);
var payment = new Payment
{
PaymentId = Guid.NewGuid(),
AccountNumber = "132456789",
Amount = 1337m,
PaymentDate = DateTime.Today.AddDays(1),
Payee = "Mr John Smith"
};
var message = new ServiceBusMessage(JsonSerializer.SerializeToUtf8Bytes(payment));
Console.WriteLine("Press any key to send a message. Press Enter to exit.");
while (Console.ReadKey(true).Key != ConsoleKey.Enter)
{
await sender.SendMessageAsync(message);
Console.WriteLine($"Message Sent for {nameof(SendComplexObjectMessage)}");
}
Console.ReadLine();
await managementClient.DeleteQueueAsync(queueName);
}
public static async Task CreateQueueFromOptionsAsync(ServiceBusOptions options, string queueName)
{
var adminClient = new ServiceBusAdministrationClient(options.ConnectionString);
try
{
await adminClient.CreateQueueAsync(new CreateQueueOptions(queueName)
{
EnablePartitioning = true,
RequiresSession = false,
EnableBatchedOperations = true,
AutoDeleteOnIdle = options.QueueTtl,
DefaultMessageTimeToLive = options.MessageTtl,
MaxSizeInMegabytes = options.MaxQueueSizeMegabytes
});
}
catch (ServiceBusException exception)
when(exception.Reason == ServiceBusFailureReason.MessagingEntityAlreadyExists)
{
// Ignore
}
}
public async Task <T> Request <T>(string queueName, object payload) where T : class
{
var temporaryQueueName = Guid.NewGuid().ToString();
var timeoutMillis = Math.Max(MinimumAutoDeleteOnIdleMillis, 2 * _options.RequestTimeOutMillis);
var autoDeleteOnIdleTimespan = TimeSpan.FromMilliseconds(timeoutMillis);
var createQueueOptions = new CreateQueueOptions(temporaryQueueName)
{
AutoDeleteOnIdle = autoDeleteOnIdleTimespan,
Name = temporaryQueueName
};
await _administrationClient.CreateQueueAsync(createQueueOptions);
var sender = _clientFactory.CreateSendClient(queueName);
var receiver = _clientFactory.CreateReceiverClient(temporaryQueueName);
try
{
var outboundMessage = new ServiceBusMessage(JsonSerializer.SerializeToUtf8Bytes(payload, Constants.DefaultJsonSerializerOptions))
{
ReplyTo = temporaryQueueName
};
await sender.SendMessageAsync(outboundMessage);
var reply = await receiver.ReceiveMessageAsync(_options.RequestTimeout);
return(reply != null
? JsonSerializer.Deserialize <T>(reply.Body, Constants.DefaultJsonSerializerOptions)
: null);
}
finally
{
await _administrationClient.DeleteQueueAsync(temporaryQueueName)
.ConfigureAwait(false);
}
}
