Merge pull request #12 from Shuttle/no-blocking

eben-roux · web-flow · commit aecbd0dd61f5 · 2024-07-21T15:58:37.000+02:00
Removed  blocking implementation as DatabaseContext does not need to be thread-safe.
diff --git a/README.md b/README.md
@@ -8,6 +8,8 @@ Provides an abstraction built directly on ADO.NET which falls within the Micro O
 
 # Overview
 
+***NOTE:*** Since a database connection is represented by a `IDatabaseContext` instance it is important to understand that this instance is not thread-safe.  It is therefore important to ensure that the `IDatabaseContext` instance is not shared between threads.  See the `DatabaseContextScope` to ensure thread-safe database context flow.
+
 The `Shuttle.Core.Data` package provides a thin abstraction over ADO.NET by making use of the `DbProviderFactories`.  Even though it provides object/relational mapping mechanisms it is in no way a fully fledged ORM.
 
 ## Configuration
diff --git a/Shuttle.Core.Data.Tests/AsyncFixture.cs b/Shuttle.Core.Data.Tests/AsyncFixture.cs
@@ -71,22 +71,6 @@ public void Should_be_able_to_use_the_different_database_context_for_separate_ta
         Task.WaitAll(tasks.ToArray());
     }
 
-    [Test]
-    public void Should_be_able_to_use_the_same_database_context_across_tasks()
-    {
-        var tasks = new List<Task>();
-
-        using (DatabaseContextFactory.Create())
-        {
-            for (var i = 0; i < 10; i++)
-            {
-                tasks.Add(DatabaseGateway.GetRowsAsync(_rowsQuery));
-            }
-
-            Task.WaitAll(tasks.ToArray());
-        }
-    }
-
     [Test]
     public async Task Should_be_able_to_use_the_same_database_context_across_synchronized_tasks_async()
     {
diff --git a/Shuttle.Core.Data.Tests/DbCommandFactoryFixture.cs b/Shuttle.Core.Data.Tests/DbCommandFactoryFixture.cs
@@ -1,4 +1,5 @@
 ﻿using System.Data;
+using System.Data.Common;
 using Microsoft.Extensions.Options;
 using Moq;
 using NUnit.Framework;
@@ -14,7 +15,7 @@ public void Should_be_able_to_create_a_command()
             var factory = new DbCommandFactory(Options.Create(new DataAccessOptions { CommandTimeout = 15 }));
             var connection = new Mock<IDbConnection>();
             var query = new Mock<IQuery>();
-            var command = new Mock<IDbCommand>();
+            var command = new Mock<DbCommand>();
 
             command.SetupSet(m => m.CommandTimeout = 15).Verifiable("CommandTimeout not set to 15");
 
diff --git a/Shuttle.Core.Data/BlockedDbCommand.cs b/Shuttle.Core.Data/BlockedDbCommand.cs
diff --git a/Shuttle.Core.Data/BlockedDbConnection.cs b/Shuttle.Core.Data/BlockedDbConnection.cs
diff --git a/Shuttle.Core.Data/BlockedDbDataReader.cs b/Shuttle.Core.Data/BlockedDbDataReader.cs
diff --git a/Shuttle.Core.Data/DatabaseContext.cs b/Shuttle.Core.Data/DatabaseContext.cs
@@ -1,21 +1,16 @@
 using System;
 using System.Data;
 using System.Data.Common;
-using System.Threading;
 using System.Threading.Tasks;
 using Shuttle.Core.Contract;
-using Shuttle.Core.Threading;
 
 namespace Shuttle.Core.Data
 {
     public class DatabaseContext : IDatabaseContext
     {
         private readonly IDatabaseContextService _databaseContextService;
         private readonly IDbCommandFactory _dbCommandFactory;
-        private readonly SemaphoreSlim _dbCommandLock = new SemaphoreSlim(1, 1);
         private readonly IDbConnection _dbConnection;
-        private readonly SemaphoreSlim _dbConnectionLock = new SemaphoreSlim(1, 1);
-        private readonly SemaphoreSlim _dbDataReaderLock = new SemaphoreSlim(1, 1);
         private bool _disposed;
 
         public DatabaseContext(string name, string providerName, IDbConnection dbConnection, IDbCommandFactory dbCommandFactory, IDatabaseContextService databaseContextService)
@@ -39,27 +34,23 @@ public DatabaseContext(string name, string providerName, IDbConnection dbConnect
 
         public Guid Key { get; }
         public string Name { get; }
-        public IDbTransaction Transaction { get; private set; }
+        public DbTransaction Transaction { get; private set; }
         public string ProviderName { get; }
 
-        public BlockedDbCommand CreateCommand(IQuery query)
+        public DbCommand CreateCommand(IQuery query)
         {
             GuardDisposed();
 
-            _dbCommandLock.Wait(CancellationToken.None);
-
             var command = _dbCommandFactory.Create(GetOpenConnectionAsync(true).GetAwaiter().GetResult(), Guard.AgainstNull(query, nameof(query)));
 
             command.Transaction = Transaction;
 
-            return new BlockedDbCommand((DbCommand)command, new BlockingSemaphoreSlim(_dbCommandLock), _dbDataReaderLock);
+            return command;
         }
 
-        public BlockedDbConnection GetDbConnection()
+        public IDbConnection GetDbConnection()
         {
-            _dbConnectionLock.Wait(CancellationToken.None);
-
-            return new BlockedDbConnection(GetOpenConnectionAsync(true).GetAwaiter().GetResult(), new BlockingSemaphoreSlim(_dbConnectionLock));
+            return GetOpenConnectionAsync(true).GetAwaiter().GetResult();
         }
 
         public bool HasTransaction => Transaction != null;
@@ -112,6 +103,13 @@ public void Dispose()
             Disposed?.Invoke(this, EventArgs.Empty);
         }
 
+        public async ValueTask DisposeAsync()
+        {
+            Dispose();
+
+            await new ValueTask();
+        }
+
         private async Task<IDatabaseContext> BeginTransactionAsync(IsolationLevel isolationLevel, bool sync)
         {
             if (HasTransaction || System.Transactions.Transaction.Current != null)
@@ -180,12 +178,5 @@ private void GuardDisposed()
 
             throw new ObjectDisposedException(nameof(DatabaseContext));
         }
-
-        public async ValueTask DisposeAsync()
-        {
-            Dispose();
-
-            await new ValueTask();
-        }
     }
 }
diff --git a/Shuttle.Core.Data/DatabaseContextService.cs b/Shuttle.Core.Data/DatabaseContextService.cs
@@ -109,12 +109,7 @@ public IDatabaseContext Find(Predicate<IDatabaseContext> match)
 
         private DatabaseContextCollection GetDatabaseContextCollection()
         {
-            if (DatabaseContextScope.Current == null)
-            {
-                return _databaseContextCollection;
-            }
-
-            return DatabaseContextScope.Current;
+            return DatabaseContextScope.Current ?? _databaseContextCollection;
         }
     }
 }
