fix bug.

src/DotNetCore.CAP.SqlServer/SqlServerStorageConnection.cs

@@ -25,12 +25,13 @@ namespace DotNetCore.CAP.SqlServer
             return new SqlServerStorageTransaction(this);
         }
 
-        public Task<CapPublishedMessage> GetPublishedMessageAsync(int id)
+        public async Task<CapPublishedMessage> GetPublishedMessageAsync(int id)
         {
             var sql = $@"SELECT * FROM [{_options.Schema}].[Published] WITH (readpast) WHERE Id={id}";
+
             using (var connection = new SqlConnection(_options.ConnectionString))
             {
-                return connection.QueryFirstOrDefaultAsync<CapPublishedMessage>(sql);
+                return await connection.QueryFirstOrDefaultAsync<CapPublishedMessage>(sql);
             }
         }
 
@@ -56,7 +57,7 @@ OUTPUT DELETED.MessageId,DELETED.[MessageType];";
 
         // CapReceviedMessage
 
-        public Task StoreReceivedMessageAsync(CapReceivedMessage message)
+        public async Task StoreReceivedMessageAsync(CapReceivedMessage message)
         {
             if (message == null) throw new ArgumentNullException(nameof(message));
 
@@ -66,16 +67,16 @@ VALUES(@Name,@Group,@Content,@Retries,@Added,@ExpiresAt,@StatusName);";
 
             using (var connection = new SqlConnection(_options.ConnectionString))
             {
-                return connection.ExecuteAsync(sql, message);
+                await connection.ExecuteAsync(sql, message);
             }
         }
 
-        public Task<CapReceivedMessage> GetReceivedMessageAsync(int id)
+        public async Task<CapReceivedMessage> GetReceivedMessageAsync(int id)
         {
             var sql = $@"SELECT * FROM [{_options.Schema}].[Received] WITH (readpast) WHERE Id={id}";
             using (var connection = new SqlConnection(_options.ConnectionString))
             {
-                return connection.QueryFirstOrDefaultAsync<CapReceivedMessage>(sql);
+                return await connection.QueryFirstOrDefaultAsync<CapReceivedMessage>(sql);
             }
         }
 
@@ -94,26 +95,30 @@ VALUES(@Name,@Group,@Content,@Retries,@Added,@ExpiresAt,@StatusName);";
 
         private async Task<IFetchedMessage> FetchNextMessageCoreAsync(string sql, object args = null)
         {
-            using (var connection = new SqlConnection(_options.ConnectionString))
-            {
-                using (var transaction = connection.BeginTransaction(IsolationLevel.ReadCommitted))
-                {
+            //here don't use `using` to dispose 
+            var connection = new SqlConnection(_options.ConnectionString);
+            await connection.OpenAsync();
+            var transaction = connection.BeginTransaction(IsolationLevel.ReadCommitted);
+            FetchedMessage fetchedMessage = null;
             try
             {
-                        var fetched = await connection.QueryFirstOrDefaultAsync<FetchedMessage>(sql, args, transaction);
-
-                        if (fetched == null)
-                            return null;
-
-                        return new SqlServerFetchedMessage(fetched.MessageId, fetched.MessageType, connection, transaction);
+                fetchedMessage = await connection.QueryFirstOrDefaultAsync<FetchedMessage>(sql, args, transaction);
+            }
+            catch (SqlException)
+            {
+                transaction.Dispose();
+                throw;
             }
-                    catch (Exception)
+
+            if (fetchedMessage == null)
             {
                 transaction.Rollback();
+                transaction.Dispose();
+                connection.Dispose();
                 return null;
             }
-                }
-            }
+
+            return new SqlServerFetchedMessage(fetchedMessage.MessageId, fetchedMessage.MessageType, connection, transaction);
         }
     }
 }
\ No newline at end of file

src/DotNetCore.CAP.SqlServer/SqlServerStorageTransaction.cs

@@ -20,6 +20,7 @@ namespace DotNetCore.CAP.SqlServer
             _schema = options.Schema;
 
             _dbConnection = new SqlConnection(options.ConnectionString);
+            _dbConnection.Open();
             _dbTransaction = _dbConnection.BeginTransaction(IsolationLevel.ReadCommitted);
         }
 
