Nested database context scope.

eben-roux · eben-roux · commit 85cac96e2965 · 2024-08-05T16:50:04.000+02:00
diff --git a/README.md b/README.md
@@ -65,9 +65,9 @@ The default JSON settings structure is as follows:
 
 # DatabaseContextScope
 
-The `DatabaseContextService` contains a collection of the `DatabaseContext` instances created by `IDatabaseContextFactory`.  However, these will not be flowed across async contexts.  
+The `DatabaseContextService` contains a collection of the `DatabaseContext` instances created by `IDatabaseContextFactory`.  However, since the `DatabaseContextService` is a singleton the same collection will be used in all thread contexts.  This includes not only the same execution context, but also "peered" execution context running in parallel.
 
-To enable async context flow wrap the initial database context creation in a `using` statement:
+To enable an individual execution/thread context-specific collection which also enables async context flow wrap the initial database context creation in a new `DatabaseContextScope()`:
 
 ``` c#
 using (new DatabaseContextScope())
diff --git a/Shuttle.Core.Data.Tests/AsyncFixture.cs b/Shuttle.Core.Data.Tests/AsyncFixture.cs
@@ -2,13 +2,14 @@
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Transactions;
 using NUnit.Framework;
 
 namespace Shuttle.Core.Data.Tests;
 
 public class AsyncFixture : MappingFixture
 {
-    private readonly Query _rowsQuery = new(@"
+    private readonly Query _rowsQuery = new Query(@"
 select
     Id,
     Name,
@@ -53,26 +54,61 @@ public void Should_be_able_to_use_the_different_database_context_for_separate_th
     }
 
     [Test]
-    public void Should_be_able_to_use_the_same_connection_name_for_separate_tasks_and_have_them_block_async()
+    public void Should_not_be_able_to_create_duplicate_database_contexts_async()
     {
-        var tasks = new List<Task>();
+        using (new DatabaseContextScope())
+        using (DatabaseContextFactory.Create())
+        {
+            Assert.That(()=> DatabaseContextFactory.Create(), Throws.InvalidOperationException);
+        }
+    }
+
+    [Test]
+    public async Task Should_be_able_to_create_nested_database_context_scopes_async()
+    {
+        await using (DatabaseContextFactory.Create())
+        {
+            await DatabaseGateway.ExecuteAsync(new Query("DROP TABLE IF EXISTS dbo.Nested"));
+            await DatabaseGateway.ExecuteAsync(new Query("CREATE TABLE dbo.Nested (Id int)"));
+        }
 
         using (new DatabaseContextScope())
+        await using (DatabaseContextFactory.Create())
         {
-            for (var i = 0; i < 10; i++)
+            var count = await DatabaseGateway.GetScalarAsync<int>(new Query("select count(*) from dbo.Nested"));
+
+            Assert.That(count, Is.Zero);
+
+            await DatabaseGateway.ExecuteAsync(new Query("INSERT INTO dbo.Nested (Id) VALUES (1)"));
+
+            count = await DatabaseGateway.GetScalarAsync<int>(new Query("select count(*) from dbo.Nested"));
+
+            Assert.That(count, Is.EqualTo(1));
+
+            using (new TransactionScope(TransactionScopeOption.Required, TransactionScopeAsyncFlowOption.Enabled))
+            using (new DatabaseContextScope())
+            await using (DatabaseContextFactory.Create())
             {
-                tasks.Add(Task.Run(() =>
-                {
-                    using (DatabaseContextFactory.Create())
-                    {
-                        Console.WriteLine($"{DateTime.Now:O}");
-                        DatabaseGateway.GetRowsAsync(_rowsQuery);
-                    }
-                }));
+                await DatabaseGateway.ExecuteAsync(new Query("INSERT INTO dbo.Nested (Id) VALUES (2)"));
+
+                count = await DatabaseGateway.GetScalarAsync<int>(new Query("select count(*) from dbo.Nested"));
+
+                Assert.That(count, Is.EqualTo(2));
             }
+
+            count = await DatabaseGateway.GetScalarAsync<int>(new Query("select count(*) from dbo.Nested"));
+
+            Assert.That(count, Is.EqualTo(1));
         }
 
-        Task.WaitAll(tasks.ToArray());
+        await using (DatabaseContextFactory.Create())
+        {
+            var count = await DatabaseGateway.GetScalarAsync<int>(new Query("select count(*) from dbo.Nested"));
+
+            Assert.That(count, Is.EqualTo(1));
+
+            await DatabaseGateway.ExecuteAsync(new Query("DROP TABLE IF EXISTS dbo.Nested"));
+        }
     }
 
     [Test]
diff --git a/Shuttle.Core.Data.Tests/DatabaseContextFactoryFixture.cs b/Shuttle.Core.Data.Tests/DatabaseContextFactoryFixture.cs
@@ -18,16 +18,6 @@ public void Should_be_able_to_create_a_database_context()
         }
     }
 
-    [Test]
-    public void Should_be_able_to_time_out_when_creating_another_context_with_the_same_name_as_an_existing_context_tha_does_not_complete()
-    {
-        var factory = DatabaseContextFactory;
-
-        using (factory.Create(DefaultConnectionStringName))
-        {
-            Assert.That(() => factory.Create(DefaultConnectionStringName, TimeSpan.FromMilliseconds(20)), Throws.TypeOf<TimeoutException>());
-        }
-    }
 
     [Test]
     public void Should_be_able_to_check_connection_availability()
@@ -37,8 +27,8 @@ public void Should_be_able_to_check_connection_availability()
         Assert.That(databaseContextFactory.Object.IsAvailable(new CancellationToken(), 0, 0), Is.True);
         Assert.That(databaseContextFactory.Object.IsAvailable("name", new CancellationToken(), 0, 0), Is.True);
 
-        databaseContextFactory.Setup(m => m.Create(null)).Throws(new Exception());
-        databaseContextFactory.Setup(m => m.Create(It.IsAny<string>(), null)).Throws(new Exception());
+        databaseContextFactory.Setup(m => m.Create()).Throws(new Exception());
+        databaseContextFactory.Setup(m => m.Create(It.IsAny<string>())).Throws(new Exception());
 
         Assert.That(databaseContextFactory.Object.IsAvailable(new CancellationToken(), 0, 0), Is.False);
         Assert.That(databaseContextFactory.Object.IsAvailable("name", new CancellationToken(), 0, 0), Is.False);
diff --git a/Shuttle.Core.Data.Tests/DatabaseContextFixture.cs b/Shuttle.Core.Data.Tests/DatabaseContextFixture.cs
@@ -1,6 +1,5 @@
 ﻿using System;
 using System.Data.Common;
-using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Data.SqlClient;
 using Moq;
@@ -17,7 +16,7 @@ public void Should_not_be_able_to_create_an_invalid_connection()
     {
         Assert.Throws<ArgumentException>(() =>
         {
-            using (new DatabaseContext("context", "Microsoft.Data.SqlClient", new SqlConnection("```"), new Mock<IDbCommandFactory>().Object, DatabaseContextService, new SemaphoreSlim(1,1)))
+            using (new DatabaseContext("context", "Microsoft.Data.SqlClient", new SqlConnection("```"), new Mock<IDbCommandFactory>().Object, DatabaseContextService))
             {
             }
         });
