YG-OPP-WCS/DBHelper/DB.cs

using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Transactions;

namespace DBHelper
{
    public class DB2 : IDisposable
    {
        public static Type DefaultDbContextType { get; private set; }

        private static object lockObj = new object();

        public static T Do<T>(Func<DB2, T> func)
        {
            lock (lockObj)
                using (var db = new DB2())
                {
                    try
                    {
                        var res = func(db);
                        db.Commit();
                        return res;
                    }
                    catch (EntityValidationException ex)
                    {
                        var qty = ex.EntityValidationErrors.Count();
                        var info = ex.EntityValidationErrors.First();
                        var msg = "有" + qty + "条数据验证失败，首条错误信息:\n" + string.Join("\n", info.MemberNames) + "\n" + (info.ErrorMessage ?? "");
                        Console.WriteLine(msg);
                        throw new Exception(msg);
                    }
                }
        }

        public static void Do(Action<DB2> act)
        {
            Do(db =>
            {
                act(db);
                return 1;
            });
        }

        public static void SetDefaultDbContextType(Type dbContextType)
        {
            DefaultDbContextType = dbContextType;
        }

        public static void SetDefaultDbContextType<T>()
        {
            SetDefaultDbContextType(typeof(T));
        }

        private Dictionary<Type, DbContext> Contexts = new Dictionary<Type, DbContext>();

        public T Context<T>() where T : DbContext
        {
            return (T)Context(typeof(T));
        }

        public DbContext Default
        {
            get
            {
                if (DefaultDbContextType == null)
                    throw new Exception("请先设置默认数据库,调用静态方法SetDefaultDbContextType()");
                return Context(DefaultDbContextType);
            }
        }

        public DbContext Context(Type type)
        {
            if (Contexts.ContainsKey(type))
                return Contexts[type];
            else
            {
                DbContext ctx = Activator.CreateInstance(type) as DbContext;
                ctx.Database.BeginTransaction();
                Contexts.Add(type, ctx);
                return ctx;
            }
        }

        private void Commit()
        {
            Exception exception = null;
            try
            {
                foreach (var ctx in Contexts.Values)
                {
                    ctx.SaveChanges();
                }
            }
            catch (EntityValidationException ex)
            {
                var qty = ex.EntityValidationErrors.Count();
                var info = ex.EntityValidationErrors.First();
                var msg = "有" + qty + "条数据验证失败，首条错误信息:\n" + string.Join("\n", info.MemberNames) + "\n" + (info.ErrorMessage ?? "");
                Console.WriteLine(msg);
                exception = new Exception(msg);
            }
            catch (Exception ex)
            {
                exception = ex.GetBaseException();
            }

            foreach (var ctx in Contexts.Values)
            {
                try
                {
                    if (exception == null)
                        ctx.Database.CurrentTransaction.Commit();
                    else
                    {
                        ctx.Database.CurrentTransaction.Rollback();
                        throw exception;
                    }
                }
                finally
                {
                    ctx.Dispose();
                }
            }
        }

        public void Dispose()
        {
            foreach (var ctx in Contexts.Values)
                ctx.Dispose();
            Contexts.Clear();
            Contexts = null;
        }
    }

    public class DB : IDisposable
    {
        private List<DbContext> Contexts = new List<DbContext>();
        public static Type DefaultDbContextType { get; private set; }

        public static T Do<T>(Func<DB, T> func)
        {
            TransactionOptions transactionOptions = new TransactionOptions();
            transactionOptions.IsolationLevel = IsolationLevel.ReadCommitted;
            transactionOptions.Timeout = new TimeSpan(0, 2, 0);
            using (var trans = new TransactionScope(TransactionScopeOption.RequiresNew, transactionOptions))
            {
                using (var db = new DB())
                {
                    try
                    {
                        var res = func(db);
                        trans.Complete();
                        return res;
                    }
                    catch (EntityValidationException ex)
                    {
                        var qty = ex.EntityValidationErrors.Count();
                        var info = ex.EntityValidationErrors.First();
                        var msg = "有" + qty + "条数据验证失败，首条错误信息:\n" + string.Join("\n", info.MemberNames) + "\n" + (info.ErrorMessage ?? "");
                        Console.WriteLine(msg);
                        throw new Exception(msg);
                    }
                    finally
                    {
                        db.Dispose();
                    }
                }
            }
        }

        public static void Do(Action<DB> act)
        {
            Do(db =>
            {
                act(db);
                return 1;
            });
        }

        public static void SetDefaultDbContextType(Type dbContextType)
        {
            DefaultDbContextType = dbContextType;
        }

        public static void SetDefaultDbContextType<T>()
        {
            SetDefaultDbContextType(typeof(T));
        }

        public DbContext Default
        {
            get
            {
                if (DefaultDbContextType == null)
                    throw new Exception("请先设置默认数据库,调用静态方法SetDefaultDbContextType()");
                return Context(DefaultDbContextType);
            }
        }

        public DbContext Context(Type type)
        {
            var ctx = Contexts.Where(v => v.GetType() == type).FirstOrDefault();
            if (ctx == null)
            {
                ctx = Activator.CreateInstance(type) as DbContext;
                Contexts.Add(ctx);
            }
            return ctx;
        }

        public DbContext Context<TDbContext>()
        {
            return Context(typeof(TDbContext));
        }

