public async Task CreateDeleteTableAsync() { string storageUri = StorageUri; string accountName = StorageAccountName; string storageAccountKey = PrimaryStorageAccountKey; string tableName = "OfficeSupplies1p2a"; // Construct a new <see cref="TableServiceClient" /> using a <see cref="TableSharedKeyCredential" />. var serviceClient = new TableServiceClient( new Uri(storageUri), new TableSharedKeyCredential(accountName, storageAccountKey)); #region Snippet:TablesSample1CreateTableAsync // Create a new table. The <see cref="TableItem" /> class stores properties of the created table. TableItem table = await serviceClient.CreateTableAsync(tableName); Console.WriteLine($"The created table's name is {table.Name}."); #endregion #region Snippet:TablesSample1DeleteTableAsync // Deletes the table made previously. await serviceClient.DeleteTableAsync(tableName); #endregion }
public async Task GetTablesReturnsTablesWithFilter() { string tableName = $"testtable{Recording.GenerateId()}"; bool doCleanup = false; TableServiceClient service = CreateTableServiceClient(); try { var createdTable = await service.CreateTableAsync(tableName).ConfigureAwait(false); Assert.That(() => createdTable.TableName, Is.EqualTo(tableName), $"Created table should be '{tableName}'"); doCleanup = true; // Query with a filter. var tableResponses = (await service.GetTablesAsync(filter: $"TableName eq '{tableName}'").ToEnumerableAsync().ConfigureAwait(false)).ToList(); Assert.That(() => tableResponses, Is.Not.Empty); Assert.That(() => tableResponses.Select(r => r.TableName), Contains.Item(tableName)); } finally { if (doCleanup) { await service.DeleteTableAsync(tableName); } } }
public async Task GetTablesReturnsTables() { string tableName = $"testtable{Recording.GenerateId()}"; bool doCleanup = false; TableServiceClient service = CreateTableServiceClient(); try { var createdTable = await service.CreateTableAsync(tableName).ConfigureAwait(false); Assert.That(() => createdTable.TableName, Is.EqualTo(tableName), $"Created table should be {tableName}"); doCleanup = true; List <TableResponseProperties> tableResponses = new List <TableResponseProperties>(); await foreach (var table in service.GetTablesAsync()) { tableResponses.Add(table); } Assert.That(() => tableResponses, Is.Not.Empty); Assert.That(() => tableResponses.Select(r => r.TableName), Contains.Item(tableName)); } finally { if (doCleanup) { await service.DeleteTableAsync(tableName); } } }
public async Task QueryTablesAsync() { string storageUri = StorageUri; string accountName = StorageAccountName; string storageAccountKey = PrimaryStorageAccountKey; string tableName = "OfficeSupplies3p2"; var serviceClient = new TableServiceClient( new Uri(storageUri), new TableSharedKeyCredential(accountName, storageAccountKey)); await serviceClient.CreateTableAsync(tableName); #region Snippet:TablesSample3QueryTablesAsync // Use the <see cref="TableServiceClient"> to query the service. Passing in OData filter strings is optional. AsyncPageable <TableItem> queryTableResults = serviceClient.GetTablesAsync(filter: $"TableName eq '{tableName}'"); Console.WriteLine("The following are the names of the tables in the query result:"); // Iterate the <see cref="Pageable"> in order to access individual queried tables. await foreach (TableItem table in queryTableResults) { Console.WriteLine(table.TableName); } #endregion await serviceClient.DeleteTableAsync(tableName); }
public async Task UpdateUpsertEntitiesAsync() { string storageUri = StorageUri; string accountName = StorageAccountName; string storageAccountKey = PrimaryStorageAccountKey; string tableName = "OfficeSupplies5p2" + _random.Next(); string partitionKey = "Stationery"; string rowKey = "A1"; var serviceClient = new TableServiceClient( new Uri(storageUri), new TableSharedKeyCredential(accountName, storageAccountKey)); await serviceClient.CreateTableAsync(tableName); var tableClient = serviceClient.GetTableClient(tableName); #region Snippet:TablesSample5UpsertEntityAsync var entity = new TableEntity(partitionKey, rowKey) { { "Product", "Markers" }, { "Price", 5.00 }, { "Brand", "myCompany" } }; // Entity doesn't exist in table, so invoking UpsertEntity will simply insert the entity. await tableClient.UpsertEntityAsync(entity); #endregion #region Snippet:TablesSample5UpsertWithReplaceAsync // Delete an entity property. entity.Remove("Brand"); // Entity does exist in the table, so invoking UpsertEntity will update using the given UpdateMode, which defaults to Merge if not given. // Since UpdateMode.Replace was passed, the existing entity will be replaced and delete the "Brand" property. await tableClient.UpsertEntityAsync(entity, TableUpdateMode.Replace); #endregion #region Snippet:TablesSample5UpdateEntityAsync // Get the entity to update. TableEntity qEntity = await tableClient.GetEntityAsync <TableEntity>(partitionKey, rowKey); qEntity["Price"] = 7.00; // Since no UpdateMode was passed, the request will default to Merge. await tableClient.UpdateEntityAsync(qEntity, qEntity.ETag); TableEntity updatedEntity = await tableClient.GetEntityAsync <TableEntity>(partitionKey, rowKey); Console.WriteLine($"'Price' before updating: ${entity.GetDouble("Price")}"); Console.WriteLine($"'Price' after updating: ${updatedEntity.GetDouble("Price")}"); #endregion await serviceClient.DeleteTableAsync(tableName); }
public async Task CreateTableAsync_RequiredArgsOnly_CreatesTable() { ITableServiceClient client = new TableServiceClient(_accountSettings); var tableName = GenerateSampleTableName(); await client.CreateTableAsync(tableName); AssertTableExists(tableName); }
public async Task CreateTableAsync_TableAlreadyExists_ReportsConflict() { ITableServiceClient client = new TableServiceClient(_accountSettings); var tableName = GenerateSampleTableName(); CreateTable(tableName); await client.CreateTableAsync(tableName); // expects exception }
public async Task EntitiyCanBeUpserted() { string tableName = $"testtable{Recording.GenerateId()}"; const string partitionKeyValue = "somPartition"; const string rowKeyValue = "1"; const string propertyName = "SomeStringProperty"; const string originalValue = "This is the original"; const string updatedValue = "This is new and improved!"; bool doCleanup = false; TableServiceClient service = CreateTableServiceClient(); try { var createdTable = await service.CreateTableAsync(tableName).ConfigureAwait(false); TableClient client = InstrumentClient(service.GetTableClient(tableName)); var entity = new Dictionary <string, object> { { "PartitionKey", partitionKeyValue }, { "RowKey", rowKeyValue }, { propertyName, originalValue } }; // Insert the new entity. await client.UpsertAsync(entity).ConfigureAwait(false); // Fetch the created entity from the service. var entityToUpdate = (await client.QueryAsync(filter: $"PartitionKey eq '{partitionKeyValue}' and RowKey eq '{rowKeyValue}'").ToEnumerableAsync().ConfigureAwait(false)).Single(); entityToUpdate[propertyName] = updatedValue; await client.UpsertAsync(entityToUpdate).ConfigureAwait(false); // Fetch the updated entity from the service. var updatedEntity = (await client.QueryAsync(filter: $"PartitionKey eq '{partitionKeyValue}' and RowKey eq '{rowKeyValue}'").ToEnumerableAsync().ConfigureAwait(false)).Single(); Assert.That(updatedEntity[propertyName], Is.EqualTo(updatedValue), $"The property value should be {updatedValue}"); } finally { if (doCleanup) { await service.DeleteTableAsync(tableName); } } }
public async Task InsertedEntitiesCanBeQueriedWithAndWithoutPagination(int?pageCount) { string tableName = $"testtable{Recording.GenerateId()}"; const string partitionKeyValue = "somPartition"; bool doCleanup = false; TableServiceClient service = CreateTableServiceClient(); List <IDictionary <string, object> > entityResults = new List <IDictionary <string, object> >(); try { var createdTable = await service.CreateTableAsync(tableName).ConfigureAwait(false); TableClient client = InstrumentClient(service.GetTableClient(tableName)); List <Dictionary <string, object> > entitiesToInsert = CreateTableEntities(partitionKeyValue, 20); // Insert the new entities. foreach (var entity in entitiesToInsert) { await client.InsertAsync(entity).ConfigureAwait(false); } // Query the entities. entityResults = (await client.QueryAsync(top: pageCount).ToEnumerableAsync().ConfigureAwait(false)).ToList(); Assert.That(entityResults.Count, Is.EqualTo(entitiesToInsert.Count), "The entity result count should match the inserted count"); entityResults.Clear(); } finally { if (doCleanup) { await service.DeleteTableAsync(tableName); } } }
public async Task InsertedEntitiesCanBeQueriedWithFilters() { string tableName = $"testtable{Recording.GenerateId()}"; const string partitionKeyValue = "somPartition"; bool doCleanup = false; TableServiceClient service = CreateTableServiceClient(); List <IDictionary <string, object> > entityResults = new List <IDictionary <string, object> >(); try { var createdTable = await service.CreateTableAsync(tableName).ConfigureAwait(false); TableClient client = InstrumentClient(service.GetTableClient(tableName)); List <Dictionary <string, object> > entitiesToInsert = CreateTableEntities(partitionKeyValue, 20); // Insert the new entities. foreach (var entity in entitiesToInsert) { await client.InsertAsync(entity).ConfigureAwait(false); } // Query the entities with a filter specifying that to RowKey value must be greater than or equal to '10'. entityResults = (await client.QueryAsync(filter: $"PartitionKey eq '{partitionKeyValue}' and RowKey gt '10'").ToEnumerableAsync().ConfigureAwait(false)).ToList(); Assert.That(entityResults.Count, Is.EqualTo(10), "The entity result count should be 10"); } finally { if (doCleanup) { await service.DeleteTableAsync(tableName); } } }
public async Task QueryEntitiesAsync() { string storageUri = StorageUri; string accountName = StorageAccountName; string storageAccountKey = PrimaryStorageAccountKey; string tableName = "OfficeSupplies4p2" + _random.Next(); string partitionKey = "somePartition"; string rowKey = "1"; string rowKey2 = "2"; var serviceClient = new TableServiceClient( new Uri(storageUri), new TableSharedKeyCredential(accountName, storageAccountKey)); await serviceClient.CreateTableAsync(tableName); var tableClient = serviceClient.GetTableClient(tableName); var entity = new TableEntity(partitionKey, rowKey) { { "Product", "Markers" }, { "Price", 5.00 }, }; await tableClient.AddEntityAsync(entity); var entity2 = new TableEntity(partitionKey, rowKey2) { { "Product", "Chair" }, { "Price", 7.00 }, }; await tableClient.AddEntityAsync(entity2); #region Snippet:TablesSample4QueryEntitiesAsync // Use the <see cref="TableClient"> to query the table. Passing in OData filter strings is optional. AsyncPageable <TableEntity> queryResults = tableClient.QueryAsync <TableEntity>(filter: $"PartitionKey eq '{partitionKey}'"); int count = 0; // Iterate the list in order to access individual queried entities. await foreach (TableEntity qEntity in queryResults) { Console.WriteLine($"{qEntity.GetString("Product")}: {qEntity.GetDouble("Price")}"); count++; } Console.WriteLine($"The query returned {count} entities."); #endregion #region Snippet:TablesSample4QueryEntitiesExpressionAsync // Use the <see cref="TableClient"> to query the table using a filter expression. double priceCutOff = 6.00; AsyncPageable <OfficeSupplyEntity> queryResultsLINQ = tableClient.QueryAsync <OfficeSupplyEntity>(ent => ent.Price >= priceCutOff); #endregion #region Snippet:TablesSample4QueryEntitiesSelectAsync AsyncPageable <TableEntity> queryResultsSelect = tableClient.QueryAsync <TableEntity>(select: new List <string>() { "Product", "Price" }); #endregion #region Snippet:TablesSample4QueryEntitiesMaxPerPageAsync AsyncPageable <TableEntity> queryResultsMaxPerPage = tableClient.QueryAsync <TableEntity>(maxPerPage: 10); // Iterate the <see cref="Pageable"> by page. await foreach (Page <TableEntity> page in queryResultsMaxPerPage.AsPages()) { Console.WriteLine("This is a new page!"); foreach (TableEntity qEntity in page.Values) { Console.WriteLine($"# of {qEntity.GetString("Product")} inventoried: {qEntity.GetInt32("Quantity")}"); } } #endregion await serviceClient.DeleteTableAsync(tableName); }
public async Task EntityDeleteRespectsEtag() { string tableName = $"testtable{Recording.GenerateId()}"; const string partitionKeyValue = "somPartition"; const string rowKeyValue = "1"; const string propertyName = "SomeStringProperty"; const string originalValue = "This is the original"; bool doCleanup = false; TableServiceClient service = CreateTableServiceClient(); try { var createdTable = await service.CreateTableAsync(tableName).ConfigureAwait(false); TableClient client = InstrumentClient(service.GetTableClient(tableName)); var entity = new Dictionary <string, object> { { "PartitionKey", partitionKeyValue }, { "RowKey", rowKeyValue }, { propertyName, originalValue } }; // Insert the new entity. await client.UpsertAsync(entity).ConfigureAwait(false); // Fetch the created entity from the service. var originalEntity = (await client.QueryAsync(filter: $"PartitionKey eq '{partitionKeyValue}' and RowKey eq '{rowKeyValue}'").ToEnumerableAsync().ConfigureAwait(false)).Single(); var staleEtag = originalEntity[TableConstants.PropertyNames.Etag] as string; // Use a wildcard ETag to delete unconditionally. await client.DeleteAsync(partitionKeyValue, rowKeyValue).ConfigureAwait(false); // Validate that the entity is deleted. var emptyresult = (await client.QueryAsync(filter: $"PartitionKey eq '{partitionKeyValue}' and RowKey eq '{rowKeyValue}'").ToEnumerableAsync().ConfigureAwait(false)); Assert.That(emptyresult, Is.Empty, $"The query should have returned no results."); // Insert the new entity again. await client.UpsertAsync(entity).ConfigureAwait(false); // Fetch the created entity from the service. originalEntity = (await client.QueryAsync(filter: $"PartitionKey eq '{partitionKeyValue}' and RowKey eq '{rowKeyValue}'").ToEnumerableAsync().ConfigureAwait(false)).Single(); // Use a non-matching ETag. Assert.That(async() => await client.DeleteAsync(partitionKeyValue, rowKeyValue, staleEtag).ConfigureAwait(false), Throws.InstanceOf <RequestFailedException>()); // Use a matching ETag. await client.DeleteAsync(partitionKeyValue, rowKeyValue, originalEntity[TableConstants.PropertyNames.Etag] as string).ConfigureAwait(false); // Validate that the entity is deleted. emptyresult = (await client.QueryAsync(filter: $"PartitionKey eq '{partitionKeyValue}' and RowKey eq '{rowKeyValue}'").ToEnumerableAsync().ConfigureAwait(false)); Assert.That(emptyresult, Is.Empty, $"The query should have returned no results."); } finally { if (doCleanup) { await service.DeleteTableAsync(tableName); } } }
public async Task EntityMergeDoesPartialPropertyUpdates() { string tableName = $"testtable{Recording.GenerateId()}"; const string partitionKeyValue = "somPartition"; const string rowKeyValue = "1"; const string propertyName = "SomeStringProperty"; const string mergepropertyName = "MergedProperty"; const string originalValue = "This is the original"; const string mergeValue = "This was merged!"; const string mergeUpdatedValue = "merged value was updated!"; bool doCleanup = false; TableServiceClient service = CreateTableServiceClient(); try { var createdTable = await service.CreateTableAsync(tableName).ConfigureAwait(false); TableClient client = InstrumentClient(service.GetTableClient(tableName)); var entity = new Dictionary <string, object> { { "PartitionKey", partitionKeyValue }, { "RowKey", rowKeyValue }, { propertyName, originalValue } }; var partialEntity = new Dictionary <string, object> { { "PartitionKey", partitionKeyValue }, { "RowKey", rowKeyValue }, { mergepropertyName, mergeValue } }; // Insert the new entity. await client.UpsertAsync(entity).ConfigureAwait(false); // Fetch the created entity from the service. var originalEntity = (await client.QueryAsync(filter: $"PartitionKey eq '{partitionKeyValue}' and RowKey eq '{rowKeyValue}'").ToEnumerableAsync().ConfigureAwait(false)).Single(); // Verify that the merge property does not yet exist yet and that the original property does exist. Assert.That(originalEntity.TryGetValue(mergepropertyName, out var _), Is.False); Assert.That(originalEntity[propertyName], Is.EqualTo(originalValue)); // Do not provide an ETag to update unconditionally. await client.MergeAsync(partialEntity).ConfigureAwait(false); // Fetch the updated entity from the service. var mergedEntity = (await client.QueryAsync(filter: $"PartitionKey eq '{partitionKeyValue}' and RowKey eq '{rowKeyValue}'").ToEnumerableAsync().ConfigureAwait(false)).Single(); // Verify that the merge property does not yet exist yet and that the original property does exist. Assert.That(mergedEntity[mergepropertyName], Is.EqualTo(mergeValue)); Assert.That(mergedEntity[propertyName], Is.EqualTo(originalValue)); // Update just the merged value. partialEntity[mergepropertyName] = mergeUpdatedValue; await client.MergeAsync(partialEntity).ConfigureAwait(false); // Fetch the updated entity from the service. mergedEntity = (await client.QueryAsync(filter: $"PartitionKey eq '{partitionKeyValue}' and RowKey eq '{rowKeyValue}'").ToEnumerableAsync().ConfigureAwait(false)).Single(); // Verify that the merge property does not yet exist yet and that the original property does exist. Assert.That(mergedEntity[mergepropertyName], Is.EqualTo(mergeUpdatedValue)); Assert.That(mergedEntity[propertyName], Is.EqualTo(originalValue)); } finally { if (doCleanup) { await service.DeleteTableAsync(tableName); } } }
public async Task CreateTableAsync_TableAlreadyExists_ReportsConflict() { ITableServiceClient client = new TableServiceClient(_accountSettings); var tableName = GenerateSampleTableName(); CreateTable(tableName); await client.CreateTableAsync(tableName); // expects exception }
public async Task CreateTableAsync_RequiredArgsOnly_CreatesTable() { ITableServiceClient client = new TableServiceClient(_accountSettings); var tableName = GenerateSampleTableName(); await client.CreateTableAsync(tableName); AssertTableExists(tableName); }
public async Task QueryEntitiesAsync() { string storageUri = StorageUri; string accountName = StorageAccountName; string storageAccountKey = PrimaryStorageAccountKey; string tableName = "OfficeSupplies4p2"; string partitionKey = "somePartition"; string rowKey = "1"; string rowKey2 = "2"; var serviceClient = new TableServiceClient( new Uri(storageUri), new TableSharedKeyCredential(accountName, storageAccountKey)); await serviceClient.CreateTableAsync(tableName); var client = serviceClient.GetTableClient(tableName); var entity = new TableEntity(partitionKey, rowKey) { { "Product", "Markers" }, { "Price", 5.00 }, }; await client.CreateEntityAsync(entity); var entity2 = new TableEntity(partitionKey, rowKey2) { { "Product", "Chair" }, { "Price", 7.00 }, }; await client.CreateEntityAsync(entity2); #region Snippet:TablesSample4QueryEntitiesAsync // Use the <see cref="TableClient"> to query the table. Passing in OData filter strings is optional. AsyncPageable <TableEntity> queryResults = client.QueryAsync <TableEntity>(filter: $"PartitionKey eq '{partitionKey}'"); int count = 0; // Iterate the list in order to access individual queried entities. await foreach (TableEntity qEntity in queryResults) { Console.WriteLine($"{qEntity.GetString("Product")}: {qEntity.GetDouble("Price")}"); count++; } Console.WriteLine($"The query returned {count} entities."); #endregion #region Snippet:TablesSample4QueryEntitiesExpressionTreeAsync // Use the <see cref="TableClient"> to query the table and pass in expression tree. double priceCutOff = 6.00; AsyncPageable <OfficeSupplyEntity> queryResultsLINQ = client.QueryAsync <OfficeSupplyEntity>(ent => ent.Price >= priceCutOff); count = 0; // Iterate the <see cref="Pageable"> in order to access individual queried entities. await foreach (OfficeSupplyEntity qEntity in queryResultsLINQ) { Console.WriteLine($"{qEntity.Product}: ${qEntity.Price}"); count++; } Console.WriteLine($"The LINQ query returned {count} entities."); #endregion await serviceClient.DeleteTableAsync(tableName); }
public async Task UpdateUpsertEntitiesAsync() { string storageUri = StorageUri; string accountName = StorageAccountName; string storageAccountKey = PrimaryStorageAccountKey; string tableName = "OfficeSupplies5p2"; string partitionKey = "somePartition"; string rowKey = "A1"; var serviceClient = new TableServiceClient( new Uri(storageUri), new TableSharedKeyCredential(accountName, storageAccountKey)); await serviceClient.CreateTableAsync(tableName); #region Snippet:TablesSample5UpsertEntityAsync // Get the <see cref="TableClient" /> of the table. var client = serviceClient.GetTableClient(tableName); // Make an entity. var entity = new TableEntity(partitionKey, rowKey) { { "Product", "Markers" }, { "Price", 5.00 }, { "Brand", "myCompany" } }; // Entity doesn't exist in table, so invoking UpsertEntity will simply insert the entity. await client.UpsertEntityAsync(entity); // Delete an entity property. entity.Remove("Brand"); // Entity does exist in the table, so invoking UpsertEntity will update using the given UpdateMode (which defaults to Merge if not given). // Since UpdateMode.Replace was passed, the existing entity will be replaced and delete the "Brand" property. await client.UpsertEntityAsync(entity, TableUpdateMode.Replace); #endregion #region Snippet:TablesSample5UpdateEntityAsync // Query for entities to update. AsyncPageable <TableEntity> queryResultsBefore = client.QueryAsync <TableEntity>(); await foreach (TableEntity qEntity in queryResultsBefore) { // Changing property of entity. qEntity["Price"] = 7.00; // Updating to changed entity using its generated eTag. // Since no UpdateMode was passed, the request will default to Merge. await client.UpdateEntityAsync(qEntity, qEntity.ETag); } #endregion AsyncPageable <TableEntity> queryResultsAfter = client.QueryAsync <TableEntity>(); await foreach (TableEntity qEntity in queryResultsAfter) { Console.WriteLine($"'Price' before updating: ${entity.GetDouble("Price")}"); Console.WriteLine($"'Price' after updating: ${qEntity.GetDouble("Price")}"); } await serviceClient.DeleteTableAsync(tableName); }
public async Task EntityMergeRespectsEtag() { string tableName = $"testtable{Recording.GenerateId()}"; const string partitionKeyValue = "somPartition"; const string rowKeyValue = "1"; const string propertyName = "SomeStringProperty"; const string originalValue = "This is the original"; const string updatedValue = "This is new and improved!"; const string updatedValue2 = "This changed due to a matching Etag"; bool doCleanup = false; TableServiceClient service = CreateTableServiceClient(); try { var createdTable = await service.CreateTableAsync(tableName).ConfigureAwait(false); TableClient client = InstrumentClient(service.GetTableClient(tableName)); var entity = new Dictionary <string, object> { { "PartitionKey", partitionKeyValue }, { "RowKey", rowKeyValue }, { propertyName, originalValue } }; // Insert the new entity. await client.UpsertAsync(entity).ConfigureAwait(false); // Fetch the created entity from the service. var originalEntity = (await client.QueryAsync(filter: $"PartitionKey eq '{partitionKeyValue}' and RowKey eq '{rowKeyValue}'").ToEnumerableAsync().ConfigureAwait(false)).Single(); originalEntity[propertyName] = updatedValue; // Use a wildcard ETag to update unconditionally. await client.MergeAsync(originalEntity, "*").ConfigureAwait(false); // Fetch the updated entity from the service. var updatedEntity = (await client.QueryAsync(filter: $"PartitionKey eq '{partitionKeyValue}' and RowKey eq '{rowKeyValue}'").ToEnumerableAsync().ConfigureAwait(false)).Single(); Assert.That(updatedEntity[propertyName], Is.EqualTo(updatedValue), $"The property value should be {updatedValue}"); updatedEntity[propertyName] = updatedValue2; // Use a non-matching ETag. Assert.That(async() => await client.MergeAsync(updatedEntity, originalEntity[TableConstants.PropertyNames.Etag] as string).ConfigureAwait(false), Throws.InstanceOf <RequestFailedException>()); // Use a matching ETag. await client.MergeAsync(updatedEntity, updatedEntity[TableConstants.PropertyNames.Etag] as string).ConfigureAwait(false); // Fetch the newly updated entity from the service. updatedEntity = (await client.QueryAsync(filter: $"PartitionKey eq '{partitionKeyValue}' and RowKey eq '{rowKeyValue}'").ToEnumerableAsync().ConfigureAwait(false)).Single(); Assert.That(updatedEntity[propertyName], Is.EqualTo(updatedValue2), $"The property value should be {updatedValue2}"); } finally { if (doCleanup) { await service.DeleteTableAsync(tableName); } } }
public async Task TransactionalBatchAsync() { string storageUri = StorageUri; string accountName = StorageAccountName; string storageAccountKey = PrimaryStorageAccountKey; string tableName = "OfficeSuppliesBatch"; string partitionKey = "BatchInsertSample"; var serviceClient = new TableServiceClient( new Uri(storageUri), new TableSharedKeyCredential(accountName, storageAccountKey)); await serviceClient.CreateTableAsync(tableName); TableClient client = serviceClient.GetTableClient(tableName); #region Snippet:BatchAdd // Create a list of 5 entities with the same partition key. #if SNIPPET string partitionKey = "BatchInsertSample"; #endif List <TableEntity> entityList = new List <TableEntity> { new TableEntity(partitionKey, "01") { { "Product", "Marker" }, { "Price", 5.00 }, { "Brand", "Premium" } }, new TableEntity(partitionKey, "02") { { "Product", "Pen" }, { "Price", 3.00 }, { "Brand", "Premium" } }, new TableEntity(partitionKey, "03") { { "Product", "Paper" }, { "Price", 0.10 }, { "Brand", "Premium" } }, new TableEntity(partitionKey, "04") { { "Product", "Glue" }, { "Price", 1.00 }, { "Brand", "Generic" } }, }; // Create the batch. List <TableTransactionAction> addEntitiesBatch = new List <TableTransactionAction>(); // Add the entities to be added to the batch. addEntitiesBatch.AddRange(entityList.Select(e => new TableTransactionAction(TableTransactionActionType.Add, e))); // Submit the batch. Response <IReadOnlyList <Response> > response = await client.SubmitTransactionAsync(addEntitiesBatch).ConfigureAwait(false); for (int i = 0; i < entityList.Count; i++) { Console.WriteLine($"The ETag for the entity with RowKey: '{entityList[i].RowKey}' is {response.Value[i].Headers.ETag}"); } #endregion #region Snippet:BatchMixed // Create a new batch. List <TableTransactionAction> mixedBatch = new List <TableTransactionAction>(); // Add an entity for deletion to the batch. mixedBatch.Add(new TableTransactionAction(TableTransactionActionType.Delete, entityList[0])); // Remove this entity from our list so that we can track that it will no longer be in the table. entityList.RemoveAt(0); // Change only the price of the entity with a RoyKey equal to "02". TableEntity mergeEntity = new TableEntity(partitionKey, "02") { { "Price", 3.50 }, }; // Add a merge operation to the batch. // We specify an ETag value of ETag.All to indicate that this merge should be unconditional. mixedBatch.Add(new TableTransactionAction(TableTransactionActionType.UpdateMerge, mergeEntity, ETag.All)); // Update a property on an entity. TableEntity updateEntity = entityList[2]; updateEntity["Brand"] = "Generic"; // Add an upsert operation to the batch. // Using the UpsertEntity method allows us to implicitly ignore the ETag value. mixedBatch.Add(new TableTransactionAction(TableTransactionActionType.UpsertReplace, updateEntity)); // Submit the batch. await client.SubmitTransactionAsync(mixedBatch).ConfigureAwait(false); #endregion #region Snippet:BatchDelete // Create a new batch. List <TableTransactionAction> deleteEntitiesBatch = new List <TableTransactionAction>(); // Add the entities for deletion to the batch. foreach (TableEntity entity in entityList) { deleteEntitiesBatch.Add(new TableTransactionAction(TableTransactionActionType.Delete, entity)); } // Submit the batch. await client.SubmitTransactionAsync(deleteEntitiesBatch).ConfigureAwait(false); #endregion // Delete the table. await client.DeleteAsync(); }
public async Task CreateDeleteEntitiesAsync() { string storageUri = StorageUri; string accountName = StorageAccountName; string storageAccountKey = PrimaryStorageAccountKey; string tableName = "OfficeSupplies2p2"; string partitionKey = "somePartition"; string rowKey = "A1"; string rowKeyStrong = "B1"; var serviceClient = new TableServiceClient( new Uri(storageUri), new TableSharedKeyCredential(accountName, storageAccountKey)); await serviceClient.CreateTableAsync(tableName); try { // Get a reference to the <see cref="TableClient" /> of the table. var client = serviceClient.GetTableClient(tableName); #region Snippet:TablesSample2CreateEntityAsync // Make an entity by defining a <see cref="Dictionary"> that includes the partition and row key. var entity = new Dictionary <string, object> { { "PartitionKey", partitionKey }, { "RowKey", rowKey }, { "Product", "Markers" }, { "Price", 5.00 }, }; // Insert the newly created entity. await client.CreateEntityAsync(entity); #endregion #region Snippet:TablesSample2CreateStronglyTypedEntityAsync // Make a strongly typed entity by defining a custom class that extends <see cref="TableEntity">. var strongEntity = new OfficeSupplyEntity { PartitionKey = partitionKey, RowKey = rowKeyStrong, Product = "Notebook", Price = 3.00 }; // Insert the newly created entity. await client.CreateEntityAsync(strongEntity); #endregion #region Snippet:TablesSample2DeleteEntityAsync // Delete the entity given the partition and row key. await client.DeleteEntityAsync(partitionKey, rowKey); #endregion } finally { await serviceClient.DeleteTableAsync(tableName); } }