New ambient data implementation

Author: eben-roux

README.md

@@ -61,20 +61,17 @@ The default JSON settings structure is as follows:
 }
 ```
 
-# IDatabaseContextService
+# DatabaseContextScope
 
-The `DatabaseContextService` provides ambient access to the current `IDatabaseContext` instance.  This is useful in situations where you do not want to pass the `IDatabaseContext` instance around.
+The `DatabaseContextService` contains a collection of the `DatabaseContext` instances created by `IDatabaseContextFactory`.  However, these will not be flowed across async contexts.  
 
-``` c#
-event EventHandler<DatabaseContextAsyncLocalValueChangedEventArgs> DatabaseContextAsyncLocalValueChanged;
-
-event EventHandler<DatabaseContextAsyncLocalValueAssignedEventArgs> DatabaseContextAsyncLocalValueAssigned;
-```
-
-Attach delegates to the above events should you wish to track ambient data changes.
+To enable async context flow wrap the initial database context creation in a `using` statement:
 
 ``` c#
-void BeginScope()
+using (new DatabaseContextScope())
+{
+	// database interaction
+})
 ```
 
 # IDatabaseContextFactory
@@ -83,17 +80,21 @@ In order to access a database we need a database connection.  A database connect
 
 The `DatabaseContextFactory` implementation makes use of an `IDbConnectionFactory` implementation which creates a `System.Data.IDbConnection` by using the provider name and connection string, which is obtained from the registered connection name.  An `IDbCommandFactory` creates a `System.Data.IDbCommand` by using an `IDbConnection` instance.
 
-Before any database context can be created a scope must be started.  This is typically done in the integration/application layer (controller/minimal API methods, message handlers).  Nested scopes are not permitted as the ambient context will flow across any `async` methods.
-
 ``` c#
-var databaseContextService = provider.GetRequiredService<IDatabaseContextService>();
 var databaseContextFactory = provider.GetRequiredService<IDatabaseContextFactory>();
 
-using (databaseContextService.BeginScope()) // <-- will configure the scope (cannot be nested)
 using (var databaseContext = databaseContextFactory.Create("connection-name"))
 {
 	// database interaction
 }
