/// <summary> /// Begins an asynchronous operation to delete a table. /// </summary> /// <param name="tableName">The table name.</param> /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param> /// <param name="state">A user-defined object that will be passed to the callback delegate.</param> /// <returns> /// An <see cref="IAsyncResult"/> that references the asynchronous request. /// </returns> public IAsyncResult BeginDeleteTable(string tableName, AsyncCallback callback, object state) { CommonUtils.CheckStringParameter(tableName, false, "tableName", Protocol.Constants.TableServiceMaxStringPropertySizeInChars); TableServiceUtilities.CheckTableName(tableName, "tableName"); return(TaskImplHelper.BeginImplWithRetry(() => this.DeleteTableImpl(tableName), RetryPolicy, callback, state)); }
/// <summary> /// Begins an asynchronous operation to create a table with the specified name if it does not already exist. /// </summary> /// <param name="tableName">The table name.</param> /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param> /// <param name="state">A user-defined object that will be passed to the callback delegate.</param> /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns> public IAsyncResult BeginCreateTableIfNotExist(string tableName, AsyncCallback callback, object state) { return(TaskImplHelper.BeginImpl <bool>( (setResult) => this.CreateTableIfNotExistImpl(tableName, setResult), callback, state)); }
/// <summary> /// Begins an asynchronous operation to return a result segment containing a collection of queues /// whose names begin with the specified prefix. /// </summary> /// <param name="prefix">The queue name prefix.</param> /// <param name="detailsIncluded">One of the enumeration values that indicates which details to include in the listing.</param> /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the /// per-operation limit of 5000. If this value is zero, the maximum possible number of results will be returned, up to 5000.</param> /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param> /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param> /// <param name="state">A user-defined object that will be passed to the callback delegate.</param> /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns> public IAsyncResult BeginListQueuesSegmented(string prefix, QueueListingDetails detailsIncluded, int maxResults, ResultContinuation continuationToken, AsyncCallback callback, object state) { return(TaskImplHelper.BeginImplWithRetry <ResultSegment <CloudQueue> >( (setResult) => this.ListQueuesImpl(prefix, detailsIncluded, continuationToken, maxResults, setResult), this.RetryPolicy, callback, state)); }
/// <summary> /// Begins the asynchronous request with retry. /// </summary> /// <typeparam name="T">The result type of the task.</typeparam> /// <param name="oracle">The oracle to use.</param> /// <param name="impl">The task implementation.</param> /// <param name="callback">The asynchronous callback.</param> /// <param name="state">The asynchronous state.</param> /// <returns>An <see cref="IAsyncResult"/> that represents the asynchronous operation.</returns> internal static IAsyncResult BeginAsynchronousRequestWithRetry <T>( ShouldRetry oracle, Func <Action <T>, TaskSequence> impl, AsyncCallback callback, object state) { return(TaskImplHelper.BeginImpl <T>((setResult) => RequestWithRetryImpl <T>(oracle, impl, setResult), callback, state)); }
/// <summary> /// Begins an asynchronous operation to execute a query and return the results as a result segment. /// </summary> /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param> /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param> /// <param name="state">A user-defined object that will be passed to the callback delegate.</param> /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns> public IAsyncResult BeginExecuteSegmented(ResultContinuation continuationToken, AsyncCallback callback, object state) { return(TaskImplHelper.BeginImplWithRetry <ResultSegment <TElement> >( (setResult) => this.ExecuteSegmentedImpl(continuationToken, setResult), this.RetryPolicy, callback, state)); }
/// <summary> /// Begins an asynchronous operation to delete the tables if it exists. /// </summary> /// <param name="tableName">The table name.</param> /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param> /// <param name="state">A user-defined object that will be passed to the callback delegate.</param> /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns> public IAsyncResult BeginDeleteTableIfExist(string tableName, AsyncCallback callback, object state) { CommonUtils.CheckStringParameter(tableName, false, "tableName", Protocol.Constants.TableServiceMaxStringPropertySizeInChars); TableServiceUtilities.CheckTableName(tableName, "tableName"); return(TaskImplHelper.BeginImpl <bool>((setResult) => this.DeleteTableIfExistImpl(tableName, setResult), callback, state)); }
/// <summary> /// Begins an asynchronous operation to upload a list of blocks to a new or existing blob. /// </summary> /// <param name="blockList">An enumerable collection of block IDs, as base64-encoded strings.</param> /// <param name="options">An object that specifies any additional options for the request.</param> /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param> /// <param name="state">A user-defined object that will be passed to the callback delegate.</param> /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns> public IAsyncResult BeginPutBlockList(IEnumerable <string> blockList, BlobRequestOptions options, AsyncCallback callback, object state) { var fullModifier = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options); List <PutBlockListItem> items = blockList.Select(i => { return(new PutBlockListItem(i, BlockSearchMode.Latest)); }).ToList(); return(TaskImplHelper.BeginImplWithRetry(() => { return this.UploadBlockList(items, fullModifier); }, fullModifier.RetryPolicy, callback, state)); }
/// <summary> /// Completes the asyncresult. /// </summary> /// <param name="asyncResults">The async results.</param> /// <param name="index">The index.</param> private static void CompleteAsyncresult(List <IAsyncResult> asyncResults, int index) { IAsyncResult signalledResult = asyncResults[index]; // NO locking necessary as they happen on the singleton producer thread asyncResults.RemoveAt(index); TaskImplHelper.EndImpl(signalledResult); }
/// <summary> /// Gets a collection of page ranges and their starting and ending bytes. /// </summary> /// <param name="options">An object that specifies any additional options for the request.</param> /// <returns>An enumerable collection of page ranges.</returns> public IEnumerable <PageRange> GetPageRanges(BlobRequestOptions options) { var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options); return(TaskImplHelper.ExecuteImplWithRetry <IEnumerable <PageRange> >( (setResult) => this.GetPageRangesImpl(fullModifiers, setResult), fullModifiers.RetryPolicy)); }
/// <summary> /// Uploads a list of blocks to a new or existing blob. /// </summary> /// <param name="blockList">An enumerable collection of block IDs, as base64-encoded strings.</param> /// <param name="options">An object that specifies any additional options for the request.</param> public void PutBlockList(IEnumerable <string> blockList, BlobRequestOptions options) { var fullModifier = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options); List <PutBlockListItem> items = blockList.Select(i => { return(new PutBlockListItem(i, BlockSearchMode.Latest)); }).ToList(); TaskImplHelper.ExecuteImplWithRetry(() => { return(this.UploadBlockList(items, fullModifier)); }, fullModifier.RetryPolicy); }
/// <summary> /// Begins an asynchronous operation to save changes, using the retry policy specified for the service context. /// </summary> /// <param name="options">Additional options for saving changes.</param> /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param> /// <param name="state">A user-defined object that will be passed to the callback delegate.</param> /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns> public IAsyncResult BeginSaveChangesWithRetries(SaveChangesOptions options, AsyncCallback callback, object state) { return(TaskImplHelper.BeginImplWithRetry <DataServiceResponse>( (setResult) => this.SaveChangesWithRetriesImpl(options, setResult), RetryPolicy, callback, state)); }
/// <summary> /// Begins an asynchronous operation to return a collection of page ranges and their starting and ending bytes. /// </summary> /// <param name="options">An object that specifies any additional options for the request.</param> /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param> /// <param name="state">A user-defined object that will be passed to the callback delegate.</param> /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns> public IAsyncResult BeginGetPageRanges(BlobRequestOptions options, AsyncCallback callback, object state) { var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options); return(TaskImplHelper.BeginImplWithRetry <IEnumerable <PageRange> >( (setResult) => this.GetPageRangesImpl(fullModifiers, setResult), fullModifiers.RetryPolicy, callback, state)); }
/// <summary> /// Begins an asynchronous operation to clear pages from a page blob. /// </summary> /// <param name="startOffset">The offset at which to begin clearing pages, in bytes. The offset must be a multiple of 512.</param> /// <param name="length">The length of the data range to be cleared, in bytes. The length must be a multiple of 512.</param> /// <param name="options">An object that specifies any additional options for the request.</param> /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param> /// <param name="state">A user-defined object that will be passed to the callback delegate.</param> /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns> public IAsyncResult BeginClearPages(long startOffset, long length, BlobRequestOptions options, AsyncCallback callback, object state) { var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options); return(TaskImplHelper.BeginImplWithRetry( () => this.ClearPageImpl(startOffset, length, fullModifiers), fullModifiers.RetryPolicy, callback, state)); }
/// <summary> /// Returns an enumerable collection of the blob's blocks, using the specified block list filter. /// </summary> /// <param name="blockListingFilter">One of the enumeration values that indicates whether to return /// committed blocks, uncommitted blocks, or both.</param> /// <param name="options">An object that specifies any additional options for the request.</param> /// <returns>An enumerable collection of objects implementing <see cref="ListBlockItem"/>.</returns> public IEnumerable <ListBlockItem> DownloadBlockList(BlockListingFilter blockListingFilter, BlobRequestOptions options) { var fullModifier = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options); return(TaskImplHelper.ExecuteImplWithRetry <IEnumerable <ListBlockItem> >( (result) => { return this.GetDownloadBlockList(blockListingFilter, fullModifier, result); }, fullModifier.RetryPolicy)); }
/// <summary> /// Begins an asynchronous operation to return a result segment containing a collection /// of table names beginning with the specified prefix. /// </summary> /// <param name="prefix">The table name prefix.</param> /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the /// per-operation limit of 5000. If this value is zero, the maximum possible number of results will be returned, up to 5000.</param> /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param> /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param> /// <param name="state">A user-defined object that will be passed to the callback delegate.</param> /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns> public IAsyncResult BeginListTablesSegmented(string prefix, int maxResults, ResultContinuation continuationToken, AsyncCallback callback, object state) { return(TaskImplHelper.BeginImplWithRetry <ResultSegment <string> >( (setResult) => this.ListTablesSegmentedImpl( prefix, maxResults, continuationToken, setResult), this.RetryPolicy, callback, state)); }
/// <summary> /// Verifies whether the table exist implementation. /// </summary> /// <param name="tableName">The table name.</param> /// <param name="setResult">The set result.</param> /// <returns>A sequence of tasks to do the operation.</returns> private TaskSequence DoesTableExistImpl(string tableName, Action <bool> setResult) { CommonUtils.CheckStringParameter(tableName, false, "tableName", Protocol.Constants.TableServiceMaxStringPropertySizeInChars); TableServiceUtilities.CheckTableName(tableName, "tableName"); var svc = this.GetDataServiceContext(); var tableExistsQuery = (from table in svc.CreateQuery <TableServiceTable>(Protocol.Constants.TableServiceTablesName) where table.TableName == tableName select table).AsTableServiceQuery(); ResultSegment <TableServiceTable> segment = null; while (true) { Task <ResultSegment <TableServiceTable> > tableExistsSegmentTask; if (segment == null) { tableExistsSegmentTask = TaskImplHelper.GetRetryableAsyncTask <ResultSegment <TableServiceTable> >( (setResultInner) => tableExistsQuery.ExecuteSegmentedImpl(null, setResultInner), RetryPolicy); } else { tableExistsSegmentTask = TaskImplHelper.GetRetryableAsyncTask <ResultSegment <TableServiceTable> >(segment.GetNextImpl, RetryPolicy); } yield return(tableExistsSegmentTask); if (GetResultOrDefault(tableExistsSegmentTask, out segment)) { if (segment.Results.Any()) { setResult(true); break; } else { setResult(false); break; } } else { setResult(false); break; } } }
/// <summary> /// Begins an asynchronous operation to return an enumerable collection of the blob's blocks, /// using the specified block list filter. /// </summary> /// <param name="blockListingFilter">One of the enumeration values that indicates whether to return /// committed blocks, uncommitted blocks, or both.</param> /// <param name="options">An object that specifies any additional options for the request.</param> /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param> /// <param name="state">A user-defined object that will be passed to the callback delegate.</param> /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns> public IAsyncResult BeginDownloadBlockList(BlockListingFilter blockListingFilter, BlobRequestOptions options, AsyncCallback callback, object state) { var fullModifier = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options); return(TaskImplHelper.BeginImplWithRetry <IEnumerable <ListBlockItem> >( (result) => { return this.GetDownloadBlockList(blockListingFilter, fullModifier, result); }, fullModifier.RetryPolicy, callback, state)); }
/// <summary> /// Creates the table if not exist implementation. /// </summary> /// <param name="tableName">The table name.</param> /// <param name="setResult">The set result.</param> /// <returns>A sequence of tasks to do the operation.</returns> private TaskSequence CreateTableIfNotExistImpl(string tableName, Action <bool> setResult) { CommonUtils.CheckStringParameter(tableName, false, "tableName", Protocol.Constants.TableServiceMaxStringPropertySizeInChars); TableServiceUtilities.CheckTableName(tableName, "tableName"); var doesTableExistTask = new InvokeTaskSequenceTask <bool>((set) => this.DoesTableExistImpl(tableName, set)); yield return(doesTableExistTask); if (doesTableExistTask.Result) { setResult(false); } else { var createTableTask = TaskImplHelper.GetRetryableAsyncTask <InvalidOperationException>((resultSetter) => this.CreateTableImpl(tableName, resultSetter), RetryPolicy); yield return(createTableTask); // wrap any exceptions try { if (createTableTask.Result == null) { setResult(true); } else { StorageClientException exception = Utilities.TranslateDataServiceClientException(createTableTask.Result) as StorageClientException; if (exception != null && exception.ErrorCode == StorageErrorCode.ResourceAlreadyExists && exception.ExtendedErrorInformation != null && exception.ExtendedErrorInformation.ErrorCode == TableErrorCodeStrings.TableAlreadyExists) { setResult(false); } else { throw createTableTask.Result; } } } catch (InvalidOperationException ex) { throw Utilities.TranslateDataServiceClientException(ex); } } }
/// <summary> /// Writes pages to a page blob. /// </summary> /// <param name="pageData">A stream providing the page data.</param> /// <param name="startOffset">The offset at which to begin writing, in bytes. The offset must be a multiple of 512.</param> /// <param name="options">An object that specifies any additional options for the request.</param> public void WritePages(Stream pageData, long startOffset, BlobRequestOptions options) { var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options); long sourcePosition = pageData.CanSeek ? pageData.Position : 0; TaskImplHelper.ExecuteImplWithRetry( () => { if (pageData.CanSeek == false) { sourcePosition--; } return(this.WritePageImpl(pageData, startOffset, sourcePosition, fullModifiers)); }, fullModifiers.RetryPolicy); }
/// <summary> /// Uploads a single block. /// </summary> /// <param name="blockId">A base64-encoded block ID that identifies the block.</param> /// <param name="blockData">A stream that provides the data for the block.</param> /// <param name="contentMD5">An optional hash value that will be used to set the <see cref="BlobProperties.ContentMD5"/> property /// on the blob. May be <c>null</c> or an empty string.</param> /// <param name="options">An object that specifies any additional options for the request.</param> public void PutBlock(string blockId, Stream blockData, string contentMD5, BlobRequestOptions options) { var fullModifier = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options); var position = blockData.Position; var retryPolicy = blockData.CanSeek ? fullModifier.RetryPolicy : RetryPolicies.NoRetry(); TaskImplHelper.ExecuteImplWithRetry( () => { if (blockData.CanSeek) { blockData.Position = position; } return(this.UploadBlock(blockData, blockId, contentMD5, fullModifier)); }, retryPolicy); }
/// <summary> /// Commits the blob by uploading any remaining data and the blocklist asynchronously. /// </summary> /// <returns>A sequence of events required for commit.</returns> private TaskSequence CommitImpl() { this.CheckWriteState(); if (this.blockBuffer != null && this.blockBuffer.Length != 0) { var task = new InvokeTaskSequenceTask(this.FlushInternal); yield return(task); var result = task.Result; // Materialize the errors Console.WriteLine(result); } // If all blocks are uploaded, commit if (this.UseBlocks) { this.SetBlobMD5(); var task = TaskImplHelper.GetRetryableAsyncTask( () => { // At the convenience layer we always upload uncommitted blocks List <PutBlockListItem> putBlockList = new List <PutBlockListItem>(); foreach (var id in this.blockList) { putBlockList.Add(new PutBlockListItem(id, BlockSearchMode.Uncommitted)); } return(this.Blob.ToBlockBlob.UploadBlockList(putBlockList, this.currentModifier)); }, this.currentModifier.RetryPolicy); yield return(task); var result = task.Result; Console.WriteLine(result); } // Now we can set the full size. this.Blob.Properties.Length = this.Length; // Clear the internal state this.Abort(); }
/// <summary> /// Begins an asynchronous operation to upload a single block. /// </summary> /// <param name="blockId">A base64-encoded block ID that identifies the block.</param> /// <param name="blockData">A stream that provides the data for the block.</param> /// <param name="contentMD5">An optional hash value that will be used to set the <see cref="BlobProperties.ContentMD5"/> property /// on the blob. May be <c>null</c> or an empty string.</param> /// <param name="options">An object that specifies any additional options for the request.</param> /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param> /// <param name="state">A user-defined object that will be passed to the callback delegate.</param> /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns> public IAsyncResult BeginPutBlock(string blockId, Stream blockData, string contentMD5, BlobRequestOptions options, AsyncCallback callback, object state) { var fullModifier = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options); var position = blockData.Position; var retryPolicy = blockData.CanSeek ? fullModifier.RetryPolicy : RetryPolicies.NoRetry(); return(TaskImplHelper.BeginImplWithRetry( () => { if (blockData.CanSeek) { blockData.Position = position; } return this.UploadBlock(blockData, blockId, contentMD5, fullModifier); }, retryPolicy, callback, state)); }
/// <summary> /// Begins an asynchronous operation to write pages to a page blob. /// </summary> /// <param name="pageData">A stream providing the page data.</param> /// <param name="startOffset">The offset at which to begin writing, in bytes. The offset must be a multiple of 512.</param> /// <param name="options">An object that specifies any additional options for the request.</param> /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param> /// <param name="state">A user-defined object that will be passed to the callback delegate.</param> /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns> public IAsyncResult BeginWritePages(Stream pageData, long startOffset, BlobRequestOptions options, AsyncCallback callback, object state) { var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options); long sourcePosition = pageData.CanSeek ? pageData.Position : 0; return(TaskImplHelper.BeginImplWithRetry( () => { if (pageData.CanSeek == false) { sourcePosition--; } return this.WritePageImpl(pageData, startOffset, sourcePosition, fullModifiers); }, fullModifiers.RetryPolicy, callback, state)); }
/// <summary> /// Deletes table if exists implementation. /// </summary> /// <param name="tableName">The table name.</param> /// <param name="setResult">The set result.</param> /// <returns>A sequence of tasks to do the operation.</returns> private TaskSequence DeleteTableIfExistImpl(string tableName, Action <bool> setResult) { var doesTableExistTask = TaskImplHelper.GetRetryableAsyncTask <bool>( (set) => this.DoesTableExistImpl(tableName, set), RetryPolicy); yield return(doesTableExistTask); if (!doesTableExistTask.Result) { setResult(false); } else { var deleteTableTask = TaskImplHelper.GetRetryableAsyncTask(() => this.DeleteTableImpl(tableName), RetryPolicy); yield return(deleteTableTask); var result = deleteTableTask.Result; setResult(true); } }
internal static IEnumerable <T> LazyEnumerateSegmented <T>(Func <Action <ResultSegment <T> >, TaskSequence> impl, RetryPolicy retryPolicy) { var segment = TaskImplHelper.ExecuteImplWithRetry <ResultSegment <T> >(impl, retryPolicy); CloudBlobDirectory cloudDirectoryInLastPartition = null; T lastElement = default(T); while (true) { foreach (var result in segment.Results) { if (cloudDirectoryInLastPartition != null && result is CloudBlobDirectory) { var cloudBlobDirectory = result as CloudBlobDirectory; if (cloudDirectoryInLastPartition.Uri == cloudBlobDirectory.Uri) { continue; } } lastElement = result; yield return(result); } if (!segment.HasMoreResults) { break; } if (lastElement is CloudBlobDirectory) { cloudDirectoryInLastPartition = lastElement as CloudBlobDirectory; } segment = segment.GetNext(); } }
/// <summary> /// Ends an asynchronous operation to set the properties of the queue service. /// </summary> /// <param name="asyncResult">The result returned from a prior call to <see cref="BeginSetServiceProperties"/>.</param> public void EndSetServiceProperties(IAsyncResult asyncResult) { TaskImplHelper.EndImplWithRetry(asyncResult); }
/// <summary> /// Begins an asynchronous operation to set the properties of the queue service. /// </summary> /// <param name="properties">The queue service properties.</param> /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param> /// <param name="state">A user defined object to be passed to the callback delegate.</param> /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns> public IAsyncResult BeginSetServiceProperties(ServiceProperties properties, AsyncCallback callback, object state) { return(TaskImplHelper.BeginImplWithRetry(() => this.SetServicePropertiesImpl(properties), this.RetryPolicy, callback, state)); }
/// <summary> /// Sets the properties of the queue service. /// </summary> /// <param name="properties">The queue service properties.</param> public void SetServiceProperties(ServiceProperties properties) { TaskImplHelper.ExecuteImplWithRetry(() => this.SetServicePropertiesImpl(properties), this.RetryPolicy); }
/// <summary> /// Ends an asynchronous operation to get the properties of the queue service. /// </summary> /// <param name="asyncResult">The result returned from a prior call to <see cref="BeginGetServiceProperties"/>.</param> /// <returns>The queue service properties.</returns> public ServiceProperties EndGetServiceProperties(IAsyncResult asyncResult) { return(TaskImplHelper.EndImplWithRetry <ServiceProperties>(asyncResult)); }
/// <summary> /// Begins an asynchronous operation to get the properties of the queue service. /// </summary> /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param> /// <param name="state">A user defined object to be passed to the callback delegate.</param> /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns> public IAsyncResult BeginGetServiceProperties(AsyncCallback callback, object state) { return(TaskImplHelper.BeginImplWithRetry <ServiceProperties>((setResult) => this.GetServicePropertiesImpl(setResult), this.RetryPolicy, callback, state)); }