diff --git a/framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/Uow/EntityFrameworkCore/UnitOfWorkDbContextProvider.cs b/framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/Uow/EntityFrameworkCore/UnitOfWorkDbContextProvider.cs
index ca18146225..9ea6ffef19 100644
--- a/framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/Uow/EntityFrameworkCore/UnitOfWorkDbContextProvider.cs
+++ b/framework/src/Volo.Abp.EntityFrameworkCore/Volo/Abp/Uow/EntityFrameworkCore/UnitOfWorkDbContextProvider.cs
@@ -18,6 +18,8 @@ namespace Volo.Abp.Uow.EntityFrameworkCore;
 public class UnitOfWorkDbContextProvider<TDbContext> : IDbContextProvider<TDbContext>
     where TDbContext : IEfCoreDbContext
 {
+    private const string TransactionsNotSupportedErrorMessage = "Current database does not support transactions. Your database may remain in an inconsistent state in an error case.";
+    
     public ILogger<UnitOfWorkDbContextProvider<TDbContext>> Logger { get; set; }
 
     private readonly IUnitOfWorkManager _unitOfWorkManager;
@@ -170,19 +172,29 @@ public class UnitOfWorkDbContextProvider<TDbContext> : IDbContextProvider<TDbCon
         {
             var dbContext = unitOfWork.ServiceProvider.GetRequiredService<TDbContext>();
 
-            var dbtransaction = unitOfWork.Options.IsolationLevel.HasValue
-                ? dbContext.Database.BeginTransaction(unitOfWork.Options.IsolationLevel.Value)
-                : dbContext.Database.BeginTransaction();
-
-            unitOfWork.AddTransactionApi(
-                transactionApiKey,
-                new EfCoreTransactionApi(
-                    dbtransaction,
-                    dbContext,
-                    _cancellationTokenProvider
-                )
-            );
-
+            try
+            {
+                var dbtransaction = unitOfWork.Options.IsolationLevel.HasValue
+                    ? dbContext.Database.BeginTransaction(unitOfWork.Options.IsolationLevel.Value)
+                    : dbContext.Database.BeginTransaction();
+
+                unitOfWork.AddTransactionApi(
+                    transactionApiKey,
+                    new EfCoreTransactionApi(
+                        dbtransaction,
+                        dbContext,
+                        _cancellationTokenProvider
+                    )
+                );
+            }
+            catch (Exception e) when (e is InvalidOperationException || e is NotSupportedException)
+            {
+                Logger.LogError(TransactionsNotSupportedErrorMessage);
+                Logger.LogException(e);
+                
+                return dbContext;
+            }
+            
             return dbContext;
         }
         else
@@ -199,25 +211,45 @@ public class UnitOfWorkDbContextProvider<TDbContext> : IDbContextProvider<TDbCon
                 }
                 else
                 {
-                    /* User did not re-use the ExistingConnection and we are starting a new transaction.
-                     * EfCoreTransactionApi will check the connection string match and separately
-                     * commit/rollback this transaction over the DbContext instance. */
-                    if (unitOfWork.Options.IsolationLevel.HasValue)
+                    try
                     {
-                        dbContext.Database.BeginTransaction(unitOfWork.Options.IsolationLevel.Value);
+                        /* User did not re-use the ExistingConnection and we are starting a new transaction.
+                            * EfCoreTransactionApi will check the connection string match and separately
+                            * commit/rollback this transaction over the DbContext instance. */
+                        if (unitOfWork.Options.IsolationLevel.HasValue)
+                        {
+                            dbContext.Database.BeginTransaction(unitOfWork.Options.IsolationLevel.Value);
+                        }
+                        else
+                        {
+                            dbContext.Database.BeginTransaction();
+                        }
                     }
-                    else
+                    catch (Exception e) when (e is InvalidOperationException || e is NotSupportedException)
                     {
-                        dbContext.Database.BeginTransaction();
+                        Logger.LogError(TransactionsNotSupportedErrorMessage);
+                        Logger.LogException(e);
+
+                        return dbContext;
                     }
                 }
             }
             else
             {
-                /* No need to store the returning IDbContextTransaction for non-relational databases
-                 * since EfCoreTransactionApi will handle the commit/rollback over the DbContext instance.
-                 */
-                dbContext.Database.BeginTransaction();
+                try
+                {
+                    /* No need to store the returning IDbContextTransaction for non-relational databases
+                        * since EfCoreTransactionApi will handle the commit/rollback over the DbContext instance.
+                        */
+                    dbContext.Database.BeginTransaction();
+                }
+                catch (Exception e) when (e is InvalidOperationException || e is NotSupportedException)
+                {
+                    Logger.LogError(TransactionsNotSupportedErrorMessage);
+                    Logger.LogException(e);
+                    
+                    return dbContext;
+                }
             }
 
             activeTransaction.AttendedDbContexts.Add(dbContext);
