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.");
}
}
