public async Task <Tuple <bool, CMPStorageError> > DeleteQueueAsync(CMPQueueStorageOptions queueStorageOptions =
null)
{
try
{
if (_queueReference == null)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
var couldDelete = false;
if (queueStorageOptions == null)
{
couldDelete = await _queueReference.DeleteIfExistsAsync();
}
else
{
couldDelete = await _queueReference.DeleteIfExistsAsync(queueStorageOptions.QueueRequestOptions,
queueStorageOptions.OperationContext,
_tokenSource.Token);
}
return(new Tuple <bool, CMPStorageError>(couldDelete, null));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
catch (ArgumentException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
}
public async Task <int> GetMessagesCountAsync(CMPQueueStorageOptions queueStorageOptions)
{
try
{
if (_queueReference == null)
{
return(-1);
}
if (queueStorageOptions == null)
{
await _queueReference.FetchAttributesAsync();
}
else
{
await _queueReference.FetchAttributesAsync(queueStorageOptions.QueueRequestOptions,
queueStorageOptions.OperationContext,
_tokenSource.Token);
}
return((int)(_queueReference.ApproximateMessageCount));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(-1);
}
}
public async Task <Tuple <bool, CMPStorageError> > AddMessageAsync(string messageString,
string popupTokenString,
CMPQueueStorageOptions queueStorageOptions =
null)
{
if (string.IsNullOrEmpty(messageString) == true)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
try
{
if (_queueReference == null)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
CloudQueueMessage queueMessage = null;
if (string.IsNullOrEmpty(popupTokenString) == true)
{
queueMessage = new CloudQueueMessage(messageString);
}
else
{
queueMessage = new CloudQueueMessage(messageString, popupTokenString);
}
if (queueStorageOptions == null)
{
await _queueReference.AddMessageAsync(queueMessage);
}
else
{
await _queueReference.AddMessageAsync(queueMessage, queueStorageOptions.TimeToLive,
queueStorageOptions.VisibilityTimeoutOrDelay,
queueStorageOptions.QueueRequestOptions,
queueStorageOptions.OperationContext, _tokenSource.Token);
}
return(new Tuple <bool, CMPStorageError>(true, null));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
catch (ArgumentException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
catch (OperationCanceledException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
}
public async Task <Tuple <bool, CMPStorageError> > UpdateMessageAsync(string updateMessageString,
TimeSpan visibilityTimeOut,
CMPQueueStorageOptions
queueStorageOptions = null)
{
try
{
if (_queueReference == null)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
var cloudMessage = await _queueReference.GetMessageAsync();
cloudMessage?.SetMessageContent(updateMessageString);
if (queueStorageOptions == null)
{
await _queueReference.UpdateMessageAsync(cloudMessage, visibilityTimeOut,
MessageUpdateFields.Content | MessageUpdateFields.Visibility);
}
else
{
await _queueReference.UpdateMessageAsync(cloudMessage, visibilityTimeOut,
MessageUpdateFields.Content | MessageUpdateFields.Visibility,
queueStorageOptions.QueueRequestOptions,
queueStorageOptions.OperationContext, _tokenSource.Token);
}
return(new Tuple <bool, CMPStorageError>(true, null));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
catch (ArgumentException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
catch (OperationCanceledException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
}
public async Task <Tuple <bool, CMPStorageError> > UpdateMessageAsync(string messageString,
string messageIdString,
string popupTokenString,
CMPQueueStorageOptions queueStorageOptions)
{
if (queueStorageOptions == null)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
if ((string.IsNullOrEmpty(messageIdString) == true) || (string.IsNullOrEmpty(popupTokenString) == true))
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
try
{
if (_queueReference == null)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
CloudQueueMessage queueMessage = new CloudQueueMessage(messageIdString, popupTokenString);
queueMessage.SetMessageContent((queueStorageOptions.MessageUpdateFields ==
MessageUpdateFields.Content) ? messageString : string.Empty);
await _queueReference.UpdateMessageAsync(queueMessage, queueStorageOptions.VisibilityTimeoutOrDelay,
queueStorageOptions.MessageUpdateFields);
return(new Tuple <bool, CMPStorageError>(true, null));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
catch (ArgumentException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
catch (OperationCanceledException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
}
public async Task <Tuple <bool, CMPStorageError> > AddStreamToBlobAsync(Stream blobStream, string blobNameString,
CMPBlobStorageOptions
blobStorageOptions = null)
{
if (blobStream == null)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
if (string.IsNullOrEmpty(blobNameString) == true)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
try
{
var blobReference = PrepareBlockBlobReference(blobNameString);
if (blobReference == null)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
if (blobStorageOptions == null)
{
await blobReference.UploadFromStreamAsync(blobStream, blobStream.Length);
}
else
{
await blobReference.UploadFromStreamAsync(blobStream, blobStream.Length,
blobStorageOptions.AccessCondition,
blobStorageOptions.BlobRequestOptions,
blobStorageOptions.OperationContext, _tokenSource.Token);
}
return(new Tuple <bool, CMPStorageError>(true, null));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
catch (ArgumentException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
}
public async Task <Tuple <T, CMPStorageError> > FetchAsync <T>(string tableNameString, string partitionKeyString,
string rowKeyString,
CMPTableStorageOptions tableStorageOptions = null)
where T : CMPTableStorageModel, new()
{
if (_cloudTableClient == null)
{
return(new Tuple <T, CMPStorageError>(null, null));
}
if (string.IsNullOrEmpty(tableNameString) == true)
{
return(new Tuple <T, CMPStorageError>(null, null));
}
try
{
var tableReference = _cloudTableClient.GetTableReference(tableNameString);
if (tableReference == null)
{
return(new Tuple <T, CMPStorageError>(null, null));
}
var tableOperation = TableOperation.Retrieve <T>(partitionKeyString, rowKeyString);
TableResult fetchedResultInfo = null;
if (tableStorageOptions == null)
{
fetchedResultInfo = await tableReference.ExecuteAsync(tableOperation);
}
else
{
fetchedResultInfo = await tableReference.ExecuteAsync(tableOperation,
tableStorageOptions.TableRequestOptions,
tableStorageOptions.OperationContext,
_tokenSource.Token);
}
return(new Tuple <T, CMPStorageError>(fetchedResultInfo.Result as T, null));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <T, CMPStorageError>(null, error));
}
}
public async Task <Tuple <bool, CMPStorageError> > DeleteBatchMessagesAsync(List <CloudQueueMessage>
queueMessagesList,
CMPQueueStorageOptions
queueStorageOptions = null)
{
try
{
if (_queueReference == null)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
await Task.Run(() =>
{
var deleteTasksArray = queueMessagesList.Select(async(CloudQueueMessage queueMessageInfo) =>
{
if (queueMessageInfo == null)
{
return;
}
await DeleteMessageAsync(queueMessageInfo, queueStorageOptions);
}).ToArray();
Task.WaitAll(deleteTasksArray, _tokenSource.Token);
});
return(new Tuple <bool, CMPStorageError>(true, null));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
catch (ArgumentException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
catch (OperationCanceledException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
}
public async Task <Tuple <bool, CMPStorageError> > DeQueueMessageAsync(TimeSpan visibilityTimeOut,
CMPQueueStorageOptions
queueStorageOptions = null)
{
try
{
if (_queueReference == null)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
CloudQueueMessage queueMessage = null;
if (queueStorageOptions == null)
{
queueMessage = await _queueReference.GetMessageAsync();
}
else
{
queueMessage = await _queueReference.GetMessageAsync(visibilityTimeOut,
queueStorageOptions.QueueRequestOptions,
queueStorageOptions.OperationContext,
_tokenSource.Token);
}
ProcessQueueMessage?.Invoke(queueMessage);
var couldDeleteInfo = await DeleteMessageAsync(queueMessage, queueStorageOptions);
return(couldDeleteInfo);
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
catch (ArgumentException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
catch (OperationCanceledException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
}
public async Task <Tuple <byte[], CMPStorageError> > DownloadFromBlobAsync(string blobNameString,
CMPBlobStorageOptions
blobStorageOptions = null)
{
if (string.IsNullOrEmpty(blobNameString) == true)
{
return(new Tuple <byte[], CMPStorageError>(null, null));
}
try
{
var blobReference = PrepareBlockBlobReference(blobNameString);
if (blobReference == null)
{
return(new Tuple <byte[], CMPStorageError>(null, null));
}
var memoryStream = new MemoryStream();
if (blobStorageOptions == null)
{
await blobReference.DownloadToStreamAsync(memoryStream);
}
else
{
await blobReference.DownloadToStreamAsync(memoryStream, blobStorageOptions.AccessCondition,
blobStorageOptions.BlobRequestOptions,
blobStorageOptions.OperationContext, _tokenSource.Token);
}
memoryStream.Close();
var downloadedBytesArray = memoryStream.GetBuffer();
return(new Tuple <byte[], CMPStorageError>(downloadedBytesArray, null));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <byte[], CMPStorageError>(null, null));
}
catch (ArgumentException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <byte[], CMPStorageError>(null, null));
}
}
public async Task <Tuple <bool, CMPStorageError> > DeleteBlobAsync(string blobNameString,
CMPBlobStorageOptions
blobStorageOptions = null)
{
if (string.IsNullOrEmpty(blobNameString) == true)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
try
{
var blobReference = PrepareBlockBlobReference(blobNameString);
if (blobReference == null)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
var couldDelete = false;
if (blobStorageOptions == null)
{
couldDelete = await blobReference.DeleteIfExistsAsync();
}
else
{
couldDelete = await blobReference.DeleteIfExistsAsync(blobStorageOptions.DeleteSnapshotsOption,
blobStorageOptions.AccessCondition,
blobStorageOptions.BlobRequestOptions,
blobStorageOptions.OperationContext,
_tokenSource.Token);
}
return(new Tuple <bool, CMPStorageError>(couldDelete, null));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
catch (ArgumentException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
}
public async Task <Tuple <bool, CMPStorageError> > AddBytesToBlobAsync(byte[] blobBytesArray,
string blobNameString,
CMPBlobStorageOptions
blobStorageOptions = null)
{
if ((blobBytesArray == null) || (blobBytesArray.Length == 0))
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
try
{
var blobReference = PrepareBlockBlobReference(blobNameString);
if (blobReference == null)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
if (blobStorageOptions == null)
{
await blobReference.UploadFromByteArrayAsync(blobBytesArray, 0, blobBytesArray.Length);
}
else
{
await blobReference.UploadFromByteArrayAsync(blobBytesArray, 0, blobBytesArray.Length,
blobStorageOptions.AccessCondition,
blobStorageOptions.BlobRequestOptions,
blobStorageOptions.OperationContext,
_tokenSource.Token);
}
return(new Tuple <bool, CMPStorageError>(true, null));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
catch (ArgumentException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
}
public async Task <Tuple <bool, CMPStorageError> > DeleteMessageAsync(string deleteMessageString,
string popupTokenString,
CMPQueueStorageOptions
queueStorageOptions = null)
{
try
{
if (_queueReference == null)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
var cloudMessage = await _queueReference.GetMessageAsync();
if (queueStorageOptions == null)
{
await _queueReference.DeleteMessageAsync(deleteMessageString, popupTokenString);
}
else
{
await _queueReference.DeleteMessageAsync(deleteMessageString, popupTokenString,
queueStorageOptions.QueueRequestOptions,
queueStorageOptions.OperationContext, _tokenSource.Token);
}
return(new Tuple <bool, CMPStorageError>(true, null));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
catch (ArgumentException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
catch (OperationCanceledException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
}
public async Task <Tuple <string, string, CMPStorageError> > PeekMessageAsync(CMPQueueStorageOptions
queueStorageOptions = null)
{
try
{
if (_queueReference == null)
{
return(new Tuple <string, string, CMPStorageError>(null, null, null));
}
CloudQueueMessage queueMessage = null;
if (queueStorageOptions == null)
{
await _queueReference.PeekMessageAsync();
}
else
{
await _queueReference.PeekMessageAsync(queueStorageOptions.QueueRequestOptions,
queueStorageOptions.OperationContext, _tokenSource.Token);
}
return(new Tuple <string, string, CMPStorageError>(queueMessage.AsString, queueMessage.PopReceipt,
null));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <string, string, CMPStorageError>(null, null, error));
}
catch (ArgumentException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <string, string, CMPStorageError>(null, null, error));
}
catch (OperationCanceledException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <string, string, CMPStorageError>(null, null, error));
}
}
public async Task <Tuple <bool, CMPStorageError> > CreateBlobContainerAsync(CMPBlobStorageOptions
blobStorageOptions = null)
{
if (string.IsNullOrEmpty(_containerNameString) == true)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
try
{
var blobContainerReference = _cloudBlobClient.GetContainerReference(_containerNameString);
if (blobContainerReference == null)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
var couldCreate = false;
if (blobStorageOptions == null)
{
couldCreate = await blobContainerReference.CreateIfNotExistsAsync();
}
else
{
couldCreate = await blobContainerReference.CreateIfNotExistsAsync(blobStorageOptions.
BlobContainerPublicAccessType,
blobStorageOptions.
BlobRequestOptions,
blobStorageOptions.
OperationContext,
_tokenSource.Token);
}
return(new Tuple <bool, CMPStorageError>(couldCreate, null));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
}
public async Task <Tuple <List <T>, CMPStorageError> > FetchAsync <T>(string tableNameString,
string partitionKeyString,
FetchProgressCallback <T> fetchProgressCallback)
where T : CMPTableStorageModel, new()
{
if (_cloudTableClient == null)
{
return(new Tuple <List <T>, CMPStorageError>(null, null));
}
if (string.IsNullOrEmpty(tableNameString) == true)
{
return(new Tuple <List <T>, CMPStorageError>(null, null));
}
try
{
var tableReference = _cloudTableClient.GetTableReference(tableNameString);
if (tableReference == null)
{
return(new Tuple <List <T>, CMPStorageError>(null, null));
}
string filterConditionString = TableQuery.GenerateFilterCondition(KPartitionKeystring,
QueryComparisons.Equal,
partitionKeyString);
var fetchedResultsInfo = await FetchForFilterAsync <T>(tableReference, filterConditionString,
fetchProgressCallback);
return(fetchedResultsInfo);
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <List <T>, CMPStorageError>(null, error));
}
}
public async Task <Tuple <bool, CMPStorageError> > CreateTableAsync(string tableNameString,
CMPTableStorageOptions tableStorageOptions =
null)
{
if (_cloudTableClient == null)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
try
{
var tableReference = _cloudTableClient.GetTableReference(tableNameString);
if (tableReference == null)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
var couldCreate = false;
if (tableStorageOptions == null)
{
couldCreate = await tableReference.CreateIfNotExistsAsync();
}
else
{
couldCreate = await tableReference.CreateIfNotExistsAsync(tableStorageOptions.TableRequestOptions,
tableStorageOptions.OperationContext,
_tokenSource.Token);
}
return(new Tuple <bool, CMPStorageError>(true, null));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, error));
}
}
public async Task <Tuple <T, CMPStorageError> > DeleteRowAsync <T>(string tableNameString, T deleteModel,
CMPTableStorageOptions tableStorageOptions =
null)
where T : CMPTableStorageModel, new()
{
if (_cloudTableClient == null)
{
return(new Tuple <T, CMPStorageError>(null, null));
}
if (string.IsNullOrEmpty(tableNameString) == true)
{
return(new Tuple <T, CMPStorageError>(null, null));
}
if (deleteModel == null)
{
return(new Tuple <T, CMPStorageError>(null, null));
}
try
{
var tableReference = _cloudTableClient.GetTableReference(tableNameString);
if (tableReference == null)
{
return(new Tuple <T, CMPStorageError>(null, null));
}
var retrieveOperation = TableOperation.Retrieve <T>(deleteModel.PartitionKey, deleteModel.RowKey);
var retrieveResult = await tableReference.ExecuteAsync(retrieveOperation);
var retrievedModel = retrieveResult?.Result as T;
if (retrievedModel == null)
{
return(new Tuple <T, CMPStorageError>(null, null));
}
var deleteOperation = TableOperation.Delete(retrievedModel);
TableResult deleteResult = null;
if (tableStorageOptions == null)
{
deleteResult = await tableReference.ExecuteAsync(deleteOperation);
}
else
{
deleteResult = await tableReference.ExecuteAsync(deleteOperation,
tableStorageOptions.TableRequestOptions,
tableStorageOptions.OperationContext,
_tokenSource.Token);
}
return(new Tuple <T, CMPStorageError>(deleteResult?.Result as T, null));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <T, CMPStorageError>(null, error));
}
catch (ArgumentException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <T, CMPStorageError>(null, error));
}
}
public async Task <List <Tuple <T, CMPStorageError> > > DeleteRowsAsync <T>(string tableNameString,
string partitionKeyString,
CMPTableStorageOptions
tableStorageOptions = null)
where T : CMPTableStorageModel, new()
{
if (_cloudTableClient == null)
{
return(null);
}
if (string.IsNullOrEmpty(tableNameString) == true)
{
return(null);
}
try
{
var tableReference = _cloudTableClient.GetTableReference(tableNameString);
if (tableReference == null)
{
return(null);
}
string filterConditionString = TableQuery.GenerateFilterCondition(KPartitionKeystring,
QueryComparisons.Equal,
partitionKeyString);
var fetchedResultsInfo = await FetchForFilterAsync <T>(tableReference, filterConditionString);
var fetchedResultsList = fetchedResultsInfo.Item1;
if ((fetchedResultsList == null) || (fetchedResultsList.Count == 0))
{
return(null);
}
var deleteResultsInfoList = new List <Tuple <T, CMPStorageError> >();
var deleteTasksArray = fetchedResultsList.Select(async(T deleteModel) =>
{
var deleteResultInfo = await DeleteRowAsync <T>(tableNameString, deleteModel, tableStorageOptions);
deleteResultsInfoList.Add(deleteResultInfo);
}).ToArray();
await Task.WhenAll(deleteTasksArray);
return(deleteResultsInfoList);
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
var errorInfo = new Tuple <T, CMPStorageError>(null, error);
return(new List <Tuple <T, CMPStorageError> >()
{
errorInfo
});
}
catch (ArgumentException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
var errorInfo = new Tuple <T, CMPStorageError>(null, error);
return(new List <Tuple <T, CMPStorageError> >()
{
errorInfo
});
}
}
public async Task <Tuple <List <T>, CMPStorageError> > InsertRowsInBatchAsync <T>(List <T> insertModelsList,
string tableNameString,
CMPTableStorageOptions
tableStorageOptions = null)
where T : CMPTableStorageModel, new()
{
if (_cloudTableClient == null)
{
return(new Tuple <List <T>, CMPStorageError>(null, null));
}
if (string.IsNullOrEmpty(tableNameString) == true)
{
return(new Tuple <List <T>, CMPStorageError>(null, null));
}
if ((insertModelsList == null) || (insertModelsList.Count == 0) || (_cloudTableClient == null))
{
return(new Tuple <List <T>, CMPStorageError>(null, null));
}
try
{
var tableReference = _cloudTableClient.GetTableReference(tableNameString);
if (tableReference == null)
{
return(new Tuple <List <T>, CMPStorageError>(null, null));
}
var insertInBatchOperation = new TableBatchOperation();
foreach (var insertModel in insertModelsList)
{
insertInBatchOperation.Insert(insertModel);
}
IList <TableResult> insertInBatchResult = null;
if (tableStorageOptions == null)
{
insertInBatchResult = await tableReference.ExecuteBatchAsync(insertInBatchOperation);
}
else
{
insertInBatchResult = await tableReference.ExecuteBatchAsync(insertInBatchOperation,
tableStorageOptions.TableRequestOptions,
tableStorageOptions.OperationContext,
_tokenSource.Token);
}
var insertResultsList = insertInBatchResult.Select((TableResult insertResult) =>
{
return(insertResult?.Result as T);
}).ToList();
return(new Tuple <List <T>, CMPStorageError>(insertResultsList, null));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <List <T>, CMPStorageError>(null, error));
}
catch (ArgumentException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <List <T>, CMPStorageError>(null, error));
}
}
public async Task <Tuple <bool, CMPStorageError> > DeQueueBatchMessagesAsync(TimeSpan visibilityTimeOut,
int deQueueCount,
CMPQueueStorageOptions
queueStorageOptions = null)
{
try
{
if (_queueReference == null)
{
return(new Tuple <bool, CMPStorageError>(false, null));
}
if (deQueueCount == 0)
{
deQueueCount = await GetMessagesCountAsync(queueStorageOptions);
}
int batchCount = (deQueueCount / 10);
if (batchCount == 0)
{
batchCount = deQueueCount;
}
do
{
IEnumerable <CloudQueueMessage> queueMessages = null;
if (queueStorageOptions == null)
{
queueMessages = await _queueReference.GetMessagesAsync(batchCount);
}
else
{
queueMessages = await _queueReference.GetMessagesAsync(batchCount, visibilityTimeOut,
queueStorageOptions.QueueRequestOptions,
queueStorageOptions.OperationContext,
_tokenSource.Token);
}
var queueMessagesList = queueMessages.ToList();
ProcessQueueBatchMessages?.Invoke(queueMessagesList);
await DeleteBatchMessagesAsync(queueMessagesList, queueStorageOptions);
} while ((deQueueCount -= batchCount) > 0);
return(new Tuple <bool, CMPStorageError>(true, null));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, null));
}
catch (ArgumentException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, null));
}
catch (OperationCanceledException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <bool, CMPStorageError>(false, null));
}
}
public async Task <Tuple <T, CMPStorageError> > InsertRowAsync <T>(T insertModel, string tableNameString,
CMPTableStorageOptions tableStorageOptions =
null)
where T : CMPTableStorageModel, new()
{
if (_cloudTableClient == null)
{
return(new Tuple <T, CMPStorageError>(null, null));
}
if (string.IsNullOrEmpty(tableNameString) == true)
{
return(new Tuple <T, CMPStorageError>(null, null));
}
if ((insertModel == null) || (_cloudTableClient == null))
{
return(new Tuple <T, CMPStorageError>(null, null));
}
try
{
var tableReference = _cloudTableClient.GetTableReference(tableNameString);
if (tableReference == null)
{
return(new Tuple <T, CMPStorageError>(null, null));
}
var insertOperation = TableOperation.Insert(insertModel);
TableResult insertResult = null;
if (tableStorageOptions == null)
{
insertResult = await tableReference.ExecuteAsync(insertOperation);
}
else
{
insertResult = await tableReference.ExecuteAsync(insertOperation,
tableStorageOptions.TableRequestOptions,
tableStorageOptions.OperationContext,
_tokenSource.Token);
}
CMPStorageError error = null;
if (insertResult.HttpStatusCode != 200)
{
error = CMPStorageError.CreateError(insertResult.HttpStatusCode.ToString(), string.Empty);
}
return(new Tuple <T, CMPStorageError>(insertResult.Result as T,
error));
}
catch (StorageException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <T, CMPStorageError>(null, error));
}
catch (ArgumentException exception)
{
var error = CMPStorageError.CreateErrorFromException(exception);
return(new Tuple <T, CMPStorageError>(null, error));
}
}