+
+// or, in async/await implementations
+
+using (new DatabaseContextScope())
+using (var databaseContext = databaseContextFactory.Create("connection-name"))
+{
+	// database interaction that will flow across threads
+}
 ```
 
 # IQuery

Shuttle.Core.Data.Tests/AsyncFixture.cs

@@ -1,7 +1,6 @@
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Extensions.DependencyInjection;
 using NUnit.Framework;
 
 namespace Shuttle.Core.Data.Tests;
@@ -22,20 +21,17 @@ public void Should_be_able_to_use_the_different_database_context_for_separate_th
     {
         var threads = new List<Thread>();
 
-        using (DatabaseContextService.BeginScope())
-        {
-            var databaseContext = DatabaseContextService.Find(context => context.Name.Equals(DefaultConnectionStringName));
+        var databaseContext = DatabaseContextService.Find(context => context.Name.Equals(DefaultConnectionStringName));
 
-            Assert.That(databaseContext, Is.Null);
-        }
+        Assert.That(databaseContext, Is.Null);
 
         for (var i = 0; i < 10; i++)
         {
             using (ExecutionContext.SuppressFlow())
             {
                 threads.Add(new Thread(() =>
                 {
-                    using (DatabaseContextService.BeginScope())
+                    using (new DatabaseContextScope())
                     using (DatabaseContextFactory.Create())
                     {
                         DatabaseGateway.GetRowsAsync(_rowsQuery);
@@ -64,7 +60,7 @@ public void Should_be_able_to_use_the_different_database_context_for_separate_ta
         {
             tasks.Add(Task.Run(() =>
             {
-                using (DatabaseContextService.BeginScope())
+                using (new DatabaseContextScope())
                 using (DatabaseContextFactory.Create())
                 {
                     DatabaseGateway.GetRowsAsync(_rowsQuery);
@@ -80,7 +76,6 @@ public void Should_be_able_to_use_the_same_database_context_across_tasks()
     {
         var tasks = new List<Task>();
 
-        using (DatabaseContextService.BeginScope())
         using (DatabaseContextFactory.Create())
         {
             for (var i = 0; i < 10; i++)
@@ -95,7 +90,6 @@ public void Should_be_able_to_use_the_same_database_context_across_tasks()
     [Test]
     public async Task Should_be_able_to_use_the_same_database_context_across_synchronized_tasks_async()
     {
-        using (DatabaseContextService.BeginScope())
         await using (DatabaseContextFactory.Create())
         {
             await GetRowsAsync(0);

Shuttle.Core.Data.Tests/DatabaseContextFactoryFixture.cs

@@ -12,7 +12,6 @@ public class DatabaseContextFactoryFixture : Fixture
     [Test]
     public void Should_be_able_to_create_a_database_context()
     {
-        using (DatabaseContextService.BeginScope())
         using (var context = DatabaseContextFactory.Create(DefaultConnectionStringName))
         {
             Assert.IsNotNull(context);
@@ -24,7 +23,6 @@ public void Should_not_not_be_able_to_create_another_context_with_the_same_name_
     {
         var factory = DatabaseContextFactory;
 
-        using (DatabaseContextService.BeginScope())
         using (factory.Create(DefaultConnectionStringName))
         {
             Assert.That(()=> factory.Create(DefaultConnectionStringName), Throws.InvalidOperationException);

Shuttle.Core.Data.Tests/DatabaseContextFixture.cs

@@ -27,7 +27,6 @@ public void Should_not_be_able_to_create_a_non_existent_connection()
     {
         Assert.Throws<SqlException>(() =>
         {
-            using (DatabaseContextService.BeginScope())
             using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", new SqlConnection("data source=.;initial catalog=idontexist;integrated security=sspi"),
                        new Mock<IDbCommandFactory>().Object, DatabaseContextService))
             {
@@ -50,7 +49,6 @@ 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)
     {
-        using (DatabaseContextService.BeginScope())
         await using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, DatabaseContextService))
         {
             if (sync)
@@ -80,7 +78,6 @@ 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)
     {
-        using (DatabaseContextService.BeginScope())
         await using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, new DatabaseContextService()))
         {
             if (sync)
@@ -108,7 +105,6 @@ 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)
     {
-        using (DatabaseContextService.BeginScope())
         await using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, DatabaseContextService))
         {
             if (sync)
@@ -125,7 +121,6 @@ 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 (DatabaseContextService.BeginScope())
         using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", DbConnectionFactory.Create(DefaultProviderName, DefaultConnectionString), new Mock<IDbCommandFactory>().Object, DatabaseContextService))
         {
             databaseContext.Dispose();
@@ -143,7 +138,6 @@ public void Should_be_able_to_create_a_command()
 
         dbCommandFactory.Setup(m => m.Create(dbConnection, query.Object)).Returns(dbCommand.Object);
 
-        using (DatabaseContextService.BeginScope())
         using (var databaseContext = new DatabaseContext("context", "Microsoft.Data.SqlClient", dbConnection, dbCommandFactory.Object, DatabaseContextService))
         {
             databaseContext.CreateCommand(query.Object);

Shuttle.Core.Data.Tests/DatabaseContextServiceFixture.cs

@@ -11,31 +11,28 @@ public void Should_be_able_to_use_different_contexts()
     {
         var service = new DatabaseContextService();
 
-        using (service.BeginScope())
-        {
-            var context1 = new DatabaseContext("mock-1", "provider-name", new Mock<DbConnection>().Object, new Mock<IDbCommandFactory>().Object, service);
+        var context1 = new DatabaseContext("mock-1", "provider-name", new Mock<DbConnection>().Object, new Mock<IDbCommandFactory>().Object, service);
 
-            Assert.That(service.Current.Key, Is.EqualTo(context1.Key));
+        Assert.That(service.Current.Key, Is.EqualTo(context1.Key));
 
-            var context2 = new DatabaseContext("mock-2", "provider-name", new Mock<DbConnection>().Object, new Mock<IDbCommandFactory>().Object, service);
+        var context2 = new DatabaseContext("mock-2", "provider-name", new Mock<DbConnection>().Object, new Mock<IDbCommandFactory>().Object, service);
 
-            Assert.That(service.Current.Key, Is.EqualTo(context2.Key));
+        Assert.That(service.Current.Key, Is.EqualTo(context2.Key));
 
-            service.Activate("mock-1");
+        service.Activate("mock-1");
 
-            Assert.That(service.Current.Key, Is.EqualTo(context1.Key));
+        Assert.That(service.Current.Key, Is.EqualTo(context1.Key));
 
-            service.Activate("mock-2");
+        service.Activate("mock-2");
 
-            Assert.That(service.Current.Key, Is.EqualTo(context2.Key));
+        Assert.That(service.Current.Key, Is.EqualTo(context2.Key));
 
-            service.Activate(context1);
+        service.Activate(context1);
 
-            Assert.That(service.Current.Key, Is.EqualTo(context1.Key));
+        Assert.That(service.Current.Key, Is.EqualTo(context1.Key));
 
-            service.Activate(context2);
+        service.Activate(context2);
 
-            Assert.That(service.Current.Key, Is.EqualTo(context2.Key));
-        }
+        Assert.That(service.Current.Key, Is.EqualTo(context2.Key));
     }
 }

Shuttle.Core.Data.Tests/Mapping/DataRowMapperFixture.cs

@@ -40,7 +40,6 @@ select top 1
     BasicMapping
 ");
 
-        using (DatabaseContextService.BeginScope())
         await using (DatabaseContextFactory.Create())
         {
             var item = sync
@@ -101,7 +100,6 @@ Age as TheAge
     BasicMapping
 ");
 
-        using (DatabaseContextService.BeginScope())
         await using (DatabaseContextFactory.Create())
         {
             var item = sync
@@ -159,7 +157,6 @@ select top 1
     BasicMapping
 ");
 
-        using (DatabaseContextService.BeginScope())
         await using (DatabaseContextFactory.Create())
         {
             var value = sync
@@ -216,7 +213,6 @@ private async Task Should_be_able_to_perform_dynamic_mapping_async(bool sync)
     BasicMapping
 ");
 
-        using (DatabaseContextService.BeginScope())
         await using (DatabaseContextFactory.Create())
         {
             var item = sync

Shuttle.Core.Data.Tests/Mapping/MappingFixture.cs

@@ -8,7 +8,6 @@ public class MappingFixture : Fixture
     [SetUp]
     public async Task SetUp()
     {
-        using (DatabaseContextService.BeginScope())
         using (DatabaseContextFactory.Create())
         {
             await DatabaseGateway.ExecuteAsync(new Query(@"

Shuttle.Core.Data.Tests/Mapping/QueryMapperFixture.cs

@@ -42,7 +42,6 @@ select top 1
     BasicMapping
 ");
 
-        using (DatabaseContextService.BeginScope())
         await using (DatabaseContextFactory.Create())
         {
             var item = sync
@@ -103,7 +102,6 @@ Age as TheAge
     BasicMapping
 ");
 
-        using (DatabaseContextService.BeginScope())
         await using (DatabaseContextFactory.Create())
         {
             var item = await mapper.MapObjectAsync<BasicMapping>(queryRow);
@@ -150,7 +148,6 @@ select top 1
     BasicMapping
 ");
 
-        using (DatabaseContextService.BeginScope())
         await using (DatabaseContextFactory.Create())
         {
             var value = sync
@@ -200,7 +197,6 @@ select top 1
     BasicMapping
 ");
 
-        using (DatabaseContextService.BeginScope())
         await using (DatabaseContextFactory.Create())
         {
             var item = sync

Shuttle.Core.Data/.package/package.nuspec

@@ -3,7 +3,7 @@
 <package>
 	<metadata>
 		<id>Shuttle.Core.Data</id>
-		<version>16.0.1</version>
+		<version>16.0.2</version>
 		<authors>Eben Roux</authors>
 		<owners>Eben Roux</owners>
 		<license type="expression">BSD-3-Clause</license>

Shuttle.Core.Data/DatabaseContextAsyncLocalValueAssignedEventArgs.cs

@@ -3,7 +3,7 @@
 
 namespace Shuttle.Core.Data
 {
-    public class DatabaseContextAmbientData
+    public class DatabaseContextCollection
     {
         public IEnumerable<IDatabaseContext> DatabaseContexts => _databaseContexts.AsReadOnly();
 

Shuttle.Core.Data/DatabaseContextAsyncValueEventArgs.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Threading;
+
+namespace Shuttle.Core.Data
+{
+    public class DatabaseContextScope : IDisposable
+    {
+        private static readonly AsyncLocal<DatabaseContextCollection> AmbientData = new AsyncLocal<DatabaseContextCollection>();
+
+        public DatabaseContextScope()
+        {
+            if (AmbientData.Value != null)
+            {
+                throw new InvalidOperationException(Resources.AmbientScopeException);
+            }
+
+            AmbientData.Value = new DatabaseContextCollection();
+        }
+
+        public static DatabaseContextCollection Current => AmbientData.Value;
+
+        public void Dispose()
+        {
+            AmbientData.Value = null;
+        }
+    }
+}