Merge pull request #12 from Shuttle/no-blocking

Removed  blocking implementation as DatabaseContext does not need to be thread-safe.

Author: eben-roux

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

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()
     {

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");
 

Shuttle.Core.Data/BlockedDbCommand.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();
-        }
     }
 }

Shuttle.Core.Data/BlockedDbConnection.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;
         }
     }
 }

Shuttle.Core.Data/BlockedDbDataReader.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));
 

Shuttle.Core.Data/DatabaseContext.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;
         }
     }
 }