internal DeleteMessageResponse DeleteMessage(DeleteMessageRequest request) { var marshaller = new DeleteMessageRequestMarshaller(); var unmarshaller = DeleteMessageResponseUnmarshaller.Instance; return(Invoke <DeleteMessageRequest, DeleteMessageResponse>(request, marshaller, unmarshaller)); }
/// <summary> /// Initiates the asynchronous execution of the DeleteMessage operation. /// <seealso cref="Amazon.SQS.IAmazonSQS"/> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DeleteMessage operation.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The task object representing the asynchronous operation.</returns> public Task <DeleteMessageResponse> DeleteMessageAsync(DeleteMessageRequest request, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new DeleteMessageRequestMarshaller(); var unmarshaller = DeleteMessageResponseUnmarshaller.Instance; return(Invoke <IRequest, DeleteMessageRequest, DeleteMessageResponse>(request, marshaller, unmarshaller, signer, cancellationToken)); }
public async Task <DeleteMessageResponse> DeleteMessageAsync(DeleteMessageRequest request) { request.QueueName = this.QueueName; var marshaller = new DeleteMessageRequestMarshaller(); var unmarshaller = DeleteMessageResponseUnmarshaller.Instance; return(await _serviceClient.InvokeAsync <DeleteMessageRequest, DeleteMessageResponse>(request, marshaller, unmarshaller).ConfigureAwait(false)); }
/// <inheritdoc/> public DeleteMessageResponse DeleteMessage(DeleteMessageRequest request) { request.QueueName = this.QueueName; var marshaller = new DeleteMessageRequestMarshaller(); var unmarshaller = DeleteMessageResponseUnmarshaller.Instance; return(_serviceClient.Invoke <DeleteMessageRequest, DeleteMessageResponse>(request, marshaller, unmarshaller)); }
/// <inheritdoc/> public IAsyncResult BeginDeleteMessage(DeleteMessageRequest request, AsyncCallback callback, object state) { request.QueueName = this.QueueName; var marshaller = new DeleteMessageRequestMarshaller(); var unmarshaller = DeleteMessageResponseUnmarshaller.Instance; return(_serviceClient.BeginInvoke <DeleteMessageRequest>(request, marshaller, unmarshaller, callback, state)); }
public void DeleteMessageMarshallTest() { var operation = service_model.FindOperation("DeleteMessage"); var request = InstantiateClassGenerator.Execute <DeleteMessageRequest>(); var marshaller = new DeleteMessageRequestMarshaller(); var internalRequest = marshaller.Marshall(request); var validator = new AWSQueryValidator(internalRequest.Parameters, request, service_model, operation); validator.Validate(); }
/// <summary> /// <para>The <c>DeleteMessage</c> action unconditionally removes the specified message from the specified queue. Even if the message is locked /// by another reader due to the visibility timeout setting, it is still deleted from the queue.</para> /// </summary> /// /// <param name="deleteMessageRequest">Container for the necessary parameters to execute the DeleteMessage service method on AmazonSQS.</param> /// /// <exception cref="T:Amazon.SQS.Model.ReceiptHandleIsInvalidException" /> /// <exception cref="T:Amazon.SQS.Model.InvalidIdFormatException" /> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> public Task<DeleteMessageResponse> DeleteMessageAsync(DeleteMessageRequest deleteMessageRequest, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new DeleteMessageRequestMarshaller(); var unmarshaller = DeleteMessageResponseUnmarshaller.GetInstance(); return Invoke<IRequest, DeleteMessageRequest, DeleteMessageResponse>(deleteMessageRequest, marshaller, unmarshaller, signer, cancellationToken); }
/// <summary> /// Initiates the asynchronous execution of the DeleteMessage operation. /// <seealso cref="Amazon.SQS.IAmazonSQS.DeleteMessage"/> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DeleteMessage operation.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The task object representing the asynchronous operation.</returns> public async Task<DeleteMessageResponse> DeleteMessageAsync(DeleteMessageRequest request, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new DeleteMessageRequestMarshaller(); var unmarshaller = DeleteMessageResponseUnmarshaller.GetInstance(); var response = await Invoke<IRequest, DeleteMessageRequest, DeleteMessageResponse>(request, marshaller, unmarshaller, signer, cancellationToken) .ConfigureAwait(continueOnCapturedContext: false); return response; }
/// <summary> /// Initiates the asynchronous execution of the DeleteMessage operation. /// <seealso cref="Amazon.SQS.IAmazonSQS"/> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DeleteMessage operation on AmazonSQSClient.</param> /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param> /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> /// /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteMessage /// operation.</returns> public IAsyncResult BeginDeleteMessage(DeleteMessageRequest request, AsyncCallback callback, object state) { var marshaller = new DeleteMessageRequestMarshaller(); var unmarshaller = DeleteMessageResponseUnmarshaller.Instance; return BeginInvoke<DeleteMessageRequest>(request, marshaller, unmarshaller, callback, state); }
/// <summary> /// Deletes the specified message from the specified queue. You specify the /// message by using the message's <code>receipt handle</code> and not the <code>message /// ID</code> you received when you sent the message. Even if the message is locked /// by another reader due to the visibility timeout setting, it is still deleted /// from the queue. If you leave a message in the queue for longer than the queue's /// configured retention period, Amazon SQS automatically deletes it. /// /// <note> /// <para> /// The receipt handle is associated with a specific instance of receiving the /// message. If you receive a message more than once, the receipt handle you get /// each time you receive the message is different. When you request <code>DeleteMessage</code>, /// if you don't provide the most recently received receipt handle for the message, /// the request will still succeed, but the message might not be deleted. /// /// </para> /// </note> <important> /// <para> /// It is possible you will receive a message even after you have deleted it. This /// might happen on rare occasions if one of the servers storing a copy of the message /// is unavailable when you request to delete the message. The copy remains on the /// server and might be returned to you again on a subsequent receive request. You /// should create your system to be idempotent so that receiving a particular message /// more than once is not a problem. /// </para> /// </important> /// </summary> /// <param name="request">Container for the necessary parameters to execute the DeleteMessage service method.</param> /// /// <returns>The response from the DeleteMessage service method, as returned by SQS.</returns> /// <exception cref="InvalidIdFormatException"> /// The receipt handle is not valid for the current version. /// </exception> /// <exception cref="ReceiptHandleIsInvalidException"> /// The receipt handle provided is not valid. /// </exception> public DeleteMessageResponse DeleteMessage(DeleteMessageRequest request) { var marshaller = new DeleteMessageRequestMarshaller(); var unmarshaller = DeleteMessageResponseUnmarshaller.Instance; return Invoke<DeleteMessageRequest,DeleteMessageResponse>(request, marshaller, unmarshaller); }
/// <summary> /// Initiates the asynchronous execution of the DeleteMessage operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DeleteMessage operation.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The task object representing the asynchronous operation.</returns> public Task<DeleteMessageResponse> DeleteMessageAsync(DeleteMessageRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new DeleteMessageRequestMarshaller(); var unmarshaller = DeleteMessageResponseUnmarshaller.Instance; return InvokeAsync<DeleteMessageRequest,DeleteMessageResponse>(request, marshaller, unmarshaller, cancellationToken); }
IAsyncResult invokeDeleteMessage(DeleteMessageRequest deleteMessageRequest, AsyncCallback callback, object state, bool synchronized) { IRequest irequest = new DeleteMessageRequestMarshaller().Marshall(deleteMessageRequest); var unmarshaller = DeleteMessageResponseUnmarshaller.GetInstance(); AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller); Invoke(result); return result; }
public void DeleteMessageMarshallTest() { var operation = service_model.FindOperation("DeleteMessage"); var request = InstantiateClassGenerator.Execute<DeleteMessageRequest>(); var marshaller = new DeleteMessageRequestMarshaller(); var internalRequest = marshaller.Marshall(request); var validator = new AWSQueryValidator(internalRequest.Parameters, request, service_model, operation); validator.Validate(); }
/// <summary> /// Initiates the asynchronous execution of the DeleteMessage operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DeleteMessage operation on AmazonSQSClient.</param> /// <param name="callback">An Action delegate that is invoked when the operation completes.</param> /// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> public void DeleteMessageAsync(DeleteMessageRequest request, AmazonServiceCallback<DeleteMessageRequest, DeleteMessageResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new DeleteMessageRequestMarshaller(); var unmarshaller = DeleteMessageResponseUnmarshaller.Instance; Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if(callback !=null ) callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult<DeleteMessageRequest,DeleteMessageResponse> responseObject = new AmazonServiceResult<DeleteMessageRequest,DeleteMessageResponse>((DeleteMessageRequest)req, (DeleteMessageResponse)res, ex , ao.State); callback(responseObject); }; BeginInvoke<DeleteMessageRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
IAsyncResult invokeDeleteMessage(DeleteMessageRequest request, AsyncCallback callback, object state, bool synchronized) { var marshaller = new DeleteMessageRequestMarshaller(); var unmarshaller = DeleteMessageResponseUnmarshaller.Instance; return Invoke(request, callback, state, synchronized, marshaller, unmarshaller, signer); }