public SingleMultiRegion() { string endpoint, key, region; databaseName = Environment.GetEnvironmentVariable("database"); containerName = Environment.GetEnvironmentVariable("container"); storedProcName = Environment.GetEnvironmentVariable("storedproc"); databaseUri = UriFactory.CreateDatabaseUri(databaseName); containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName); storedProcUri = UriFactory.CreateStoredProcedureUri(databaseName, containerName, storedProcName); //Single-Region account client endpoint = Environment.GetEnvironmentVariable("SingleRegionEndpoint"); key = Environment.GetEnvironmentVariable("SingleRegionKey"); region = Environment.GetEnvironmentVariable("SingleRegionRegion"); ConnectionPolicy policy = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp, }; policy.SetCurrentLocation(region); clientSingle = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual); clientSingle.OpenAsync().GetAwaiter().GetResult(); //Multi-Region account client endpoint = Environment.GetEnvironmentVariable("MultiRegionEndpoint"); key = Environment.GetEnvironmentVariable("MultiRegionKey"); region = Environment.GetEnvironmentVariable("MultiRegionRegion"); policy.SetCurrentLocation(region); clientMulti = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual); clientMulti.OpenAsync().GetAwaiter().GetResult(); }
private DocumentClient readClient; //Read from West US public async Task Initialize(Uri accountEndpoint, string key) { //Write Policy ConnectionPolicy writeConnectionPolicy = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp }; //Write to West US 2 writeConnectionPolicy.SetCurrentLocation(LocationNames.WestUS2); //Read Policy ConnectionPolicy readConnectionPolicy = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp }; //Read from West US readConnectionPolicy.SetCurrentLocation(LocationNames.WestUS); writeClient = new DocumentClient(accountEndpoint, key, writeConnectionPolicy); readClient = new DocumentClient(accountEndpoint, key, readConnectionPolicy); await Task.WhenAll(new Task[] { writeClient.OpenAsync(), readClient.OpenAsync() }); }
internal ConnectionPolicy GetConnectionPolicy() { ConnectionPolicy connectionPolicy = new ConnectionPolicy { EnableEndpointDiscovery = true, UseMultipleWriteLocations = true, UserAgentSuffix = string.Format(" {0}/{1} {2}", "cosmos-table-sdk", "1.0.4", UserAgentSuffix) }; if (UseConnectionModeDirect) { connectionPolicy.ConnectionMode = ConnectionMode.Direct; connectionPolicy.ConnectionProtocol = Microsoft.Azure.Documents.Client.Protocol.Tcp; } else { connectionPolicy.ConnectionMode = ConnectionMode.Gateway; connectionPolicy.ConnectionProtocol = Microsoft.Azure.Documents.Client.Protocol.Https; MaxConnectionLimit = MaxConnectionLimit; } if (!string.IsNullOrEmpty(CurrentRegion)) { connectionPolicy.SetCurrentLocation(CurrentRegion); } if (MaxRetryAttemptsOnThrottledRequests.HasValue) { connectionPolicy.RetryOptions.MaxRetryAttemptsOnThrottledRequests = MaxRetryAttemptsOnThrottledRequests.Value; } if (MaxRetryWaitTimeOnThrottledRequests.HasValue) { connectionPolicy.RetryOptions.MaxRetryWaitTimeInSeconds = MaxRetryWaitTimeOnThrottledRequests.Value; } return(connectionPolicy); }
public Conflicts() { databaseName = Environment.GetEnvironmentVariable("database"); lwwContainerName = Environment.GetEnvironmentVariable("LwwPolicyContainer"); udpContainerName = Environment.GetEnvironmentVariable("UdpPolicyContainer"); noneContainerName = Environment.GetEnvironmentVariable("NoPolicyContainer"); databaseUri = UriFactory.CreateDatabaseUri(databaseName); lwwContainerUri = UriFactory.CreateDocumentCollectionUri(databaseName, lwwContainerName); udpContainerUri = UriFactory.CreateDocumentCollectionUri(databaseName, udpContainerName); noneContainerUri = UriFactory.CreateDocumentCollectionUri(databaseName, noneContainerName); string endpoint = Environment.GetEnvironmentVariable("MultiMasterEndpoint"); string key = Environment.GetEnvironmentVariable("MultiMasterKey"); List <string> regions = Environment.GetEnvironmentVariable("ConflictRegions").Split(';').ToList(); clients = new List <DocumentClient>(); foreach (string region in regions) { ConnectionPolicy policy = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp, UseMultipleWriteLocations = true //Multiple write locations }; policy.SetCurrentLocation(region); DocumentClient client = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual); client.OpenAsync().GetAwaiter().GetResult(); clients.Add(client); } }
public CustomSynchronization() { string endpoint, key, writeRegion, readRegion; databaseName = ConfigurationManager.AppSettings["database"]; containerName = ConfigurationManager.AppSettings["container"]; databaseUri = UriFactory.CreateDatabaseUri(databaseName); containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName); writeRegion = ConfigurationManager.AppSettings["WriteRegion"]; readRegion = ConfigurationManager.AppSettings["readRegion"]; Console.WriteLine("Custom Synchronization for Stronger Consistency without Latency"); Console.WriteLine("---------------------------------------------------------------"); //Shared endpoint and key endpoint = ConfigurationManager.AppSettings["CustomSyncEndpoint"]; key = ConfigurationManager.AppSettings["CustomSyncKey"]; //Write client ConnectionPolicy writePolicy = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp, UseMultipleWriteLocations = true }; writePolicy.SetCurrentLocation(writeRegion); writeClient = new DocumentClient(new Uri(endpoint), key, writePolicy); Console.WriteLine($"Created Write Client with Session consistency in: {writeRegion}."); //Read client policy ConnectionPolicy readPolicy = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp }; readPolicy.SetCurrentLocation(readRegion); readClient = new DocumentClient(new Uri(endpoint), key, readPolicy, ConsistencyLevel.Session); Console.WriteLine($"Created Read Client with Session consistency in: {readRegion}."); //Strong consistency client ConnectionPolicy strongPolicy = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp, }; strongPolicy.SetCurrentLocation(writeRegion); endpoint = ConfigurationManager.AppSettings["StrongEndpoint"]; key = ConfigurationManager.AppSettings["StrongKey"]; strongClient = new DocumentClient(new Uri(endpoint), key, strongPolicy, ConsistencyLevel.Strong); Console.WriteLine($"Created client with Strong consistency in: {writeRegion}."); Console.WriteLine(); writeClient.OpenAsync(); readClient.OpenAsync(); strongClient.OpenAsync(); }
public SingleMultiRegion() { Console.WriteLine("Single Region vs Multi-Region Read Latency"); Console.WriteLine("-------------------------------------------------------------------------"); string endpoint, key, region; databaseName = ConfigurationManager.AppSettings["database"]; containerName = ConfigurationManager.AppSettings["container"]; storedProcName = ConfigurationManager.AppSettings["storedproc"]; databaseUri = UriFactory.CreateDatabaseUri(databaseName); containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName); storedProcUri = UriFactory.CreateStoredProcedureUri(databaseName, containerName, storedProcName); //Single-Region account client endpoint = ConfigurationManager.AppSettings["SingleRegionEndpoint"]; key = ConfigurationManager.AppSettings["SingleRegionKey"]; region = ConfigurationManager.AppSettings["SingleRegionRegion"]; ConnectionPolicy policy = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp, }; policy.SetCurrentLocation(region); clientSingle = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual); clientSingle.OpenAsync(); Console.WriteLine($"Created DocumentClient for Single-Region account in: {region}."); //Multi-Region account client endpoint = ConfigurationManager.AppSettings["MultiRegionEndpoint"]; key = ConfigurationManager.AppSettings["MultiRegionKey"]; region = ConfigurationManager.AppSettings["MultiRegionRegion"]; policy.SetCurrentLocation(region); clientMulti = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual); clientMulti.OpenAsync(); Console.WriteLine($"Created DocumentClient for Multi-Region account in: {region}."); Console.WriteLine(); }
public SingleMultiMaster() { string endpoint, key, region; databaseName = ConfigurationManager.AppSettings["database"]; containerName = ConfigurationManager.AppSettings["container"]; storedProcName = ConfigurationManager.AppSettings["storedproc"]; databaseUri = UriFactory.CreateDatabaseUri(databaseName); containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName); storedProcUri = UriFactory.CreateStoredProcedureUri(databaseName, containerName, storedProcName); Console.WriteLine($"Single-Master vs Multi-Master Latency"); Console.WriteLine("--------------------------------------"); //Single-Master Connection Policy ConnectionPolicy policySingleMaster = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp, }; region = ConfigurationManager.AppSettings["SingleMultiMasterRegion"]; policySingleMaster.SetCurrentLocation(region); // Create the Single-Master account client endpoint = ConfigurationManager.AppSettings["SingleMasterEndpoint"]; key = ConfigurationManager.AppSettings["SingleMasterKey"]; clientSingle = new DocumentClient(new Uri(endpoint), key, policySingleMaster, ConsistencyLevel.Eventual); clientSingle.OpenAsync(); Console.WriteLine($"Created DocumentClient for Single-Master account in: {region}."); //Multi-Master Connection Policy ConnectionPolicy policyMultiMaster = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp, UseMultipleWriteLocations = true //Required for Multi-Master }; region = ConfigurationManager.AppSettings["SingleMultiMasterRegion"]; policyMultiMaster.SetCurrentLocation(region); //Enable multi-homing // Create the Multi-Master account client endpoint = ConfigurationManager.AppSettings["MultiMasterEndpoint"]; key = ConfigurationManager.AppSettings["MultiMasterKey"]; clientMulti = new DocumentClient(new Uri(endpoint), key, policyMultiMaster, ConsistencyLevel.Eventual); clientMulti.OpenAsync(); Console.WriteLine($"Created DocumentClient for Multi-Master account in: {region}."); Console.WriteLine(); }
public CustomSynchronization() { string endpoint, key, writeRegion, readRegion; databaseName = Environment.GetEnvironmentVariable("database"); containerName = Environment.GetEnvironmentVariable("container"); databaseUri = UriFactory.CreateDatabaseUri(databaseName); containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName); writeRegion = Environment.GetEnvironmentVariable("WriteRegion"); readRegion = Environment.GetEnvironmentVariable("readRegion"); //Shared endpoint and key endpoint = Environment.GetEnvironmentVariable("CustomSyncEndpoint"); key = Environment.GetEnvironmentVariable("CustomSyncKey"); //Write client ConnectionPolicy writePolicy = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp, UseMultipleWriteLocations = true }; writePolicy.SetCurrentLocation(writeRegion); writeClient = new DocumentClient(new Uri(endpoint), key, writePolicy); //Read client policy ConnectionPolicy readPolicy = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp }; readPolicy.SetCurrentLocation(readRegion); readClient = new DocumentClient(new Uri(endpoint), key, readPolicy, ConsistencyLevel.Session); //Strong consistency client ConnectionPolicy strongPolicy = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp, }; strongPolicy.SetCurrentLocation(writeRegion); endpoint = Environment.GetEnvironmentVariable("StrongEndpoint"); key = Environment.GetEnvironmentVariable("StrongKey"); strongClient = new DocumentClient(new Uri(endpoint), key, strongPolicy, ConsistencyLevel.Strong); writeClient.OpenAsync().GetAwaiter().GetResult(); readClient.OpenAsync().GetAwaiter().GetResult(); strongClient.OpenAsync().GetAwaiter().GetResult(); }
/// <summary> /// Main method for the sample. /// </summary> /// <param name="args">command line arguments.</param> public static void Main(string[] args) { ThreadPool.SetMinThreads(MinThreadPoolSize, MinThreadPoolSize); string endpoint = ConfigurationManager.AppSettings["EndPointUrl"]; string authKey = ConfigurationManager.AppSettings["AuthorizationKey"]; Console.WriteLine("Summary:"); Console.WriteLine("--------------------------------------------------------------------- "); Console.WriteLine("Endpoint: {0}", endpoint); Console.WriteLine("Collection : {0}.{1} at {2} request units per second", DatabaseName, DataCollectionName, ConfigurationManager.AppSettings["CollectionThroughput"]); Console.WriteLine("Document Template*: {0}", ConfigurationManager.AppSettings["DocumentTemplateFile"]); Console.WriteLine("Degree of parallelism*: {0}", ConfigurationManager.AppSettings["DegreeOfParallelism"]); Console.WriteLine("--------------------------------------------------------------------- "); Console.WriteLine(); Console.WriteLine("CosmosDBBenchmark starting..."); try { ConnectionPolicy.SetCurrentLocation(LocationNames.WestUS2); ConnectionPolicy.UseMultipleWriteLocations = true; using (var client = new DocumentClient( new Uri(endpoint), authKey, ConnectionPolicy)) { var program = new Program(client); program.RunAsync().Wait(); Console.WriteLine("Cosmos DB Benchmark completed successfully."); } } #if !DEBUG catch (Exception e) { // If the Exception is a DocumentClientException, the "StatusCode" value might help identity // the source of the problem. Console.WriteLine("Samples failed with exception:{0}", e); } #endif finally { Console.WriteLine("Press any key to exit..."); Console.ReadLine(); } }
public ConsistencyLatency() { string endpoint, key, region; databaseName = ConfigurationManager.AppSettings["database"]; containerName = ConfigurationManager.AppSettings["container"]; databaseUri = UriFactory.CreateDatabaseUri(databaseName); containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName); region = ConfigurationManager.AppSettings["ConsistencyLatencyRegion"]; Console.WriteLine("Latency vs Eventual and Strong Consistency"); Console.WriteLine("-------------------------------------------------------------------------------------"); //Shared connection policy ConnectionPolicy policy = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp, }; policy.SetCurrentLocation(region); //Eventual consistency client endpoint = ConfigurationManager.AppSettings["EventualEndpoint"]; key = ConfigurationManager.AppSettings["EventualKey"]; clientEventual = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual); clientEventual.OpenAsync(); Console.WriteLine($"Created DocumentClient with Eventual consistency in: {region}."); //Strong consistency client 1K miles endpoint = ConfigurationManager.AppSettings["Strong1kMilesEndpoint"]; key = ConfigurationManager.AppSettings["Strong1kMilesKey"]; clientStrong1kMiles = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Strong); clientStrong1kMiles.OpenAsync(); Console.WriteLine($"Created DocumentClient with Strong consistency in: {region} replicating 1000 miles."); //Strong consistency client 2K miles endpoint = ConfigurationManager.AppSettings["Strong2kMilesEndpoint"]; key = ConfigurationManager.AppSettings["Strong2kMilesKey"]; clientStrong2kMiles = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Strong); clientStrong2kMiles.OpenAsync(); Console.WriteLine($"Created DocumentClient with Strong consistency in: {region} replicating 2000 miles."); Console.WriteLine(); }
public static IWebHostBuilder CreateWebHostBuilder(string[] args) => WebHost.CreateDefaultBuilder(args). UseApplicationInsights(). ConfigureAppConfiguration((hostingContext, config) => { Configuration = config.Build(); }). ConfigureServices(s => { s.AddMvc(); #region CosmosDB var cosmosDbConfig = ConfigurationBinder.Get <CosmosDbConfig>(Configuration.GetSection("CosmosDb")); s.AddSingleton(cosmosDbConfig); var connectionPolicy = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp, UseMultipleWriteLocations = true }; if (cosmosDbConfig.PreferredLocations != null && cosmosDbConfig.PreferredLocations.Any() && cosmosDbConfig.PreferredLocations.All(l => AllowedLocations.Contains(l))) { // write connectionPolicy.SetCurrentLocation(cosmosDbConfig.PreferredLocations.First()); // read foreach (var location in cosmosDbConfig.PreferredLocations) { connectionPolicy.PreferredLocations.Add(location); } } var client = new DocumentClient(new Uri(cosmosDbConfig.Endpoint), cosmosDbConfig.Key, connectionPolicy); client.OpenAsync().GetAwaiter().GetResult(); s.AddSingleton(client); #endregion }). Configure(app => { app.UseHttpsRedirection(); app.UseMvc(); });
public SingleMultiMaster() { string endpoint, key, region; databaseName = Environment.GetEnvironmentVariable("database"); containerName = Environment.GetEnvironmentVariable("container"); storedProcName = Environment.GetEnvironmentVariable("storedproc"); databaseUri = UriFactory.CreateDatabaseUri(databaseName); containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName); storedProcUri = UriFactory.CreateStoredProcedureUri(databaseName, containerName, storedProcName); //Single-Master Connection Policy ConnectionPolicy policySingleMaster = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp, }; region = Environment.GetEnvironmentVariable("SingleMultiMasterRegion"); policySingleMaster.SetCurrentLocation(region); // Create the Single-Master account client endpoint = Environment.GetEnvironmentVariable("SingleMasterEndpoint"); key = Environment.GetEnvironmentVariable("SingleMasterKey"); clientSingle = new DocumentClient(new Uri(endpoint), key, policySingleMaster, ConsistencyLevel.Eventual); clientSingle.OpenAsync().GetAwaiter().GetResult(); //Multi-Master Connection Policy ConnectionPolicy policyMultiMaster = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp, UseMultipleWriteLocations = true //Required for Multi-Master }; region = Environment.GetEnvironmentVariable("SingleMultiMasterRegion"); policyMultiMaster.SetCurrentLocation(region); //Enable multi-homing // Create the Multi-Master account client endpoint = Environment.GetEnvironmentVariable("MultiMasterEndpoint"); key = Environment.GetEnvironmentVariable("MultiMasterKey"); clientMulti = new DocumentClient(new Uri(endpoint), key, policyMultiMaster, ConsistencyLevel.Eventual); clientMulti.OpenAsync().GetAwaiter().GetResult(); }
public ConsistencyLatency() { string endpoint, key, region; databaseName = Environment.GetEnvironmentVariable("database"); containerName = Environment.GetEnvironmentVariable("container"); databaseUri = UriFactory.CreateDatabaseUri(databaseName); containerUri = UriFactory.CreateDocumentCollectionUri(databaseName, containerName); region = Environment.GetEnvironmentVariable("ConsistencyLatencyRegion"); //Shared connection policy ConnectionPolicy policy = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp, }; policy.SetCurrentLocation(region); //Eventual consistency client endpoint = Environment.GetEnvironmentVariable("EventualEndpoint"); key = Environment.GetEnvironmentVariable("EventualKey"); clientEventual = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual); clientEventual.OpenAsync().GetAwaiter().GetResult(); //Strong consistency client 1K miles endpoint = Environment.GetEnvironmentVariable("Strong1kMilesEndpoint"); key = Environment.GetEnvironmentVariable("Strong1kMilesKey"); clientStrong1kMiles = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Strong); clientStrong1kMiles.OpenAsync().GetAwaiter().GetResult(); //Strong consistency client 2K miles endpoint = Environment.GetEnvironmentVariable("Strong2kMilesEndpoint"); key = Environment.GetEnvironmentVariable("Strong2kMilesKey"); clientStrong2kMiles = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Strong); clientStrong2kMiles.OpenAsync().GetAwaiter().GetResult(); }
public Conflicts() { databaseName = ConfigurationManager.AppSettings["database"]; lwwContainerName = ConfigurationManager.AppSettings["LwwPolicyContainer"]; udpContainerName = ConfigurationManager.AppSettings["UdpPolicyContainer"]; noneContainerName = ConfigurationManager.AppSettings["NoPolicyContainer"]; databaseUri = UriFactory.CreateDatabaseUri(databaseName); lwwContainerUri = UriFactory.CreateDocumentCollectionUri(databaseName, lwwContainerName); udpContainerUri = UriFactory.CreateDocumentCollectionUri(databaseName, udpContainerName); noneContainerUri = UriFactory.CreateDocumentCollectionUri(databaseName, noneContainerName); Console.WriteLine("Multi Master: Conflict Resolution"); Console.WriteLine("---------------------------------"); string endpoint = ConfigurationManager.AppSettings["MultiMasterEndpoint"]; string key = ConfigurationManager.AppSettings["MultiMasterKey"]; List <string> regions = ConfigurationManager.AppSettings["ConflictRegions"].Split(';').ToList(); clients = new List <DocumentClient>(); foreach (string region in regions) { ConnectionPolicy policy = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp, UseMultipleWriteLocations = true //Multiple write locations }; policy.SetCurrentLocation(region); DocumentClient client = new DocumentClient(new Uri(endpoint), key, policy, ConsistencyLevel.Eventual); client.OpenAsync(); clients.Add(client); Console.WriteLine($"Created Multi-Master DocumentClient in: {region}"); } Console.WriteLine(); }
public static async Task Run([EventHubTrigger("melonhubs", Connection = "EventHubConnectionAppSetting")] EventData[] events, ILogger log) { var exceptions = new List <Exception>(); foreach (EventData eventData in events) { try { string messageBody = Encoding.UTF8.GetString(eventData.Body.Array, eventData.Body.Offset, eventData.Body.Count); // Replace these two lines with your processing logic. log.LogInformation($"C# Event Hub trigger function processed a message: {messageBody}"); Uri collectionLink = UriFactory.CreateDocumentCollectionUri(Environment.GetEnvironmentVariable($"database_name"), Environment.GetEnvironmentVariable($"lwwcollection")); // Art of possible : Entity entity = JsonConvert.DeserializeObject <Entity>(messageBody); ConnectionPolicy policy = new ConnectionPolicy { ConnectionMode = ConnectionMode.Direct, ConnectionProtocol = Protocol.Tcp, UseMultipleWriteLocations = true }; policy.SetCurrentLocation("North Europe"); DocumentCollection lwwCollection = await client.CreateDocumentCollectionIfNotExistsAsync( UriFactory.CreateDatabaseUri(Environment.GetEnvironmentVariable($"database_name")), new DocumentCollection { Id = Environment.GetEnvironmentVariable($"lwwcollection"), ConflictResolutionPolicy = new ConflictResolutionPolicy { Mode = ConflictResolutionMode.LastWriterWins, ConflictResolutionPath = "/id", }, }); WriteToCosmos(client, entity, collectionLink); await Task.Yield(); } catch (Exception e) { // We need to keep processing the rest of the batch - capture this exception and continue. // Also, consider capturing details of the message that failed processing so it can be processed again later. exceptions.Add(e); } } // Once processing of the batch is complete, if any messages in the batch failed processing throw an exception so that there is a record of the failure. if (exceptions.Count > 1) { throw new AggregateException(exceptions); } if (exceptions.Count == 1) { throw exceptions.Single(); } }