@@ -235,18 +267,28 @@ public class UnitOfWorkDbContextProvider<TDbContext> : IDbContextProvider<TDbCon
         {
             var dbContext = unitOfWork.ServiceProvider.GetRequiredService<TDbContext>();
 
-            var dbTransaction = unitOfWork.Options.IsolationLevel.HasValue
-                ? await dbContext.Database.BeginTransactionAsync(unitOfWork.Options.IsolationLevel.Value, GetCancellationToken())
-                : await dbContext.Database.BeginTransactionAsync(GetCancellationToken());
-
-            unitOfWork.AddTransactionApi(
-                transactionApiKey,
-                new EfCoreTransactionApi(
-                    dbTransaction,
-                    dbContext,
-                    _cancellationTokenProvider
-                )
-            );
+            try
+            {
+                var dbTransaction = unitOfWork.Options.IsolationLevel.HasValue
+                    ? await dbContext.Database.BeginTransactionAsync(unitOfWork.Options.IsolationLevel.Value, GetCancellationToken())
+                    : await dbContext.Database.BeginTransactionAsync(GetCancellationToken());
+
+                unitOfWork.AddTransactionApi(
+                    transactionApiKey,
+                    new EfCoreTransactionApi(
+                        dbTransaction,
+                        dbContext,
+                        _cancellationTokenProvider
+                    )
+                );
+            }
+            catch (Exception e) when (e is InvalidOperationException || e is NotSupportedException)
+            {
+                Logger.LogError(TransactionsNotSupportedErrorMessage);
+                Logger.LogException(e);
+                    
+                return dbContext;
+            }
 
             return dbContext;
         }
@@ -264,30 +306,50 @@ public class UnitOfWorkDbContextProvider<TDbContext> : IDbContextProvider<TDbCon
                 }
                 else
                 {
-                    /* User did not re-use the ExistingConnection and we are starting a new transaction.
-                     * EfCoreTransactionApi will check the connection string match and separately
-                     * commit/rollback this transaction over the DbContext instance. */
-                    if (unitOfWork.Options.IsolationLevel.HasValue)
+                    try
                     {
-                        await dbContext.Database.BeginTransactionAsync(
-                            unitOfWork.Options.IsolationLevel.Value,
-                            GetCancellationToken()
-                        );
+                        /* User did not re-use the ExistingConnection and we are starting a new transaction.
+                            * EfCoreTransactionApi will check the connection string match and separately
+                            * commit/rollback this transaction over the DbContext instance. */
+                        if (unitOfWork.Options.IsolationLevel.HasValue)
+                        {
+                            await dbContext.Database.BeginTransactionAsync(
+                                unitOfWork.Options.IsolationLevel.Value,
+                                GetCancellationToken()
+                            );
+                        }
+                        else
+                        {
+                            await dbContext.Database.BeginTransactionAsync(
+                                GetCancellationToken()
+                            );
+                        }
                     }
-                    else
+                    catch (Exception e) when (e is InvalidOperationException || e is NotSupportedException)
                     {
-                        await dbContext.Database.BeginTransactionAsync(
-                            GetCancellationToken()
-                        );
+                        Logger.LogError(TransactionsNotSupportedErrorMessage);
+                        Logger.LogException(e);
+                    
+                        return dbContext;
                     }
                 }
             }
             else
             {
-                /* No need to store the returning IDbContextTransaction for non-relational databases
-                 * since EfCoreTransactionApi will handle the commit/rollback over the DbContext instance.
-                 */
-                await dbContext.Database.BeginTransactionAsync(GetCancellationToken());
+                try
+                {
+                    /* No need to store the returning IDbContextTransaction for non-relational databases
+                        * since EfCoreTransactionApi will handle the commit/rollback over the DbContext instance.
+                          */
+                    await dbContext.Database.BeginTransactionAsync(GetCancellationToken());
+                }
+                catch (Exception e) when (e is InvalidOperationException || e is NotSupportedException)
+                {
+                    Logger.LogError(TransactionsNotSupportedErrorMessage);
+                    Logger.LogException(e);
+                    
+                    return dbContext;
+                }
             }
 
             activeTransaction.AttendedDbContexts.Add(dbContext);
