コード例 #1
0
 public void MessageUpdated(UpdatedMessage m)
 {
     if (OnMessageUpdated != null)
     {
         OnMessageUpdated(m);
     }
 }
コード例 #2
0
 /// <summary>
 /// Update a <see cref="DequeuedMessage"/> after calling
 /// <see cref="QueueClient.UpdateMessageAsync"/> with the resulting
 /// <see cref="UpdatedMessage"/>
 /// </summary>
 /// <param name="updated">The message details.</param>
 /// <returns>The updated <see cref="DequeuedMessage"/>.</returns>
 public DequeuedMessage Update(UpdatedMessage updated) =>
 QueuesModelFactory.DequeuedMessage(
     this.MessageId,
     this.InsertionTime,
     this.ExpirationTime,
     updated.PopReceipt,
     updated.TimeNextVisible,
     this.DequeueCount,
     this.MessageText);
コード例 #3
0
        public async Task DequeueAndUpdateAsync()
        {
            // Get a connection string to our Azure Storage account.
            string connectionString = ConnectionString;

            // Get a reference to a queue named "sample-queue" and then create it
            QueueClient queue = new QueueClient(connectionString, Randomize("sample-queue"));
            await queue.CreateAsync();

            try
            {
                // Add several messages to the queue
                await queue.EnqueueMessageAsync("first");

                await queue.EnqueueMessageAsync("second");

                await queue.EnqueueMessageAsync("third");

                // Get the messages from the queue with a short visibility timeout
                List <DequeuedMessage> messages = new List <DequeuedMessage>();
                foreach (DequeuedMessage message in (await queue.DequeueMessagesAsync(10, TimeSpan.FromSeconds(1))).Value)
                {
                    // Tell the service we need a little more time to process the message
                    UpdatedMessage changedMessage = await queue.UpdateMessageAsync(
                        message.MessageText,
                        message.MessageId,
                        message.PopReceipt,
                        TimeSpan.FromSeconds(5));

                    messages.Add(message.Update(changedMessage));
                }

                // Wait until the visibility window times out
                await Task.Delay(TimeSpan.FromSeconds(1.5));

                // Ensure the messages aren't visible yet
                Assert.AreEqual(0, (await queue.DequeueMessagesAsync(10)).Value.Count());

                // Finish processing the messages
                foreach (DequeuedMessage message in messages)
                {
                    // Tell the service we need a little more time to process the message
                    await queue.DeleteMessageAsync(message.MessageId, message.PopReceipt);
                }
            }
            finally
            {
                // Clean up after the test when we're finished
                await queue.DeleteAsync();
            }
        }