        public void Dispose()
        {
            foreach (var ctx in Contexts)
            {
                ctx.Dispose();
            }
            Contexts.Clear();
        }
    }

    public class DB<TContext> where TContext : DbContext
    {
        public static IEnumerable<Type> EntityTypes
        {
            get
            {
                var ps = typeof(TContext).GetProperties().Where(v => v.PropertyType.Name == "DbSet`1").ToArray();
                var ts = ps.Select(v => v.PropertyType.GenericTypeArguments[0]).ToArray();
                return ts;
            }
        }

        /// <summary>
        /// 单数据库事务
        /// </summary>
        /// <typeparam name="TR"></typeparam>
        /// <param name="func"></param>
        /// <returns></returns>
        public static T Do<T>(Func<TContext, T> func)
        {
            using (var ctx = Activator.CreateInstance<TContext>())
            {
                var trans = ctx.Database.BeginTransaction(System.Data.IsolationLevel.Serializable);
                try
                {
                    try
                    {
                        var result = func(ctx);
                        ctx.SaveChanges();
                        trans.Commit();
                        return result;
                    }
                    catch (Exception ex)
                    {
                        trans.Rollback();
                        throw ex.GetBaseException();
                    }
                }
                catch (EntityValidationException ex)
                {
                    var qty = ex.EntityValidationErrors.Count();
                    var info = ex.EntityValidationErrors.First();
                    var msg = "有" + qty + "条数据验证失败，首条错误信息:\n" + string.Join("\n", info.MemberNames) + "\n" + (info.ErrorMessage ?? "");
                    Console.WriteLine(msg);
                    throw new Exception(msg);
                }
            }
        }

        /// <summary>
        /// 单数据库事务
        /// </summary>
        /// <param name="act"></param>
        public static void Do(Action<TContext> act)
        {
            Do(ctx =>
            {
                act(ctx);
                return 1;
            });
        }
    }

    public class DB<TContext1, TContext2> where TContext1 : DbContext where TContext2 : DbContext
    {
        public static T Do<T>(Func<TContext1, TContext2, T> func)
        {
            using (var ctx = Activator.CreateInstance<TContext1>())
            {
                using (var ctx2 = Activator.CreateInstance<TContext2>())
                {
                    var trans = ctx.Database.BeginTransaction(System.Data.IsolationLevel.Serializable);
                    var trans2 = ctx2.Database.BeginTransaction(System.Data.IsolationLevel.Serializable);
                    try
                    {
                        try
                        {
                            var result = func(ctx, ctx2);
                            ctx.SaveChanges();
                            ctx2.SaveChanges();
                            trans.Commit();
                            trans2.Commit();
                            return result;
                        }
                        catch (Exception ex)
                        {
                            trans.Rollback();
                            trans2.Rollback();
                            throw ex.GetBaseException();
                        }
                    }
                    catch (EntityValidationException ex)
                    {
                        var qty = ex.EntityValidationErrors.Count();
                        var info = ex.EntityValidationErrors.First();
                        var msg = "有" + qty + "条数据验证失败，首条错误信息:\n" + string.Join("\n", info.MemberNames) + "\n" + (info.ErrorMessage ?? "");
                        Console.WriteLine(msg);
                        throw new Exception(msg);
                    }
                }
            }
        }

        public static void Do(Action<TContext1, TContext2> act)
        {
            Do((ctx, ctx2) =>
            {
                act(ctx, ctx2);
                return 1;
            });
        }
    }

    public class DB<TContext1, TContext2, TContext3> where TContext1 : DbContext where TContext2 : DbContext where TContext3 : DbContext
    {
        public static T Do<T>(Func<TContext1, TContext2, TContext3, T> func)
        {
            using (var ctx = Activator.CreateInstance<TContext1>())
            {
                using (var ctx2 = Activator.CreateInstance<TContext2>())
                {
                    using (var ctx3 = Activator.CreateInstance<TContext3>())
                    {
                        var trans = ctx.Database.BeginTransaction(System.Data.IsolationLevel.Serializable);
                        var trans2 = ctx2.Database.BeginTransaction(System.Data.IsolationLevel.Serializable);
                        var trans3 = ctx3.Database.BeginTransaction(System.Data.IsolationLevel.Serializable);
                        try
                        {
                            try
                            {
                                var result = func(ctx, ctx2, ctx3);
                                ctx.SaveChanges();
                                ctx2.SaveChanges();
                                ctx3.SaveChanges();
                                trans.Commit();
                                trans2.Commit();
                                trans3.Commit();
                                return result;
                            }
                            catch (Exception ex)
                            {
                                trans.Rollback();
                                trans2.Rollback();
                                trans3.Rollback();
                                throw ex.GetBaseException();
                            }
                        }
                        catch (EntityValidationException ex)
                        {
                            var qty = ex.EntityValidationErrors.Count();
                            var info = ex.EntityValidationErrors.First();
                            var msg = "有" + qty + "条数据验证失败，首条错误信息:\n" + string.Join("\n", info.MemberNames) + "\n" + (info.ErrorMessage ?? "");
                            Console.WriteLine(msg);
                            throw new Exception(msg);
                        }
                    }
                }
            }
        }

        public static void Do(Action<TContext1, TContext2, TContext3> act)
        {
            Do((ctx, ctx2, ctx3) =>
            {
                act(ctx, ctx2, ctx3);
                return 1;
            });
        }
    }
}