/// <summary>
/// Returns an enumerable collection of tables segmented implementation.
/// </summary>
/// <param name="prefix">The prefix.</param>
/// <param name="continuationToken">The continuation token.</param>
/// <param name="pagination">The pagination.</param>
/// <param name="lastResult">The last result.</param>
/// <param name="setResult">The set result.</param>
/// <returns>A sequence of tasks to do the operation.</returns>
private TaskSequence ListTablesSegmentedImplCore(
string prefix,
ResultContinuation continuationToken,
ResultPagination pagination,
ResultSegment <TableServiceTable> lastResult,
Action <ResultSegment <string> > setResult)
{
CommonUtils.AssertContinuationType(continuationToken, ResultContinuation.ContinuationType.Table);
InvokeTaskSequenceTask <ResultSegment <TableServiceTable> > listTablesSegmentedTask;
if (lastResult == null)
{
var svc = this.GetDataServiceContext();
var query = from table in svc.CreateQuery <TableServiceTable>(Protocol.Constants.TableServiceTablesName)
select table;
if (prefix != string.Empty)
{
// Append Max char to end '{' is 1 + 'z' in AsciiTable
string uppperBound = prefix + '{';
query = query.Where((table) => table.TableName.CompareTo(prefix) >= 0 && table.TableName.CompareTo(uppperBound) < 0);
}
if (pagination.IsPagingEnabled)
{
query = query.Take(pagination.GetNextRequestPageSize().Value);
}
var listTablesQuery = query.AsTableServiceQuery();
listTablesSegmentedTask = new InvokeTaskSequenceTask <ResultSegment <TableServiceTable> >(
(setResultInner) =>
listTablesQuery.ExecuteSegmentedImpl(continuationToken, setResultInner));
}
else
{
listTablesSegmentedTask = new InvokeTaskSequenceTask <ResultSegment <TableServiceTable> >(lastResult.GetNextImpl);
}
yield return(listTablesSegmentedTask);
if (GetResultOrDefault <ResultSegment <TableServiceTable> >(listTablesSegmentedTask, out lastResult))
{
setResult(new ResultSegment <string>(
lastResult.Results.Select((table) => table.TableName),
lastResult.HasMoreResults,
(setResultInner) =>
this.ListTablesSegmentedImplCore(prefix, lastResult.ContinuationToken, pagination, lastResult, setResultInner),
RetryPolicy)
{
ContinuationToken = lastResult.ContinuationToken
});
}
else
{
setResult(new ResultSegment <string>(new List <string>(), false, null, RetryPolicy));
}
}
/// <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>
/// Returns an enumerable collection of tables segmented impl.
/// </summary>
/// <param name="prefix">The prefix.</param>
/// <param name="maxResults">The max results.</param>
/// <param name="continuationToken">The continuation token.</param>
/// <param name="setResult">The set result.</param>
/// <returns>A <see cref="TaskSequence"/> that lists the tables.</returns>
private TaskSequence ListTablesSegmentedImpl(
string prefix,
int?maxResults,
ResultContinuation continuationToken,
Action <ResultSegment <string> > setResult)
{
ResultPagination pagination = new ResultPagination(maxResults.GetValueOrDefault());
return(this.ListTablesSegmentedImplCore(prefix, continuationToken, pagination, null, setResult));
}
/// <summary>
/// Asserts the type of the continuation.
/// </summary>
/// <param name="continuationToken">The continuation token.</param>
/// <param name="continuationType">Type of the continuation.</param>
internal static void AssertContinuationType(ResultContinuation continuationToken, ResultContinuation.ContinuationType continuationType)
{
if (continuationToken != null)
{
if (!(continuationToken.Type == ResultContinuation.ContinuationType.None || continuationToken.Type == continuationType))
{
string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.InvalidContinuationType, continuationToken.Type, continuationType);
throw new InvalidOperationException(errorMessage);
}
}
}
/// <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>
/// Lists the queues impl core.
/// </summary>
/// <param name="prefix">The prefix.</param>
/// <param name="detailsIncluded">The details included.</param>
/// <param name="continuationToken">The continuation token.</param>
/// <param name="pagination">The pagination.</param>
/// <param name="setResult">The set result.</param>
/// <returns>A <see cref="TaskSequence"/> for listing the queues.</returns>
private TaskSequence ListQueuesImplCore(
string prefix,
QueueListingDetails detailsIncluded,
ResultContinuation continuationToken,
ResultPagination pagination,
Action <ResultSegment <CloudQueue> > setResult)
{
CommonUtils.AssertContinuationType(continuationToken, ResultContinuation.ContinuationType.Queue);
ListingContext listingContext = new ListingContext(prefix, pagination.GetNextRequestPageSize())
{
Marker = continuationToken != null ? continuationToken.NextMarker : null
};
var queueList = new List <CloudQueue>();
var webRequest = QueueRequest.List(this.BaseUri, this.Timeout.RoundUpToSeconds(), listingContext, detailsIncluded);
this.Credentials.SignRequest(webRequest);
var listTask = webRequest.GetResponseAsyncWithTimeout(this, this.Timeout);
yield return(listTask);
string nextMarker;
using (var response = listTask.Result as HttpWebResponse)
{
var parsedResponse = QueueResponse.List(response);
// Materialize the results so that we can close the response
queueList.AddRange(parsedResponse.Queues.Select((Func <QueueEntry, CloudQueue>) this.SelectResponse));
nextMarker = parsedResponse.NextMarker;
}
ResultContinuation newContinuationToken = new ResultContinuation()
{
NextMarker = nextMarker, Type = ResultContinuation.ContinuationType.Queue
};
ResultSegment.CreateResultSegment(
setResult,
queueList,
newContinuationToken,
pagination,
this.RetryPolicy,
(paginationArg, continuationArg, resultSegment) =>
this.ListQueuesImplCore(prefix, detailsIncluded, continuationArg, paginationArg, resultSegment));
}
/// <summary>
/// Lists the queues impl.
/// </summary>
/// <param name="prefix">The prefix.</param>
/// <param name="detailsIncluded">The details included.</param>
/// <param name="continuationToken">The continuation token.</param>
/// <param name="maxResults">The max results.</param>
/// <param name="setResult">The set result.</param>
/// <returns>A <see cref="TaskSequence"/> for listing the queues.</returns>
private TaskSequence ListQueuesImpl(
string prefix,
QueueListingDetails detailsIncluded,
ResultContinuation continuationToken,
int?maxResults,
Action <ResultSegment <CloudQueue> > setResult)
{
ResultPagination pagination = new ResultPagination(maxResults.GetValueOrDefault());
return(this.ListQueuesImplCore(
prefix,
detailsIncluded,
continuationToken,
pagination,
setResult));
}
/// <summary>
/// Executes the segmented impl.
/// </summary>
/// <param name="continuationToken">The continuation token.</param>
/// <param name="setResult">The set result.</param>
/// <returns>A <see cref="TaskSequence"/> that executes the query and returns the first segment of results.</returns>
internal TaskSequence ExecuteSegmentedImpl(ResultContinuation continuationToken, Action <ResultSegment <TElement> > setResult)
{
var localQuery = this.query;
localQuery = RewriteQueryForTakeCount(localQuery, this.pagination);
localQuery = ApplyContinuationToQuery(continuationToken, localQuery);
var requestTask = localQuery.ExecuteAsync();
yield return(requestTask);
try
{
var responseResult = requestTask.Result;
var response = responseResult as QueryOperationResponse;
ResultContinuation newContinuationToken = this.GetTableContinuationFromResponse(response);
List <TElement> listResult = new List <TElement>(responseResult.ToList());
ResultSegment.CreateResultSegment <TElement>(
setResult,
listResult,
newContinuationToken,
this.pagination,
this.RetryPolicy,
(scratch, continuationArg, setResultInnerArg) => this.ExecuteSegmentedImpl(continuationArg, setResultInnerArg));
}
catch (InvalidOperationException ex)
{
var dsce = CommonUtils.FindInnerDataServiceClientException(ex);
if (dsce == null)
{
throw;
}
if ((HttpStatusCode)dsce.StatusCode == HttpStatusCode.NotFound)
{
setResult(new ResultSegment <TElement>(new List <TElement>(), false, null, null));
}
throw;
}
}
/// <summary>
/// Serializes the token.
/// </summary>
/// <param name="serializer">The serializer.</param>
/// <param name="token">The token.</param>
/// <returns>System.String.</returns>
public static string SerializeToken(XmlSerializer serializer, ResultContinuation token)
{
if (token == null)
{
return null;
}
using (var writer = new StringWriter())
{
var writerSettings = new XmlWriterSettings { OmitXmlDeclaration = true, NewLineChars = String.Empty };
using (var xmlWriter = XmlWriter.Create(writer, writerSettings))
{
serializer.Serialize(xmlWriter, token);
}
return writer.ToString();
}
}
/// <summary>
/// Gets the table continuation from response.
/// </summary>
/// <param name="response">The response.</param>
/// <returns>The continuation.</returns>
private ResultContinuation GetTableContinuationFromResponse(QueryOperationResponse response)
{
string nextPartitionKey;
string nextRowKey;
string nextTableName;
response.Headers.TryGetValue(TableServicePrefixForTableContinuation + TableServiceNextPartitionKey, out nextPartitionKey);
response.Headers.TryGetValue(TableServicePrefixForTableContinuation + TableServiceNextRowKey, out nextRowKey);
response.Headers.TryGetValue(TableServicePrefixForTableContinuation + TableServiceNextTableName, out nextTableName);
ResultContinuation newContinuationToken = new ResultContinuation()
{
NextPartitionKey = nextPartitionKey,
NextRowKey = nextRowKey,
NextTableName = nextTableName,
Type = ResultContinuation.ContinuationType.Table
};
return(newContinuationToken);
}
/// <summary>
/// Applies the continuation to query.
/// </summary>
/// <param name="continuationToken">The continuation token.</param>
/// <param name="localQuery">The local query.</param>
/// <returns>The modified query.</returns>
private static DataServiceQuery <TElement> ApplyContinuationToQuery(ResultContinuation continuationToken, DataServiceQuery <TElement> localQuery)
{
if (continuationToken != null)
{
if (continuationToken.NextPartitionKey != null)
{
localQuery = localQuery.AddQueryOption(TableServiceNextPartitionKey, continuationToken.NextPartitionKey);
}
if (continuationToken.NextRowKey != null)
{
localQuery = localQuery.AddQueryOption(TableServiceNextRowKey, continuationToken.NextRowKey);
}
if (continuationToken.NextTableName != null)
{
localQuery = localQuery.AddQueryOption(TableServiceNextTableName, continuationToken.NextTableName);
}
}
return(localQuery);
}
/// <summary>
/// Core implementation for the ListContainers method.
/// </summary>
/// <param name="prefix">The container prefix.</param>
/// <param name="detailsIncluded">The details included.</param>
/// <param name="continuationToken">The continuation token.</param>
/// <param name="pagination">The pagination.</param>
/// <param name="setResult">The result report delegate.</param>
/// <returns>A <see cref="TaskSequence"/> that lists the containers.</returns>
private TaskSequence ListContainersImplCore(
string prefix,
ContainerListingDetails detailsIncluded,
ResultContinuation continuationToken,
ResultPagination pagination,
Action<ResultSegment<CloudBlobContainer>> setResult)
{
CommonUtils.AssertContinuationType(continuationToken, ResultContinuation.ContinuationType.Container);
ListingContext listingContext = new ListingContext(prefix, pagination.GetNextRequestPageSize())
{
Marker = continuationToken != null ? continuationToken.NextMarker : null
};
var containersList = new List<CloudBlobContainer>();
var request = ContainerRequest.List(this.BaseUri, this.Timeout.RoundUpToSeconds(), listingContext, detailsIncluded);
this.Credentials.SignRequest(request);
var listTask = request.GetResponseAsyncWithTimeout(this, this.Timeout);
yield return listTask;
string nextMarker;
using (var response = listTask.Result as HttpWebResponse)
{
ListContainersResponse listContainersResponse = ContainerResponse.List(response);
containersList.AddRange(listContainersResponse.Containers.Select((item) => new CloudBlobContainer(item.Attributes, this)));
nextMarker = listContainersResponse.NextMarker;
}
ResultContinuation newContinuationToken = new ResultContinuation() { NextMarker = nextMarker, Type = ResultContinuation.ContinuationType.Container };
ResultSegment.CreateResultSegment(
setResult,
containersList,
newContinuationToken,
pagination,
this.RetryPolicy,
(paginationArg, continuationArg, resultSegmentArg) =>
this.ListContainersImplCore(
prefix,
detailsIncluded,
continuationArg,
paginationArg,
resultSegmentArg));
}
/// <summary>
/// Implementation for the ListContainers method.
/// </summary>
/// <param name="prefix">The container prefix.</param>
/// <param name="detailsIncluded">The details included.</param>
/// <param name="continuationToken">The continuation token.</param>
/// <param name="maxResults">The maximum results to return.</param>
/// <param name="setResult">The result report delegate.</param>
/// <returns>A <see cref="TaskSequence"/> that lists the containers.</returns>
private TaskSequence ListContainersImpl(
string prefix,
ContainerListingDetails detailsIncluded,
ResultContinuation continuationToken,
int? maxResults,
Action<ResultSegment<CloudBlobContainer>> setResult)
{
ResultPagination pagination = new ResultPagination(maxResults.GetValueOrDefault());
return this.ListContainersImplCore(prefix, detailsIncluded, continuationToken, pagination, setResult);
}
/// <summary>
/// Begins an asynchronous request to return a result segment containing a collection of blob items.
/// </summary>
/// <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="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 BeginListBlobsSegmented(int maxResults, ResultContinuation continuationToken, BlobRequestOptions options, AsyncCallback callback, object state)
{
var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
return(TaskImplHelper.BeginImplWithRetry <ResultSegment <IListBlobItem> >((setResult) => this.Container.ListBlobsImpl(this.Prefix, fullModifiers, continuationToken, maxResults, setResult), fullModifiers.RetryPolicy, callback, state));
}
/// <summary>
/// Returns 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>
/// <returns>A result segment containing table names.</returns>
public ResultSegment <string> ListTablesSegmented(string prefix, int maxResults, ResultContinuation continuationToken)
{
return(this.EndListTablesSegmented(
this.BeginListTablesSegmented(prefix, maxResults, continuationToken, null, null)));
}
/// <summary>
/// Implementation for the ListBlobs method.
/// </summary>
/// <param name="prefix">The blob prefix.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <param name="continuationToken">The continuation token.</param>
/// <param name="maxResults">The maximum result size.</param>
/// <param name="setResult">The result report delegate.</param>
/// <returns>A <see cref="TaskSequence"/> that lists the blobs.</returns>
internal TaskSequence ListBlobsImpl(
string prefix,
BlobRequestOptions options,
ResultContinuation continuationToken,
int? maxResults,
Action<ResultSegment<IListBlobItem>> setResult)
{
ResultPagination pagination = new ResultPagination(maxResults.GetValueOrDefault());
return this.ListBlobsImplCore(prefix, options, continuationToken, pagination, setResult);
}
/// <summary>
/// Begins an asynchronous operation to return a result segment containing a collection of blob items
/// in the container.
/// </summary>
/// <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="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 BeginListBlobsSegmented(
int maxResults,
ResultContinuation continuationToken,
BlobRequestOptions options,
AsyncCallback callback,
object state)
{
var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
return TaskImplHelper.BeginImplWithRetry<ResultSegment<IListBlobItem>>(
(setResult) => this.ListBlobsImpl(null, fullModifiers, continuationToken, maxResults, setResult),
fullModifiers.RetryPolicy,
callback,
state);
}
public IAsyncResult BeginListTablesSegmented(string prefix, int maxResults, ResultContinuation continuationToken, AsyncCallback callback, object state);
/// <summary>
/// Lists the queues impl core.
/// </summary>
/// <param name="prefix">The prefix.</param>
/// <param name="detailsIncluded">The details included.</param>
/// <param name="continuationToken">The continuation token.</param>
/// <param name="pagination">The pagination.</param>
/// <param name="setResult">The set result.</param>
/// <returns>A <see cref="TaskSequence"/> for listing the queues.</returns>
private TaskSequence ListQueuesImplCore(
string prefix,
QueueListingDetails detailsIncluded,
ResultContinuation continuationToken,
ResultPagination pagination,
Action<ResultSegment<CloudQueue>> setResult)
{
CommonUtils.AssertContinuationType(continuationToken, ResultContinuation.ContinuationType.Queue);
ListingContext listingContext = new ListingContext(prefix, pagination.GetNextRequestPageSize())
{
Marker = continuationToken != null ? continuationToken.NextMarker : null
};
var queueList = new List<CloudQueue>();
var webRequest = QueueRequest.List(this.BaseUri, this.Timeout.RoundUpToSeconds(), listingContext, detailsIncluded);
this.Credentials.SignRequest(webRequest);
var listTask = webRequest.GetResponseAsyncWithTimeout(this, this.Timeout);
yield return listTask;
string nextMarker;
using (var response = listTask.Result as HttpWebResponse)
{
var parsedResponse = QueueResponse.List(response);
// Materialize the results so that we can close the response
queueList.AddRange(parsedResponse.Queues.Select((Func<QueueEntry, CloudQueue>)this.SelectResponse));
nextMarker = parsedResponse.NextMarker;
}
ResultContinuation newContinuationToken = new ResultContinuation() { NextMarker = nextMarker, Type = ResultContinuation.ContinuationType.Queue };
ResultSegment.CreateResultSegment(
setResult,
queueList,
newContinuationToken,
pagination,
this.RetryPolicy,
(paginationArg, continuationArg, resultSegment) =>
this.ListQueuesImplCore(prefix, detailsIncluded, continuationArg, paginationArg, resultSegment));
}
public static ResultSegment<IListBlobItem> ListBlobxWithPrefixSegmented(this CloudBlobContainer container,
string prefix, int maxresults, ResultContinuation continuationToken, BlobRequestOptions options = null)
{
string searchRoot = container.Name + "/" + prefix;
if (options != null)
return CurrBlobClient.ListBlobsWithPrefixSegmented(searchRoot, maxresults, continuationToken, options);
return CurrBlobClient.ListBlobsWithPrefixSegmented(searchRoot, maxresults, continuationToken);
}
/// <summary>
/// Implementation for the ListBlobs method.
/// </summary>
/// <param name="prefix">The blob prefix.</param>
/// <param name="continuationToken">The continuation token.</param>
/// <param name="maxResults">The max results.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <param name="setResult">The result report delegate.</param>
/// <returns>
/// A <see cref="TaskSequence"/> that lists the blobs.
/// </returns>
private TaskSequence ListBlobImpl(
string prefix,
ResultContinuation continuationToken,
int? maxResults,
BlobRequestOptions options,
Action<ResultSegment<IListBlobItem>> setResult)
{
CommonUtils.AssertContinuationType(continuationToken, ResultContinuation.ContinuationType.Blob);
string containerName = null;
string listingPrefix = null;
ParseUserPrefix(prefix, out containerName, out listingPrefix);
var containerInfo = new CloudBlobContainer(containerName, this);
var fullModifier = BlobRequestOptions.CreateFullModifier(this, options);
return containerInfo.ListBlobsImpl(listingPrefix, fullModifier, continuationToken, maxResults, setResult);
}
/// <summary>
/// Core implementation of the ListBlobs method.
/// </summary>
/// <param name="prefix">The blob prefix.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <param name="continuationToken">The continuation token.</param>
/// <param name="pagination">The pagination.</param>
/// <param name="setResult">The result report delegate.</param>
/// <returns>A <see cref="TaskSequence"/> that lists the blobs.</returns>
private TaskSequence ListBlobsImplCore(
string prefix,
BlobRequestOptions options,
ResultContinuation continuationToken,
ResultPagination pagination,
Action<ResultSegment<IListBlobItem>> setResult)
{
CommonUtils.AssertContinuationType(continuationToken, ResultContinuation.ContinuationType.Blob);
CommonUtils.AssertNotNull("options", options);
if (!options.UseFlatBlobListing
&& (options.BlobListingDetails & BlobListingDetails.Snapshots) == BlobListingDetails.Snapshots)
{
throw new ArgumentException(SR.ListSnapshotsWithDelimiterError, "options");
}
var delimiter = options.UseFlatBlobListing ? null : this.ServiceClient.DefaultDelimiter;
BlobListingContext listingContext = new BlobListingContext(prefix, pagination.GetNextRequestPageSize(), delimiter, options.BlobListingDetails)
{
Marker = continuationToken != null ? continuationToken.NextMarker : null
};
var blobList = new List<IListBlobItem>();
var request = ProtocolHelper.GetWebRequest(this.ServiceClient, options, (timeout) => BlobRequest.List(this.TransformedAddress, timeout, listingContext));
this.ServiceClient.Credentials.SignRequest(request);
var listTask = request.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
yield return listTask;
string nextMarker;
using (var response = listTask.Result as HttpWebResponse)
{
ListBlobsResponse listBlobResponse = BlobResponse.List(response);
blobList.AddRange(listBlobResponse.Blobs.Select(
(item) => CloudBlobClient.SelectProtocolResponse(item, this.ServiceClient, this)));
nextMarker = listBlobResponse.NextMarker;
}
ResultContinuation newContinuationToken = new ResultContinuation() { NextMarker = nextMarker, Type = ResultContinuation.ContinuationType.Blob };
ResultSegment.CreateResultSegment(
setResult,
blobList,
newContinuationToken,
pagination,
options.RetryPolicy,
(paginationArg, continuationArg, resultSegmentArg) =>
this.ListBlobsImplCore(prefix, options, continuationArg, paginationArg, resultSegmentArg));
}
/// <summary>
/// Returns a result segment containing a collection of containers
/// whose names begin with the specified prefix.
/// </summary>
/// <param name="prefix">The container name prefix.</param>
/// <param name="detailsIncluded">A value that indicates whether to return container metadata with the listing.</param>
/// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned
/// in the result segment, 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>
/// <returns>A result segment of containers.</returns>
public ResultSegment<CloudBlobContainer> ListContainersSegmented(
string prefix,
ContainerListingDetails detailsIncluded,
int maxResults,
ResultContinuation continuationToken)
{
return TaskImplHelper.ExecuteImplWithRetry<ResultSegment<CloudBlobContainer>>(
(setResult) => this.ListContainersImpl(prefix, detailsIncluded, continuationToken, maxResults, setResult),
this.RetryPolicy);
}
/// <summary>
/// Returns a result segment containing a collection of blob items
/// in the container.
/// </summary>
/// <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="options">An object that specifies any additional options for the request.</param>
/// <returns>A result segment containing objects that implement <see cref="IListBlobItem"/>.</returns>
public ResultSegment<IListBlobItem> ListBlobsSegmented(int maxResults, ResultContinuation continuationToken, BlobRequestOptions options)
{
var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
return TaskImplHelper.ExecuteImplWithRetry<ResultSegment<IListBlobItem>>(
(setResult) => this.ListBlobsImpl(null, fullModifiers, continuationToken, maxResults, setResult),
fullModifiers.RetryPolicy);
}
/// <summary>
/// Returns 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>
/// <returns>A result segment containing a collection of queues.</returns>
public ResultSegment <CloudQueue> ListQueuesSegmented(string prefix, QueueListingDetails detailsIncluded, int maxResults, ResultContinuation continuationToken)
{
return(TaskImplHelper.ExecuteImplWithRetry <ResultSegment <CloudQueue> >(
(setResult) => this.ListQueuesImpl(prefix, detailsIncluded, continuationToken, maxResults, setResult),
this.RetryPolicy));
}
/// <summary>
/// Returns a result segment containing a collection of table names in the storage account.
/// </summary>
/// <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>
/// <returns>A result segment containing table names.</returns>
public ResultSegment <string> ListTablesSegmented(int maxResults, ResultContinuation continuationToken)
{
return(this.ListTablesSegmented(String.Empty, maxResults, continuationToken));
}
/// <summary>
/// Returns a result segment containing a collection of blob items.
/// </summary>
/// <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="options">An object that specifies any additional options for the request.</param>
/// <returns>A result segment containing objects that implement <see cref="IListBlobItem"/>.</returns>
public ResultSegment <IListBlobItem> ListBlobsSegmented(int maxResults, ResultContinuation continuationToken, BlobRequestOptions options)
{
var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
return(TaskImplHelper.ExecuteImplWithRetry <ResultSegment <IListBlobItem> >((setResult) => this.Container.ListBlobsImpl(this.Prefix, fullModifiers, continuationToken, maxResults, setResult), fullModifiers.RetryPolicy));
}
public ResultSegment<string> ListTablesSegmented(string prefix, int maxResults, ResultContinuation continuationToken);
/// <summary>
/// Begins an asynchronous operation to return a result segment containing a collection
/// of blob items whose names begin with the specified prefix.
/// </summary>
/// <param name="prefix">The blob name prefix. This value must be preceded either by the name of the container or by the absolute path to the container.</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 BeginListBlobsWithPrefixSegmented(
string prefix,
int maxResults,
ResultContinuation continuationToken,
AsyncCallback callback,
object state)
{
return TaskImplHelper.BeginImplWithRetry<ResultSegment<IListBlobItem>>(
(setResult) => this.ListBlobImpl(prefix, continuationToken, maxResults, null, setResult),
this.RetryPolicy,
callback,
state);
}
/// <summary>
/// Begins an asynchronous request to return a result segment containing a collection of containers
/// whose names begin with the specified prefix.
/// </summary>
/// <param name="prefix">The container name prefix.</param>
/// <param name="detailsIncluded">A value that indicates whether to return container metadata with the listing.</param>
/// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned
/// in the result segment, 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 BeginListContainersSegmented(
string prefix,
ContainerListingDetails detailsIncluded,
int maxResults,
ResultContinuation continuationToken,
AsyncCallback callback,
object state)
{
return TaskImplHelper.BeginImplWithRetry<ResultSegment<CloudBlobContainer>>(
(setResult) => this.ListContainersImpl(prefix, detailsIncluded, continuationToken, maxResults, setResult),
this.RetryPolicy,
callback,
state);
}
/// <summary>
/// Executes the query with the retry policy specified on the <see cref="CloudTableQuery<TElement>"/> object.
/// </summary>
/// <param name="continuationToken">A continuation token returned by a previous listing operation.</param>
/// <returns>The results of the query, retrieved lazily.</returns>
public IEnumerable <TElement> Execute(ResultContinuation continuationToken)
{
return(CommonUtils.LazyEnumerateSegmented <TElement>(
(setResult) => this.ExecuteSegmentedImpl(continuationToken, setResult),
this.RetryPolicy));
}
/// <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>
/// Returns a result segment containing a collection of blob items whose names
/// begin with the specified prefix.
/// </summary>
/// <param name="prefix">The blob name prefix. This value must be preceded either by the name of the container or by the absolute path to the container.</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>
/// <returns>A result segment containing objects that implement <see cref="IListBlobItem"/>.</returns>
public ResultSegment<IListBlobItem> ListBlobsWithPrefixSegmented(
string prefix,
int maxResults,
ResultContinuation continuationToken)
{
return this.ListBlobsWithPrefixSegmented(prefix, maxResults, continuationToken, null);
}
/// <summary>
/// Returns a result segment containing a collection of blob items whose names
/// begin with the specified prefix.
/// </summary>
/// <param name="prefix">The blob name prefix. This value must be preceded either by the name of the container or by the absolute path to the container.</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="options">An object that specifies any additional options for the request.</param>
/// <returns>A result segment containing objects that implement <see cref="IListBlobItem"/>.</returns>
public ResultSegment<IListBlobItem> ListBlobsWithPrefixSegmented(
string prefix,
int maxResults,
ResultContinuation continuationToken,
BlobRequestOptions options)
{
var fullModifier = BlobRequestOptions.CreateFullModifier(this, options);
return TaskImplHelper.ExecuteImplWithRetry<ResultSegment<IListBlobItem>>(
(setResult) => this.ListBlobImpl(prefix, continuationToken, maxResults, fullModifier, setResult),
this.RetryPolicy);
}
/// <summary>Returns 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>
/// <returns>A result segment containing a collection of queues. </returns>
public ResultSegment<CloudQueue> ListQueuesSegmented(
string prefix, QueueListingDetails detailsIncluded, int maxResults, ResultContinuation continuationToken)
{
return
TaskImplHelper.ExecuteImplWithRetry<ResultSegment<CloudQueue>>(
setResult =>
this.ListQueuesImpl(prefix, detailsIncluded, continuationToken, maxResults, setResult),
this.RetryPolicy);
}