diff --git a/Shuttle.Core.Data/DatabaseGateway.cs b/Shuttle.Core.Data/DatabaseGateway.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Data;
+using System.Data.Common;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -35,7 +36,7 @@ private async Task<DataTable> GetDataTableAsync(IQuery query, CancellationToken
 
             using (var reader = sync ? GetReader(query, cancellationToken) : await GetReaderAsync(query, cancellationToken).ConfigureAwait(false))
             {
-                results.Load(reader.DbDataReader);
+                results.Load(reader);
             }
 
             return results;
@@ -74,17 +75,17 @@ private async Task<DataRow> GetRowAsync(IQuery query, CancellationToken cancella
             return table.Rows[0];
         }
 
-        public BlockedDbDataReader GetReader(IQuery query, CancellationToken cancellationToken = default)
+        public DbDataReader GetReader(IQuery query, CancellationToken cancellationToken = default)
         {
             return GetReaderAsync(query, cancellationToken, true).GetAwaiter().GetResult();
         }
 
-        public async Task<BlockedDbDataReader> GetReaderAsync(IQuery query, CancellationToken cancellationToken = default)
+        public async Task<DbDataReader> GetReaderAsync(IQuery query, CancellationToken cancellationToken = default)
         {
             return await GetReaderAsync(query, cancellationToken, false).ConfigureAwait(false);
         }
 
-        private async Task<BlockedDbDataReader> GetReaderAsync(IQuery query, CancellationToken cancellationToken, bool sync)
+        private async Task<DbDataReader> GetReaderAsync(IQuery query, CancellationToken cancellationToken, bool sync)
         {
             Guard.AgainstNull(query, nameof(query));
 
diff --git a/Shuttle.Core.Data/DbCommandFactory.cs b/Shuttle.Core.Data/DbCommandFactory.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Data;
+using System.Data.Common;
 using Microsoft.Extensions.Options;
 using Shuttle.Core.Contract;
 
@@ -18,7 +19,7 @@ public DbCommandFactory(IOptions<DataAccessOptions> options)
 
 	    public event EventHandler<DbCommandCreatedEventArgs> DbCommandCreated;
 
-	    public IDbCommand Create(IDbConnection connection, IQuery query)
+	    public DbCommand Create(IDbConnection connection, IQuery query)
         {
             var command = Guard.AgainstNull(connection, nameof(connection)).CreateCommand();
 
@@ -28,7 +29,7 @@ public IDbCommand Create(IDbConnection connection, IQuery query)
 
             DbCommandCreated?.Invoke(this, new DbCommandCreatedEventArgs(command));
 
-            return command;
+            return (DbCommand)command;
         }
     }
 }
