public async Task TestCustomJsonSerializer() { int toStreamCount = 0; int fromStreamCount = 0; Mock <CosmosJsonSerializer> mockJsonSerializer = new Mock <CosmosJsonSerializer>(); //The item object will be serialized with the custom json serializer. ToDoActivity testItem = CreateRandomToDoActivity(); mockJsonSerializer.Setup(x => x.ToStream <ToDoActivity>(It.IsAny <ToDoActivity>())).Callback(() => toStreamCount++).Returns(this.jsonSerializer.ToStream <ToDoActivity>(testItem)); mockJsonSerializer.Setup(x => x.FromStream <ToDoActivity>(It.IsAny <Stream>())).Callback <Stream>(x => { x.Dispose(); fromStreamCount++; }).Returns(testItem); //Create a new cosmos client with the mocked cosmos json serializer CosmosClient mockClient = TestCommon.CreateCosmosClient( (cosmosClientBuilder) => cosmosClientBuilder.WithCustomJsonSerializer(mockJsonSerializer.Object)); CosmosContainer mockContainer = mockClient.GetContainer(this.database.Id, this.container.Id); //Validate that the custom json serializer is used for creating the item ItemResponse <ToDoActivity> response = await mockContainer.CreateItemAsync <ToDoActivity>(item : testItem); Assert.IsNotNull(response); Assert.AreEqual(HttpStatusCode.Created, response.StatusCode); Assert.AreEqual(1, toStreamCount); Assert.AreEqual(1, fromStreamCount); await mockContainer.DeleteItemAsync <ToDoActivity>(new Cosmos.PartitionKey(testItem.status), testItem.id); }
/// <summary> /// The function demonstrates the Item CRUD operation using the NonePartitionKeyValue /// NonePartitionKeyValue represents the information that the current item doesn't have a value for partitition key /// All items inserted pre-migration are grouped into this logical partition and can be accessed by providing this value /// for the partitionKey parameter /// New item CRUD could be performed using this NonePartitionKeyValue to target the same logical partition /// </summary> private static async Task ItemOperationsWithNonePartitionKeyValue(CosmosContainer container) { string itemid = Guid.NewGuid().ToString(); DeviceInformationItem itemWithoutPK = GetDeviceWithNoPartitionKey(itemid); // Insert a new item with NonePartitionKeyValue ItemResponse <DeviceInformationItem> createResponse = await container.CreateItemAsync <DeviceInformationItem>( partitionKey : PartitionKey.NonePartitionKeyValue, item : itemWithoutPK); Console.WriteLine("Creating Item {0} Status Code {1}", itemid, createResponse.StatusCode); // Read an existing item with NonePartitionKeyValue ItemResponse <DeviceInformationItem> readResponse = await container.ReadItemAsync <DeviceInformationItem>( partitionKey : PartitionKey.NonePartitionKeyValue, id : itemid); Console.WriteLine("Reading Item {0} Status Code {1}", itemid, readResponse.StatusCode); // Replace the content of existing item with NonePartitionKeyValue itemWithoutPK.DeviceId = Guid.NewGuid().ToString(); ItemResponse <DeviceInformationItem> replaceResponse = await container.ReplaceItemAsync <DeviceInformationItem>( partitionKey : PartitionKey.NonePartitionKeyValue, id : itemWithoutPK.Id, item : itemWithoutPK); Console.WriteLine("Replacing Item {0} Status Code {1}", itemid, replaceResponse.StatusCode); // Delete an item with NonePartitionKeyValue. ItemResponse <DeviceInformationItem> deleteResponse = await container.DeleteItemAsync <DeviceInformationItem>( partitionKey : PartitionKey.NonePartitionKeyValue, id : itemid); Console.WriteLine("Deleting Item {0} Status Code {1}", itemid, deleteResponse.StatusCode); }
/// <summary> /// Runs a simple script which just does a server side query /// </summary> private static async Task RunSimpleScript(CosmosContainer container) { // 1. Create stored procedure for script. string scriptFileName = @"js\SimpleScript.js"; string scriptId = Path.GetFileNameWithoutExtension(scriptFileName); await TryDeleteStoredProcedure(container, scriptId); CosmosScripts cosmosScripts = container.GetScripts(); StoredProcedureResponse sproc = await cosmosScripts.CreateStoredProcedureAsync(new CosmosStoredProcedureSettings(scriptId, File.ReadAllText(scriptFileName))); // 2. Create a document. SampleDocument doc = new SampleDocument { Id = Guid.NewGuid().ToString(), LastName = "Estel", Headquarters = "Russia", Locations = new Location[] { new Location { Country = "Russia", City = "Novosibirsk" } }, Income = 50000 }; ItemResponse <SampleDocument> created = await container.CreateItemAsync(doc, new PartitionKey(doc.LastName)); // 3. Run the script. Pass "Hello, " as parameter. // The script will take the 1st document and echo: Hello, <document as json>. StoredProcedureExecuteResponse <string> response = await container.GetScripts().ExecuteStoredProcedureAsync <string, string>(new PartitionKey(doc.LastName), scriptId, "Hello"); Console.WriteLine("Result from script: {0}\r\n", response.Resource); await container.DeleteItemAsync <SampleDocument>(new PartitionKey(doc.LastName), doc.Id); }
public static async Task DeleteItemsByIdsAsync <T>(CosmosContainer container, List <string> ids, string partitionKeyValue) { // Delete item foreach (var id in ids) { await container.DeleteItemAsync <T>(id, new PartitionKey(partitionKeyValue)); } ; }
public async Task <Image> DeleteImageAsync(string id) { var partitionKey = new PartitionKey(id); var response = await CosmosContainer.DeleteItemAsync <Image>(id, partitionKey); return(response.Value); //TODO : Bubble up errors through the stack }
private static async Task DeleteItemAsync() { Console.WriteLine("\n1.7 - Deleting a item"); ItemResponse <SalesOrder> response = await container.DeleteItemAsync <SalesOrder>( partitionKey : new PartitionKey("Account1"), id : "SalesOrder3"); Console.WriteLine("Request charge of delete operation: {0}", response.RequestCharge); Console.WriteLine("StatusCode of operation: {0}", response.StatusCode); }
public async Task DeleteAsync(string entityId, string partionKey) { try { CosmosContainer container = GetContainer(); await container.DeleteItemAsync <T>(entityId, new PartitionKey(partionKey)); }catch (Exception ex) { Log.Error($"Entity with ID: {entityId} was not removed successfully - error details: {ex.Message}"); } }
// </ReplaceFamilyItemAsync> // <DeleteFamilyItemAsync> /// <summary> /// Delete an item in the container /// </summary> private static async Task DeleteFamilyItemAsync(CosmosClient cosmosClient) { CosmosContainer container = cosmosClient.GetContainer(Program.DatabaseId, Program.ContainerId); string partitionKeyValue = "Wakefield"; string familyId = "Wakefield.7"; // Delete an item. Note we must provide the partition key value and id of the item to delete ItemResponse <Family> wakefieldFamilyResponse = await container.DeleteItemAsync <Family>(familyId, new PartitionKey(partitionKeyValue)); Console.WriteLine("Deleted Family [{0},{1}]\n", partitionKeyValue, familyId); }
public static async Task <T> TryDeleteItemAsync <T>( this CosmosContainer container, object partitionKey, string itemId, ItemRequestOptions cosmosItemRequestOptions = null) { var response = await container.DeleteItemAsync <T>(partitionKey, itemId, cosmosItemRequestOptions).ConfigureAwait(false); if (response.StatusCode == HttpStatusCode.NotFound) { return(default(T)); } return(response.Resource); }
public async Task DeleteAsync(string entityId) { try { CosmosContainer container = GetContainer(); await container.DeleteItemAsync <T>(entityId, new PartitionKey(entityId)); } catch (CosmosException ex) { _logger.LogError(ex.Message); if (ex.Status != (int)HttpStatusCode.NotFound) { throw; } } }
public async Task DeleteAsync(string entityId) { try { CosmosContainer container = GetContainer(); await container.DeleteItemAsync <T>(entityId, new PartitionKey(entityId)); } catch (CosmosException ex) { Log.Error($"Entity with ID: {entityId} was not removed successfully - error details: {ex.Message}"); if (ex.Status != (int)HttpStatusCode.NotFound) { throw; } } }
private async void dataGridView1_UserDeletingRow(object sender, DataGridViewRowCancelEventArgs e) { this.Cursor = System.Windows.Forms.Cursors.WaitCursor; var clickedId = dataGridView1.Rows[e.Row.Index].Cells[0].Value.ToString(); try { CosmosContainer container = cosmosClient.GetContainer(_settings.DatabaseId, _settings.ContainerId); Session session = new Session(); ItemResponse <Session> sessionCosmos = await container.DeleteItemAsync <Session>(clickedId, new PartitionKey(session.partition)); _allSessions.Remove(_allSessions.Where(c => c.id.Equals(clickedId)).FirstOrDefault()); } catch (Exception) { this.Cursor = System.Windows.Forms.Cursors.Default; } Thread.Sleep(100); this.Cursor = System.Windows.Forms.Cursors.Default; }
/// <summary> /// The function demonstrates CRUD operations on the migrated collection supplying a value for the partition key /// <summary> private static async Task ItemOperationsWithValidPartitionKeyValue(CosmosContainer container) { string itemid = Guid.NewGuid().ToString(); string partitionKey = "a"; DeviceInformationItem itemWithPK = GetDeviceWithPartitionKey(itemid, partitionKey); // Insert a new item ItemResponse <DeviceInformationItem> createResponse = await container.CreateItemAsync <DeviceInformationItem>( partitionKey : new PartitionKey(partitionKey), item : itemWithPK); Console.WriteLine("Creating Item {0} with Partition Key Status Code {1}", itemid, createResponse.StatusCode); // Read the item back ItemResponse <DeviceInformationItem> readResponse = await container.ReadItemAsync <DeviceInformationItem>( partitionKey : new PartitionKey(partitionKey), id : itemid); Console.WriteLine("Reading Item {0} with Partition Key Status Code {1}", itemid, readResponse.StatusCode); // Replace the content of the item itemWithPK.DeviceId = Guid.NewGuid().ToString(); ItemResponse <DeviceInformationItem> replaceResponse = await container.ReplaceItemAsync <DeviceInformationItem>( partitionKey : new PartitionKey(partitionKey), id : itemWithPK.Id, item : itemWithPK); Console.WriteLine("Replacing Item {0} with Partition Key Status Code {1}", itemid, replaceResponse.StatusCode); // Delete the item. ItemResponse <DeviceInformationItem> deleteResponse = await container.DeleteItemAsync <DeviceInformationItem>( partitionKey : new PartitionKey(partitionKey), id : itemid); Console.WriteLine("Deleting Item {0} with Partition Key Status Code {1}", itemid, deleteResponse.StatusCode); }
public async Task <ItemResponse <Recipe> > DeleteRecipeAsync(Recipe recipe) { _logger.LogInformation("Deleting item: " + recipe.id); return(await _cosmosContainer.DeleteItemAsync <Recipe>(recipe.id, new PartitionKey(recipe.type))); }
public async Task DeleteTestDataAsync(string id) { await _container.DeleteItemAsync <TestData>(id, new PartitionKey(id)); }
private async Task VerifyItemNullPartitionKeyExpectations( dynamic testItem, ItemRequestOptions requestOptions = null) { TestHandler testHandler = new TestHandler((request, cancellationToken) => { Assert.IsNotNull(request.Headers.PartitionKey); Assert.AreEqual(Documents.Routing.PartitionKeyInternal.Undefined.ToString(), request.Headers.PartitionKey.ToString()); return(Task.FromResult(new CosmosResponseMessage(HttpStatusCode.OK))); }); CosmosClient client = MockCosmosUtil.CreateMockCosmosClient( (cosmosClientBuilder) => cosmosClientBuilder.AddCustomHandlers(testHandler)); CosmosContainer container = client.GetDatabase("testdb") .GetContainer("testcontainer"); await container.CreateItemAsync <dynamic>( item : testItem, requestOptions : requestOptions); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => { await container.ReadItemAsync <dynamic>( partitionKey: null, id: testItem.id, requestOptions: requestOptions); }, "ReadItemAsync should throw ArgumentNullException without the correct request option set."); await container.UpsertItemAsync <dynamic>( item : testItem, requestOptions : requestOptions); await container.ReplaceItemAsync <dynamic>( id : testItem.id, item : testItem, requestOptions : requestOptions); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => { await container.DeleteItemAsync <dynamic>( partitionKey: null, id: testItem.id, requestOptions: requestOptions); }, "DeleteItemAsync should throw ArgumentNullException without the correct request option set."); CosmosJsonSerializerCore jsonSerializer = new CosmosJsonSerializerCore(); using (Stream itemStream = jsonSerializer.ToStream <dynamic>(testItem)) { await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => { await container.CreateItemStreamAsync( partitionKey: null, streamPayload: itemStream, requestOptions: requestOptions); }, "CreateItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => { await container.ReadItemStreamAsync( partitionKey: null, id: testItem.id, requestOptions: requestOptions); }, "ReadItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => { await container.UpsertItemStreamAsync( partitionKey: null, streamPayload: itemStream, requestOptions: requestOptions); }, "UpsertItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => { await container.ReplaceItemStreamAsync( partitionKey: null, id: testItem.id, streamPayload: itemStream, requestOptions: requestOptions); }, "ReplaceItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => { await container.DeleteItemStreamAsync( partitionKey: null, id: testItem.id, requestOptions: requestOptions); }, "DeleteItemAsync should throw ArgumentNullException without the correct request option set."); } }
private async Task VerifyItemOperations( object partitionKey, string partitionKeySerialized, dynamic testItem, ItemRequestOptions requestOptions = null) { CosmosResponseMessage response = null; HttpStatusCode httpStatusCode = HttpStatusCode.OK; int testHandlerHitCount = 0; TestHandler testHandler = new TestHandler((request, cancellationToken) => { Assert.IsTrue(request.RequestUri.OriginalString.StartsWith(@"/dbs/testdb/colls/testcontainer")); Assert.AreEqual(requestOptions, request.RequestOptions); Assert.AreEqual(ResourceType.Document, request.ResourceType); Assert.IsNotNull(request.Headers.PartitionKey); Assert.AreEqual(partitionKeySerialized, request.Headers.PartitionKey); testHandlerHitCount++; response = new CosmosResponseMessage(httpStatusCode, request, errorMessage: null); response.Content = request.Content; return Task.FromResult(response); }); CosmosClient client = MockCosmosUtil.CreateMockCosmosClient( (builder) => builder.AddCustomHandlers(testHandler)); CosmosContainer container = client.Databases["testdb"] .Containers["testcontainer"]; ItemResponse<dynamic> itemResponse = await container.CreateItemAsync<dynamic>( partitionKey: partitionKey, item: testItem, requestOptions: requestOptions); Assert.IsNotNull(itemResponse); Assert.AreEqual(httpStatusCode, itemResponse.StatusCode); itemResponse = await container.ReadItemAsync<dynamic>( partitionKey: partitionKey, id: testItem.id, requestOptions: requestOptions); Assert.IsNotNull(itemResponse); Assert.AreEqual(httpStatusCode, itemResponse.StatusCode); itemResponse = await container.UpsertItemAsync<dynamic>( partitionKey: partitionKey, item: testItem, requestOptions: requestOptions); Assert.IsNotNull(itemResponse); Assert.AreEqual(httpStatusCode, itemResponse.StatusCode); itemResponse = await container.ReplaceItemAsync<dynamic>( partitionKey: partitionKey, id: testItem.id, item: testItem, requestOptions: requestOptions); Assert.IsNotNull(itemResponse); Assert.AreEqual(httpStatusCode, itemResponse.StatusCode); itemResponse = await container.DeleteItemAsync<dynamic>( partitionKey: partitionKey, id: testItem.id, requestOptions: requestOptions); Assert.IsNotNull(itemResponse); Assert.AreEqual(httpStatusCode, itemResponse.StatusCode); Assert.AreEqual(5, testHandlerHitCount, "An operation did not make it to the handler"); CosmosJsonSerializerCore jsonSerializer = new CosmosJsonSerializerCore(); using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem)) { using (CosmosResponseMessage streamResponse = await container.CreateItemAsStreamAsync( partitionKey: partitionKey, streamPayload: itemStream)) { Assert.IsNotNull(streamResponse); Assert.AreEqual(httpStatusCode, streamResponse.StatusCode); } } using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem)) { using (CosmosResponseMessage streamResponse = await container.ReadItemAsStreamAsync( partitionKey: partitionKey, id: testItem.id, requestOptions: requestOptions)) { Assert.IsNotNull(streamResponse); Assert.AreEqual(httpStatusCode, streamResponse.StatusCode); } } using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem)) { using (CosmosResponseMessage streamResponse = await container.UpsertItemAsStreamAsync( partitionKey: partitionKey, streamPayload: itemStream, requestOptions: requestOptions)) { Assert.IsNotNull(streamResponse); Assert.AreEqual(httpStatusCode, streamResponse.StatusCode); } } using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem)) { using (CosmosResponseMessage streamResponse = await container.ReplaceItemAsStreamAsync( partitionKey: partitionKey, id: testItem.id, streamPayload: itemStream, requestOptions: requestOptions)) { Assert.IsNotNull(streamResponse); Assert.AreEqual(httpStatusCode, streamResponse.StatusCode); } } using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem)) { using (CosmosResponseMessage streamResponse = await container.DeleteItemAsStreamAsync( partitionKey: partitionKey, id: testItem.id, requestOptions: requestOptions)) { Assert.IsNotNull(streamResponse); Assert.AreEqual(httpStatusCode, streamResponse.StatusCode); } } Assert.AreEqual(10, testHandlerHitCount, "A stream operation did not make it to the handler"); }
private async Task VerifyItemNullExceptions( dynamic testItem, ItemRequestOptions requestOptions = null) { TestHandler testHandler = new TestHandler((request, cancellationToken) => { Assert.Fail("Null partition key should be blocked without the correct request option"); return null; }); CosmosClient client = MockCosmosUtil.CreateMockCosmosClient( (cosmosClientBuilder) => cosmosClientBuilder.AddCustomHandlers(testHandler)); CosmosContainer container = client.Databases["testdb"] .Containers["testcontainer"]; await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.CreateItemAsync<dynamic>( partitionKey: null, item: testItem, requestOptions: requestOptions); }, "CreateItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.ReadItemAsync<dynamic>( partitionKey: null, id: testItem.id, requestOptions: requestOptions); }, "ReadItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.UpsertItemAsync<dynamic>( partitionKey: null, item: testItem, requestOptions: requestOptions); }, "UpsertItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.ReplaceItemAsync<dynamic>( partitionKey: null, id: testItem.id, item: testItem, requestOptions: requestOptions); }, "ReplaceItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.DeleteItemAsync<dynamic>( partitionKey: null, id: testItem.id, requestOptions: requestOptions); }, "DeleteItemAsync should throw ArgumentNullException without the correct request option set."); CosmosJsonSerializerCore jsonSerializer = new CosmosJsonSerializerCore(); using (Stream itemStream = jsonSerializer.ToStream<dynamic>(testItem)) { await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.CreateItemAsStreamAsync( partitionKey: null, streamPayload: itemStream, requestOptions: requestOptions); }, "CreateItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.ReadItemAsStreamAsync( partitionKey: null, id: testItem.id, requestOptions: requestOptions); }, "ReadItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.UpsertItemAsStreamAsync( partitionKey: null, streamPayload: itemStream, requestOptions: requestOptions); }, "UpsertItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.ReplaceItemAsStreamAsync( partitionKey: null, id: testItem.id, streamPayload: itemStream, requestOptions: requestOptions); }, "ReplaceItemAsync should throw ArgumentNullException without the correct request option set."); await Assert.ThrowsExceptionAsync<ArgumentNullException>(async () => { await container.DeleteItemAsStreamAsync( partitionKey: null, id: testItem.id, requestOptions: requestOptions); }, "DeleteItemAsync should throw ArgumentNullException without the correct request option set."); } }
public static async Task DeleteItemByIdAsync <T>(CosmosContainer container, string id, string partitionKeyValue) { // Delete item await container.DeleteItemAsync <T>(id, new PartitionKey(partitionKeyValue)); }
public async Task DeleteAsync(string id, PartitionKey partitionKey) { await _container.DeleteItemAsync <TEntity>(id, partitionKey); }
public async Task DeleteAsync(Guid id) { await _container.DeleteItemAsync <T>(id.ToString(), new PartitionKey(id.ToString())); }
public async Task DeleteAsync(string id, string partitionKey) { await _container.DeleteItemAsync <TEntity>(id, new PartitionKey(partitionKey)); }
/// <summary> /// The function demonstrates migrating documents that were inserted without a value for partition key, and those inserted /// pre-migration to other logical partitions, those with a value for partition key. /// </summary> private static async Task MigratedItemsFromNonePartitionKeyToValidPartitionKeyValue(CosmosContainer container) { // Pre-create a few items in the container to demo the migration const int ItemsToCreate = 4; // Insert a few items with no Partition Key for (int i = 0; i < ItemsToCreate; i++) { string itemid = Guid.NewGuid().ToString(); DeviceInformationItem itemWithoutPK = GetDeviceWithNoPartitionKey(itemid); ItemResponse <DeviceInformationItem> createResponse = await container.CreateItemAsync <DeviceInformationItem>( partitionKey : PartitionKey.NonePartitionKeyValue, item : itemWithoutPK); } // Query items on the container that have no partition key value by supplying NonePartitionKeyValue // The operation is made in batches to not lose work in case of partial execution int resultsFetched = 0; CosmosSqlQueryDefinition sql = new CosmosSqlQueryDefinition("select * from r"); FeedIterator <DeviceInformationItem> setIterator = container.CreateItemQuery <DeviceInformationItem>(sql, partitionKey: PartitionKey.NonePartitionKeyValue, maxItemCount: 2); while (setIterator.HasMoreResults) { FeedResponse <DeviceInformationItem> queryResponse = await setIterator.FetchNextSetAsync(); resultsFetched += queryResponse.Count(); // For the items returned with NonePartitionKeyValue IEnumerator <DeviceInformationItem> iter = queryResponse.GetEnumerator(); while (iter.MoveNext()) { DeviceInformationItem item = iter.Current; if (item.DeviceId != null) { // Using existing deviceID for partition key item.PartitionKey = item.DeviceId; Console.WriteLine("Migrating item {0} to Partition {1}", item.Id, item.DeviceId); // Re-Insert into container with a partition key // This could result in exception if the same item was inserted in a previous run of the program on existing container // and the program stopped before the delete. ItemResponse <DeviceInformationItem> createResponseWithPk = await container.CreateItemAsync <DeviceInformationItem>( partitionKey : new PartitionKey(item.PartitionKey), item : item); // Deleting item from fixed container with CosmosContainerSettings.NonePartitionKeyValue. ItemResponse <DeviceInformationItem> deleteResponseWithoutPk = await container.DeleteItemAsync <DeviceInformationItem>( partitionKey : PartitionKey.NonePartitionKeyValue, id : item.Id); } } } }