public async Task PeekUsingConnectionStringWithSisgnature() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { var options = new ServiceBusClientOptions(); var audience = ServiceBusConnection.BuildConnectionResource(options.TransportType, TestEnvironment.FullyQualifiedNamespace, scope.QueueName); var connectionString = TestEnvironment.BuildConnectionStringWithSharedAccessSignature(scope.QueueName, audience); await using var client = new ServiceBusClient(connectionString, options); var messageCt = 10; ServiceBusSender sender = client.CreateSender(scope.QueueName); using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable <ServiceBusMessage> sentMessages = AddMessages(batch, messageCt).AsEnumerable <ServiceBusMessage>(); await sender.SendMessagesAsync(batch); await using var receiver = client.CreateReceiver(scope.QueueName); var messageEnum = sentMessages.GetEnumerator(); var ct = 0; while (ct < messageCt) { foreach (ServiceBusReceivedMessage peekedMessage in await receiver.PeekMessagesAsync( maxMessages: messageCt)) { messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, peekedMessage.MessageId); ct++; } } Assert.AreEqual(messageCt, ct); } }
public async Task LogsPluginExceptionEvents() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { var options = new ServiceBusClientOptions(); options.AddPlugin(new PluginLiveTests.SendExceptionPlugin()); var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString, options); ServiceBusSender sender = client.CreateSender(scope.QueueName); ServiceBusMessage message = GetMessage(); Assert.That( async() => await sender.SendMessageAsync(message), Throws.InstanceOf <NotImplementedException>()); _listener.SingleEventById(ServiceBusEventSource.PluginStartEvent); _listener.SingleEventById(ServiceBusEventSource.PluginExceptionEvent); options = new ServiceBusClientOptions(); options.AddPlugin(new PluginLiveTests.ReceiveExceptionPlugin()); client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString, options); sender = client.CreateSender(scope.QueueName); await sender.SendMessageAsync(message); Assert.AreEqual(2, _listener.EventsById(ServiceBusEventSource.PluginStartEvent).Count()); Assert.AreEqual(1, _listener.EventsById(ServiceBusEventSource.PluginExceptionEvent).Count()); var receiver = client.CreateReceiver(scope.QueueName); Assert.That( async() => await receiver.ReceiveMessageAsync(), Throws.InstanceOf <NotImplementedException>()); Assert.AreEqual(3, _listener.EventsById(ServiceBusEventSource.PluginStartEvent).Count()); Assert.AreEqual(2, _listener.EventsById(ServiceBusEventSource.PluginExceptionEvent).Count()); }; }
public async Task PluginsCanAlterMessage(bool schedule) { await using var scope = await ServiceBusScope.CreateWithQueue( enablePartitioning : false, enableSession : false); var plugin = new SendReceivePlugin(); var options = new ServiceBusClientOptions(); options.AddPlugin(plugin); var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString, options); var sender = client.CreateSender(scope.QueueName); var receiver = client.CreateReceiver(scope.QueueName); if (schedule) { await sender.ScheduleMessageAsync(new ServiceBusMessage(), DateTimeOffset.UtcNow); } else { await sender.SendMessageAsync(new ServiceBusMessage()); } Assert.True(plugin.WasCalled); var receivedMessage = await receiver.ReceiveMessageAsync(); Assert.AreEqual("received", receivedMessage.Body.ToString()); }
/// <summary> /// Initializes a new instance of the <see cref="AmqpClient"/> class. /// </summary> /// /// <param name="host">The fully qualified host name for the Service Bus namespace. This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param> /// <param name="credential">The Azure managed identity credential to use for authorization. Access controls may be specified by the Service Bus namespace or the requested Service Bus entity, depending on Azure configuration.</param> /// <param name="clientOptions">A set of options to apply when configuring the client.</param> /// <param name="connectionScope">The optional scope to use for AMQP connection management. If <c>null</c>, a new scope will be created.</param> /// /// <remarks> /// As an internal type, this class performs only basic sanity checks against its arguments. It /// is assumed that callers are trusted and have performed deep validation. /// /// Any parameters passed are assumed to be owned by this instance and safe to mutate or dispose; /// creation of clones or otherwise protecting the parameters is assumed to be the purview of the /// caller. /// </remarks> /// protected AmqpClient( string host, ServiceBusTokenCredential credential, ServiceBusClientOptions clientOptions, AmqpConnectionScope connectionScope) { Argument.AssertNotNullOrEmpty(host, nameof(host)); Argument.AssertNotNull(credential, nameof(credential)); Argument.AssertNotNull(clientOptions, nameof(clientOptions)); try { //TODO add event ServiceBusEventSource.Log.ClientCreateStart(host, entityName); ServiceEndpoint = new UriBuilder { Scheme = clientOptions.TransportType.GetUriScheme(), Host = host }.Uri; Credential = credential; ConnectionScope = connectionScope ?? new AmqpConnectionScope(ServiceEndpoint, credential, clientOptions.TransportType, clientOptions.Proxy); } finally { // TODO add event ServiceBusEventSource.Log.ServiceBusClientCreateComplete(host, entityName); } }
public async Task PluginsCanAlterMessageUsingSessionProcessor() { await using (var scope = await ServiceBusScope.CreateWithQueue( enablePartitioning: false, enableSession: true)) { var plugin = new SendReceivePlugin(); var options = new ServiceBusClientOptions(); options.AddPlugin(plugin); var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString, options); var sender = client.CreateSender(scope.QueueName); await sender.SendMessageAsync(GetMessage("sessionId")); Assert.True(plugin.WasCalled); var processor = client.CreateSessionProcessor(scope.QueueName, new ServiceBusSessionProcessorOptions { MaxConcurrentSessions = 1 }); processor.ProcessErrorAsync += ExceptionHandler; var tcs = new TaskCompletionSource <bool>(); processor.ProcessMessageAsync += args => { Assert.AreEqual("received", args.Message.Body.ToString()); tcs.SetResult(true); return(Task.CompletedTask); }; await processor.StartProcessingAsync(); await tcs.Task; await processor.StopProcessingAsync(); } }
public async Task PluginCausingExceptionShouldThrow() { await using (var scope = await ServiceBusScope.CreateWithQueue( enablePartitioning: false, enableSession: false)) { var options = new ServiceBusClientOptions(); options.AddPlugin(new SendExceptionPlugin()); var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString, options); var sender = client.CreateSender(scope.QueueName); Assert.That( async() => await sender.SendMessageAsync(new ServiceBusMessage()), Throws.InstanceOf <NotImplementedException>()); options = new ServiceBusClientOptions(); options.AddPlugin(new ReceiveExceptionPlugin()); client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString, options); sender = client.CreateSender(scope.QueueName); await sender.SendMessageAsync(new ServiceBusMessage()); var receiver = client.CreateReceiver(scope.QueueName); Assert.That( async() => await receiver.ReceiveMessageAsync(), Throws.InstanceOf <NotImplementedException>()); } }
public async Task ClientCanConnectUsingSharedKeyCredential() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: true, enableSession: false)) { var options = new ServiceBusClientOptions(); var audience = ServiceBusConnection.BuildConnectionResource(options.TransportType, TestEnvironment.FullyQualifiedNamespace, scope.QueueName); var credential = new AzureNamedKeyCredential(TestEnvironment.SharedAccessKeyName, TestEnvironment.SharedAccessKey); await using (var client = new ServiceBusClient(TestEnvironment.FullyQualifiedNamespace, credential, options)) { Assert.That(async() => { ServiceBusReceiver receiver = null; try { receiver = client.CreateReceiver(scope.QueueName); } finally { await(receiver?.DisposeAsync() ?? new ValueTask()); } }, Throws.Nothing); } } }
public async Task OrderOfPluginsRespected() { await using (var scope = await ServiceBusScope.CreateWithQueue( enablePartitioning: false, enableSession: false)) { var options = new ServiceBusClientOptions(); options.AddPlugin(new FirstPlugin()); options.AddPlugin(new SecondPlugin()); var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString, options); var sender = client.CreateSender(scope.QueueName); var receiver = client.CreateReceiver(scope.QueueName); var sendMessage = new ServiceBusMessage(); await sender.SendMessageAsync(sendMessage); var receivedMessage = await receiver.ReceiveMessageAsync(); var firstSendPluginUserProperty = (bool)receivedMessage.Properties["FirstSendPlugin"]; var secondSendPluginUserProperty = (bool)receivedMessage.Properties["SecondSendPlugin"]; Assert.True(firstSendPluginUserProperty); Assert.True(secondSendPluginUserProperty); } }
/// <summary> /// Initializes a new instance of the <see cref="AmqpClient"/> class. /// </summary> /// /// <param name="host">The fully qualified host name for the Service Bus namespace. This is likely to be similar to <c>{yournamespace}.servicebus.windows.net</c>.</param> /// <param name="credential">The Azure managed identity credential to use for authorization. Access controls may be specified by the Service Bus namespace or the requested Service Bus entity, depending on Azure configuration.</param> /// <param name="options">A set of options to apply when configuring the client.</param> /// /// <remarks> /// As an internal type, this class performs only basic sanity checks against its arguments. It /// is assumed that callers are trusted and have performed deep validation. /// /// Any parameters passed are assumed to be owned by this instance and safe to mutate or dispose; /// creation of clones or otherwise protecting the parameters is assumed to be the purview of the /// caller. /// </remarks> /// internal AmqpClient( string host, ServiceBusTokenCredential credential, ServiceBusClientOptions options) { Argument.AssertNotNullOrEmpty(host, nameof(host)); Argument.AssertNotNull(credential, nameof(credential)); Argument.AssertNotNull(options, nameof(options)); ServiceEndpoint = new UriBuilder { Scheme = options.TransportType.GetUriScheme(), Host = host }.Uri; Credential = credential; if (options.EnableTransportMetrics) { TransportMetrics = new ServiceBusTransportMetrics(); } ConnectionScope = new AmqpConnectionScope( ServiceEndpoint, credential, options.TransportType, options.WebProxy, options.EnableCrossEntityTransactions, options.RetryOptions.TryTimeout, TransportMetrics); }
public async Task TransactionalSendMultipleSessionsRollback() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true)) { var options = new ServiceBusClientOptions(); options.RetryOptions.TryTimeout = TimeSpan.FromSeconds(5); options.RetryOptions.MaxRetries = 0; var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString, options); ServiceBusSender sender = client.CreateSender(scope.QueueName); ServiceBusMessage message1 = GetMessage("session1"); ServiceBusMessage message2 = GetMessage("session2"); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await sender.SendAsync(message1); await sender.ScheduleMessageAsync(message2, DateTimeOffset.UtcNow.AddMinutes(1)); } Assert.That( async() => await client.CreateSessionReceiverAsync(scope.QueueName), Throws.InstanceOf <ServiceBusException>() .And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusException.FailureReason.ServiceTimeout)); }; }
public async Task CrossEntityTransactionWrongOrder() { await using var queueA = await ServiceBusScope.CreateWithQueue(enablePartitioning : false, enableSession : false); await using var queueB = await ServiceBusScope.CreateWithQueue(enablePartitioning : false, enableSession : false); await using var topicC = await ServiceBusScope.CreateWithTopic(enablePartitioning : false, enableSession : false); #region Snippet:ServiceBusCrossEntityTransactionWrongOrder #if SNIPPET string connectionString = "<connection_string>"; var options = new ServiceBusClientOptions { EnableCrossEntityTransactions = true }; await using var client = new ServiceBusClient(connectionString, options); ServiceBusReceiver receiverA = client.CreateReceiver("queueA"); ServiceBusSender senderB = client.CreateSender("queueB"); ServiceBusSender senderC = client.CreateSender("topicC"); #else await using var client = new ServiceBusClient( TestEnvironment.ServiceBusConnectionString, new ServiceBusClientOptions { EnableCrossEntityTransactions = true }); ServiceBusSender senderA = client.CreateSender(queueA.QueueName); await senderA.SendMessageAsync(new ServiceBusMessage()); ServiceBusReceiver receiverA = client.CreateReceiver(queueA.QueueName); ServiceBusSender senderB = client.CreateSender(queueB.QueueName); ServiceBusSender senderC = client.CreateSender(topicC.TopicName); #endif // SenderB becomes the entity through which subsequent "sends" are routed through, since it is the first // entity on which an operation is performed with the cross-entity transaction client. await senderB.SendMessageAsync(new ServiceBusMessage()); ServiceBusReceivedMessage receivedMessage = await receiverA.ReceiveMessageAsync(); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { // This will through an InvalidOperationException because a "receive" cannot be // routed through a different entity. await receiverA.CompleteMessageAsync(receivedMessage); await senderB.SendMessageAsync(new ServiceBusMessage()); await senderC.SendMessageAsync(new ServiceBusMessage()); ts.Complete(); } #endregion receivedMessage = await receiverA.ReceiveMessageAsync(); Assert.IsNull(receivedMessage); }
internal override TransportClient CreateTransportClient(ServiceBusTokenCredential credential, ServiceBusClientOptions options) { TransportClientCredential = credential; TransportClient ??= new(); return(TransportClient); }
public void ConstructorWithExpandedArgumentsValidatesOptions() { var token = new Mock <ServiceBusTokenCredential>(Mock.Of <TokenCredential>(), "{namespace}.servicebus.windows.net"); var invalidOptions = new ServiceBusClientOptions { TransportType = ServiceBusTransportType.AmqpTcp, Proxy = Mock.Of <IWebProxy>() }; Assert.That(() => new ServiceBusClient("fullyQualifiedNamespace", Mock.Of <TokenCredential>(), invalidOptions), Throws.InstanceOf <ArgumentException>(), "The expanded argument constructor should validate client options"); }
public SubmissionServiceBusService(string serviceBusConnection, string queueName, ILogger log) { _serviceBusClientOptions = new ServiceBusClientOptions(); #if DEBUG _serviceBusClientOptions.TransportType = ServiceBusTransportType.AmqpWebSockets; #endif _serviceBusClient = new ServiceBusClient(serviceBusConnection, _serviceBusClientOptions); _log = log; }
public void ConstructorWithConnectionStringValidatesOptions() { var fakeConnection = "Endpoint=sb://not-real.servicebus.windows.net/;SharedAccessKeyName=DummyKey;SharedAccessKey=[not_real];EntityPath=fake"; var invalidOptions = new ServiceBusClientOptions { TransportType = ServiceBusTransportType.AmqpTcp, WebProxy = Mock.Of <IWebProxy>() }; Assert.That(() => new ServiceBusClient(fakeConnection, invalidOptions), Throws.InstanceOf <ArgumentException>(), "The connection string constructor should validate client options"); }
public void ConstructorWithSharedKeyCredentialValidatesOptions() { var token = new AzureNamedKeyCredential("key", "value"); var invalidOptions = new ServiceBusClientOptions { TransportType = ServiceBusTransportType.AmqpTcp, WebProxy = Mock.Of <IWebProxy>() }; Assert.That(() => new ServiceBusClient("fullyQualifiedNamespace", token, invalidOptions), Throws.InstanceOf <ArgumentException>(), "The expanded argument constructor should validate client options"); }
public void ConstructorWithSharedKeyCredentialSetsTransportTypeFromOptions() { var token = new AzureNamedKeyCredential("key", "value"); var options = new ServiceBusClientOptions { TransportType = ServiceBusTransportType.AmqpWebSockets }; var client = new ServiceBusClient("fullyQualifiedNamespace", token, options); Assert.That(client.TransportType, Is.EqualTo(options.TransportType)); }
public void ConstructorWithTokenCredentialSetsTransportTypeFromOptions() { var token = new Mock <ServiceBusTokenCredential>(Mock.Of <TokenCredential>()); var options = new ServiceBusClientOptions { TransportType = ServiceBusTransportType.AmqpWebSockets }; var client = new ServiceBusClient("fullyQualifiedNamespace", Mock.Of <TokenCredential>(), options); Assert.That(client.TransportType, Is.EqualTo(options.TransportType)); }
public void ConstructorWithConnectionStringSetsTransportTypeFromOptions() { var fakeConnection = "Endpoint=sb://not-real.servicebus.windows.net/;SharedAccessKeyName=DummyKey;SharedAccessKey=[not_real];EntityPath=fake"; var options = new ServiceBusClientOptions { TransportType = ServiceBusTransportType.AmqpWebSockets }; var client = new ServiceBusClient(fakeConnection, options); Assert.That(client.TransportType, Is.EqualTo(options.TransportType)); }
public void ConstructorWithSasCredentialValidatesOptions() { var signature = new SharedAccessSignature("sb://fake.thing.com", "fakeKey", "fakeValue"); var token = new AzureSasCredential(signature.Value); var invalidOptions = new ServiceBusClientOptions { TransportType = ServiceBusTransportType.AmqpTcp, WebProxy = Mock.Of <IWebProxy>() }; Assert.That(() => new ServiceBusClient("fullyQualifiedNamespace", token, invalidOptions), Throws.InstanceOf <ArgumentException>(), "The expanded argument constructor should validate client options"); }
public void ConstructorWithSasCredentialSetsTransportTypeFromOptions() { var signature = new SharedAccessSignature("sb://fake.thing.com", "fakeKey", "fakeValue"); var token = new AzureSasCredential(signature.Value); var options = new ServiceBusClientOptions { TransportType = ServiceBusTransportType.AmqpWebSockets }; var client = new ServiceBusClient("fullyQualifiedNamespace", token, options); Assert.That(client.TransportType, Is.EqualTo(options.TransportType)); }
public void ConstructorCreatesDefaultOptions(ReadableOptionsMock client, string constructorDescription) { var defaultOptions = new ServiceBusClientOptions(); ServiceBusClientOptions options = client.Options; Assert.That(options, Is.Not.Null, $"The { constructorDescription } constructor should have set default options."); Assert.That(options, Is.Not.SameAs(defaultOptions), $"The { constructorDescription } constructor should not have the same options instance."); Assert.That(options.TransportType, Is.EqualTo(defaultOptions.TransportType), $"The { constructorDescription } constructor should have the correct connection type."); Assert.That(options.WebProxy, Is.EqualTo(defaultOptions.WebProxy), $"The { constructorDescription } constructor should have the correct proxy."); }
public void ConstructorClonesOptions(ReadableOptionsMock client, ServiceBusClientOptions constructorOptions, string constructorDescription) { ServiceBusClientOptions options = client.Options; Assert.That(options, Is.Not.Null, $"The { constructorDescription } constructor should have set the options."); Assert.That(options, Is.Not.SameAs(constructorOptions), $"The { constructorDescription } constructor should have cloned the options."); Assert.That(options.TransportType, Is.EqualTo(constructorOptions.TransportType), $"The { constructorDescription } constructor should have the correct connection type."); Assert.That(options.WebProxy, Is.EqualTo(constructorOptions.WebProxy), $"The { constructorDescription } constructor should have the correct proxy."); }
public async Task SendConnStringWithSignature() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { var options = new ServiceBusClientOptions(); var audience = ServiceBusConnection.BuildConnectionResource(options.TransportType, TestEnvironment.FullyQualifiedNamespace, scope.QueueName); var connectionString = TestEnvironment.BuildConnectionStringWithSharedAccessSignature(scope.QueueName, audience); await using var sender = new ServiceBusClient(connectionString, options).CreateSender(scope.QueueName); await sender.SendMessageAsync(GetMessage()); } }
public async Task CrossEntityTransaction() { await using var queueA = await ServiceBusScope.CreateWithQueue(enablePartitioning : false, enableSession : false); await using var queueB = await ServiceBusScope.CreateWithQueue(enablePartitioning : false, enableSession : false); await using var topicC = await ServiceBusScope.CreateWithTopic(enablePartitioning : false, enableSession : false); #region Snippet:ServiceBusCrossEntityTransaction #if SNIPPET string connectionString = "<connection_string>"; var options = new ServiceBusClientOptions { EnableCrossEntityTransactions = true }; await using var client = new ServiceBusClient(connectionString, options); ServiceBusReceiver receiverA = client.CreateReceiver("queueA"); ServiceBusSender senderB = client.CreateSender("queueB"); ServiceBusSender senderC = client.CreateSender("topicC"); #else await using var client = new ServiceBusClient( TestEnvironment.ServiceBusConnectionString, new ServiceBusClientOptions { EnableCrossEntityTransactions = true }); ServiceBusSender senderA = client.CreateSender(queueA.QueueName); await senderA.SendMessageAsync(new ServiceBusMessage()); ServiceBusReceiver receiverA = client.CreateReceiver(queueA.QueueName); ServiceBusSender senderB = client.CreateSender(queueB.QueueName); ServiceBusSender senderC = client.CreateSender(topicC.TopicName); #endif ServiceBusReceivedMessage receivedMessage = await receiverA.ReceiveMessageAsync(); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await receiverA.CompleteMessageAsync(receivedMessage); await senderB.SendMessageAsync(new ServiceBusMessage()); await senderC.SendMessageAsync(new ServiceBusMessage()); ts.Complete(); } #endregion receivedMessage = await receiverA.ReceiveMessageAsync(TimeSpan.FromSeconds(5)); Assert.IsNull(receivedMessage); }
/// <summary> /// Provides test cases for the constructor tests. /// </summary> /// public static IEnumerable <object[]> ConstructorClonesOptionsCases() { var credential = new Mock <ServiceBusTokenCredential>(Mock.Of <TokenCredential>()); var fakeConnection = "Endpoint=sb://not-real.servicebus.windows.net/;SharedAccessKeyName=DummyKey;SharedAccessKey=[not_real];EntityPath=fake"; var options = new ServiceBusClientOptions { TransportType = ServiceBusTransportType.AmqpWebSockets, WebProxy = Mock.Of <IWebProxy>() }; yield return(new object[] { new ReadableOptionsMock(fakeConnection, options), options, "connection string" }); yield return(new object[] { new ReadableOptionsMock("fullyQualifiedNamespace", credential.Object, options), options, "expanded argument" }); }
protected ServiceBusClient CreateClient(int tryTimeout = DefaultTryTimeout) { var options = new ServiceBusClientOptions { RetryOptions = new ServiceBusRetryOptions { TryTimeout = TimeSpan.FromSeconds(tryTimeout), } }; return(new ServiceBusClient( TestEnvironment.ServiceBusConnectionString, options)); }
/// <summary> /// /// </summary> /// <param name="serviceScopeFactory"></param> /// <param name="busOptionsAccessor"></param> /// <param name="transportOptionsAccessor"></param> /// <param name="loggerFactory"></param> public AzureServiceBusTransport(IServiceScopeFactory serviceScopeFactory, IOptions <EventBusOptions> busOptionsAccessor, IOptions <AzureServiceBusTransportOptions> transportOptionsAccessor, ILoggerFactory loggerFactory) : base(serviceScopeFactory, busOptionsAccessor, transportOptionsAccessor, loggerFactory) { var connectionString = TransportOptions.ConnectionString; managementClient = new ServiceBusAdministrationClient(connectionString); var sbcOptions = new ServiceBusClientOptions { TransportType = TransportOptions.TransportType, }; serviceBusClient = new ServiceBusClient(connectionString, sbcOptions); }
protected ServiceBusClient GetNoRetryClient() { var options = new ServiceBusClientOptions { RetryOptions = new ServiceBusRetryOptions { TryTimeout = TimeSpan.FromSeconds(10), MaxRetries = 0 } }; return(new ServiceBusClient( TestEnvironment.ServiceBusConnectionString, options)); }
public MessageServiceAzureServiceBus(ApplicationSettings applicationSettings) { _applicationSettings = applicationSettings; // Create a ServiceBusClient that will authenticate using a connection string string connectionString = _applicationSettings.QueueConnectionString; string queueName = _applicationSettings.QueueName; // since ServiceBusClient implements IAsyncDisposable we create it with "await using" var options = new ServiceBusClientOptions { EnableCrossEntityTransactions = true }; var client = new ServiceBusClient(connectionString, options); // Create the sender and receiver _sender = client.CreateSender(queueName); _receiver = client.CreateReceiver(queueName); }