diff --git a/framework/src/Volo.Abp.MongoDB/Volo/Abp/Uow/MongoDB/UnitOfWorkMongoDbContextProvider.cs b/framework/src/Volo.Abp.MongoDB/Volo/Abp/Uow/MongoDB/UnitOfWorkMongoDbContextProvider.cs
index 4ca0aefdd3..2a4b95f6e0 100644
--- a/framework/src/Volo.Abp.MongoDB/Volo/Abp/Uow/MongoDB/UnitOfWorkMongoDbContextProvider.cs
+++ b/framework/src/Volo.Abp.MongoDB/Volo/Abp/Uow/MongoDB/UnitOfWorkMongoDbContextProvider.cs
@@ -17,6 +17,7 @@ namespace Volo.Abp.Uow.MongoDB;
 public class UnitOfWorkMongoDbContextProvider<TMongoDbContext> : IMongoDbContextProvider<TMongoDbContext>
     where TMongoDbContext : IAbpMongoDbContext
 {
+    private const string TransactionsNotSupportedErrorMessage = "Current database does not support transactions. Your database may remain in an inconsistent state in an error case.";
     public ILogger<UnitOfWorkMongoDbContextProvider<TMongoDbContext>> Logger { get; set; }
 
     private readonly IUnitOfWorkManager _unitOfWorkManager;
@@ -78,7 +79,7 @@ public class UnitOfWorkMongoDbContextProvider<TMongoDbContext> : IMongoDbContext
             dbContextKey,
             () => new MongoDbDatabaseApi(CreateDbContext(unitOfWork, mongoUrl, databaseName)));
 
-        return (TMongoDbContext)((MongoDbDatabaseApi)databaseApi).DbContext;
+        return (TMongoDbContext)((MongoDbDatabaseApi) databaseApi).DbContext;
     }
 
     public async Task<TMongoDbContext> GetDbContextAsync(CancellationToken cancellationToken = default)
@@ -117,7 +118,7 @@ public class UnitOfWorkMongoDbContextProvider<TMongoDbContext> : IMongoDbContext
             unitOfWork.AddDatabaseApi(dbContextKey, databaseApi);
         }
 
-        return (TMongoDbContext)((MongoDbDatabaseApi)databaseApi).DbContext;
+        return (TMongoDbContext)((MongoDbDatabaseApi) databaseApi).DbContext;
     }
 
     [Obsolete("Use CreateDbContextAsync")]
@@ -190,7 +191,7 @@ public class UnitOfWorkMongoDbContextProvider<TMongoDbContext> : IMongoDbContext
             }
             catch (NotSupportedException e)
             {
-                Logger.LogError("The current MongoDB database does not support transactions, All operations will be performed in non-transactions, This may cause errors.");
+                Logger.LogError(TransactionsNotSupportedErrorMessage);
                 Logger.LogException(e);
 
                 dbContext.ToAbpMongoDbContext().InitializeDatabase(database, client, null);
@@ -241,7 +242,7 @@ public class UnitOfWorkMongoDbContextProvider<TMongoDbContext> : IMongoDbContext
             }
             catch (NotSupportedException e)
             {
-                Logger.LogError("The current MongoDB database does not support transactions, All operations will be performed in non-transactions, This may cause errors.");
+                Logger.LogError(TransactionsNotSupportedErrorMessage);
                 Logger.LogException(e);
 
                 dbContext.ToAbpMongoDbContext().InitializeDatabase(database, client, null);