public void ClientProperties()
{
var account = Encoding.Default.GetString(GetRandomBuffer(12));
var fullyQualifiedNamespace = new UriBuilder($"{account}.servicebus.windows.net/").Host;
var connString = $"Endpoint=sb://{fullyQualifiedNamespace};SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey={Encoding.Default.GetString(GetRandomBuffer(64))}";
var queueName = Encoding.Default.GetString(GetRandomBuffer(12));
var options = new ServiceBusReceiverOptions()
{
ReceiveMode = ReceiveMode.ReceiveAndDelete
};
var receiver = new ServiceBusClient(connString).CreateReceiver(queueName, options);
Assert.AreEqual(queueName, receiver.EntityPath);
Assert.AreEqual(fullyQualifiedNamespace, receiver.FullyQualifiedNamespace);
Assert.IsNotNull(receiver.Identifier);
Assert.IsFalse(receiver.IsSessionReceiver);
Assert.AreEqual(ReceiveMode.ReceiveAndDelete, receiver.ReceiveMode);
}
public async Task ReceiveMessagesInReceiveAndDeleteMode()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
var messageCount = 10;
var sessionId = "sessionId1";
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendAsync(batch);
var clientOptions = new ServiceBusReceiverOptions()
{
ReceiveMode = ReceiveMode.ReceiveAndDelete
};
ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync(
scope.QueueName,
clientOptions,
sessionId);
var remainingMessages = messageCount;
var messageEnum = messages.GetEnumerator();
while (remainingMessages > 0)
{
foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages))
{
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
remainingMessages--;
}
}
Assert.AreEqual(0, remainingMessages);
var peekedMessage = receiver.PeekAsync();
Assert.IsNull(peekedMessage.Result);
}
}
public static async Task Main(string[] args)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appSettings.json", optional: true, reloadOnChange: true)
.AddEnvironmentVariables();
IConfigurationRoot Configuration = builder.Build();
var publisherConnectionString = Configuration.GetConnectionString("SubscriberConnectionString");
var topicName = Configuration["TopicName"];
Console.WriteLine(topicName);
var serviceBusPubClient = new ServiceBusClient(publisherConnectionString);
var serviceBusReceiverOptions = new ServiceBusReceiverOptions()
{
ReceiveMode = ServiceBusReceiveMode.ReceiveAndDelete
};
var subNameA = "sub-a";
var subNameB = "sub-b";
ServiceBusReceiver serviceBusReceiverSubA = serviceBusPubClient.CreateReceiver(topicName, subNameA, serviceBusReceiverOptions);
ServiceBusReceiver serviceBusReceiverSubB = serviceBusPubClient.CreateReceiver(topicName, subNameB, serviceBusReceiverOptions);
IList <Task> receivers = new List <Task>();
receivers.Add(ReceivedMessagesAsync(serviceBusReceiverSubA, subNameA));
receivers.Add(ReceivedMessagesAsync(serviceBusReceiverSubB, subNameB));
await Task.WhenAll(receivers);
await serviceBusReceiverSubA.CloseAsync();
await serviceBusReceiverSubB.CloseAsync();
Console.WriteLine("All messages received");
Console.ReadLine();
}
public async Task ReceiveSingleMessageInReceiveAndDeleteMode()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
ServiceBusMessage sentMessage = GetMessage();
await sender.SendAsync(sentMessage);
var clientOptions = new ServiceBusReceiverOptions()
{
ReceiveMode = ReceiveMode.ReceiveAndDelete,
};
var receiver = client.GetReceiver(scope.QueueName, clientOptions);
var receivedMessage = await receiver.ReceiveAsync();
Assert.AreEqual(sentMessage.MessageId, receivedMessage.MessageId);
var message = receiver.PeekAsync();
Assert.IsNull(message.Result);
}
}
public async Task LockSameSessionShouldThrow()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
int messageCt = 10;
var sessionId = Guid.NewGuid().ToString();
// send the messages
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
ServiceBusMessageBatch messageBatch = AddMessages(batch, messageCt, sessionId);
await sender.SendBatchAsync(messageBatch);
var options = new ServiceBusReceiverOptions
{
RetryOptions = new ServiceBusRetryOptions
{
TryTimeout = TimeSpan.FromSeconds(5),
MaximumRetries = 0
}
};
ServiceBusReceiver receiver1 = await client.GetSessionReceiverAsync(
scope.QueueName,
options,
sessionId);
Assert.That(
async() =>
await client.GetSessionReceiverAsync(
scope.QueueName,
options,
sessionId),
Throws.Exception);
}
}
internal PluginReceiver(string topicName, string subscriptionName, ServiceBusClient client, IEnumerable <Func <ServiceBusReceivedMessage, Task> > plugins, ServiceBusReceiverOptions options) :
base(client, topicName, subscriptionName, options)
{
_plugins = plugins;
}
internal PluginReceiver(string queueName, ServiceBusClient client, IEnumerable <Func <ServiceBusReceivedMessage, Task> > plugins, ServiceBusReceiverOptions options) :
base(client, queueName, options)
{
_plugins = plugins;
}