@@ -28,7 +27,7 @@ public void Should_not_be_able_to_create_a_non_existent_connection()
     {
         Assert.Throws<SqlException>(() =>
         {
-            using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", new SqlConnection("data source=.;initial catalog=idontexist;integrated security=sspi"), new Mock<IDbCommandFactory>().Object, DatabaseContextService, new SemaphoreSlim(0, 1)))
+            using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", new SqlConnection("data source=.;initial catalog=idontexist;integrated security=sspi"), new Mock<IDbCommandFactory>().Object, DatabaseContextService))
             {
                 databaseContext.CreateCommand(new Query("select 1"));
             }
@@ -49,7 +48,7 @@ public async Task Should_be_able_to_begin_and_commit_a_transaction_async()
 
     private async Task Should_be_able_to_begin_and_commit_a_transaction_async(bool sync)
     {
-        await using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, DatabaseContextService, new SemaphoreSlim(0, 1)))
+        await using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, DatabaseContextService))
         {
             if (sync)
             {
@@ -78,7 +77,7 @@ public async Task Should_be_able_to_begin_and_rollback_a_transaction_async()
 
     private async Task Should_be_able_to_begin_and_rollback_a_transaction_async(bool sync)
     {
-        await using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, new DatabaseContextService(), new SemaphoreSlim(0, 1)))
+        await using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, new DatabaseContextService()))
         {
             if (sync)
             {
@@ -105,7 +104,7 @@ public async Task Should_be_able_to_call_commit_without_a_transaction_async()
 
     private async Task Should_be_able_to_call_commit_without_a_transaction_async(bool sync)
     {
-        await using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, DatabaseContextService, new SemaphoreSlim(0, 1)))
+        await using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, DatabaseContextService))
         {
             if (sync)
             {
@@ -121,7 +120,7 @@ private async Task Should_be_able_to_call_commit_without_a_transaction_async(boo
     [Test]
     public void Should_be_able_to_call_dispose_more_than_once()
     {
-        using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, DatabaseContextService, new SemaphoreSlim(0, 1)))
+        using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, DatabaseContextService))
         {
             databaseContext.Dispose();
             databaseContext.Dispose();
@@ -138,7 +137,7 @@ public void Should_be_able_to_create_a_command()
 
         dbCommandFactory.Setup(m => m.Create(dbConnection, query.Object)).Returns(dbCommand.Object);
 
-        using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", dbConnection, dbCommandFactory.Object, DatabaseContextService, new SemaphoreSlim(0, 1)))
+        using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", dbConnection, dbCommandFactory.Object, DatabaseContextService))
         {
             databaseContext.CreateCommand(query.Object);
         }
diff --git a/Shuttle.Core.Data.Tests/DatabaseContextServiceFixture.cs b/Shuttle.Core.Data.Tests/DatabaseContextServiceFixture.cs
@@ -1,5 +1,4 @@
 ﻿using System.Data.Common;
-using System.Threading;
 using Moq;
 using NUnit.Framework;
 
@@ -12,11 +11,11 @@ public void Should_be_able_to_use_different_contexts()
     {
         var service = new DatabaseContextService();
 
-        var context1 = new DatabaseContext("mock-1", "provider-name", new Mock<DbConnection>().Object, new Mock<IDbCommandFactory>().Object, service, new SemaphoreSlim(1, 1));
+        var context1 = new DatabaseContext("mock-1", "provider-name", new Mock<DbConnection>().Object, new Mock<IDbCommandFactory>().Object, service);
 
         Assert.That(service.Active.Name, Is.EqualTo(context1.Name));
 
-        var context2 = new DatabaseContext("mock-2", "provider-name", new Mock<DbConnection>().Object, new Mock<IDbCommandFactory>().Object, service, new SemaphoreSlim(1, 1));
+        var context2 = new DatabaseContext("mock-2", "provider-name", new Mock<DbConnection>().Object, new Mock<IDbCommandFactory>().Object, service);
 
         Assert.That(service.Active.Name, Is.EqualTo(context2.Name));
 
diff --git a/Shuttle.Core.Data/.package/package.nuspec b/Shuttle.Core.Data/.package/package.nuspec
@@ -3,7 +3,7 @@
 <package>
 	<metadata>
 		<id>Shuttle.Core.Data</id>
-		<version>16.0.2</version>
+		<version>17.0.0</version>
 		<authors>Eben Roux</authors>
 		<owners>Eben Roux</owners>
 		<license type="expression">BSD-3-Clause</license>
@@ -21,8 +21,7 @@
       <dependency id="Microsoft.Extensions.Configuration.Binder" version="7.0.3" />
       <dependency id="Microsoft.Extensions.DependencyInjection" version="7.0.0" />
       <dependency id="Microsoft.Extensions.Options" version="7.0.1" />
-      <dependency id="Shuttle.Core.Contract" version="11.1.0" />
-      <dependency id="Shuttle.Core.Threading" version="13.0.0" />
+      <dependency id="Shuttle.Core.Contract" version="11.1.1" />
 		</dependencies>
 	</metadata>
 	<files>
diff --git a/Shuttle.Core.Data/Configuration/DatabaseContextFactoryOptions.cs b/Shuttle.Core.Data/Configuration/DatabaseContextFactoryOptions.cs
@@ -5,6 +5,5 @@ namespace Shuttle.Core.Data
     public class DatabaseContextFactoryOptions
     {
         public string DefaultConnectionStringName { get; set; }
-        public TimeSpan DefaultCreateTimeout { get; set; } = TimeSpan.FromSeconds(30);
     }
 }
diff --git a/Shuttle.Core.Data/DatabaseContext.cs b/Shuttle.Core.Data/DatabaseContext.cs
@@ -9,21 +9,19 @@ namespace Shuttle.Core.Data
 {
     public class DatabaseContext : IDatabaseContext
     {
-        private readonly SemaphoreSlim _lock;
         private readonly IDatabaseContextService _databaseContextService;
         private readonly IDbCommandFactory _dbCommandFactory;
         private readonly IDbConnection _dbConnection;
         private bool _disposed;
 
-        public DatabaseContext(string name, string providerName, IDbConnection dbConnection, IDbCommandFactory dbCommandFactory, IDatabaseContextService databaseContextService, SemaphoreSlim semaphoreSlim)
+        public DatabaseContext(string name, string providerName, IDbConnection dbConnection, IDbCommandFactory dbCommandFactory, IDatabaseContextService databaseContextService)
         {
             Name = Guard.AgainstNullOrEmptyString(name, nameof(name));
             ProviderName = Guard.AgainstNullOrEmptyString(providerName, "providerName");
 
             _dbCommandFactory = Guard.AgainstNull(dbCommandFactory, nameof(dbCommandFactory));
             _databaseContextService = Guard.AgainstNull(databaseContextService, nameof(databaseContextService));
             _dbConnection = Guard.AgainstNull(dbConnection, nameof(dbConnection));
-            _lock = Guard.AgainstNull(semaphoreSlim, nameof(semaphoreSlim));
 
             _databaseContextService.Add(this);
         }
@@ -105,7 +103,6 @@ public void Dispose()
             }
             finally
             {
-                _lock.Release();
                 _disposed = true;
             }
 
diff --git a/Shuttle.Core.Data/DatabaseContextFactory.cs b/Shuttle.Core.Data/DatabaseContextFactory.cs
@@ -16,7 +16,6 @@ public class DatabaseContextFactory : IDatabaseContextFactory
 
         private readonly IDbConnectionFactory _dbConnectionFactory;
         private readonly SemaphoreSlim _lock = new SemaphoreSlim(1, 1);
-        private readonly Dictionary<string, SemaphoreSlim> _semaphores = new Dictionary<string, SemaphoreSlim>();
 
         public DatabaseContextFactory(IOptionsMonitor<ConnectionStringOptions> connectionStringOptions, IOptions<DataAccessOptions> dataAccessOptions, IDbConnectionFactory dbConnectionFactory, IDbCommandFactory dbCommandFactory, IDatabaseContextService databaseContextService)
         {
@@ -32,22 +31,12 @@ public DatabaseContextFactory(IOptionsMonitor<ConnectionStringOptions> connectio
 
         public event EventHandler<DatabaseContextEventArgs> DatabaseContextCreated;
 
-        public IDatabaseContext Create(string connectionStringName, TimeSpan? timeout = null)
+        public IDatabaseContext Create(string connectionStringName)
         {
             Guard.AgainstNullOrEmptyString(connectionStringName, nameof(connectionStringName));
 
             _lock.Wait();
 
-            if (!_semaphores.ContainsKey(connectionStringName))
-            {
-                _semaphores.Add(connectionStringName, new SemaphoreSlim(1, 1)); 
-            }
-
-            if (!_semaphores[connectionStringName].Wait(timeout ?? _dataAccessOptions.DatabaseContextFactory.DefaultCreateTimeout))
-            {
-                throw new TimeoutException(string.Format(Resources.DatabaseContextFactoryTimeoutException, connectionStringName, timeout ?? _dataAccessOptions.DatabaseContextFactory.DefaultCreateTimeout));
-            }
-
             try
             {
                 var connectionStringOptions = _connectionStringOptions.Get(connectionStringName);
@@ -62,7 +51,7 @@ public IDatabaseContext Create(string connectionStringName, TimeSpan? timeout =
                     throw new InvalidOperationException(string.Format(Resources.DuplicateDatabaseContextException, connectionStringName));
                 }
 
-                var databaseContext = new DatabaseContext(connectionStringName, connectionStringOptions.ProviderName, (DbConnection)_dbConnectionFactory.Create(connectionStringOptions.ProviderName, connectionStringOptions.ConnectionString), _dbCommandFactory, _databaseContextService, _semaphores[connectionStringName]);
+                var databaseContext = new DatabaseContext(connectionStringName, connectionStringOptions.ProviderName, (DbConnection)_dbConnectionFactory.Create(connectionStringOptions.ProviderName, connectionStringOptions.ConnectionString), _dbCommandFactory, _databaseContextService);
 
                 DatabaseContextCreated?.Invoke(this, new DatabaseContextEventArgs(databaseContext));
 
@@ -74,14 +63,14 @@ public IDatabaseContext Create(string connectionStringName, TimeSpan? timeout =
             }
         }
 
-        public IDatabaseContext Create(TimeSpan? timeout = null)
+        public IDatabaseContext Create()
         {
             if (string.IsNullOrEmpty(_dataAccessOptions.DatabaseContextFactory.DefaultConnectionStringName))
             {
                 throw new InvalidOperationException(Resources.DatabaseContextFactoryOptionsException);
             }
 
-            return Create(_dataAccessOptions.DatabaseContextFactory.DefaultConnectionStringName, timeout);
+            return Create(_dataAccessOptions.DatabaseContextFactory.DefaultConnectionStringName);
         }
     }
 }
diff --git a/Shuttle.Core.Data/DatabaseContextScope.cs b/Shuttle.Core.Data/DatabaseContextScope.cs
@@ -1,27 +1,31 @@
 ﻿using System;
+using System.Collections.Generic;
 using System.Threading;
 
 namespace Shuttle.Core.Data
 {
     public class DatabaseContextScope : IDisposable
     {
+        private static readonly AsyncLocal<Stack<DatabaseContextCollection>> DatabaseContextCollectionStack = new AsyncLocal<Stack<DatabaseContextCollection>>();
         private static readonly AsyncLocal<DatabaseContextCollection> AmbientData = new AsyncLocal<DatabaseContextCollection>();
 
         public DatabaseContextScope()
         {
-            if (AmbientData.Value != null)
+            if (DatabaseContextCollectionStack.Value == null)
             {
-                throw new InvalidOperationException(Resources.AmbientScopeException);
+                DatabaseContextCollectionStack.Value = new Stack<DatabaseContextCollection>();
             }
 
+            DatabaseContextCollectionStack.Value.Push(AmbientData.Value);
+
             AmbientData.Value = new DatabaseContextCollection();
         }
 
         public static DatabaseContextCollection Current => AmbientData.Value;
 
         public void Dispose()
         {
-            AmbientData.Value = null;
+            AmbientData.Value = DatabaseContextCollectionStack.Value.Pop();
         }
     }
 }
diff --git a/Shuttle.Core.Data/Extensions/DatabaseContextFactoryExtensions.cs b/Shuttle.Core.Data/Extensions/DatabaseContextFactoryExtensions.cs
@@ -1,15 +1,12 @@
 ﻿using System;
-using System.Data;
-using System.Data.Common;
 using System.Threading;
 using Shuttle.Core.Contract;
 
 namespace Shuttle.Core.Data
 {
     public static class DatabaseContextFactoryExtensions
     {
-        public static bool IsAvailable(this IDatabaseContextFactory databaseContextFactory,
-            CancellationToken cancellationToken, int retries = 4, int secondsBetweenRetries = 15)
+        public static bool IsAvailable(this IDatabaseContextFactory databaseContextFactory, CancellationToken cancellationToken, int retries = 4, int secondsBetweenRetries = 15)
         {
             Guard.AgainstNull(databaseContextFactory, nameof(databaseContextFactory));
 
diff --git a/Shuttle.Core.Data/IDatabaseContextFactory.cs b/Shuttle.Core.Data/IDatabaseContextFactory.cs
diff --git a/Shuttle.Core.Data/Properties/AssemblyInfo.cs b/Shuttle.Core.Data/Properties/AssemblyInfo.cs
diff --git a/Shuttle.Core.Data/ServiceCollectionExtensions.cs b/Shuttle.Core.Data/ServiceCollectionExtensions.cs
diff --git a/Shuttle.Core.Data/Shuttle.Core.Data.csproj b/Shuttle.Core.Data/Shuttle.Core.Data.csproj

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Data.Common;`
`3`		`-using System.Threading;`
`4`	`3`	`using System.Threading.Tasks;`
`5`	`4`	`using Microsoft.Data.SqlClient;`
`6`	`5`	`using Moq;`
`@@ -17,7 +16,7 @@ public void Should_not_be_able_to_create_an_invalid_connection()`
`17`	`16`	`{`
`18`	`17`	`Assert.Throws<ArgumentException>(() =>`
`19`	`18`	`{`
`20`		- using (new DatabaseContext("context", "Microsoft.Data.SqlClient", new SqlConnection("```"), new Mock<IDbCommandFactory>().Object, DatabaseContextService, new SemaphoreSlim(1,1)))
	`19`	+ using (new DatabaseContext("context", "Microsoft.Data.SqlClient", new SqlConnection("```"), new Mock<IDbCommandFactory>().Object, DatabaseContextService))
`21`	`20`	`{`
`22`	`21`	`}`
`23`	`22`	`});`
`@@ -28,7 +27,7 @@ public void Should_not_be_able_to_create_a_non_existent_connection()`
`28`	`27`	`{`
`29`	`28`	`Assert.Throws<SqlException>(() =>`
`30`	`29`	`{`
`31`		`- using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", new SqlConnection("data source=.;initial catalog=idontexist;integrated security=sspi"), new Mock<IDbCommandFactory>().Object, DatabaseContextService, new SemaphoreSlim(0, 1)))`
	`30`	`+ using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", new SqlConnection("data source=.;initial catalog=idontexist;integrated security=sspi"), new Mock<IDbCommandFactory>().Object, DatabaseContextService))`
`32`	`31`	`{`
`33`	`32`	`databaseContext.CreateCommand(new Query("select 1"));`
`34`	`33`	`}`
`@@ -49,7 +48,7 @@ public async Task Should_be_able_to_begin_and_commit_a_transaction_async()`
`49`	`48`
`50`	`49`	`private async Task Should_be_able_to_begin_and_commit_a_transaction_async(bool sync)`
`51`	`50`	`{`
`52`		`- await using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, DatabaseContextService, new SemaphoreSlim(0, 1)))`
	`51`	`+ await using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, DatabaseContextService))`
`53`	`52`	`{`
`54`	`53`	`if (sync)`
`55`	`54`	`{`
`@@ -78,7 +77,7 @@ public async Task Should_be_able_to_begin_and_rollback_a_transaction_async()`
`78`	`77`
`79`	`78`	`private async Task Should_be_able_to_begin_and_rollback_a_transaction_async(bool sync)`
`80`	`79`	`{`
`81`		`- await using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, new DatabaseContextService(), new SemaphoreSlim(0, 1)))`
	`80`	`+ await using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, new DatabaseContextService()))`
`82`	`81`	`{`
`83`	`82`	`if (sync)`
`84`	`83`	`{`
`@@ -105,7 +104,7 @@ public async Task Should_be_able_to_call_commit_without_a_transaction_async()`
`105`	`104`
`106`	`105`	`private async Task Should_be_able_to_call_commit_without_a_transaction_async(bool sync)`
`107`	`106`	`{`
`108`		`- await using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, DatabaseContextService, new SemaphoreSlim(0, 1)))`
	`107`	`+ await using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, DatabaseContextService))`
`109`	`108`	`{`
`110`	`109`	`if (sync)`
`111`	`110`	`{`
`@@ -121,7 +120,7 @@ private async Task Should_be_able_to_call_commit_without_a_transaction_async(boo`
`121`	`120`	`[Test]`
`122`	`121`	`public void Should_be_able_to_call_dispose_more_than_once()`
`123`	`122`	`{`
`124`		`- using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, DatabaseContextService, new SemaphoreSlim(0, 1)))`
	`123`	`+ using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, DatabaseContextService))`
`125`	`124`	`{`
`126`	`125`	`databaseContext.Dispose();`
`127`	`126`	`databaseContext.Dispose();`
`@@ -138,7 +137,7 @@ public void Should_be_able_to_create_a_command()`
`138`	`137`
`139`	`138`	`dbCommandFactory.Setup(m => m.Create(dbConnection, query.Object)).Returns(dbCommand.Object);`
`140`	`139`
`141`		`- using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", dbConnection, dbCommandFactory.Object, DatabaseContextService, new SemaphoreSlim(0, 1)))`
	`140`	`+ using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", dbConnection, dbCommandFactory.Object, DatabaseContextService))`
`142`	`141`	`{`
`143`	`142`	`databaseContext.CreateCommand(query.Object);`
`144`	`143`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,5 @@ namespace Shuttle.Core.Data`
`5`	`5`	`public class DatabaseContextFactoryOptions`
`6`	`6`	`{`
`7`	`7`	`public string DefaultConnectionStringName { get; set; }`
`8`		`- public TimeSpan DefaultCreateTimeout { get; set; } = TimeSpan.FromSeconds(30);`
`9`	`8`	`}`
`10`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,21 +9,19 @@ namespace Shuttle.Core.Data`
`9`	`9`	`{`
`10`	`10`	`public class DatabaseContext : IDatabaseContext`
`11`	`11`	`{`
`12`		`- private readonly SemaphoreSlim _lock;`
`13`	`12`	`private readonly IDatabaseContextService _databaseContextService;`
`14`	`13`	`private readonly IDbCommandFactory _dbCommandFactory;`
`15`	`14`	`private readonly IDbConnection _dbConnection;`
`16`	`15`	`private bool _disposed;`
`17`	`16`
`18`		`- public DatabaseContext(string name, string providerName, IDbConnection dbConnection, IDbCommandFactory dbCommandFactory, IDatabaseContextService databaseContextService, SemaphoreSlim semaphoreSlim)`
	`17`	`+ public DatabaseContext(string name, string providerName, IDbConnection dbConnection, IDbCommandFactory dbCommandFactory, IDatabaseContextService databaseContextService)`
`19`	`18`	`{`
`20`	`19`	`Name = Guard.AgainstNullOrEmptyString(name, nameof(name));`
`21`	`20`	`ProviderName = Guard.AgainstNullOrEmptyString(providerName, "providerName");`
`22`	`21`
`23`	`22`	`_dbCommandFactory = Guard.AgainstNull(dbCommandFactory, nameof(dbCommandFactory));`
`24`	`23`	`_databaseContextService = Guard.AgainstNull(databaseContextService, nameof(databaseContextService));`
`25`	`24`	`_dbConnection = Guard.AgainstNull(dbConnection, nameof(dbConnection));`
`26`		`- _lock = Guard.AgainstNull(semaphoreSlim, nameof(semaphoreSlim));`
`27`	`25`
`28`	`26`	`_databaseContextService.Add(this);`
`29`	`27`	`}`
`@@ -105,7 +103,6 @@ public void Dispose()`
`105`	`103`	`}`
`106`	`104`	`finally`
`107`	`105`	`{`
`108`		`- _lock.Release();`
`109`	`106`	`_disposed = true;`
`110`	`107`	`}`
`111`	`108`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,6 @@ public class DatabaseContextFactory : IDatabaseContextFactory`
`16`	`16`
`17`	`17`	`private readonly IDbConnectionFactory _dbConnectionFactory;`
`18`	`18`	`private readonly SemaphoreSlim _lock = new SemaphoreSlim(1, 1);`
`19`		`- private readonly Dictionary<string, SemaphoreSlim> _semaphores = new Dictionary<string, SemaphoreSlim>();`
`20`	`19`
`21`	`20`	`public DatabaseContextFactory(IOptionsMonitor<ConnectionStringOptions> connectionStringOptions, IOptions<DataAccessOptions> dataAccessOptions, IDbConnectionFactory dbConnectionFactory, IDbCommandFactory dbCommandFactory, IDatabaseContextService databaseContextService)`
`22`	`21`	`{`
`@@ -32,22 +31,12 @@ public DatabaseContextFactory(IOptionsMonitor<ConnectionStringOptions> connectio`
`32`	`31`
`33`	`32`	`public event EventHandler<DatabaseContextEventArgs> DatabaseContextCreated;`
`34`	`33`
`35`		`- public IDatabaseContext Create(string connectionStringName, TimeSpan? timeout = null)`
	`34`	`+ public IDatabaseContext Create(string connectionStringName)`
`36`	`35`	`{`
`37`	`36`	`Guard.AgainstNullOrEmptyString(connectionStringName, nameof(connectionStringName));`
`38`	`37`
`39`	`38`	`_lock.Wait();`
`40`	`39`
`41`		`- if (!_semaphores.ContainsKey(connectionStringName))`
`42`		`- {`
`43`		`- _semaphores.Add(connectionStringName, new SemaphoreSlim(1, 1));`
`44`		`- }`
`45`		`-`
`46`		`- if (!_semaphores[connectionStringName].Wait(timeout ?? _dataAccessOptions.DatabaseContextFactory.DefaultCreateTimeout))`
`47`		`- {`
`48`		`- throw new TimeoutException(string.Format(Resources.DatabaseContextFactoryTimeoutException, connectionStringName, timeout ?? _dataAccessOptions.DatabaseContextFactory.DefaultCreateTimeout));`
`49`		`- }`
`50`		`-`
`51`	`40`	`try`
`52`	`41`	`{`
`53`	`42`	`var connectionStringOptions = _connectionStringOptions.Get(connectionStringName);`
`@@ -62,7 +51,7 @@ public IDatabaseContext Create(string connectionStringName, TimeSpan? timeout =`
`62`	`51`	`throw new InvalidOperationException(string.Format(Resources.DuplicateDatabaseContextException, connectionStringName));`
`63`	`52`	`}`
`64`	`53`
`65`		`- var databaseContext = new DatabaseContext(connectionStringName, connectionStringOptions.ProviderName, (DbConnection)_dbConnectionFactory.Create(connectionStringOptions.ProviderName, connectionStringOptions.ConnectionString), _dbCommandFactory, _databaseContextService, _semaphores[connectionStringName]);`
	`54`	`+ var databaseContext = new DatabaseContext(connectionStringName, connectionStringOptions.ProviderName, (DbConnection)_dbConnectionFactory.Create(connectionStringOptions.ProviderName, connectionStringOptions.ConnectionString), _dbCommandFactory, _databaseContextService);`
`66`	`55`
`67`	`56`	`DatabaseContextCreated?.Invoke(this, new DatabaseContextEventArgs(databaseContext));`
`68`	`57`
`@@ -74,14 +63,14 @@ public IDatabaseContext Create(string connectionStringName, TimeSpan? timeout =`
`74`	`63`	`}`
`75`	`64`	`}`
`76`	`65`
`77`		`- public IDatabaseContext Create(TimeSpan? timeout = null)`
	`66`	`+ public IDatabaseContext Create()`
`78`	`67`	`{`
`79`	`68`	`if (string.IsNullOrEmpty(_dataAccessOptions.DatabaseContextFactory.DefaultConnectionStringName))`
`80`	`69`	`{`
`81`	`70`	`throw new InvalidOperationException(Resources.DatabaseContextFactoryOptionsException);`
`82`	`71`	`}`
`83`	`72`
`84`		`- return Create(_dataAccessOptions.DatabaseContextFactory.DefaultConnectionStringName, timeout);`
	`73`	`+ return Create(_dataAccessOptions.DatabaseContextFactory.DefaultConnectionStringName);`
`85`	`74`	`}`
`86`	`75`	`}`
`87`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,27 +1,31 @@`
`1`	`1`	`using System;`
	`2`	`+using System.Collections.Generic;`
`2`	`3`	`using System.Threading;`
`3`	`4`
`4`	`5`	`namespace Shuttle.Core.Data`
`5`	`6`	`{`
`6`	`7`	`public class DatabaseContextScope : IDisposable`
`7`	`8`	`{`
	`9`	`+ private static readonly AsyncLocal<Stack<DatabaseContextCollection>> DatabaseContextCollectionStack = new AsyncLocal<Stack<DatabaseContextCollection>>();`
`8`	`10`	`private static readonly AsyncLocal<DatabaseContextCollection> AmbientData = new AsyncLocal<DatabaseContextCollection>();`
`9`	`11`
`10`	`12`	`public DatabaseContextScope()`
`11`	`13`	`{`
`12`		`- if (AmbientData.Value != null)`
	`14`	`+ if (DatabaseContextCollectionStack.Value == null)`
`13`	`15`	`{`
`14`		`- throw new InvalidOperationException(Resources.AmbientScopeException);`
	`16`	`+ DatabaseContextCollectionStack.Value = new Stack<DatabaseContextCollection>();`
`15`	`17`	`}`
`16`	`18`
	`19`	`+ DatabaseContextCollectionStack.Value.Push(AmbientData.Value);`
	`20`	`+`
`17`	`21`	`AmbientData.Value = new DatabaseContextCollection();`
`18`	`22`	`}`
`19`	`23`
`20`	`24`	`public static DatabaseContextCollection Current => AmbientData.Value;`
`21`	`25`
`22`	`26`	`public void Dispose()`
`23`	`27`	`{`
`24`		`- AmbientData.Value = null;`
	`28`	`+ AmbientData.Value = DatabaseContextCollectionStack.Value.Pop();`
`25`	`29`	`}`
`26`	`30`	`}`
`27`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,15 +1,12 @@`
`1`	`1`	`using System;`
`2`		`-using System.Data;`
`3`		`-using System.Data.Common;`
`4`	`2`	`using System.Threading;`
`5`	`3`	`using Shuttle.Core.Contract;`
`6`	`4`
`7`	`5`	`namespace Shuttle.Core.Data`
`8`	`6`	`{`
`9`	`7`	`public static class DatabaseContextFactoryExtensions`
`10`	`8`	`{`
`11`		`- public static bool IsAvailable(this IDatabaseContextFactory databaseContextFactory,`
`12`		`- CancellationToken cancellationToken, int retries = 4, int secondsBetweenRetries = 15)`
	`9`	`+ public static bool IsAvailable(this IDatabaseContextFactory databaseContextFactory, CancellationToken cancellationToken, int retries = 4, int secondsBetweenRetries = 15)`
`13`	`10`	`{`
`14`	`11`	`Guard.AgainstNull(databaseContextFactory, nameof(databaseContextFactory));`
`15`	`12`