diff --git a/Shuttle.Core.Data/IDatabaseContext.cs b/Shuttle.Core.Data/IDatabaseContext.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Data;
+using System.Data.Common;
 using System.Threading.Tasks;
 using IsolationLevel = System.Data.IsolationLevel;
 
@@ -15,9 +16,9 @@ public interface IDatabaseContext : IDisposable, IAsyncDisposable
 	    Guid Key { get; }
 		string Name { get; }
 
-		IDbTransaction Transaction { get; }
-		BlockedDbCommand CreateCommand(IQuery query);
-		BlockedDbConnection GetDbConnection();
+		DbTransaction Transaction { get; }
+		DbCommand CreateCommand(IQuery query);
+		IDbConnection GetDbConnection();
 
         bool HasTransaction { get; }
         string ProviderName { get; }
diff --git a/Shuttle.Core.Data/IDatabaseGateway.cs b/Shuttle.Core.Data/IDatabaseGateway.cs
@@ -1,20 +1,21 @@
 using System.Collections.Generic;
 using System.Data;
+using System.Data.Common;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace Shuttle.Core.Data
 {
     public interface IDatabaseGateway
     {
-	    BlockedDbDataReader GetReader(IQuery query, CancellationToken cancellationToken = default);
+	    DbDataReader GetReader(IQuery query, CancellationToken cancellationToken = default);
 	    int Execute(IQuery query, CancellationToken cancellationToken = default);
 	    T GetScalar<T>(IQuery query, CancellationToken cancellationToken = default);
 	    DataTable GetDataTable(IQuery query, CancellationToken cancellationToken = default);
 	    IEnumerable<DataRow> GetRows(IQuery query, CancellationToken cancellationToken = default);
 	    DataRow GetRow(IQuery query, CancellationToken cancellationToken = default);
 	    
-	    Task<BlockedDbDataReader> GetReaderAsync(IQuery query, CancellationToken cancellationToken = default);
+	    Task<DbDataReader> GetReaderAsync(IQuery query, CancellationToken cancellationToken = default);
 		Task<int> ExecuteAsync(IQuery query, CancellationToken cancellationToken = default);
         Task<T> GetScalarAsync<T>(IQuery query, CancellationToken cancellationToken = default);
         Task<DataTable> GetDataTableAsync(IQuery query, CancellationToken cancellationToken = default);
diff --git a/Shuttle.Core.Data/IDbCommandFactory.cs b/Shuttle.Core.Data/IDbCommandFactory.cs
@@ -1,12 +1,13 @@
 using System;
 using System.Data;
+using System.Data.Common;
 
 namespace Shuttle.Core.Data
 {
 	public interface IDbCommandFactory
     {
         event EventHandler<DbCommandCreatedEventArgs> DbCommandCreated;
 
-        IDbCommand Create(IDbConnection connection, IQuery query);
+        DbCommand Create(IDbConnection connection, IQuery query);
     }
 }
diff --git a/Shuttle.Core.Data/QueryMapper.cs b/Shuttle.Core.Data/QueryMapper.cs

Original file line number	Diff line number	Diff line change
`@@ -109,12 +109,7 @@ public IDatabaseContext Find(Predicate<IDatabaseContext> match)`
`109`	`109`
`110`	`110`	`private DatabaseContextCollection GetDatabaseContextCollection()`
`111`	`111`	`{`
`112`		`- if (DatabaseContextScope.Current == null)`
`113`		`- {`
`114`		`- return _databaseContextCollection;`
`115`		`- }`
`116`		`-`
`117`		`- return DatabaseContextScope.Current;`
	`112`	`+ return DatabaseContextScope.Current ?? _databaseContextCollection;`
`118`	`113`	`}`
`119`	`114`	`}`
`120`	`115`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
`3`	`3`	`using System.Data;`
	`4`	`+using System.Data.Common;`
`4`	`5`	`using System.Linq;`
`5`	`6`	`using System.Threading;`
`6`	`7`	`using System.Threading.Tasks;`
`@@ -35,7 +36,7 @@ private async Task<DataTable> GetDataTableAsync(IQuery query, CancellationToken`
`35`	`36`
`36`	`37`	`using (var reader = sync ? GetReader(query, cancellationToken) : await GetReaderAsync(query, cancellationToken).ConfigureAwait(false))`
`37`	`38`	`{`
`38`		`- results.Load(reader.DbDataReader);`
	`39`	`+ results.Load(reader);`
`39`	`40`	`}`
`40`	`41`
`41`	`42`	`return results;`
`@@ -74,17 +75,17 @@ private async Task<DataRow> GetRowAsync(IQuery query, CancellationToken cancella`
`74`	`75`	`return table.Rows[0];`
`75`	`76`	`}`
`76`	`77`
`77`		`- public BlockedDbDataReader GetReader(IQuery query, CancellationToken cancellationToken = default)`
	`78`	`+ public DbDataReader GetReader(IQuery query, CancellationToken cancellationToken = default)`
`78`	`79`	`{`
`79`	`80`	`return GetReaderAsync(query, cancellationToken, true).GetAwaiter().GetResult();`
`80`	`81`	`}`
`81`	`82`
`82`		`- public async Task<BlockedDbDataReader> GetReaderAsync(IQuery query, CancellationToken cancellationToken = default)`
	`83`	`+ public async Task<DbDataReader> GetReaderAsync(IQuery query, CancellationToken cancellationToken = default)`
`83`	`84`	`{`
`84`	`85`	`return await GetReaderAsync(query, cancellationToken, false).ConfigureAwait(false);`
`85`	`86`	`}`
`86`	`87`
`87`		`- private async Task<BlockedDbDataReader> GetReaderAsync(IQuery query, CancellationToken cancellationToken, bool sync)`
	`88`	`+ private async Task<DbDataReader> GetReaderAsync(IQuery query, CancellationToken cancellationToken, bool sync)`
`88`	`89`	`{`
`89`	`90`	`Guard.AgainstNull(query, nameof(query));`
`90`	`91`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Data;`
	`3`	`+using System.Data.Common;`
`3`	`4`	`using Microsoft.Extensions.Options;`
`4`	`5`	`using Shuttle.Core.Contract;`
`5`	`6`
`@@ -18,7 +19,7 @@ public DbCommandFactory(IOptions<DataAccessOptions> options)`
`18`	`19`
`19`	`20`	`public event EventHandler<DbCommandCreatedEventArgs> DbCommandCreated;`
`20`	`21`
`21`		`- public IDbCommand Create(IDbConnection connection, IQuery query)`
	`22`	`+ public DbCommand Create(IDbConnection connection, IQuery query)`
`22`	`23`	`{`
`23`	`24`	`var command = Guard.AgainstNull(connection, nameof(connection)).CreateCommand();`
`24`	`25`
`@@ -28,7 +29,7 @@ public IDbCommand Create(IDbConnection connection, IQuery query)`
`28`	`29`
`29`	`30`	`DbCommandCreated?.Invoke(this, new DbCommandCreatedEventArgs(command));`
`30`	`31`
`31`		`- return command;`
	`32`	`+ return (DbCommand)command;`
`32`	`33`	`}`
`33`	`34`	`}`
`34`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,13 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Data;`
	`3`	`+using System.Data.Common;`
`3`	`4`
`4`	`5`	`namespace Shuttle.Core.Data`
`5`	`6`	`{`
`6`	`7`	`public interface IDbCommandFactory`
`7`	`8`	`{`
`8`	`9`	`event EventHandler<DbCommandCreatedEventArgs> DbCommandCreated;`
`9`	`10`
`10`		`- IDbCommand Create(IDbConnection connection, IQuery query);`
	`11`	`+ DbCommand Create(IDbConnection connection, IQuery query);`
`11`	`12`	`}`
`12`	`13`	`}`