public ReceiveMessageResponse GetMessages(string queueURL) { var sqsConfig = new AmazonSQSConfig(); sqsConfig.ServiceURL = "http://sqs.us-west-2.amazonaws.com"; var sqsClient = new AmazonSQSClient(sqsConfig); var receiveMessageRequest = new ReceiveMessageRequest(); receiveMessageRequest.QueueUrl = queueURL; var receiveMessageResponse = sqsClient.ReceiveMessage(receiveMessageRequest); return(receiveMessageResponse); }
public void Start() { Request = new ReceiveMessageRequest { QueueUrl = Queue.QueueUrl, WaitTimeSeconds = 10 }; Receipt = new DeleteMessageRequest { QueueUrl = Queue.QueueUrl }; new Thread(KeepPolling).Start(); }
static void Main(string[] args) { Console.WriteLine("Starting.."); string sQueue = "https://sqs.eu-west-1.amazonaws.com/{CODE}/{QUEUENAME}"; // Region / CODE and QueueName try { var config = new AmazonSQSConfig() { ServiceURL = "https://sqs.eu-west-1.amazonaws.com/" // Region and URL }; AmazonSQSClient _client = new AmazonSQSClient("ACCESSKEY", "ACCESSSECRET", config); ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(); receiveMessageRequest.QueueUrl = sQueue; ReceiveMessageResponse receiveMessageResponse = _client.ReceiveMessage(receiveMessageRequest); foreach (var oMessage in receiveMessageResponse.Messages) { Console.WriteLine(oMessage.Body); // Delete the message from the queue DeleteMessageRequest deleteMessageRequest = new DeleteMessageRequest(); deleteMessageRequest.QueueUrl = sQueue; deleteMessageRequest.ReceiptHandle = oMessage.ReceiptHandle; DeleteMessageResponse response = _client.DeleteMessage(deleteMessageRequest); } } catch (Exception ex) { Console.WriteLine("Error: " + ex.ToString()); } Console.WriteLine("Complete"); Console.WriteLine("Press any key to close"); Console.ReadKey(); }
private async Task <ReceiveMessageResponse> GetMessagesFromSqsQueueAsync(string queueName, string region, CancellationToken ct) { int maxNumberOfMessages = await GetDesiredNumberOfMessagesToRequestFromSqsAsync() .ConfigureAwait(false); if (maxNumberOfMessages < 1) { return(null); } var request = new ReceiveMessageRequest { QueueUrl = _queue.Uri.AbsoluteUri, MaxNumberOfMessages = maxNumberOfMessages, WaitTimeSeconds = 20, AttributeNames = _requestMessageAttributeNames }; using (var receiveTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(300))) { ReceiveMessageResponse sqsMessageResponse; var stopwatch = System.Diagnostics.Stopwatch.StartNew(); try { using (var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(ct, receiveTimeout.Token)) { sqsMessageResponse = await _queue.Client.ReceiveMessageAsync(request, linkedCts.Token) .ConfigureAwait(false); } } finally { if (receiveTimeout.Token.IsCancellationRequested) { _log.LogInformation("Timed out while receiving messages from queue '{QueueName}' in region '{Region}'.", queueName, region); } } stopwatch.Stop(); _messagingMonitor.ReceiveMessageTime(stopwatch.Elapsed, queueName, region); return(sqsMessageResponse); } }
private static void ReceiveMessage(string queueUrl, AmazonSQSClient sqsClient) { ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(); receiveMessageRequest.QueueUrl = queueUrl; var counter = 0; var lenght = NumbersOfMessagesInQueue(queueUrl, sqsClient); while (counter < lenght) { ReceiveMessageResponse receiveMessageResponse = Task.Run(async() => await sqsClient.ReceiveMessageAsync(receiveMessageRequest)).Result; if (receiveMessageResponse.HttpStatusCode == HttpStatusCode.OK) { Message message = receiveMessageResponse.Messages[0]; ReportFilters filter = JsonSerializer.Deserialize <ReportFilters>(message.Body); Console.WriteLine("*********************************"); Console.WriteLine($"SQS Message Id: {message.MessageId}"); Console.WriteLine($"SQS Message Id: {message.ReceiptHandle}"); Console.WriteLine($"Message Id: {filter.Id}"); Console.WriteLine($"Message DataIni: {filter.DataIni}"); Console.WriteLine($"Message DateEnd: {filter.DataEnd}"); Console.WriteLine("*********************************"); Console.WriteLine($"Deleting Message..."); DeleteMessageRequest deleteMessageRequest = new DeleteMessageRequest(); deleteMessageRequest.QueueUrl = queueUrl; deleteMessageRequest.ReceiptHandle = message.ReceiptHandle; DeleteMessageResponse response = Task.Run(async() => await sqsClient.DeleteMessageAsync(deleteMessageRequest)).Result; if (response.HttpStatusCode == HttpStatusCode.OK) { Console.WriteLine($"Deleted Message..."); } else { Console.WriteLine($"ERROR: {response.HttpStatusCode}"); } Console.WriteLine(); } counter++; } }
public async Task ChangeMessageVisibilityBatch() { // Create service client using the SDK's default logic for determining AWS credentials and region to use. // For information configuring service clients checkout the .NET developer guide: https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config.html AmazonSQSClient client = new AmazonSQSClient(); string queueUrl = "SQS_QUEUE_URL"; var receiveMessageRequest = new ReceiveMessageRequest { AttributeNames = { "SentTimestamp" }, MaxNumberOfMessages = 5, MessageAttributeNames = { "All" }, QueueUrl = queueUrl }; var receiveMessageResponse = await client.ReceiveMessageAsync(receiveMessageRequest); List <ChangeMessageVisibilityBatchRequestEntry> entries = new List <ChangeMessageVisibilityBatchRequestEntry>(); foreach (var message in receiveMessageResponse.Messages) { entries.Add(new ChangeMessageVisibilityBatchRequestEntry { Id = message.MessageId, ReceiptHandle = message.ReceiptHandle, VisibilityTimeout = 36000, // 10 hour timeout }); } var changeMessageVisibilityBatchResponse = await client.ChangeMessageVisibilityBatchAsync(new ChangeMessageVisibilityBatchRequest { QueueUrl = queueUrl, Entries = entries }); Console.WriteLine("Messages successfully changed:"); foreach (var success in changeMessageVisibilityBatchResponse.Successful) { Console.WriteLine(" Message id : {0}", success.Id); } Console.WriteLine("Messages failed to change:"); foreach (var failed in changeMessageVisibilityBatchResponse.Failed) { Console.WriteLine(" Message id : {0}", failed.Id); Console.WriteLine(" Sender's fault? : {0}", failed.SenderFault); } }
private async Task <int> ProcessSingleBatch() { var request = new ReceiveMessageRequest { QueueUrl = EnvironmentVariables.MailQueue, MaxNumberOfMessages = EnvironmentVariables.MailNumberPerBatch }; var sqsResult = await _sqsClient.ReceiveMessageAsync(request); var sendEmailTasks = sqsResult.Messages.Select(async sqsMessage => await InvokeLambdaAndDeleteMessage(sqsMessage)); await Task.WhenAll(sendEmailTasks); return(sqsResult.Messages.Count); }
/// <summary> /// Retrieve messages from the underlying queue /// </summary> /// <param name="cancellationToken">Cancellation token</param> /// <returns>Messages or empty</returns> public async Task <IEnumerable <TransportMessage> > GetMessages(CancellationToken cancellationToken) { ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest(); receiveMessageRequest.WaitTimeSeconds = WaitTimeSeconds; receiveMessageRequest.MaxNumberOfMessages = MaxNumberOfMessages; receiveMessageRequest.AttributeNames = new List <string>() { "ApproximateReceiveCount" }; receiveMessageRequest.QueueUrl = _queueUrl; ReceiveMessageResponse receiveMessageResponse = await _simpleQueueService.ReceiveMessageAsync(receiveMessageRequest, cancellationToken); return(receiveMessageResponse.Messages.Select(x => MessageParser.ParseMessage(x)).ToList()); }
public Task <ReceiveMessageResponse> ReceiveMessageAsync(ReceiveMessageRequest request, CancellationToken cancellationToken = default) { if (request == null) { throw new ArgumentNullException(nameof(request)); } var option = new InvokeOptions() { OriginalRequest = request, RequestMarshaller = new ReceiveMessageRequestMarshaller(), ResponseUnmarshaller = new ReceiveMessageResponseUnmarshaller() }; return(InvokeAsync <ReceiveMessageResponse>(option, cancellationToken)); }
private static ReceiveMessageRequest CreateSQSRequest(string attribute, int maxMessages, string queueURL, int timeout, int wait) { var request = new ReceiveMessageRequest { AttributeNames = new List <string>() { attribute }, MaxNumberOfMessages = maxMessages, QueueUrl = queueURL, VisibilityTimeout = timeout, WaitTimeSeconds = wait }; return(request); }
public void Start() { Request = new ReceiveMessageRequest { QueueUrl = Queue.QueueUrl, WaitTimeSeconds = 10, MaxNumberOfMessages = Queue.MaxNumberOfMessages, VisibilityTimeout = Queue.VisibilityTimeout, }; Receipt = new DeleteMessageRequest { QueueUrl = Queue.QueueUrl }; (PollingThread = new Thread(KeepPolling)).Start(); }
private int GetNumberOfMessages() { Debug.WriteLine("SqsSnsTest Thread sleeping for {0} seconds...", sleep); System.Threading.Thread.Sleep(sleep); Debug.WriteLine("SqsSnsTest ...Thread running."); int numMessages = 0; ReceiveMessageRequest request = new ReceiveMessageRequest(queueUrl); request.WaitTimeSeconds = 20; request.MaxNumberOfMessages = 10; ReceiveMessageResponse receiveMessageResult = sqsClient.ReceiveMessage(request); numMessages = receiveMessageResult.Messages.Count; return(numMessages); }
public async Task <ReceiveMessageResponse> ReceiveMessageAsync( ReceiveMessageRequest request, CancellationToken cancellationToken = new CancellationToken()) { await Task.Delay(50, cancellationToken); ReceiveMessageRequests.Add(request); _getMessagesEnumerator ??= _getMessages().GetEnumerator(); _getMessagesEnumerator.MoveNext(); return(new ReceiveMessageResponse() { Messages = _getMessagesEnumerator.Current.Messages }); }
static void Read(AmazonSQSClient client, string dir, string queueUrl) { var recieveMessageRequest = new ReceiveMessageRequest(); var deleteMessageRequest = new DeleteMessageRequest(); recieveMessageRequest.QueueUrl = queueUrl; recieveMessageRequest.VisibilityTimeout = 3600; deleteMessageRequest.QueueUrl = queueUrl; while (true) { ReadMessages(client, recieveMessageRequest, deleteMessageRequest, dir); } }
private Task <ReceiveMessageResponse> GetMessagesFromSQS(CancellationToken stoppingToken) { var queueUrl = _configuration["AmazonSQSCheckoutQueueURL"]; _logger.LogInformation("Trying to get new messages from {queueUrl}", queueUrl); var request = new ReceiveMessageRequest() { QueueUrl = queueUrl, MaxNumberOfMessages = 10, VisibilityTimeout = 5 * 60, WaitTimeSeconds = 15 }; return(_amazonSQSClient.ReceiveMessageAsync(request, stoppingToken)); }
public async Task ProcessMessages() { await InitializeAsync(); var receiveMessageRequest = new ReceiveMessageRequest(); receiveMessageRequest.QueueUrl = this.queueUrl; receiveMessageRequest.MaxNumberOfMessages = 10; receiveMessageRequest.WaitTimeSeconds = 3; //long polling var response = await sqsClient.ReceiveMessageAsync(receiveMessageRequest); foreach (var message in response.Messages) { await ProcessMessage(message); } }
internal async Task ConsumeDelayedMessages(ReceiveMessageRequest request, CancellationToken token) { var receivedMessages = await sqsClient.ReceiveMessageAsync(request, token).ConfigureAwait(false); if (receivedMessages.Messages.Count == 0) { return; } var clockCorrection = CorrectClockSkew.GetClockCorrectionForEndpoint(awsEndpointUrl); var preparedMessages = PrepareMessages(token, receivedMessages, clockCorrection); token.ThrowIfCancellationRequested(); await BatchDispatchPreparedMessages(preparedMessages).ConfigureAwait(false); }
public async Task <IEnumerable <IAwsArgs> > Dequeue() { //Retrieve message var recieveRequest = new ReceiveMessageRequest(_queueUrl); var response = await _client.ReceiveMessageAsync(recieveRequest); //Initialize return collections var returnList = response.Messages.Select(msg => JsonConvert.DeserializeObject <AwsEventArgs>(msg.Body)).Cast <IAwsArgs>().ToList(); //Delete messages var deleteList = response.Messages.Select(msg => new DeleteMessageBatchRequestEntry(msg.MessageId, msg.ReceiptHandle)).ToList(); var result = await _client.DeleteMessageBatchAsync(_queueUrl, deleteList); //Return messages return(returnList); }
static void ReadFromQueue(AWSCredentials credentials) { AmazonSQSClient client = new AmazonSQSClient(credentials, RegionEndpoint.USEast1); string queueUrl = "https://sqs.us-east-1.amazonaws.com/025631894481/aws-talk"; ReceiveMessageRequest request = new ReceiveMessageRequest(queueUrl); request.MaxNumberOfMessages = 1; ReceiveMessageResponse response = client.ReceiveMessage(request); foreach (var message in response.Messages) { // Do something with the message } }
private static async Task <Message> GetJobFromSQS() { //Build message request, only get one message var receiveMessageRequest = new ReceiveMessageRequest() { QueueUrl = sqsQueueUrl, MaxNumberOfMessages = 1 }; var receiveMessageResponse = await sqsClient.ReceiveMessageAsync(receiveMessageRequest); System.Console.WriteLine($"Info: GetSQS, MessageID: {receiveMessageResponse.Messages.FirstOrDefault().MessageId}"); //Change visibility of message so that nothing else picks up the same job await sqsClient.ChangeMessageVisibilityAsync(sqsQueueUrl, receiveMessageResponse.Messages.FirstOrDefault().ReceiptHandle, 40000); return(receiveMessageResponse.Messages.FirstOrDefault()); }
public async Task <IEnumerable <Message> > FetchMessagesAsync(string queueUrl) { var request = new ReceiveMessageRequest { QueueUrl = queueUrl, WaitTimeSeconds = 5, MaxNumberOfMessages = 10 }; var response = await _sqsClient.ReceiveMessageAsync(request); var messages = response.Messages; await DeleteMessagesAsync(queueUrl, messages); return(messages); }
async Task <ReceiveMessageResponse> ReceiveMessages(ReceiveSettings receiveSettings, string queueUrl, int maxNumberOfMessages) { var request = new ReceiveMessageRequest(queueUrl) { MaxNumberOfMessages = maxNumberOfMessages, WaitTimeSeconds = receiveSettings.WaitTimeSeconds, AttributeNames = new List <string> { "All" }, MessageAttributeNames = new List <string> { "All" } }; return(await _amazonSqs.ReceiveMessageAsync(request, CancellationToken).ConfigureAwait(false)); }
/// <summary> /// Initializes the specified aws queue URL. This needs to be called before starting the listener. /// </summary> /// <param name="awsQueueUrl">The aws queue URL.</param> /// <param name="awsRegionEndpoint">The region endpoint.</param> /// <param name="awsAccessKey">The aws access key.</param> /// <param name="awsSecretKey">The aws secret key.</param> /// <param name="isConnectedToSns">if set to <c>true</c> it assumes a SNS message structure and parsed only the "message" part of it. This is an optional feature, default is false.</param> /// <param name="longPollTimeout">The long poll timeout in seconds.</param> public void Initialize(string awsQueueUrl, string awsRegionEndpoint, string awsAccessKey, string awsSecretKey, bool isConnectedToSns = false, int longPollTimeout = 20) { var region = RegionEndpointHelper.Parse(awsRegionEndpoint); AWSCredentials credentials = new BasicAWSCredentials(awsAccessKey, awsSecretKey); _sqs = new AmazonSQSClient(credentials, region); _queueUrl = awsQueueUrl; _isConnectedToSns = isConnectedToSns; _receiveMessageRequest = new ReceiveMessageRequest { QueueUrl = awsQueueUrl, WaitTimeSeconds = longPollTimeout }; _logger.InfoFormat("AwsSyncQueueListener initialized for queue {0} in {1}", awsQueueUrl, region); }
public void Test_ReceiveMessage_With_ValidQueue_And_Check_For_ReceivedMessage() { bool hasCallbackArrived = false; string actualValue = string.Empty; string expectedValue = "A test message body during Unit-Testing"; SQSResponseEventHandler <object, ResponseEventArgs> handler = null; handler = delegate(object sender, ResponseEventArgs args) { ISQSResponse result = args.Response; //Unhook from event. _client.OnSQSResponse -= handler; ReceiveMessageResponse response = result as ReceiveMessageResponse; if (null != response) { ReceiveMessageResult messageResult = response.ReceiveMessageResult; if (null != messageResult) { if (messageResult.Message.Count > 0) { Message message = messageResult.Message[0]; if (null != message) { actualValue = message.Body; } } } } hasCallbackArrived = true; }; //Hook to event _client.OnSQSResponse += handler; //Create request object. ReceiveMessageRequest request = new ReceiveMessageRequest { QueueUrl = (string.Format("{0}/{1}", QueueURL, _queue_UnitTesting)), }; _client.ReceiveMessage(request); EnqueueConditional(() => hasCallbackArrived); EnqueueCallback(() => Assert.IsTrue(string.Compare(expectedValue, actualValue) == 0)); EnqueueTestComplete(); }
public async Task <IActionResult> DeleteMessage() { var queueUrl = await QueueUrl.Build(_client, QueueName, _sqsConfigParam.QueueAttributes); var receiveMessageRequest = new ReceiveMessageRequest { QueueUrl = queueUrl.Value }; var response = await _client.ReceiveMessageAsync(receiveMessageRequest); var deleteResults = new List <dynamic>(); foreach (var message in response.Messages) { _logger.LogDebug($"messageId:{message.MessageId} / ReceiptHandle:{message.ReceiptHandle}"); var deleteRequest = new DeleteMessageRequest { QueueUrl = queueUrl.Value, ReceiptHandle = message.ReceiptHandle }; var deleteResponse = await _client.DeleteMessageAsync(deleteRequest); if (deleteResponse.HttpStatusCode == HttpStatusCode.OK) { deleteResults.Add(new { MessageId = message.MessageId, Status = "success" }); } else { deleteResults.Add(new { MessageId = message.MessageId, Status = "fail" }); } } if (deleteResults.All(result => result.Status == "success")) { var result = new { StatusCode = "正常終了", Message = "SQSへメッセージの削除に成功しました。", }; return(Ok(JsonConvert.SerializeObject(result))); } else { return(new StatusCodeResult(500)); } }
private ObjectMessage <T> Next <T>(bool delete) where T : new() { var rmr = new ReceiveMessageRequest(); rmr.QueueUrl = queueUrl; rmr.AttributeNames.Add("SentTimestamp"); rmr.AttributeNames.Add("ApproximateReceiveCount"); rmr.AttributeNames.Add("ApproximateFirstReceiveTimestamp"); var response = this.client.ReceiveMessage(rmr); if (response.Messages != null && response.Messages.Any()) { ObjectMessage <T> value = new ObjectMessage <T>(); Message m = response.Messages[0]; DateTime epochDate = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); value.Object = this.Serializer.Deserialize <T>(m.Body); value.ReceiptHandle = m.ReceiptHandle; foreach (KeyValuePair <string, string> att in m.Attributes) { switch (att.Key) { case "SentTimestamp": value.Sent = epochDate.AddMilliseconds(double.Parse(att.Value)); break; case "ApproximateReceiveCount": value.ApproximateReceiveCount = Int32.Parse(att.Value); break; case "ApproximateFirstReceiveTimestamp": value.FirstReceived = epochDate.AddMilliseconds(double.Parse(att.Value)); break; } } if (delete) { DeleteMessage(m.ReceiptHandle); } return(value); } return(default(ObjectMessage <T>)); }
static void Main(string[] args) { var batch_size = int.Parse(args[0]); var queue_url = args[1]; System.Console.WriteLine($"Reading {batch_size} messages at a time from SQS queue {queue_url}"); var sqs = new AmazonSQSClient(); // need keys and region try { while (true) { var receive_message_request = new ReceiveMessageRequest { AttributeNames = new List <string>() { "All" }, MaxNumberOfMessages = batch_size, QueueUrl = queue_url, WaitTimeSeconds = 20 }; var result = sqs.ReceiveMessageAsync(receive_message_request).Result; foreach (var message in result.Messages) { if (process_message(message)) { sqs.DeleteMessageAsync(new DeleteMessageRequest { QueueUrl = queue_url, ReceiptHandle = message.ReceiptHandle }); } else { sqs.ChangeMessageVisibilityAsync(queue_url, message.ReceiptHandle, 10); } } } } catch (System.Exception) { throw; } }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { var QueueUrl = "https://sqs.us-east-1.amazonaws.com/220972709433/Reports"; while (!stoppingToken.IsCancellationRequested) { try { var request = new ReceiveMessageRequest { QueueUrl = QueueUrl, MaxNumberOfMessages = 10, WaitTimeSeconds = 5 }; var result = await _sqs.ReceiveMessageAsync(request); if (result.Messages.Any()) { foreach (var message in result.Messages) { ReportGenerate(JsonConvert.DeserializeObject <ReceivedMessage>(message.Body)); // Some Processing code would live here _logger.LogInformation("Processing Message: {message} | {time}", message.Body, DateTimeOffset.Now); //var processedMessage = new ProcessedMessage(message.Body); //var sendRequest = new SendMessageRequest(_processedMessageQueueUrl, JsonConvert.SerializeObject(processedMessage)); //var sendResult = await _sqs.SendMessageAsync(sendRequest, stoppingToken); //if (sendResult.HttpStatusCode == System.Net.HttpStatusCode.OK) //{ var deleteResult = await _sqs.DeleteMessageAsync(QueueUrl, message.ReceiptHandle); //} } } } catch (Exception e) { _logger.LogError(e.InnerException.ToString()); } _logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now); } }
public void RetrieveOrders(ILogger _logger, int?messagesToRetreive = null, CancellationToken?token = null) { var orders = new List <Order>(); AmazonSQSConfig amazonSQSConfig = new AmazonSQSConfig(); var count = 0; var amazonSQSClient = new AmazonSQSClient(amazonSQSConfig); ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest { QueueUrl = MyQueueUrl }; while (true) { if (token != null && ((CancellationToken)token).IsCancellationRequested || (messagesToRetreive != null && count >= messagesToRetreive)) { break; } ReceiveMessageResponse receiveMessageResponse = amazonSQSClient.ReceiveMessage(receiveMessageRequest); var result = receiveMessageResponse; if (result.Messages.Count != 0) { for (int i = 0; i < result.Messages.Count; i++) { var order = JsonConvert.DeserializeObject <Order>(result.Messages[i].Body); orders.Add(order); Task.Run(async() => { await SiloManager.StartOrder(order); }); Console.WriteLine(order); count++; try { amazonSQSClient.DeleteMessage(MyQueueUrl, result.Messages[i].ReceiptHandle); } catch (Exception e) { Console.WriteLine(e); } } } Thread.Sleep(1000); } // return orders; }
/// <summary> /// Initializes the Amazon SQS client object. It then calls the /// ReceiveMessageAsync method to retrieve information about the /// available methods before deleting them. /// </summary> public static async Task Main() { string queueUrl = "https://sqs.us-east-2.amazonaws.com/0123456789ab/Example_Queue"; var attributeNames = new List <string>() { "All" }; int maxNumberOfMessages = 5; var visibilityTimeout = (int)TimeSpan.FromMinutes(10).TotalSeconds; var waitTimeSeconds = (int)TimeSpan.FromSeconds(5).TotalSeconds; // If the Amazon SQS message queue is not in the same AWS Region as your // default user, you need to provide the AWS Region as a parameter to the // client constructor. var client = new AmazonSQSClient(); var request = new ReceiveMessageRequest { QueueUrl = queueUrl, AttributeNames = attributeNames, MaxNumberOfMessages = maxNumberOfMessages, VisibilityTimeout = visibilityTimeout, WaitTimeSeconds = waitTimeSeconds, }; var response = await client.ReceiveMessageAsync(request); if (response.Messages.Count > 0) { response.Messages.ForEach(async m => { Console.Write($"Message ID: '{m.MessageId}'"); var delRequest = new DeleteMessageRequest { QueueUrl = "https://sqs.us-east-1.amazonaws.com/0123456789ab/MyTestQueue", ReceiptHandle = m.ReceiptHandle, }; var delResponse = await client.DeleteMessageAsync(delRequest); }); } else { Console.WriteLine("No messages to delete."); } }