/// <summary> /// /// </summary> /// <returns></returns> public virtual async Task <ServiceBusReceiver> GetSessionReceiverAsync( string queueName, ServiceBusReceiverOptions options = default, string sessionId = default, CancellationToken cancellationToken = default) { ValidateEntityName(queueName); return(await ServiceBusReceiver.CreateSessionReceiverAsync( entityPath : queueName, connection : Connection, sessionId : sessionId, options : options, cancellationToken : cancellationToken).ConfigureAwait(false)); }
/// <summary> /// Initializes a new instance of the <see cref="ProcessMessageEventArgs"/> class. /// </summary> /// /// <param name="message">The message to be processed.</param> /// <param name="manager">The receiver manager for these event args.</param> /// <param name="cancellationToken">The processor's <see cref="System.Threading.CancellationToken"/> instance which will be cancelled /// in the event that <see cref="ServiceBusProcessor.StopProcessingAsync"/> is called. /// </param> internal ProcessMessageEventArgs( ServiceBusReceivedMessage message, ReceiverManager manager, CancellationToken cancellationToken) { Message = message; // manager would be null in scenarios where customers are using the public constructor for testing purposes. _receiver = manager?.Receiver; CancellationToken = cancellationToken; bool autoRenew = manager?.ShouldAutoRenewMessageLock() == true; _receiveActions = new ProcessorReceiveActions(message, manager, autoRenew); }
/// <summary> /// /// </summary> /// <returns></returns> public virtual async Task <ServiceBusReceiver> GetSessionReceiverAsync( string topicName, string subscriptionName, ServiceBusReceiverOptions options = default, string sessionId = default, CancellationToken cancellationToken = default) { ValidateEntityName(topicName); return(await ServiceBusReceiver.CreateSessionReceiverAsync( entityPath : EntityNameFormatter.FormatSubscriptionPath(topicName, subscriptionName), connection : Connection, sessionId : sessionId, options : options, cancellationToken : cancellationToken).ConfigureAwait(false)); }
public virtual async Task CloseReceiverIfNeeded( CancellationToken cancellationToken, bool forceClose = false) { var capturedReceiver = Receiver; if (capturedReceiver != null) { try { await capturedReceiver.DisposeAsync().ConfigureAwait(false); } finally { Receiver = null; } } }
/// <summary> /// /// </summary> /// <returns></returns> internal static async Task <ServiceBusReceiver> CreateSessionReceiverAsync( string queueName, ServiceBusConnection connection, string sessionId = default, ServiceBusReceiverOptions options = default, CancellationToken cancellationToken = default) { options = options?.Clone() ?? new ServiceBusReceiverOptions(); var receiver = new ServiceBusReceiver( connection: connection, entityName: queueName, isSessionEntity: true, sessionId: sessionId, options: options); await receiver.OpenLinkAsync(cancellationToken).ConfigureAwait(false); return(receiver); }
public ReceiverManager( ServiceBusProcessor processor, EntityScopeFactory scopeFactory, IList <ServiceBusPlugin> plugins) { Processor = processor; ProcessorOptions = processor.Options; _receiverOptions = new ServiceBusReceiverOptions { ReceiveMode = ProcessorOptions.ReceiveMode, PrefetchCount = ProcessorOptions.PrefetchCount, }; _maxReceiveWaitTime = ProcessorOptions.MaxReceiveWaitTime; _plugins = plugins; Receiver = new ServiceBusReceiver( connection: Processor.Connection, entityPath: Processor.EntityPath, isSessionEntity: false, plugins: _plugins, options: _receiverOptions); _scopeFactory = scopeFactory; }
public ReceiverManager( ServiceBusProcessor processor, EntityScopeFactory scopeFactory) { Processor = processor; ProcessorOptions = processor.Options; _receiverOptions = new ServiceBusReceiverOptions { ReceiveMode = ProcessorOptions.ReceiveMode, PrefetchCount = ProcessorOptions.PrefetchCount, // Pass None for subqueue since the subqueue has already // been taken into account when computing the EntityPath of the processor. SubQueue = SubQueue.None }; _maxReceiveWaitTime = ProcessorOptions.MaxReceiveWaitTime; Receiver = new ServiceBusReceiver( connection: Processor.Connection, entityPath: Processor.EntityPath, isSessionEntity: false, isProcessor: true, options: _receiverOptions); _scopeFactory = scopeFactory; }
/// <summary> /// Initializes a new instance of the <see cref="ProcessMessageEventArgs"/> class. /// </summary> /// /// <param name="message"></param> /// <param name="receiver"></param> /// <param name="cancellationToken"></param> internal ProcessMessageEventArgs(ServiceBusReceivedMessage message, ServiceBusReceiver receiver, CancellationToken cancellationToken) { Message = message; Receiver = receiver; CancellationToken = cancellationToken; }
/// <summary> /// /// </summary> /// <param name="topicName"></param> /// <param name="subscriptionName"></param> /// <returns></returns> public ServiceBusReceiver GetSubscriptionReceiver(string topicName, string subscriptionName) { return(ServiceBusReceiver.CreateReceiver( EntityNameFormatter.FormatSubscriptionPath(topicName, subscriptionName), Connection)); }
/// <summary> /// /// </summary> /// <param name="queueName"></param> /// <returns></returns> public ServiceBusReceiver GetReceiver(string queueName) { return(ServiceBusReceiver.CreateReceiver( queueName, Connection)); }
/// <summary> /// Initializes a new instance of the <see cref="ProcessMessageEventArgs"/> class. /// </summary> /// /// <param name="message">The message to be processed.</param> /// <param name="receiver">The receiver instance that can be used to perform message settlement.</param> /// <param name="cancellationToken">The processor's <see cref="System.Threading.CancellationToken"/> instance which will be cancelled /// in the event that <see cref="ServiceBusProcessor.StopProcessingAsync"/> is called. /// </param> public ProcessMessageEventArgs(ServiceBusReceivedMessage message, ServiceBusReceiver receiver, CancellationToken cancellationToken) : this(message, manager : null, cancellationToken) { _receiver = receiver; }