public async Task <string> Publish(string message) { await Limiter.Add(1); await using (var context = new AzureMessagingContext(QueueUrl)) { var msg = new azureMessaging.ServiceBusMessage(message); await context.Sender.SendMessageAsync(msg); return(msg.MessageId); } }
/// <summary> /// Creates a new message from the specified payload. /// </summary> /// <param name="body">The payload of the message in bytes</param> internal ServiceBusReceivedMessage(ReadOnlyMemory <byte> body) { SentMessage = new ServiceBusMessage(body); }
public static async Task SendServiceBusMessageAsync(ServiceBusSender queueSender, Azure.Messaging.ServiceBus.ServiceBusMessage message, ILogger log, TimeSpan delay) { if (queueSender == null) { throw new ArgumentNullException(nameof(queueSender)); } log.LogInformation($"Sending message with delay of {delay.TotalMinutes} minutes."); await queueSender.ScheduleMessageAsync(message, DateTimeOffset.Now.Add(delay)).ConfigureAwait(false); }
public static async Task SendServiceBusMessageAsync(ServiceBusSender queueSender, string messageContent, ILogger log, TimeSpan delay) { var message = new Azure.Messaging.ServiceBus.ServiceBusMessage(messageContent); await SendServiceBusMessageAsync(queueSender, message, log, delay).ConfigureAwait(false); }
/// <summary> /// Attempts to add a message to the batch, ensuring that the size /// of the batch does not exceed its maximum. /// </summary> /// /// <param name="message">Message to attempt to add to the batch.</param> /// /// <returns><c>true</c> if the message was added; otherwise, <c>false</c>.</returns> /// public bool TryAdd(ServiceBusMessage message) { return(InnerBatch.TryAdd(message)); }
public static ServiceBusReceivedMessage ServiceBusReceivedMessage( BinaryData body = default, string messageId = default, string partitionKey = default, string viaPartitionKey = default, string sessionId = default, string replyToSessionId = default, TimeSpan timeToLive = default, string correlationId = default, string label = default, string to = default, string contentType = default, string replyTo = default, DateTimeOffset scheduledEnqueueTime = default, IDictionary <string, object> properties = default, Guid lockTokenGuid = default, int deliveryCount = default, DateTimeOffset lockedUntil = default, long sequenceNumber = -1, string deadLetterSource = default, long enqueuedSequenceNumber = default, DateTimeOffset enqueuedTime = default) { var sentMessage = new ServiceBusMessage { Body = body, CorrelationId = correlationId, Label = label, To = to, ContentType = contentType, ReplyTo = replyTo, ScheduledEnqueueTime = scheduledEnqueueTime }; if (messageId != default) { sentMessage.MessageId = messageId; } if (partitionKey != default) { sentMessage.PartitionKey = partitionKey; } if (viaPartitionKey != default) { sentMessage.ViaPartitionKey = viaPartitionKey; } if (sessionId != default) { sentMessage.SessionId = sessionId; } if (replyToSessionId != default) { sentMessage.ReplyToSessionId = replyToSessionId; } if (timeToLive != default) { sentMessage.TimeToLive = timeToLive; } if (properties != default) { sentMessage.Properties = properties; } return(new ServiceBusReceivedMessage { SentMessage = sentMessage, LockTokenGuid = lockTokenGuid, DeliveryCount = deliveryCount, LockedUntil = lockedUntil, SequenceNumber = sequenceNumber, DeadLetterSource = deadLetterSource, EnqueuedSequenceNumber = enqueuedSequenceNumber, EnqueuedTime = enqueuedTime }); }
/// <summary> /// Called when a 'process message' event is triggered. /// </summary> /// /// <param name="message">The set of arguments to identify the context of the event to be processed.</param> /// <param name="session"></param> /// private Task OnProcessMessageAsync(ServiceBusMessage message, ServiceBusSession session) => _processMessage(message, session);
/// <summary> /// Renews the lock on the message specified by the lock token. The lock will be renewed based on the setting specified on the queue. /// </summary> /// <remarks> /// When a message is received in <see cref="ReceiveMode.PeekLock"/> mode, the message is locked on the server for this /// receiver instance for a duration as specified during the Queue/Subscription creation (LockDuration). /// If processing of the message requires longer than this duration, the lock needs to be renewed. /// For each renewal, it resets the time the message is locked by the LockDuration set on the Entity. /// </remarks> public virtual async Task RenewLockAsync( ServiceBusMessage message, CancellationToken cancellationToken = default) { message.SystemProperties.LockedUntilUtc = await _receiver.RenewLockAsync(message.SystemProperties.LockToken).ConfigureAwait(false); }