框架优化

2025-12-19 16:58:34 +08:00
parent 69aaa5c4e5
commit 4da28d08a8
46 changed files with 1178 additions and 793 deletions
--- a/ORM/DatabaseConfig.cs
+++ b/ORM/DatabaseConfig.cs
@@ -1,97 +1,132 @@
 using SqlSugar;
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+
+using System.IO;
+using System.Security.Cryptography;

 namespace ORM
 {
-    public static class DatabaseConfig
+    public class DatabaseConfig
    {
        /// <summary>
-        /// 当前数据库类型
+        /// 数据库连接类型
        /// </summary>
        public static DbType DbConnectionType { get; private set; }

        /// <summary>
-        /// 数据库连接字符串
+        /// SQLite 数据库文件路径
        /// </summary>
        public static string DbConnectionString { get; private set; }

        /// <summary>
-        /// 默认 SQLite 文件路径（仅记录，不自动启用）
-        /// </summary>
-        public static string DefaultDbFilePath { get; private set; }
-
-        /// <summary>
-        /// 租户 Id
+        /// 数据租户Id
        /// </summary>
        public static int TenantId { get; private set; }

+        /// <summary>
+        /// 雪花算法DatacenterId，值范围：0至31
+        /// </summary>
        public static int SnowFlakeDatacenterId { get; private set; }
-        public static int SnowFlakeWorkId { get; private set; }
-
-        static DatabaseConfig()
-        {
-            InitDefaultDbPath(); // 只生成路径，不指定 DB 类型/连接
-        }

        /// <summary>
-        /// 生成默认 DB 路径 EXE目录/SQLDB/Data.db
+        /// 雪花算法WorkID，值范围：0至31
        /// </summary>
-        private static void InitDefaultDbPath()
-        {
-            string baseDir = AppDomain.CurrentDomain.BaseDirectory;
+        public static int SnowFlakeWorkId { get; private set; }

+        #region 不同数据库初始化方法
+        private static void InitSqlite()
+        {
+            DbConnectionType = DbType.Sqlite;
+            // 获取程序运行目录
+            string baseDir = AppDomain.CurrentDomain.BaseDirectory;
+            // 确保 SQLDB 文件夹存在
            string folder = Path.Combine(baseDir, "SQLDB");
            if (!Directory.Exists(folder))
                Directory.CreateDirectory(folder);

-            DefaultDbFilePath = Path.Combine(folder, "Data.db");
+            // 拼接数据库文件路径
+            string DBPath = Path.Combine(folder, "SQL.db");
+            DbConnectionString = $"Data Source={DBPath};Version=3;";
        }
-
-        /// <summary>
-        /// 手动设置数据库连接
-        /// </summary>
-        public static void SetConnection(string conn, DbType dbType)
+        private static void InitMySql(string Server, int Port, string Database, string Uid,string Pwd)
        {
-            if (string.IsNullOrWhiteSpace(conn))
-                throw new Exception("数据库连接字符串为空");
-
-            DbConnectionString = conn;
-            DbConnectionType = dbType;
+            DbConnectionType = DbType.MySql;
+            DbConnectionString =
+                $"Server={Server};Port={Port};Database={Database};Uid={Uid};Pwd={Pwd};";
        }
-
-        /// <summary>
-        /// 如果未 SetConnection，默认使用 SQLite + 默认路径
-        /// </summary>
-        public static void EnsureConnection()
+        private static void InitSqlServer(string server,int port,string database,string user,string password)
        {
-            if (string.IsNullOrEmpty(DbConnectionString))
+            DbConnectionType = DbType.SqlServer;
+
+            DbConnectionString =
+                $"Data Source={server},{port};Initial Catalog={database};user={user};Password={password};";
+        }
+        private static void InitSqlServerLocalDb()
+        {
+            DbConnectionType = DbType.SqlServer;
+            string baseDir = AppDomain.CurrentDomain.BaseDirectory;
+            // 确保 SQLDB 文件夹存在
+            string folder = Path.Combine(baseDir, "SQLDB");
+            if (!Directory.Exists(folder))
+                Directory.CreateDirectory(folder);
+
+            // 拼接数据库文件路径
+            string DBPath = Path.Combine(folder, "SQL.db");
+            DbConnectionString =$@"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog={DBPath};Integrated Security=True;";
+        }
+        #endregion
+        /// <summary>
+        /// 设置数据库连接字符串（可手动覆盖）
+        /// </summary>
+        public static void SetDbConnection(string strConnection)
+        {
+            if (string.IsNullOrEmpty(strConnection))
            {
-                DbConnectionString = $"Data Source={DefaultDbFilePath};";
-                DbConnectionType = DbType.Sqlite;
+                throw new Exception("数据库连接字符串为空");
            }
+            DbConnectionString = strConnection;
        }

        /// <summary>
-        /// 设置租户并计算雪花算法节点
+        /// 设置数据租户Id
        /// </summary>
-        public static void SetTenant(int tenantId)
+        public static void SetTenant(int nTenantId)
        {
-            if (tenantId <= 10000)
+            if (nTenantId <= 10000)
+            {
                throw new Exception("数据租户Id值需大于10000");
+            }
+            TenantId = nTenantId;
+            SetSnowFlake((nTenantId - 10000) % 1024);
+        }

-            TenantId = tenantId;
-
-            int snowId = (tenantId - 10000) % 1024;
-
-            if (snowId is < 0 or > 1023)
+        /// <summary>
+        /// 将指定数字转换为雪花算法DatacenterId和WorkID
+        /// </summary>
+        private static void SetSnowFlake(int nSnowFlakeId)
+        {
+            if (nSnowFlakeId > 1023 || nSnowFlakeId < 0)
+            {
                throw new Exception("雪花算法机器码值范围0至1023");
-
-            SnowFlakeDatacenterId = snowId >> 5;
-            SnowFlakeWorkId = snowId & 31;
+            }
+            SnowFlakeDatacenterId = nSnowFlakeId >> 5;
+            SnowFlakeWorkId = nSnowFlakeId & 31;
+        }
+        /// <summary>
+        /// 检测数据库连接
+        /// </summary>
+        public static void CreateDatabaseAndCheckConnection(bool createDatabase = false, bool checkConnection = false)
+        {
+            //数据库不存在则创建数据库
+            if (createDatabase)
+            {
+                SqlSugarContext.DbContext.DbMaintenance.CreateDatabase();
+            }
+            // 检查数据库连接
+            if (checkConnection && !SqlSugarContext.DbContext.Ado.IsValidConnection())
+            {
+                throw new Exception("连接数据库失败");
+            }
        }
    }
 }
--- a/ORM/ORM.csproj
+++ b/ORM/ORM.csproj
@@ -6,9 +6,7 @@
    <Nullable>enable</Nullable>
  </PropertyGroup>

-  <ItemGroup>
-    <PackageReference Include="SqlSugarCore" Version="5.1.4.206" />
-  </ItemGroup>
+

  <ItemGroup>
    <ProjectReference Include="..\Logger\Logger.csproj" />
--- a/ORM/SqlSugarContext.cs
+++ b/ORM/SqlSugarContext.cs
@@ -0,0 +1,85 @@
+using Logger;
+using SqlSugar;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ORM
+{
+        public class SqlSugarContext
+        {
+            /// <summary>
+            /// SqlSugarScope单例模式
+            /// </summary>
+            public static readonly SqlSugarScope DbContext = new SqlSugarScope(
+                new ConnectionConfig()
+                {
+                    DbType = DatabaseConfig.DbConnectionType,
+                    ConnectionString = DatabaseConfig.DbConnectionString, // 连接符字串
+                    //ConfigId = "Db1",//管理多个数据库
+                    IsAutoCloseConnection = true, // 自动关闭连接
+                    InitKeyType = InitKeyType.Attribute // 通过实体类上的特性初始化
+                },
+                db =>
+                {
+                    // 执行超时时间，单位秒
+                    db.Ado.CommandTimeOut = 30;
+
+                    // 每次SQL执行前事件
+                    db.Aop.OnLogExecuting = (sql, pars) =>
+                    {
+#if DEBUG
+                        // 确保 SQL 只通过 sqlLogger 记录
+                        LoggerHelper.sqlLogger.Info("Executing SQL: {0} with parameters: {1}", sql, pars); // 使用 NLog 记录 SQL
+#endif
+                    };
+
+                    // SQL执行完
+                    db.Aop.OnLogExecuted = (sql, pars) =>
+                    {
+                        // 执行时间超过1秒记录慢日志
+                        if (db.Ado.SqlExecutionTime.TotalSeconds > 1)
+                        {
+                              LoggerHelper.sqlLogger.Warn("SQL Slow Execution. Time: {0}, File: {1}, Line: {2}, Method: {3}, SQL: {4}",
+                                db.Ado.SqlExecutionTime.ToString(), // SQL 执行时间
+                                db.Ado.SqlStackTrace.FirstFileName, // 代码 CS 文件名
+                                db.Ado.SqlStackTrace.FirstLine, // 代码行数
+                                db.Ado.SqlStackTrace.FirstMethodName, // 代码方法名
+                                sql); // 使用 NLog 记录慢 SQL 日志
+                        }
+                    };
+
+                    // SQL 报错
+                    db.Aop.OnError = (exp) =>
+                    {
+                        // 确保 SQL 错误日志仅通过 sqlLogger 记录
+                        LoggerHelper.sqlLogger.Error(exp, "SQL Error: {0}", exp.Sql); // 使用 NLog 记录 SQL 错误日志
+                    };
+
+                    // 数据过滤器：例如在新增数据时生成雪花 Id
+                    db.Aop.DataExecuting = (oldValue, entityInfo) =>
+                    {
+                        // 新增操作
+                        if (entityInfo.OperationType == DataFilterType.InsertByObject)
+                        {
+                            // 主键(long)赋值雪花 Id
+                            if (entityInfo.EntityColumnInfo.IsPrimarykey && entityInfo.EntityColumnInfo.PropertyInfo.PropertyType == typeof(long))
+                            {
+                                var id = ((dynamic)entityInfo.EntityValue).Id;
+                                if (id == null || id == 0)
+                                {
+                                    SnowFlakeSingle.WorkId = DatabaseConfig.SnowFlakeWorkId;
+                                    SnowFlakeSingle.DatacenterId = DatabaseConfig.SnowFlakeDatacenterId;
+                                    entityInfo.SetValue(SnowFlakeSingle.Instance.NextId());
+                                }
+                            }
+                        }
+                    };
+                }
+            );
+    }
+    }
+
+
--- a/ORM/SqlSugarRepository.cs
+++ b/ORM/SqlSugarRepository.cs
@@ -0,0 +1,396 @@
+using SqlSugar;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ORM
+{
+    public partial class SqlSugarRepository<TEntity> : SimpleClient<TEntity> where TEntity : class, new()
+    {
+        /// <summary>
+        /// 实体集合
+        /// </summary>
+        public ISugarQueryable<TEntity> Entities => Context.Queryable<TEntity>();
+
+        /// <summary>
+        /// 构造函数
+        /// </summary>
+        public SqlSugarRepository(ISqlSugarClient context = null) : base(context)
+        {
+            // 绑定数据库操作对象
+            Context = SqlSugarContext.DbContext;
+            // 备忘：GetConnectionScopeWithAttr会导致不能触发Aop.OnLogExecuting、Aop.OnLogExecuted等事件
+            // 详见：https://www.donet5.com/Home/Doc?typeId=2405（之2.1、方法说明）
+            // 详见：https://www.donet5.com/Home/Doc?typeId=2246（之2.2、根据特性获取）和（之4、多租户设置AOP）
+            // base.Context = SqlSugarContext.DbContext.GetConnectionScopeWithAttr<TEntity>(); 
+            // 根据特性获取，适合一个实体和库是一对一的情况
+        }
+
+
+        #region 查询
+        /// <summary>
+        /// 检查是否存在
+        /// </summary>
+        /// <param name="whereExpression"></param>
+        /// <returns></returns>
+        public bool IsExists(Expression<Func<TEntity, bool>> whereExpression)
+        {
+            return Entities.Any(whereExpression);
+        }
+
+        /// <summary>
+        /// 检查是否存在
+        /// </summary>
+        /// <param name="whereExpression"></param>
+        /// <returns></returns>
+        public async Task<bool> IsExistsAsync(Expression<Func<TEntity, bool>> whereExpression)
+        {
+            return await Entities.AnyAsync(whereExpression);
+        }
+
+        /// <summary>
+        /// 通过主键获取实体
+        /// </summary>
+        /// <param name="Id"></param>
+        /// <returns></returns>
+        public TEntity Single(dynamic Id)
+        {
+            return Entities.InSingle(Id);
+        }
+
+        /// <summary>
+        /// 获取一个实体
+        /// </summary>
+        /// <param name="whereExpression"></param>
+        /// <returns></returns>
+        public TEntity Single(Expression<Func<TEntity, bool>> whereExpression)
+        {
+            return Entities.Single(whereExpression);
+        }
+
+        /// <summary>
+        /// 获取一个实体
+        /// </summary>
+        /// <param name="whereExpression"></param>
+        /// <returns></returns>
+        public Task<TEntity> SingleAsync(Expression<Func<TEntity, bool>> whereExpression)
+        {
+            return Entities.SingleAsync(whereExpression);
+        }
+
+        /// <summary>
+        /// 获取一个实体
+        /// </summary>
+        /// <param name="whereExpression"></param>
+        /// <returns></returns>
+        public TEntity FirstOrDefault(Expression<Func<TEntity, bool>> whereExpression)
+        {
+            return Entities.First(whereExpression);
+        }
+
+        /// <summary>
+        /// 获取一个实体
+        /// </summary>
+        /// <param name="whereExpression"></param>
+        /// <returns></returns>
+        public async Task<TEntity> FirstOrDefaultAsync(Expression<Func<TEntity, bool>> whereExpression)
+        {
+            return await Entities.FirstAsync(whereExpression);
+        }
+
+        /// <summary>
+        /// 获取列表
+        /// </summary>
+        /// <returns></returns>
+        public List<TEntity> ToList()
+        {
+            return Entities.ToList();
+        }
+
+        /// <summary>
+        /// 获取列表
+        /// </summary>
+        /// <returns></returns>
+        public Task<List<TEntity>> ToListAsync()
+        {
+            return Entities.ToListAsync();
+        }
+
+        /// <summary>
+        /// 获取列表
+        /// </summary>
+        /// <param name="whereExpression"></param>
+        /// <returns></returns>
+        public List<TEntity> ToList(Expression<Func<TEntity, bool>> whereExpression)
+        {
+            return Entities.Where(whereExpression).ToList();
+        }
+
+        /// <summary>
+        /// 获取列表
+        /// </summary>
+        /// <param name="whereExpression"></param>
+        /// <returns></returns>
+        public Task<List<TEntity>> ToListAsync(Expression<Func<TEntity, bool>> whereExpression)
+        {
+            return Entities.Where(whereExpression).ToListAsync();
+        }
+
+        /// <summary>
+        /// 获取列表
+        /// </summary>
+        /// <param name="whereExpression"></param>
+        /// <param name="orderByExpression"></param>
+        /// <param name="orderByType"></param>
+        /// <returns></returns>
+        public List<TEntity> ToList(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, object>> orderByExpression = null, OrderByType orderByType = OrderByType.Asc)
+        {
+            return Entities.OrderByIF(orderByExpression != null, orderByExpression, orderByType).Where(whereExpression).ToList();
+        }
+
+        /// <summary>
+        /// 获取列表
+        /// </summary>
+        /// <param name="whereExpression"></param>
+        /// <param name="orderByExpression"></param>
+        /// <param name="orderByType"></param>
+        /// <returns></returns>
+        public Task<List<TEntity>> ToListAsync(Expression<Func<TEntity, bool>> whereExpression, Expression<Func<TEntity, object>> orderByExpression = null, OrderByType orderByType = OrderByType.Asc)
+        {
+            return Entities.OrderByIF(orderByExpression != null, orderByExpression, orderByType).Where(whereExpression).ToListAsync();
+        }
+        #endregion 查询
+
+
+        #region 新增
+        /// <summary>
+        /// 新增多条记录
+        /// </summary>
+        /// <param name="entities"></param>
+        /// <returns></returns>
+        public int Insert(TEntity[] entities)
+        {
+            return Context.Insertable(entities).ExecuteCommand();
+        }
+
+        /// <summary>
+        /// 新增多条记录
+        /// </summary>
+        /// <param name="entities"></param>
+        /// <returns></returns>
+        public Task<int> InsertAsync(TEntity[] entities)
+        {
+            return Context.Insertable(entities).ExecuteCommandAsync();
+        }
+
+        /// <summary>
+        /// 新增多条记录
+        /// </summary>
+        /// <param name="entities"></param>
+        /// <returns></returns>
+        public int Insert(IEnumerable<TEntity> entities)
+        {
+            return Context.Insertable(entities.ToArray()).ExecuteCommand();
+        }
+
+        /// <summary>
+        /// 新增多条记录
+        /// </summary>
+        /// <param name="entities"></param>
+        /// <returns></returns>
+        public Task<int> InsertAsync(IEnumerable<TEntity> entities)
+        {
+            if (entities != null && entities.Any())
+            {
+                return Context.Insertable(entities.ToArray()).ExecuteCommandAsync();
+            }
+            return Task.FromResult(0);
+        }
+        #endregion 新增
+
+
+        #region 更新
+        /// <summary>
+        /// 更新单条记录指定列
+        /// </summary>
+        /// <param name="entity"></param>
+        /// <param name="updateColumn"></param>
+        /// <returns></returns>
+        public int Update(TEntity entity, object updateColumn)
+        {
+            return Context.Updateable(entity).UpdateColumns(MergeUpdateColumns(updateColumn)).ExecuteCommand();
+        }
+
+        /// <summary>
+        ///  更新单条记录指定列
+        /// </summary>
+        /// <param name="entity"></param>
+        /// <param name="updateColumn"></param>
+        /// <returns></returns>
+        public Task<int> UpdateAsync(TEntity entity, object updateColumn)
+        {
+            return Context.Updateable(entity).UpdateColumns(MergeUpdateColumns(updateColumn)).ExecuteCommandAsync();
+        }
+
+        /// <summary>
+        /// 更新单条记录指定列
+        /// </summary>
+        /// <param name="entity"></param>
+        /// <param name="updateColumn"></param>
+        /// <param name="whereExpression"></param>
+        /// <returns></returns>
+        public int Update(TEntity entity, object updateColumn, Expression<Func<TEntity, bool>> whereExpression)
+        {
+            return Context.Updateable(entity).UpdateColumns(MergeUpdateColumns(updateColumn)).Where(whereExpression).ExecuteCommand();
+        }
+
+        /// <summary>
+        /// 更新单条记录指定列
+        /// </summary>
+        /// <param name="entity"></param>
+        /// <param name="updateColumn"></param>
+        /// <param name="whereExpression"></param>
+        /// <returns></returns>
+        public Task<int> UpdateAsync(TEntity entity, object updateColumn, Expression<Func<TEntity, bool>> whereExpression)
+        {
+            return Context.Updateable(entity).UpdateColumns(MergeUpdateColumns(updateColumn)).Where(whereExpression).ExecuteCommandAsync();
+        }
+
+        /// <summary>
+        /// 更新多条记录
+        /// </summary>
+        /// <param name="entities"></param>
+        /// <returns></returns>
+        public int Update(TEntity[] entities)
+        {
+            return Context.Updateable(entities).ExecuteCommand();
+        }
+
+        /// <summary>
+        /// 更新多条记录
+        /// </summary>
+        /// <param name="entities"></param>
+        /// <returns></returns>
+        public Task<int> UpdateAsync(TEntity[] entities)
+        {
+            return Context.Updateable(entities).ExecuteCommandAsync();
+        }
+
+        /// <summary>
+        /// 更新多条记录指定列
+        /// </summary>
+        /// <param name="entities"></param>
+        /// <param name="updateColumn"></param>
+        /// <returns></returns>
+        public int Update(TEntity[] entities, object updateColumn)
+        {
+            return Context.Updateable(entities).UpdateColumns(MergeUpdateColumns(updateColumn)).ExecuteCommand();
+        }
+
+        /// <summary>
+        /// 更新多条记录指定列
+        /// </summary>
+        /// <param name="entities"></param>
+        /// <param name="updateColumn"></param>
+        /// <returns></returns>
+        public Task<int> UpdateAsync(TEntity[] entities, object updateColumn)
+        {
+            return Context.Updateable(entities).UpdateColumns(MergeUpdateColumns(updateColumn)).ExecuteCommandAsync();
+        }
+
+        /// <summary>
+        /// 合并指定更新列和附加更新列
+        /// </summary>
+        /// <param name="updateColumn"></param>
+        /// <returns></returns>
+        private string[] MergeUpdateColumns(object updateColumn)
+        {
+            List<string> columnList = new List<string>();
+            if (updateColumn.GetType() == typeof(string))
+            {
+                columnList.Add((string)updateColumn);
+            }
+            else if (updateColumn.GetType() == typeof(string[]))
+            {
+                columnList.AddRange((string[])updateColumn);
+            }
+            return columnList.ToArray();
+        }
+        #endregion 更新
+
+
+        #region 删除
+        /// <summary>
+        /// 删除一条记录
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public int Delete(object key)
+        {
+            return Context.Deleteable<TEntity>().In(key).ExecuteCommand();
+        }
+
+        /// <summary>
+        /// 删除一条记录
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public Task<int> DeleteAsync(object key)
+        {
+            return Context.Deleteable<TEntity>().In(key).ExecuteCommandAsync();
+        }
+
+        /// <summary>
+        /// 删除多条记录
+        /// </summary>
+        /// <param name="keys"></param>
+        /// <returns></returns>
+        public int Delete(object[] keys)
+        {
+            return Context.Deleteable<TEntity>().In(keys).ExecuteCommand();
+        }
+
+        /// <summary>
+        /// 删除多条记录
+        /// </summary>
+        /// <param name="keys"></param>
+        /// <returns></returns>
+        public Task<int> DeleteAsync(object[] keys)
+        {
+            return Context.Deleteable<TEntity>().In(keys).ExecuteCommandAsync();
+        }
+        #endregion 删除
+
+
+        #region 事务
+        /// <summary>
+        /// 开启事务
+        /// </summary>
+        public void BeginTran()
+        {
+            Context.Ado.BeginTran();
+        }
+
+        /// <summary>
+        /// 提交事务
+        /// </summary>
+        public void CommitTran()
+        {
+            Context.Ado.CommitTran();
+        }
+
+        /// <summary>
+        /// 回滚事务
+        /// </summary>
+        public void RollbackTran()
+        {
+            Context.Ado.RollbackTran();
+        }
+        #endregion 事务
+
+    }
+}