添加项目文件。

2026-06-05 10:57:09 +08:00
parent f29671b374
commit d960cb5912
166 changed files with 15996 additions and 0 deletions
--- a/ORM/DatabaseConfig.cs
+++ b/ORM/DatabaseConfig.cs
@@ -0,0 +1,132 @@
+using SqlSugar;
+using System;
+
+using System.IO;
+using System.Security.Cryptography;
+
+namespace ORM
+{
+    public class DatabaseConfig
+    {
+        /// <summary>
+        /// 数据库连接类型
+        /// </summary>
+        public static DbType DbConnectionType { get; private set; }
+
+        /// <summary>
+        /// SQLite 数据库文件路径
+        /// </summary>
+        public static string DbConnectionString { get; private set; }
+
+        /// <summary>
+        /// 数据租户Id
+        /// </summary>
+        public static int TenantId { get; private set; }
+
+        /// <summary>
+        /// 雪花算法DatacenterId，值范围：0至31
+        /// </summary>
+        public static int SnowFlakeDatacenterId { get; private set; }
+
+        /// <summary>
+        /// 雪花算法WorkID，值范围：0至31
+        /// </summary>
+        public static int SnowFlakeWorkId { get; private set; }
+
+        #region 不同数据库初始化方法
+        public 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);
+
+            // 拼接数据库文件路径
+            string DBPath = Path.Combine(folder, "SQL.db");
+            DbConnectionString = $"Data Source={DBPath};Version=3;";
+        }
+        public static void InitMySql(string Server, int Port, string Database, string Uid,string Pwd)
+        {
+            DbConnectionType = DbType.MySql;
+            DbConnectionString =
+                $"Server={Server};Port={Port};Database={Database};Uid={Uid};Pwd={Pwd};";
+        }
+        public static void InitSqlServer(string server,int port,string database,string user,string password)
+        {
+            DbConnectionType = DbType.SqlServer;
+
+            DbConnectionString =
+                $"Data Source={server},{port};Initial Catalog={database};user={user};Password={password};";
+        }
+        public 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))
+            {
+                throw new Exception("数据库连接字符串为空");
+            }
+            DbConnectionString = strConnection;
+        }
+
+        /// <summary>
+        /// 设置数据租户Id
+        /// </summary>
+        public static void SetTenant(int nTenantId)
+        {
+            if (nTenantId <= 10000)
+            {
+                throw new Exception("数据租户Id值需大于10000");
+            }
+            TenantId = nTenantId;
+            SetSnowFlake((nTenantId - 10000) % 1024);
+        }
+
+        /// <summary>
+        /// 将指定数字转换为雪花算法DatacenterId和WorkID
+        /// </summary>
+        private static void SetSnowFlake(int nSnowFlakeId)
+        {
+            if (nSnowFlakeId > 1023 || nSnowFlakeId < 0)
+            {
+                throw new Exception("雪花算法机器码值范围0至1023");
+            }
+            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
@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Logger\Logger.csproj" />
+    <ProjectReference Include="..\Model\Model.csproj" />
+  </ItemGroup>
+
+</Project>
--- a/ORM/SqlSugarContext.cs
+++ b/ORM/SqlSugarContext.cs
@@ -0,0 +1,123 @@
+using Logger;
+using SqlSugar;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+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());
+                            }
+                        }
+                    }
+                };
+            }
+        );
+
+        /// <summary>
+        /// 初始化数据库，创建所有后缀为 Entity 的表
+        /// </summary>
+        public static void InitDatabase()
+        {
+            // 加载 Model.dll 文件
+            string modelDllPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Model.dll");
+
+            if (!File.Exists(modelDllPath))
+            {
+                throw new FileNotFoundException($"未找到 Model.dll 文件: {modelDllPath}");
+            }
+
+            // 加载指定的程序集（Model.dll）
+            var modelAssembly = Assembly.LoadFrom(modelDllPath);
+
+            // 获取所有的 Model层下的Entity 类（后缀为 Entity）
+            var entityTypes = modelAssembly.GetTypes()
+                                 .Where(t => t.Name.EndsWith("Entity") && t.IsClass && !t.IsInterface && !t.IsAbstract)
+                                 .ToList();
+
+
+            // 使用 SqlSugar 自动创建表
+            using (var db = DbContext)
+            {
+                foreach (var entityType in entityTypes)
+                {
+                    // 判断该类型是否为类且符合条件
+                    if (entityType.IsClass)
+                    {
+                        // 自动创建表
+                        db.CodeFirst.InitTables(entityType);
+                    }
+                }
+            }
+        }
+    }
+}
+
+
--- 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 事务
+
+    }
+}