@@ -27,16 +28,16 @@ namespace DotNetCore.CAP.SqlServer
         {
             if (message == null) throw new ArgumentNullException(nameof(message));
 
-            var sql = $"UPDATE [{_schema}].[Published] SET [ExpiresAt] = @ExpiresAt,[StatusName]=@StatusName WHERE Id=@Id;";
-            _dbConnection.Execute(sql, message);
+            var sql = $"UPDATE [{_schema}].[Published] SET [Retries] = @Retries,[ExpiresAt] = @ExpiresAt,[StatusName]=@StatusName WHERE Id=@Id;";
+            _dbConnection.Execute(sql, message, _dbTransaction);
         }
 
         public void UpdateMessage(CapReceivedMessage message)
         {
             if (message == null) throw new ArgumentNullException(nameof(message));
 
-            var sql = $"UPDATE [{_schema}].[Received] SET [ExpiresAt] = @ExpiresAt,[StatusName]=@StatusName WHERE Id=@Id;";
-            _dbConnection.Execute(sql, message);
+            var sql = $"UPDATE [{_schema}].[Received] SET [Retries] = @Retries,[ExpiresAt] = @ExpiresAt,[StatusName]=@StatusName WHERE Id=@Id;";
+            _dbConnection.Execute(sql, message, _dbTransaction);
         }
 
         public void EnqueueMessage(CapPublishedMessage message)
@@ -44,7 +45,7 @@ namespace DotNetCore.CAP.SqlServer
             if (message == null) throw new ArgumentNullException(nameof(message));
 
             var sql = $"INSERT INTO [{_schema}].[Queue] values(@MessageId,@MessageType);";
-            _dbConnection.Execute(sql, new CapQueue { MessageId = message.Id, MessageType = MessageType.Publish });
+            _dbConnection.Execute(sql, new CapQueue { MessageId = message.Id, MessageType = MessageType.Publish }, _dbTransaction);
         }
 
         public void EnqueueMessage(CapReceivedMessage message)
@@ -52,7 +53,7 @@ namespace DotNetCore.CAP.SqlServer
             if (message == null) throw new ArgumentNullException(nameof(message));
 
             var sql = $"INSERT INTO [{_schema}].[Queue] values(@MessageId,@MessageType);";
-            _dbConnection.Execute(sql, new CapQueue { MessageId = message.Id, MessageType = MessageType.Subscribe });
+            _dbConnection.Execute(sql, new CapQueue { MessageId = message.Id, MessageType = MessageType.Subscribe }, _dbTransaction);
         }
 
         public Task CommitAsync()

src/DotNetCore.CAP/IConsumerHandler.Default.cs

@@ -113,7 +113,7 @@ namespace DotNetCore.CAP
             var messageStore = provider.GetRequiredService<IStorageConnection>();
             var receivedMessage = new CapReceivedMessage(messageContext)
             {
-                StatusName = StatusName.Enqueued,
+                StatusName = StatusName.Scheduled,
             };
             messageStore.StoreReceivedMessageAsync(receivedMessage).Wait();
             return receivedMessage;

src/DotNetCore.CAP/IQueueExecutor.Publish.Base.cs

@@ -23,8 +23,6 @@ namespace DotNetCore.CAP
         public abstract Task<OperateResult> PublishAsync(string keyName, string content);
 
         public async Task<OperateResult> ExecuteAsync(IStorageConnection connection, IFetchedMessage fetched)
-        {
-            using (fetched)
         {
             var message = await connection.GetPublishedMessageAsync(fetched.MessageId);
             try
@@ -75,13 +73,12 @@ namespace DotNetCore.CAP
                 return OperateResult.Failed(ex);
             }
         }
-        }
 
         private async Task<bool> UpdateJobForRetryAsync(CapPublishedMessage message, IStorageConnection connection)
         {
             var retryBehavior = RetryBehavior.DefaultRetry;
 
-            var now = DateTime.UtcNow;
+            var now = DateTime.Now;
             var retries = ++message.Retries;
             if (retries >= retryBehavior.RetryCount)
             {

src/DotNetCore.CAP/IQueueExecutor.Subscibe.cs

@@ -36,8 +36,6 @@ namespace DotNetCore.CAP
         }
 
         public async Task<OperateResult> ExecuteAsync(IStorageConnection connection, IFetchedMessage fetched)
-        {
-            using (fetched)
         {
             var message = await connection.GetReceivedMessageAsync(fetched.MessageId);
             try
@@ -93,7 +91,6 @@ namespace DotNetCore.CAP
                 return OperateResult.Failed(ex);
             }
         }
-        }
 
         protected virtual async Task<OperateResult> ExecuteSubscribeAsync(CapReceivedMessage receivedMessage)
         {

test/DotNetCore.CAP.EntityFrameworkCore.Test/DotNetCore.CAP.EntityFrameworkCore.Test.csproj

@@ -18,7 +18,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\..\src\DotNetCore.CAP.EntityFrameworkCore\DotNetCore.CAP.SqlServer.csproj" />
+    <ProjectReference Include="..\..\src\DotNetCore.CAP.SqlServer\DotNetCore.CAP.SqlServer.csproj" />
     <ProjectReference Include="..\..\src\DotNetCore.CAP\DotNetCore.CAP.csproj" />
   </ItemGroup>