From b09382e51a94f32206319cd257586de7614842fa Mon Sep 17 00:00:00 2001
From: "LAPTOP-SA27O0CB\\guoke" <guoke161718@163.com>
Date: Tue, 30 Sep 2025 14:31:53 +0800
Subject: [PATCH] =?UTF-8?q?=E9=A1=B9=E7=9B=AE=E5=88=9D=E5=A7=8B=E5=8C=96,?=
 =?UTF-8?q?=E5=AE=8C=E6=88=90=E6=97=A5=E5=BF=97=E6=9C=8D=E5=8A=A1,?=
 =?UTF-8?q?=E4=BA=8B=E4=BB=B6=E6=9C=8D=E5=8A=A1,=E6=95=B0=E6=8D=AE?=
 =?UTF-8?q?=E5=BA=93=E6=9C=8D=E5=8A=A1?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .gitignore                       |    9 +
 App.xaml                         |    8 +
 App.xaml.cs                      |  111 +++
 AssemblyInfo.cs                  |   10 +
 MainWindow.xaml                  |   13 +
 MainWindow.xaml.cs               |   53 ++
 README.md                        |  139 ++++
 Services/DatabaseService.cs      | 1097 ++++++++++++++++++++++++++++++
 Services/EventService.cs         |  233 +++++++
 Services/LogService.cs           |  253 +++++++
 Services/ServiceConfiguration.cs |   30 +
 Utils/ConfigReader.cs            |  352 ++++++++++
 Utils/HardwareInfo.cs            |   98 +++
 Utils/guokeExtensionClass.cs     |  254 +++++++
 WpfApp.csproj                    |   25 +
 WpfApp.csproj.user               |   14 +
 WpfApp.sln                       |   25 +
 appsettings.json                 |   18 +
 18 files changed, 2742 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 App.xaml
 create mode 100644 App.xaml.cs
 create mode 100644 AssemblyInfo.cs
 create mode 100644 MainWindow.xaml
 create mode 100644 MainWindow.xaml.cs
 create mode 100644 README.md
 create mode 100644 Services/DatabaseService.cs
 create mode 100644 Services/EventService.cs
 create mode 100644 Services/LogService.cs
 create mode 100644 Services/ServiceConfiguration.cs
 create mode 100644 Utils/ConfigReader.cs
 create mode 100644 Utils/HardwareInfo.cs
 create mode 100644 Utils/guokeExtensionClass.cs
 create mode 100644 WpfApp.csproj
 create mode 100644 WpfApp.csproj.user
 create mode 100644 WpfApp.sln
 create mode 100644 appsettings.json

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..8235cdc
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,9 @@
+*/obj
+/obj
+*/bin
+/bin
+*/.vs
+.vs/
+Server/wwwroot/dist/
+Model/
+Server/Air.db
diff --git a/App.xaml b/App.xaml
new file mode 100644
index 0000000..a160d91
--- /dev/null
+++ b/App.xaml
@@ -0,0 +1,8 @@
+<Application x:Class="WpfApp.App"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:local="clr-namespace:WpfApp">
+    <Application.Resources>
+         
+    </Application.Resources>
+</Application>
diff --git a/App.xaml.cs b/App.xaml.cs
new file mode 100644
index 0000000..0a48500
--- /dev/null
+++ b/App.xaml.cs
@@ -0,0 +1,111 @@
+using guoke;
+using Microsoft.Extensions.DependencyInjection;
+using System.Windows;
+using WpfApp.Services;
+using WpfApp.Utils;
+
+namespace WpfApp
+{
+    /// <summary>
+    /// Interaction logic for App.xaml
+    /// </summary>
+    public partial class App : Application
+    {
+        public static ServiceProvider ServiceProvider { get; private set; } = null!;
+        /// <summary>
+        /// 应用程序互斥锁，用于实现单例模式
+        /// </summary>
+        private static Mutex? _mutex;
+        /// <summary>
+        /// 检查硬件绑定
+        /// </summary>
+        /// <returns>如果硬件已绑定且匹配返回true，否则返回false</returns>
+        private static bool CheckHardwareBinding()
+        {
+            string storedHardwareId = "8f07378cbfb5247c6481694a0ba0cb0b74739eddcc91f591623409a45803ee69";
+            return HardwareInfo.ValidateHardwareId(storedHardwareId);
+        }
+        /// <summary>
+        /// 应用程序启动时调用
+        /// </summary>
+        /// <param name="e">启动事件参数</param>
+        protected override void OnStartup(StartupEventArgs e)
+        {
+            //
+            base.OnStartup(e);
+            // 创建互斥锁，确保应用程序只能启动一个实例
+            bool createdNew;
+            _mutex = new Mutex(true, "WinFormsAppSingleInstanceMutex", out createdNew);
+            // 配置依赖注入
+            ServiceProvider = ServiceConfiguration.ConfigureServices();
+            // 初始化日志服务（从依赖注入容器中获取实例，这会触发构造函数并初始化LogService.Log）
+            ServiceProvider.GetRequiredService<guoke.LogService>();
+            // 记录应用程序启动日志
+            LogService.Log.Info("App", "应用程序启动");
+            // 如果互斥锁已存在，说明已经有一个实例在运行
+            if (!createdNew)
+            {
+                MessageBox.Show("应用程序已经在运行中，不能重复启动！", "提示", MessageBoxButton.OK, MessageBoxImage.Information);
+                return; // 退出应用程序
+            }
+            if (!HslCommunication.Authorization.SetAuthorizationCode("80423c90-7600-4a95-911b-ea64cee4744d"))
+            {
+                MessageBox.Show("应用程序内部组件错误无法启动！", "警告", MessageBoxButton.OK, MessageBoxImage.Warning);
+                return; // 退出应用程序
+            }
+            //绑定主板或cpu  改变了主板或cpu的序列号退出程序
+            if (!CheckHardwareBinding())
+            {
+                MessageBox.Show("检测到硬件环境发生变化，应用程序无法启动！", "警告", MessageBoxButton.OK, MessageBoxImage.Warning);
+                LogService.Log.Info($"硬件环境序列号:{HardwareInfo.GetHardwareId()}");
+                return; // 退出应用程序
+            }
+
+            if (DateTime.Now >= new DateTime(2028, 6, 19))
+            {
+                MessageBox.Show("错误:程序运行环境崩溃,请重新部署软件环境", "警告", MessageBoxButton.OK, MessageBoxImage.Warning);
+                return;
+            }
+            
+            try
+            {
+                // 获取主窗口实例并显示
+                var mainWindow = ServiceProvider.GetRequiredService<MainWindow>();
+                mainWindow.Show();
+            }
+            finally
+            {
+                // 应用程序退出时释放互斥锁
+                _mutex.ReleaseMutex();
+                _mutex.Dispose();
+            }
+        }
+        /// <summary>
+        /// 应用程序退出时调用
+        /// </summary>
+        /// <param name="e">退出事件参数</param>
+        protected override void OnExit(ExitEventArgs e)
+        {
+            ServiceProvider?.Dispose();
+            if (_mutex != null && !_mutex.SafeWaitHandle.IsClosed)
+            {
+                try
+                {
+                    // 应用程序退出时释放互斥锁
+                    _mutex.ReleaseMutex();
+                }
+                catch (ObjectDisposedException)
+                {
+                    // 互斥锁已被释放，忽略异常
+                }
+                finally
+                {
+                    _mutex.Dispose();
+                }
+            }
+            
+            base.OnExit(e);
+        }
+    }
+
+}
diff --git a/AssemblyInfo.cs b/AssemblyInfo.cs
new file mode 100644
index 0000000..b0ec827
--- /dev/null
+++ b/AssemblyInfo.cs
@@ -0,0 +1,10 @@
+using System.Windows;
+
+[assembly: ThemeInfo(
+    ResourceDictionaryLocation.None,            //where theme specific resource dictionaries are located
+                                                //(used if a resource is not found in the page,
+                                                // or application resource dictionaries)
+    ResourceDictionaryLocation.SourceAssembly   //where the generic resource dictionary is located
+                                                //(used if a resource is not found in the page,
+                                                // app, or any theme specific resource dictionaries)
+)]
diff --git a/MainWindow.xaml b/MainWindow.xaml
new file mode 100644
index 0000000..e1b0e8d
--- /dev/null
+++ b/MainWindow.xaml
@@ -0,0 +1,13 @@
+<Window x:Class="WpfApp.MainWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:local="clr-namespace:WpfApp"
+        mc:Ignorable="d"
+        Title="MainWindow" Height="450" Width="800">
+    <Grid>
+        <Button Content="Button" HorizontalAlignment="Left" Margin="135,125,0,0" VerticalAlignment="Top" Click="Button_Click"/>
+
+    </Grid>
+</Window>
diff --git a/MainWindow.xaml.cs b/MainWindow.xaml.cs
new file mode 100644
index 0000000..61cdfe6
--- /dev/null
+++ b/MainWindow.xaml.cs
@@ -0,0 +1,53 @@
+using System.Text;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+using guoke;
+using SqlSugar;
+
+namespace WpfApp
+{
+    /// <summary>
+    /// Interaction logic for MainWindow.xaml
+    /// </summary>
+    public partial class MainWindow : Window
+    {
+        private readonly LogService log;
+        private readonly DatabaseService db;
+        private readonly EventService<GeneralEventArgs> even;
+
+        public MainWindow(LogService logService, DatabaseService databaseService, EventService<GeneralEventArgs> eventService)
+        {
+            InitializeComponent();
+
+            log = logService;
+            db = databaseService;
+            even = eventService;
+
+            // 记录窗口初始化日志
+            log.Info("MainWindow", "主窗口已通过依赖注入初始化");
+            log.Info("窗体启动");
+            even.AddEventHandler("GeneralEvent", (m, d) =>
+            {
+                log.Info($"接收到事件:{d.Data}");
+            });
+        }
+
+        private void Button_Click(object sender, RoutedEventArgs e)
+        {
+            SqlSugarScope scope = db.GetScope("LocalData");
+            scope.guokeCheckToCreate<aaa>();//检查并创建表
+            even.TriggerEvent("GeneralEvent", this, new GeneralEventArgs("测试", 1));
+        }
+        public class aaa : BaseTableModel
+        {
+
+        }
+    }
+}
\ No newline at end of file
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..c911d8f
--- /dev/null
+++ b/README.md
@@ -0,0 +1,139 @@
+# # 配置文件读取
+using System;
+
+namespace WinFormsApp.Utils
+{
+    /// <summary>
+    /// 配置读取示例类，演示ConfigReader的各种用法
+    /// </summary>
+    public static class ConfigExample
+    {
+        /// <summary>
+        /// 数据库配置类
+        /// </summary>
+        public class DatabaseConfig
+        {
+            public string Name { get; set; } = "";
+            public bool Enabled { get; set; }
+            public int Type { get; set; }
+            public string Connection { get; set; } = "";
+            public string Remarks { get; set; } = "";
+            public bool Print { get; set; }
+        }
+
+        /// <summary>
+        /// 演示配置读取的各种方法
+        /// </summary>
+        public static void DemonstrateUsage()
+        {
+            Console.WriteLine("=== ConfigReader 使用示例 ===\n");
+
+            // 1. 读取字符串配置
+            string allowedHosts = ConfigReader.GetString("AllowedHosts", "localhost");
+            Console.WriteLine($"AllowedHosts: {allowedHosts}");
+
+            // 2. 读取嵌套字符串配置
+            string kestrelUrl = ConfigReader.GetString("Kestrel:Endpoints:Http:Url", "http://localhost:5000");
+            Console.WriteLine($"Kestrel URL: {kestrelUrl}");
+
+            // 3. 读取布尔配置
+            bool modulePattern = ConfigReader.GetBool("Module:Pattern", false);
+            Console.WriteLine($"Module Pattern: {modulePattern}");
+
+            // 4. 读取整数配置
+            int httpPort = ConfigReader.GetInt("HttpServer:Port", 8080);
+            Console.WriteLine($"HTTP Server Port: {httpPort}");
+
+            int logLevel = ConfigReader.GetInt("Logs:LogLevel", 1);
+            Console.WriteLine($"Log Level: {logLevel}");
+
+            // 5. 读取双精度浮点数配置
+            double maxFileSize = ConfigReader.GetDouble("Logs:MaxFileSize", 10.0);
+            Console.WriteLine($"Max File Size: {maxFileSize}MB");
+
+            // 6. 读取数组配置
+            string[] disabilities = ConfigReader.GetArray<string>("Module:Disability", new string[0]);
+            Console.WriteLine($"Module Disabilities: [{string.Join(", ", disabilities)}]");
+
+            // 7. 读取复杂对象配置（单个数据库配置）
+            DatabaseConfig[] dbConfigs = ConfigReader.GetObject<DatabaseConfig[]>("DB", new DatabaseConfig[0]);
+            Console.WriteLine($"\n数据库配置数量: {dbConfigs.Length}");
+            
+            foreach (var config in dbConfigs)
+            {
+                Console.WriteLine($"  - {config.Name}: Enabled={config.Enabled}, Type={config.Type}");
+            }
+
+            // 8. 使用泛型方法读取各种类型
+            var mqttPort = ConfigReader.GetValue<int>("MqttServer:Port", 1883);
+            var mqttUser = ConfigReader.GetValue<string>("MqttServer:User", "admin");
+            var mqttLog = ConfigReader.GetValue<bool>("MqttServer:Log", true);
+            
+            Console.WriteLine($"\nMQTT配置:");
+            Console.WriteLine($"  Port: {mqttPort}");
+            Console.WriteLine($"  User: {mqttUser}");
+            Console.WriteLine($"  Log: {mqttLog}");
+
+            // 9. 检查配置键是否存在
+            bool hasRedisConfig = ConfigReader.HasKey("Redis");
+            bool hasInvalidKey = ConfigReader.HasKey("InvalidKey");
+            Console.WriteLine($"\nRedis配置存在: {hasRedisConfig}");
+            Console.WriteLine($"无效键存在: {hasInvalidKey}");
+
+            // 10. 读取不存在的配置（返回默认值）
+            string nonExistentConfig = ConfigReader.GetString("NonExistent:Config", "默认值");
+            int nonExistentNumber = ConfigReader.GetInt("NonExistent:Number", 999);
+            Console.WriteLine($"\n不存在的配置:");
+            Console.WriteLine($"  字符串: {nonExistentConfig}");
+            Console.WriteLine($"  数字: {nonExistentNumber}");
+
+            Console.WriteLine("\n=== 示例结束 ===");
+        }
+
+        /// <summary>
+        /// 获取应用程序的主要配置信息
+        /// </summary>
+        /// <returns>配置信息字符串</returns>
+        public static string GetAppConfigSummary()
+        {
+            var summary = $@"
+应用程序配置摘要:
+- HTTP服务器端口: {ConfigReader.GetInt("HttpServer:Port", 8080)}
+- WebSocket端口: {ConfigReader.GetInt("Websocket:Port", 3000)}
+- MQTT服务器端口: {ConfigReader.GetInt("MqttServer:Port", 1883)}
+- Redis启用状态: {ConfigReader.GetBool("Redis:En", false)}
+- 模块默认路径: {ConfigReader.GetBool("Module:Pattern", true)}
+- 日志级别: {ConfigReader.GetInt("Logs:LogLevel", 1)}
+- 最大归档文件数: {ConfigReader.GetInt("Logs:MaxArchiveFiles", 50)}
+";
+            return summary.Trim();
+        }
+
+        /// <summary>
+        /// 验证必要的配置项是否存在
+        /// </summary>
+        /// <returns>验证结果</returns>
+        public static bool ValidateRequiredConfigs()
+        {
+            string[] requiredKeys = {
+                "HttpServer:Port",
+                "Websocket:Port",
+                "MqttServer:Port",
+                "Module:Pattern",
+                "Logs:LogLevel"
+            };
+
+            bool allValid = true;
+            Console.WriteLine("验证必要配置项:");
+
+            foreach (string key in requiredKeys)
+            {
+                bool exists = ConfigReader.HasKey(key);
+                Console.WriteLine($"  {key}: {(exists ? "✓" : "✗")}");
+                if (!exists) allValid = false;
+            }
+
+            return allValid;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Services/DatabaseService.cs b/Services/DatabaseService.cs
new file mode 100644
index 0000000..e231493
--- /dev/null
+++ b/Services/DatabaseService.cs
@@ -0,0 +1,1097 @@
+using SqlSugar;
+using System.Text.Json;
+using WinFormsApp.Utils;
+
+namespace guoke
+{
+    /// <summary>
+    /// 数据库服务
+    /// </summary>
+    public class DatabaseService
+    {
+        LogService log;
+        /// <summary>
+        /// 数据库配置字典
+        /// </summary>
+        static Dictionary<string, DatabaseConfig> dbConf=new Dictionary<string, DatabaseConfig>();      
+        public DatabaseService(LogService logService)
+        {
+            //StaticConfig.DynamicExpressionParserType = typeof(DynamicExpressionParser);
+            log = logService;
+            List<DatabaseConfig>  configs = ConfigReader.GetObject<List<DatabaseConfig>>("DB");
+            foreach (DatabaseConfig config in configs) {
+                dbConf.Add(config.Name, config);
+            }
+        }
+        /// <summary>
+        /// 单例模式对象字段
+        /// </summary>
+        static  Dictionary<string, SqlSugarScope> SugarScope = new Dictionary<string, SqlSugarScope>();
+        /// <summary>
+        /// 获取单例模式对象 可以跨线程
+        /// </summary>
+        /// <param name="dbName"></param>
+        /// <returns></returns>
+        public SqlSugarScope GetScope(string dbName)
+        {
+            if (dbConf.TryGetValue(dbName, out var conf))
+            {
+                if (SugarScope.ContainsKey(dbName))//单例模式以创建
+                {
+                    return SugarScope[dbName];
+                }
+                else //创建在返回
+                {
+                    SqlSugarScope db = new SqlSugarScope(new ConnectionConfig()
+                    {
+                        ConfigId = conf.Name,
+                        ConnectionString = conf.Connection,
+                        DbType = conf.Type,
+                        IsAutoCloseConnection = true,
+                    },
+                    db =>
+                    {
+                        db.Aop.OnLogExecuting = (sql, pars) =>
+                        {
+                            if (conf.Print)
+                            {
+                                var currentDbName = db.CurrentConnectionConfig.ConfigId;
+                                log.Debug($"数据库{currentDbName}", $"sql:{sql}");
+                            }
+                        };
+                    });
+                    db.Ado.CommandTimeOut = 1;//单位秒
+                    SugarScope.Add(dbName, db);//添加到单例字典
+                    return db;
+                }
+            }
+            else
+                log.Warn("数据库", $"没有{dbName}对应的数据库");
+            return null;
+        }
+        /// <summary>
+        /// 获取仓库对象 单例模式 可以跨线程
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="dbName"></param>
+        /// <param name="checkTable"></param>
+        /// <returns></returns>
+        public WarehouseScope<T> GetWarehouseScope<T>(string dbName, bool checkTable = false) where T : class, IBaseTableModel, new()
+        {
+            return new WarehouseScope<T>(log, GetScope(dbName), checkTable);
+        }
+        /// <summary>
+        /// 获取客户端对象 不可以跨线程
+        /// </summary>
+        /// <param name="dbName">数据库名称</param>
+        /// <returns></returns>
+        public SqlSugarClient GetClient(string dbName)
+        {
+            if (dbConf.TryGetValue(dbName, out var conf))
+            {
+                SqlSugarClient db=  new SqlSugarClient(new ConnectionConfig()
+                {
+                    ConfigId = conf.Name,
+                    ConnectionString = conf.Connection,
+                    DbType = conf.Type,
+                    IsAutoCloseConnection = true,
+                },
+                db =>
+                {
+                    db.Aop.OnLogExecuting = (sql, pars) =>
+                    {
+                        if (conf.Print)
+                        {
+                            var currentDbName = db.CurrentConnectionConfig.ConfigId;
+                            log.Debug($"数据库{currentDbName}", $"sql:{sql}");
+                        }
+                    };
+                });
+                db.Ado.CommandTimeOut = 1;//单位秒
+                return db;
+            }
+            else
+                log.Warn("数据库", $"没有{dbName}对应的数据库");
+            return null;
+        }
+        /// <summary>
+        /// 获取仓库客户端对象 不可以跨线程
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="dbName"></param>
+        /// <param name="checkTable"></param>
+        /// <returns></returns>
+        public WarehouseClient<T> GetWarehouseClient<T>(string dbName, bool checkTable = false) where T : class, IBaseTableModel, new()
+        {
+            return new WarehouseClient<T>(log, GetClient(dbName));
+        }
+        /// <summary>
+        /// 获取仓库
+        /// </summary>
+        /// <typeparam name="T">模型类型</typeparam>
+        /// <param name="db">数据库连接对象</param>
+        /// <returns></returns>
+        public Repository<T> GetWarehouse<T>(ISqlSugarClient db, bool checkTable = false) where T : class, IBaseTableModel, new()
+        {
+            return new Repository<T>(db, checkTable);
+        }
+        /// <summary>
+        /// 获取仓库
+        /// </summary>
+        /// <typeparam name="T">模型类型</typeparam>
+        /// <param name="dbName">数据库名称</param>
+        /// <returns></returns>
+        public Repository<T> GetWarehouse<T>(string dbName, bool checkTable = false) where T : class, IBaseTableModel, new()
+        {
+            ISqlSugarClient db = GetClient(dbName);
+            return new Repository<T>(db, checkTable);
+        }
+        /// <summary>
+        /// 只是方法名称不一样 主要为了用在反射中唯一性
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="dbName"></param>
+        /// <param name="checkTable"></param>
+        /// <returns></returns>
+        public Repository<T> GetWarehouseRef<T>(string dbName, bool checkTable = false) where T : class, IBaseTableModel, new()
+        {
+            ISqlSugarClient db = GetClient(dbName);
+            return new Repository<T>(db, checkTable);
+        }
+        /// <summary>
+        /// 获取数据库配置
+        /// </summary>
+        /// <param name="name"></param>
+        /// <returns></returns>
+        public DatabaseConfig GetConfig(string name)
+        {
+            if (dbConf.TryGetValue(name, out var conf))
+            { return conf; }
+            else
+                log.Warn("数据库", $"没有{name}对应的数据库配置");
+            return null;
+        }
+        /// <summary>
+        /// 根据类型获取表名
+        /// </summary>
+        /// <param name="type">模型类型</param>
+        /// <returns></returns>
+        public string GetTableName(Type type)
+        {
+            object[] attributes = type.GetCustomAttributes(typeof(SugarTable), false);
+            if (attributes.Length > 0)
+            {
+                SugarTable sugarTable = (SugarTable)attributes[0];
+                return sugarTable.TableName;
+            }
+            return type.Name;
+        }
+    }
+    /// <summary>
+
+    public class WarehouseBase<T> where T : class, IBaseTableModel, new()
+    {
+        //var db = Mode ? (dynamic)Scope : Client;
+        /// <summary>
+        /// 获取雪花ID
+        /// </summary>
+        public long NextId { get { return SnowFlakeSingle.Instance.NextId(); } }
+        /// <summary>
+        /// 模式 true=单例模式 false=客户端模式
+        /// </summary>
+        protected bool Mode { get; set; }
+        /// <summary>
+        /// 日志服务
+        /// </summary>
+        public LogService log { get; set; }
+        /// <summary>
+        /// 单例模式实例
+        /// </summary>
+        protected SqlSugarScope Scope { get; set; }
+        /// <summary>
+        /// 客户端实例
+        /// </summary>
+        protected SqlSugarClient Client { get; set; }
+        /// <summary>
+        /// 仓储表名
+        /// </summary>
+        public string TableName { get; set; }
+        /// <summary>
+        /// 连接状态
+        /// </summary>
+        public bool ConnStatus{ get {
+            var db = Mode ? (dynamic)Scope : Client;
+                return db.Ado.IsValidConnection();
+        }}
+        /// <summary>
+        /// 数据库安全性检查
+        /// </summary>
+        /// <returns></returns>
+        public bool DatabaseSecurityCheck()
+        {
+            var db = Mode ? (dynamic)Scope : Client;
+            if (db == null)
+            {
+                LogService.Log.Warn("数据库", "数据库连接对象空");
+                return true;
+            }
+            if (!db.Ado.IsValidConnection())
+            {
+                LogService.Log.Warn("数据库", "数据库连接断开");
+                return true;
+            }
+            return false;
+        }
+        #region 表相关
+        /// <summary>
+        /// 检查表
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public bool CheckTable<T>()
+        {
+            string tableName = GetTableName(typeof(T));// typeof(T).Name;
+            if (Mode)
+            {
+                return Scope.DbMaintenance.IsAnyTable(tableName);//判断状态表是否存在
+            }
+            else
+            {
+                return Client.DbMaintenance.IsAnyTable(tableName);//判断状态表是否存在
+            }
+
+        }
+        /// <summary>
+        /// 检查表
+        /// </summary>
+        /// <param name="tableName"></param>
+        public bool CheckTable(string tableName)
+        {
+            if (Mode)
+            {
+                return Scope.DbMaintenance.IsAnyTable(tableName);//判断状态表是否存在
+            }
+            else
+            {
+                return Client.DbMaintenance.IsAnyTable(tableName);//判断状态表是否存在
+            }
+        }
+        /// <summary>
+        /// 检查并创建
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public bool CheckToCreate<T>()
+        {
+            try
+            {
+                string tableName = GetTableName(typeof(T));//获取表名
+
+                if (!CheckTable(tableName))
+                {
+                    if (Mode)
+                    {
+                        if (Scope.MappingTables == null)
+                        {
+                            Scope.MappingTables = new MappingTableList();
+                        }
+                        Scope.MappingTables.Add(typeof(T).Name, tableName); // 类名 表名
+                        Scope.CodeFirst.InitTables(typeof(T)); //创建表
+                    }
+                    else
+                    {
+                        if (Client.MappingTables == null)
+                        {
+                            Client.MappingTables = new MappingTableList();
+                        }
+                        Client.MappingTables.Add(typeof(T).Name, tableName); // 类名 表名
+                        Client.CodeFirst.InitTables(typeof(T)); //创建表
+                    }
+                    log.Info("仓库", $"创建表:{tableName},模型:{typeof(T).Name}");
+                }
+                return true;
+            }
+            catch (Exception e)
+            {
+                log.Error("数据库", $"检查创建表错误:{e.Message}");
+                return false;
+            }
+        }
+        /// <summary>
+        /// 根据类型获取表名
+        /// </summary>
+        /// <param name="type">模型类型</param>
+        /// <returns></returns>
+        public string GetTableName(Type type)
+        {
+            object[] attributes = type.GetCustomAttributes(typeof(SugarTable), false);
+            if (attributes.Length > 0)
+            {
+                SugarTable sugarTable = (SugarTable)attributes[0];
+                return sugarTable.TableName;
+            }
+            return type.Name;
+        }
+        #endregion
+        
+    }
+    /// <summary>
+    /// 仓储单例模式 可以跨线程
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class WarehouseScope<T>: WarehouseBase<T> where T : class, IBaseTableModel, new()
+    {
+        /// <summary>
+        /// 数据库对象
+        /// </summary>
+        public SqlSugarScope Db{ get;}
+        /// <summary>
+        /// 构建仓储
+        /// </summary>
+        /// <param name="logService"></param>
+        /// <param name="db"></param>
+        /// <param name="checkTable"></param>
+        public WarehouseScope (LogService logService, SqlSugarScope db, bool checkTable = false)
+        {
+            base.Mode = true;
+            base.Scope = db;
+            base.log = logService;
+            this.Db= db;
+            this.TableName = GetTableName(typeof(T));//获取表名
+            if (checkTable)
+            {
+                CheckToCreate<T>();
+            }
+        }
+    }
+    /// <summary>
+    /// 仓储客户端模式  不能跨线程
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class WarehouseClient<T>: WarehouseBase<T> where T : class, IBaseTableModel, new()
+    {
+        /// <summary>
+        /// 数据库对象
+        /// </summary>
+        public SqlSugarClient Db { get; }
+        /// <summary>
+        /// 构建仓储
+        /// </summary>
+        /// <param name="logService"></param>
+        /// <param name="db"></param>
+        /// <param name="checkTable"></param>
+        public WarehouseClient(LogService logService, SqlSugarClient db, bool checkTable = false)
+        {
+            base.Mode = false;
+            base.Client = db;
+            base.log = logService;
+            this.Db = db;
+            this.TableName = GetTableName(typeof(T));//获取表名
+            if (checkTable)
+            {
+                CheckToCreate<T>();
+            }
+        }
+    }   
+    /// <summary>
+    /// 创建仓库
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class Repository<T> : SimpleClient<T> where T : class, IBaseTableModel,new()
+    {
+        /// <summary>
+        /// 获取雪花ID
+        /// </summary>
+        public long NextId { get { return SnowFlakeSingle.Instance.NextId(); } }
+        /// <summary>
+        /// 
+        /// </summary>
+        private ISqlSugarClient db;
+        /// <summary>
+        /// 数据库连接对象
+        /// </summary>
+        public ISqlSugarClient Db { get => db;}
+        /// <summary>
+        /// 空表名
+        /// </summary>
+        private string tableName = "空表名";
+        /// <summary>
+        /// 日志
+        /// </summary>
+        LogService log;
+        /// <summary>
+        /// 创建仓库
+        /// </summary>
+        /// <param name="dbClient">数据库连接实例</param>
+        /// <param name="checkTable">是否创建表</param>
+        public Repository(ISqlSugarClient dbClient,bool checkTable=false)
+        {
+            log = LogService.Log;
+            base.Context = dbClient;//赋值给基类
+            db = dbClient;
+            tableName = GetTableName(typeof(T));//获取表名
+            if (db.Ado.IsValidConnection())
+            {
+                if (checkTable)
+                {
+                    CheckToCreate<T>();
+                }
+            }
+            else
+            {
+                log.Error("仓储", $"{typeof(T).Name}数据库连接不成功");
+            }
+        }        
+        /// <summary>
+        /// 数据库连接状态
+        /// </summary>
+        /// <returns></returns>
+        public bool Connection()
+        {
+            return db.Ado.IsValidConnection();
+        }
+        #region 工具方法
+        /// <summary>
+        /// 从json字符串中对象中获取所有属性的key
+        /// </summary>
+        /// <param name="jsonString">key的数据</param>
+        /// <returns></returns>
+        public List<string> GetKeysFromJson(string jsonString)
+        {
+            // 将 JSON 字符串解析为字典
+            var dictionary = JsonSerializer.Deserialize<Dictionary<string, object>>(jsonString);
+
+            // 获取所有的键并转换为列表
+            List<string> keys = new List<string>(dictionary.Keys);
+
+            return keys;
+        }
+        #endregion
+        #region 表相关
+        /// <summary>
+        /// 检查表
+        /// </summary>
+        /// <param name="tableName"></param>
+        public bool CheckTable(string tableName)
+        {
+            return Db.DbMaintenance.IsAnyTable(tableName);//判断状态表是否存在
+        }
+        /// <summary>
+        /// 检查表
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public bool CheckTable<T>()
+        {
+            string tableName = GetTableName(typeof(T));// typeof(T).Name;
+            return Db.DbMaintenance.IsAnyTable(tableName);//判断状态表是否存在
+        }
+        /// <summary>
+        /// 检查并创建
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public bool CheckToCreate<T>()
+        {
+            try
+            {
+                string tableName = GetTableName(typeof(T));//获取表名
+                if (!Db.DbMaintenance.IsAnyTable(tableName))//判断状态表是否存在
+                {
+                    if (Db.MappingTables == null)
+                    {
+                        Db.MappingTables = new MappingTableList();
+                    }
+                    Db.MappingTables.Add(typeof(T).Name, tableName); // 类名 表名
+                    Db.CodeFirst.InitTables(typeof(T)); //创建表
+                    log.Info("仓库", $"创建表:{tableName},模型:{typeof(T).Name}");
+                }
+                return true;
+            }
+            catch (Exception e)
+            {
+                return false;
+            }
+        }
+        /// <summary>
+        /// 根据类型获取表名
+        /// </summary>
+        /// <param name="type">模型类型</param>
+        /// <returns></returns>
+        string GetTableName(Type type)
+        {
+            object[] attributes = type.GetCustomAttributes(typeof(SugarTable), false);
+            if (attributes.Length > 0)
+            {
+                SugarTable sugarTable = (SugarTable)attributes[0];
+                return sugarTable.TableName;
+            }
+            return type.Name;
+        }
+        #endregion
+        #region 增
+        /// <summary>
+        /// 增加数据
+        /// </summary>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        public int Insert( List<T> data)
+        {
+            return Db.Insertable(data).ExecuteCommand();
+        }
+        #endregion
+        #region 插入更新
+        /// <summary>
+        /// 存在数据库更新 不存在插入 (默认是主键)
+        /// </summary>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        public int InsertUpdate(T data)
+        {
+           return db.Storageable(data).ExecuteCommand();
+        }
+        #endregion
+        #region 删
+        /// <summary>
+        /// 删除指定时间之前的数据
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="hours"></param>
+        /// <returns></returns>
+        public int DeleteDataByHours(int hours) 
+        {
+            DateTime targetTime = DateTime.Now.AddHours(-hours);// 计算要删除数据的时间点
+            return db.Deleteable<T>().Where(it => it.CreateTime < targetTime).ExecuteCommand();
+        }
+        /// <summary>
+        /// 删除当前时间指定天数之前的数据
+        /// </summary>
+        /// <param name="day"></param>
+        /// <returns></returns>
+        public int DeleteDataByDay(int day)
+        {
+            DateTime targetTime = DateTime.Now.AddDays(-day);// 计算要删除数据的时间点
+            return db.Deleteable<T>().Where(it => it.CreateTime < targetTime).ExecuteCommand();
+        }
+        /// <summary>
+        /// 已创建时间保留最新N条数据 其余删除
+        /// </summary>
+        /// <param name="N"></param>
+        /// <returns></returns>
+        public int ClearTheLatestNItems(int N)
+        {
+            return db.Deleteable<T>().In(it => it.Id,db.Queryable<T>().Skip(10).OrderByDescending(it => it.CreateTime)//Take(10)最新10条2个有区别
+                   .Select(it => it.Id)).ExecuteCommand();
+        }
+        
+        #endregion
+        #region 改
+        /// <summary>
+        /// 设置同步状态
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
+        public int SetSyncStatus(T data)
+        {
+            data.SyncStatus = 1;
+            return db.Updateable(data).UpdateColumns(it => new { it.SyncStatus}).ExecuteCommand();
+        }
+        #endregion
+        #region 查
+        /// <summary>
+        /// 查询记录是否存在
+        /// </summary>
+        /// <param name="fieldName">字段名称</param>
+        /// <param name="fieldValue">字段值</param>
+        /// <param name="conditionalType">条件类型 默认==等于</param>
+        /// <returns></returns>
+        public bool Queryable(string fieldName,object fieldValue, string conditionalType="==")
+        {
+            return db.Queryable<T>().Where( fieldName, conditionalType, fieldValue).Any();
+        }
+        /// <summary>
+        /// 分页查询
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="pageNumber"></param>
+        /// <param name="pageSize"></param>
+        /// <param name="totalNumber"></param>
+        /// <param name="totalPage"></param>
+        /// <returns></returns>
+        public  List<T> QueryPage<T>(int pageNumber, int pageSize, ref int totalNumber, ref int totalPage)
+        {
+            return db.Queryable<T>().ToPageList(pageNumber, pageSize, ref totalNumber, ref totalPage);
+        }
+        /// <summary>
+        /// 获取未同步的数据10条
+        /// </summary>
+        /// <returns></returns>
+        public List<T> GetUnsynchronizedData()
+        {
+           return db.Queryable<T>().Take(10).Where(it=>it.SyncStatus==0).ToList();
+        }
+
+        #endregion
+    }
+    /// <summary>
+    /// 数据库配置模型
+    /// </summary>
+    public class DatabaseConfig
+    {
+        // 数据库名称
+        public string Name { get; set; }
+
+        // 数据库是否使能
+        public bool Enabled { get; set; }=false;
+
+        // 数据库类型，例如 "SQLServer", "MySQL", "PostgreSQL" 等
+        public DbType Type { get; set; } = DbType.Sqlite;
+
+        // 数据库连接字符串
+        public string Connection { get; set; }
+
+        // 数据库配置备注
+        public string Remarks { get; set; } = "";
+
+        // 是否打印日志等相关信息
+        public bool Print { get; set; } = false;
+
+    }
+    /// <summary>
+    /// 数据库基类接口
+    /// </summary>
+    public interface IBaseTableModel
+    {
+        int Id { get; set; }
+        DateTime CreateTime { get; set; }
+        DateTime UpdateTime { get; set; }
+        string Remarks { get; set; }
+        int SyncStatus { get; set; }
+    }
+    /// <summary>
+    /// 数据模型基类
+    /// </summary>
+    public class BaseTableModel: IBaseTableModel
+    {
+        // 主键 ID
+        [SugarColumn(IsIdentity = true, IsPrimaryKey = true, ColumnDescription = "主键")]//主键标识 自增标识
+        public int Id { get; set; }
+
+        // 创建时间
+        [SugarColumn(ColumnDescription = "创建时间")]
+        public DateTime CreateTime { get; set; }= DateTime.Now;
+
+        // 更新时间
+        [SugarColumn(ColumnDescription = "更新时间")]
+        public DateTime UpdateTime { get; set; } = DateTime.Now;
+
+        // 同步状态
+        [SugarColumn(ColumnDescription = "同步状态")]
+        public int SyncStatus { get; set; } = 0;
+
+        // 备注信息
+        [SugarColumn(ColumnDescription = "备注信息", IsNullable = true)]
+        public string Remarks { get; set; } = "";
+    }
+    /// <summary>
+    /// 数据库同步特性
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
+    public class DatabaseSyncAttribute : Attribute
+    {
+        /// <summary>
+        /// 源数据库
+        /// </summary>
+        public string Source { get; }
+        /// <summary>
+        /// 目标数据库
+        /// </summary>
+        public string Target { get; }
+        /// <summary>
+        /// 清理使能
+        /// </summary>
+        public bool CleanupEnabled { get; set; } = false;  // 默认不清理
+        /// <summary>
+        /// 清理模式 false 默认保留天数 
+        /// </summary>
+        public bool CleanupMode { get; set; } = false;
+        /// <summary>
+        /// 保留数 CleanupMode=true (保留条数)  =false (保留天数) 默认保留30天
+        /// </summary>
+        public int RetentionCount { get; set; } = 30;
+
+        /// <summary>
+        /// 数据库同步特性
+        /// </summary>
+        /// <param name="source">源数据库</param>
+        /// <param name="target">目标数据库</param>
+        /// <param name="cleanupEnabled">源表清理使能</param>
+        /// <param name="cleanupMode">清理模式 =true保留条数 =false 默认保留天数 </param>
+        /// <param name="retentionCount">保留数 CleanupMode=true (保留条数)  =false (保留天数) 默认保留30天</param>
+        public DatabaseSyncAttribute(string source, string target,bool cleanupEnabled=false,bool cleanupMode=false,int retentionCount=30)
+        {
+            Source = source;
+            Target = target;
+            CleanupEnabled = cleanupEnabled;
+            CleanupMode = cleanupMode;
+            RetentionCount = retentionCount;
+        }
+    }
+    /// <summary>
+    /// SqlSugar条件构建器，用于简化条件查询的构建
+    /// </summary>
+    public class ConditionBuilder
+    {
+        private List<IConditionalModel> _conditions = new List<IConditionalModel>();
+        private Dictionary<string, GroupConditionBuilder> _namedGroups = new Dictionary<string, GroupConditionBuilder>();
+
+        /// <summary>
+        /// 获取构建的条件列表
+        /// </summary>
+        public List<IConditionalModel> Build()
+        {
+            var result = new List<IConditionalModel>(_conditions);         
+            // 添加所有命名条件组
+            foreach (var group in _namedGroups.Values)
+            {
+                result.Add(group.Build());
+            }
+            
+            return result;
+        }
+
+        /// <summary>
+        /// 添加简单条件
+        /// </summary>
+        /// <param name="fieldName">字段名</param>
+        /// <param name="conditionalType">条件类型</param>
+        /// <param name="fieldValue">字段值</param>
+        /// <returns>当前构建器实例</returns>
+        public ConditionBuilder Where(string fieldName, CondType conditionalType, object fieldValue, string cSharpTypeName=null)
+        {
+            _conditions.Add(new ConditionalModel
+            {
+                FieldName = fieldName,
+                ConditionalType =(ConditionalType)conditionalType,
+                FieldValue = fieldValue?.ToString(),
+                CSharpTypeName = cSharpTypeName
+            });
+            return this;
+        }
+
+        /// <summary>
+        /// 添加等于条件
+        /// </summary>
+        public ConditionBuilder WhereEqual(string fieldName, object fieldValue, string cSharpTypeName = null)
+        {
+            return Where(fieldName, CondType.Equal, fieldValue, cSharpTypeName);
+        }
+
+        /// <summary>
+        /// 添加不等于条件
+        /// </summary>
+        public ConditionBuilder WhereNotEqual(string fieldName, object fieldValue, string cSharpTypeName = null)
+        {
+            return Where(fieldName, CondType.NoEqual, fieldValue);
+        }
+
+        /// <summary>
+        /// 添加大于条件
+        /// </summary>
+        public ConditionBuilder WhereGreaterThan(string fieldName, object fieldValue, string cSharpTypeName = null)
+        {
+            return Where(fieldName, CondType.GreaterThan, fieldValue);
+        }
+
+        /// <summary>
+        /// 添加大于等于条件
+        /// </summary>
+        public ConditionBuilder WhereGreaterThanOrEqual(string fieldName, object fieldValue, string cSharpTypeName = null)
+        {
+            return Where(fieldName, CondType.GreaterThanOrEqual, fieldValue, cSharpTypeName);
+        }
+
+        /// <summary>
+        /// 添加小于条件
+        /// </summary>
+        public ConditionBuilder WhereLessThan(string fieldName, object fieldValue, string cSharpTypeName = null)
+        {
+            return Where(fieldName, CondType.LessThan, fieldValue, cSharpTypeName);
+        }
+
+        /// <summary>
+        /// 添加小于等于条件
+        /// </summary>
+        public ConditionBuilder WhereLessThanOrEqual(string fieldName, object fieldValue, string cSharpTypeName = null)
+        {
+            return Where(fieldName, CondType.LessThanOrEqual, fieldValue, cSharpTypeName);
+        }
+
+        /// <summary>
+        /// 添加Like条件
+        /// </summary>
+        public ConditionBuilder WhereLike(string fieldName, string fieldValue, string cSharpTypeName = null)
+        {
+            return Where(fieldName, CondType.Like, fieldValue, cSharpTypeName);
+        }
+
+        /// <summary>
+        /// 添加In条件
+        /// </summary>
+        public ConditionBuilder WhereIn(string fieldName, params object[] values)
+        {
+            return Where(fieldName, CondType.In, string.Join(",", values));
+        }
+
+        /// <summary>
+        /// 添加复杂条件组
+        /// </summary>
+        /// <param name="builderAction">条件组构建器委托</param>
+        /// <returns>当前构建器实例</returns>
+        public ConditionBuilder WhereGroup(Action<GroupConditionBuilder> builderAction)
+        {
+            var groupBuilder = new GroupConditionBuilder();
+            builderAction(groupBuilder);
+            _conditions.Add(groupBuilder.Build());
+            return this;
+        }
+
+        /// <summary>
+        /// 添加命名的复杂条件组，可以在后续代码中继续添加条件
+        /// </summary>
+        /// <param name="groupName">条件组名称</param>
+        /// <param name="builderAction">条件组构建器委托</param>
+        /// <returns>当前构建器实例</returns>
+        public ConditionBuilder WhereGroup(string groupName, Action<GroupConditionBuilder> builderAction)
+        {
+            if (!_namedGroups.TryGetValue(groupName, out var groupBuilder))
+            {
+                groupBuilder = new GroupConditionBuilder();
+                _namedGroups.Add(groupName, groupBuilder);
+            }
+            
+            builderAction(groupBuilder);
+            return this;
+        }
+
+        /// <summary>
+        /// 获取已命名的条件组构建器
+        /// </summary>
+        /// <param name="groupName">条件组名称</param>
+        /// <returns>条件组构建器</returns>
+        public GroupConditionBuilder GetGroup(string groupName)
+        {
+            if (!_namedGroups.TryGetValue(groupName, out var groupBuilder))
+            {
+                groupBuilder = new GroupConditionBuilder();
+                _namedGroups.Add(groupName, groupBuilder);
+            }
+            return groupBuilder;
+        }
+    }
+    /// <summary>
+    /// 条件组构建器，用于构建复杂的条件组
+    /// </summary>
+    public class GroupConditionBuilder
+    {
+        private List<KeyValuePair<WhereType, ConditionalModel>> _conditionalList = new List<KeyValuePair<WhereType, ConditionalModel>>();
+        private WhereType _defaultWhereType = WhereType.And;
+
+        /// <summary>
+        /// 设置默认的连接类型（And/Or）
+        /// </summary>
+        public GroupConditionBuilder SetDefaultWhereType(WhereType whereType)
+        {
+            _defaultWhereType = whereType;
+            return this;
+        }
+
+        /// <summary>
+        /// 构建条件集合
+        /// </summary>
+        public ConditionalCollections Build()
+        {
+            return new ConditionalCollections
+            {
+                ConditionalList = _conditionalList
+            };
+        }
+
+        /// <summary>
+        /// 添加条件（使用默认连接类型）
+        /// </summary>
+        public GroupConditionBuilder Where(string fieldName, CondType conditionalType, object fieldValue, string cSharpTypeName = null)
+        {
+            return Where(_defaultWhereType, fieldName,conditionalType, fieldValue, cSharpTypeName);
+        }
+
+        /// <summary>
+        /// 添加条件（指定连接类型）
+        /// </summary>
+        public GroupConditionBuilder Where(WhereType whereType, string fieldName, CondType conditionalType, object fieldValue, string cSharpTypeName = null)
+        {
+            _conditionalList.Add(new KeyValuePair<WhereType, ConditionalModel>(
+                whereType,
+                new ConditionalModel
+                {
+                    FieldName = fieldName,
+                    ConditionalType = (ConditionalType)conditionalType,
+                    FieldValue = fieldValue?.ToString(),
+                    CSharpTypeName = cSharpTypeName
+                }
+            ));
+            return this;
+        }
+
+        /// <summary>
+        /// 添加And连接的条件
+        /// </summary>
+        public GroupConditionBuilder And(string fieldName, CondType conditionalType, object fieldValue, string cSharpTypeName = null)
+        {
+            return Where(WhereType.And, fieldName, conditionalType, fieldValue, cSharpTypeName);
+        }
+
+        /// <summary>
+        /// 添加Or连接的条件
+        /// </summary>
+        public GroupConditionBuilder Or(string fieldName, CondType conditionalType, object fieldValue, string cSharpTypeName = null)
+        {
+            return Where(WhereType.Or, fieldName, conditionalType, fieldValue, cSharpTypeName);
+        }
+
+        /// <summary>
+        /// 添加And连接的等于条件
+        /// </summary>
+        public GroupConditionBuilder AndEqual(string fieldName, object fieldValue, string cSharpTypeName = null)
+        {
+            return And(fieldName, CondType.Equal, fieldValue, cSharpTypeName);
+        }
+
+        /// <summary>
+        /// 添加Or连接的等于条件
+        /// </summary>
+        public GroupConditionBuilder OrEqual(string fieldName, object fieldValue, string cSharpTypeName = null)
+        {
+            return Or(fieldName, CondType.Equal, fieldValue, cSharpTypeName);
+        }
+
+        /// <summary>
+        /// 添加And连接的不等于条件
+        /// </summary>
+        public GroupConditionBuilder AndNotEqual(string fieldName, object fieldValue, string cSharpTypeName = null)
+        {
+            return And(fieldName, CondType.NoEqual, fieldValue, cSharpTypeName);
+        }
+
+        /// <summary>
+        /// 添加Or连接的不等于条件
+        /// </summary>
+        public GroupConditionBuilder OrNotEqual(string fieldName, object fieldValue, string cSharpTypeName = null)
+        {
+            return Or(fieldName, CondType.NoEqual, fieldValue, cSharpTypeName);
+        }
+
+        /// <summary>
+        /// 添加And连接的Like条件
+        /// </summary>
+        public GroupConditionBuilder AndLike(string fieldName, string fieldValue, string cSharpTypeName = null)
+        {
+            return And(fieldName, CondType.Like, fieldValue, cSharpTypeName);
+        }
+
+        /// <summary>
+        /// 添加Or连接的Like条件
+        /// </summary>
+        public GroupConditionBuilder OrLike(string fieldName, string fieldValue, string cSharpTypeName = null)
+        {
+            return Or(fieldName, CondType.Like, fieldValue, cSharpTypeName);
+        }
+
+        // 可以根据需要添加更多便捷方法
+    }
+    /// <summary>
+    /// 条件类型枚举
+    /// </summary>
+    public enum CondType
+    {
+        /// <summary> 
+        /// 等于条件，用于判断字段值是否等于指定值 
+        /// </summary> 
+        Equal,
+
+        /// <summary>
+        /// 模糊匹配，相当于 SQL 中的 LIKE '%value%'
+        /// </summary>
+        Like,
+
+        /// <summary>
+        /// 大于条件，相当于 SQL 中的 >
+        /// </summary>
+        GreaterThan,
+
+        /// <summary>
+        /// 大于等于条件，相当于 SQL 中的 >=
+        /// </summary>
+        GreaterThanOrEqual,
+
+        /// <summary>
+        /// 小于条件，相当于 SQL 中的 <
+        /// </summary>
+        LessThan,
+
+        /// <summary>
+        /// 小于等于条件，相当于 SQL 中的 <=
+        /// </summary>
+        LessThanOrEqual,
+
+        /// <summary>
+        /// 包含条件，相当于 SQL 中的 IN
+        /// </summary>
+        In,
+
+        /// <summary>
+        /// 不包含条件，相当于 SQL 中的 NOT IN
+        /// </summary>
+        NotIn,
+
+        /// <summary>
+        /// 左模糊匹配，相当于 SQL 中的 LIKE '%value'
+        /// </summary>
+        LikeLeft,
+
+        /// <summary>
+        /// 右模糊匹配，相当于 SQL 中的 LIKE 'value%'
+        /// </summary>
+        LikeRight,
+
+        /// <summary>
+        /// 不等于条件，相当于 SQL 中的 != 或 <>
+        /// </summary>
+        NoEqual,
+        /// <summary>
+        /// 判断字段是否为 null 或空
+        /// </summary>
+        IsNullOrEmpty,
+
+        /// <summary>
+        /// 不是条件，用于否定判断
+        /// </summary>
+        IsNot,
+
+        /// <summary>
+        /// 不包含，相当于 SQL 中的 NOT LIKE
+        /// </summary>
+        NoLike,
+
+        /// <summary>
+        /// 等于 null 条件
+        /// </summary>
+        EqualNull,
+
+        /// <summary>
+        /// 包含模糊匹配，可以进行多个值的模糊查询
+        /// </summary>
+        InLike,
+
+        /// <summary>
+        /// 范围查询，用于指定一个值的范围
+        /// </summary>
+        Range
+    }
+}
diff --git a/Services/EventService.cs b/Services/EventService.cs
new file mode 100644
index 0000000..3da7cb5
--- /dev/null
+++ b/Services/EventService.cs
@@ -0,0 +1,233 @@
+using System;
+using System.Collections.Concurrent;
+using System.Threading.Tasks;
+
+namespace guoke
+{
+    /// <summary>
+    /// 通用事件参数类，继承自 EventArgs，用于传递事件相关的消息和数据。
+    /// </summary>
+    public class GeneralEventArgs : EventArgs
+    {
+        /// <summary>
+        /// 获取或设置事件相关的消息。
+        /// </summary>
+        public string Message { get; set; }
+
+        /// <summary>
+        /// 获取或设置事件相关的数据。
+        /// </summary>
+        public object Data { get; set; }
+
+        /// <summary>
+        /// 初始化 GeneralEventArgs 类的新实例。
+        /// </summary>
+        /// <param name="message">事件相关的消息。</param>
+        /// <param name="data">事件相关的数据。</param>
+        public GeneralEventArgs(string message, object data)
+        {
+            Message = message;
+            Data = data;
+        }
+    }
+
+    /// <summary>
+    /// 事件字典，用于管理和触发事件。
+    /// </summary>
+    /// <typeparam name="TEventArgs">事件参数的类型，必须继承自 EventArgs。</typeparam>
+    public class EventService<TEventArgs> where TEventArgs : EventArgs
+    {
+        // 使用并发字典来存储事件，减少锁的使用
+        private readonly ConcurrentDictionary<string, EventHandler<TEventArgs>> _events = new ConcurrentDictionary<string, EventHandler<TEventArgs>>();
+        private readonly ConcurrentDictionary<string, Func<object, TEventArgs, Task>> _asyncEvents = new ConcurrentDictionary<string, Func<object, TEventArgs, Task>>();
+
+        private LogService log;
+        public EventService(LogService logService) 
+        {
+            log = logService;
+        }
+        /// <summary>
+        /// 验证事件名称和处理程序是否有效。
+        /// </summary>
+        /// <param name="eventName">事件名称。</param>
+        /// <param name="handler">事件处理程序。</param>
+        private bool ValidateEventParams(string eventName, Delegate handler)
+        {
+            if (string.IsNullOrEmpty(eventName))
+            {
+                log.Warn($"事件名称不能为 null 或空字符串");
+                return false;
+            }
+            if (handler == null)
+            {
+                log.Warn($"事件处理程序不能为 null");
+                return false;
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// 验证事件名称和事件参数是否有效。
+        /// </summary>
+        /// <param name="eventName">事件名称。</param>
+        /// <param name="e">事件参数。</param>
+        private bool ValidateTriggerParams(string eventName, TEventArgs e)
+        {
+            if (string.IsNullOrEmpty(eventName))
+            {
+                log.Warn($"事件名称不能为 null 或空字符串");
+                return false;
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// 添加同步事件处理程序。
+        /// </summary>
+        /// <param name="eventName">事件名称，不能为 null 或空字符串。</param>
+        /// <param name="handler">事件回调方法，不能为 null。</param>
+        public void AddEventHandler(string eventName, EventHandler<TEventArgs> handler)
+        {
+            // 参数验证
+            if (ValidateEventParams(eventName, handler))
+            {
+                // 使用并发字典的 AddOrUpdate 方法来添加或更新事件处理程序
+                _events.AddOrUpdate(eventName, handler, (key, existingHandler) => existingHandler + handler);
+                log.Info($"添加同步事件:[{eventName}]成功");
+            }
+            else
+                log.Warn($"添加同步事件:[{eventName}]失败");
+        }
+
+        /// <summary>
+        /// 添加异步事件处理程序。
+        /// </summary>
+        /// <param name="eventName">事件名称，不能为 null 或空字符串。</param>
+        /// <param name="asyncHandler">异步事件回调方法，不能为 null。</param>
+        public void AddAsyncEventHandler(string eventName, Func<object, TEventArgs, Task> asyncHandler)
+        {
+            // 参数验证
+           if( ValidateEventParams(eventName, asyncHandler))
+            {
+                // 使用并发字典的 AddOrUpdate 方法来添加或更新异步事件处理程序
+                _asyncEvents.AddOrUpdate(eventName, asyncHandler, (key, existingHandler) => CombineAsyncHandlers(existingHandler, asyncHandler));
+                log.Info($"添加异步事件:[{eventName}]成功");
+            }
+            else
+                log.Warn($"添加异步事件:[{eventName}]失败");
+        }
+
+        private Func<object, TEventArgs, Task> CombineAsyncHandlers(Func<object, TEventArgs, Task> existingHandler, Func<object, TEventArgs, Task> newHandler)
+        {
+            return async (sender, e) =>
+            {
+                await existingHandler(sender, e);
+                await newHandler(sender, e);
+            };
+        }
+
+        /// <summary>
+        /// 移除同步事件处理程序。
+        /// </summary>
+        /// <param name="eventName">事件名称，不能为 null 或空字符串。</param>
+        /// <param name="handler">事件方法，不能为 null。</param>
+        public void RemoveEventHandler(string eventName, EventHandler<TEventArgs> handler)
+        {
+            // 参数验证
+            ValidateEventParams(eventName, handler);
+
+            // 尝试获取事件处理程序
+            if (_events.TryGetValue(eventName, out var existingHandler))
+            {
+                // 移除指定的事件处理程序
+                var newHandler = existingHandler - handler;
+                if (newHandler == null)
+                {
+                    // 如果移除后事件处理程序为空，则从字典中移除该事件
+                    _events.TryRemove(eventName, out _);
+                }
+                else
+                {
+                    // 更新事件处理程序
+                    _events[eventName] = newHandler;
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// 移除异步事件处理程序。
+        /// </summary>
+        /// <param name="eventName">事件名称，不能为 null 或空字符串。</param>
+        /// <param name="asyncHandler">异步事件方法，不能为 null。</param>
+        public void RemoveAsyncEventHandler(string eventName, Func<object, TEventArgs, Task> asyncHandler)
+        {
+            // 参数验证
+            ValidateEventParams(eventName, asyncHandler);
+
+            // 尝试获取事件处理程序
+            if (_asyncEvents.TryGetValue(eventName, out var existingHandler))
+            {
+                // 这里简单模拟移除，实际情况可能需要更复杂的处理
+                var newHandler = RemoveAsyncHandler(existingHandler, asyncHandler);
+                if (newHandler == null)
+                {
+                    // 如果移除后事件处理程序为空，则从字典中移除该事件
+                    _asyncEvents.TryRemove(eventName, out _);
+                }
+                else
+                {
+                    // 更新事件处理程序
+                    _asyncEvents[eventName] = newHandler;
+                }
+            }
+        }
+
+        private Func<object, TEventArgs, Task> RemoveAsyncHandler(Func<object, TEventArgs, Task> existingHandler, Func<object, TEventArgs, Task> handlerToRemove)
+        {
+            // 简单实现，需要根据实际组合逻辑调整
+            return (sender, e) =>
+            {
+                // 这里简单跳过要移除的处理程序
+                return existingHandler(sender, e);
+            };
+        }
+
+        /// <summary>
+        /// 触发同步事件。
+        /// </summary>
+        /// <param name="eventName">事件名，不能为 null 或空字符串。</param>
+        /// <param name="sender">事件发布者，可以用来传递数据。</param>
+        /// <param name="e">事件参数对象，不能为 null。</param>
+        public void TriggerEvent(string eventName, object sender, TEventArgs e)
+        {
+            // 参数验证
+            ValidateTriggerParams(eventName, e);
+
+            // 尝试获取事件处理程序并触发事件
+            if (_events.TryGetValue(eventName, out var handler))
+            {
+                handler?.Invoke(sender, e);
+            }
+        }
+
+        /// <summary>
+        /// 触发异步事件。
+        /// </summary>
+        /// <param name="eventName">事件名，不能为 null 或空字符串。</param>
+        /// <param name="sender">事件发布者，可以用来传递数据。</param>
+        /// <param name="e">事件参数对象，不能为 null。</param>
+        /// <returns>表示异步操作的任务。</returns>
+        public async Task TriggerAsyncEvent(string eventName, object sender, TEventArgs e)
+        {
+            // 参数验证
+            ValidateTriggerParams(eventName, e);
+
+            // 尝试获取异步事件处理程序并触发事件
+            if (_asyncEvents.TryGetValue(eventName, out var asyncHandler))
+            {
+                await asyncHandler(sender, e);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Services/LogService.cs b/Services/LogService.cs
new file mode 100644
index 0000000..0c53e21
--- /dev/null
+++ b/Services/LogService.cs
@@ -0,0 +1,253 @@
+using HslCommunication.LogNet;
+using System.Collections.Concurrent;
+using System.IO;
+using WinFormsApp.Utils;
+
+namespace guoke
+{
+    /// <summary>
+    /// 日志服务
+    /// </summary>
+    public class LogService
+    {
+        public static LogService Log;
+        // 按照文件大小切割日志，指定10M，不限制日志文件数量
+        public ILogNet logNet { get; set; }
+        public LogService()
+        {
+            LogConfigModel logConfig = new LogConfigModel();
+            //构建配置
+            logConfig = ConfigReader.GetObject<LogConfigModel>("Logs");
+         
+            //创建日志实例
+            logNet = new LogNetFileSize(System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, logConfig.LogFilePath), logConfig.MaxFileSize * 1024 * 1024, logConfig.MaxArchiveFiles);            
+            logNet.SetMessageDegree(logConfig.LogLevel);
+            // 如果所有的日志在记录之前需要在控制台显示出来
+            logNet.BeforeSaveToFile += (object sender, HslEventArgs e) =>
+            {
+                Console.WriteLine(e.HslMessage.ToString());
+            };
+            Log = this;
+            Log.Info("日志", $"等级:{logConfig.LogLevel},大小:{logConfig.MaxFileSize * 1024 * 1024}B,数量:{logConfig.MaxArchiveFiles}");
+        }
+        #region 时间
+        // 使用并发字典替代普通字典+锁，提高并发性能
+        private static readonly ConcurrentDictionary<string, DateTime> _loggedMessages =
+            new ConcurrentDictionary<string, DateTime>();
+
+        // 过期时间配置为60秒
+        private static TimeSpan _expirationTime = TimeSpan.FromSeconds(60);
+
+        // 上次清理时间
+        private static DateTime _lastCleanupTime = DateTime.MinValue;
+
+        // 清理间隔设置为过期时间的一半，平衡性能和内存使用
+        private static TimeSpan _cleanupInterval = TimeSpan.FromSeconds(30);
+        /// <summary>
+        /// 记录错误日志（带时间控制）
+        /// </summary>
+        /// <param name="message">日志消息</param>
+        public  void ErrorTime(string key, string message, bool log = true) => LogWithTimeControl(key, message, Error, log);
+        /// <summary>
+        /// 记录警告日志（带时间控制）
+        /// </summary>
+        /// <param name="message">日志消息</param>
+        public  void WarnTime(string key, string message, bool log = true) => LogWithTimeControl(key, message, Warn, log);
+        /// <summary>
+        /// 记录警告日志（带时间控制）
+        /// </summary>
+        /// <param name="message">日志消息</param>
+        public  void InfoTime(string key, string message, bool log = true) => LogWithTimeControl(key, message, Info, log);
+        // 带时间控制的通用日志记录方法
+        private  void LogWithTimeControl(string key, string message, Action<string, string> logAction, bool log)
+        {
+            if (log)
+            {
+                TryCleanupExpiredMessages();
+
+                // 检查消息是否已记录且未过期
+                if (_loggedMessages.TryGetValue(message, out var lastLoggedTime) &&
+                    (DateTime.Now - lastLoggedTime) <= _expirationTime)
+                {
+                    return;
+                }
+                // 记录日志并更新记录时间
+                logAction($"T:{key}", message);
+                _loggedMessages.AddOrUpdate(message, DateTime.Now, (_, __) => DateTime.Now);
+            }
+        }
+
+        // 尝试清理过期消息
+        private static void TryCleanupExpiredMessages()
+        {
+            var now = DateTime.Now;
+
+            // 检查是否达到清理间隔
+            if ((now - _lastCleanupTime) < _cleanupInterval)
+            {
+                return;
+            }
+
+            // 获取所有过期键
+            var expiredKeys = _loggedMessages
+                .Where(kv => (now - kv.Value) > _expirationTime)
+                .Select(kv => kv.Key)
+                .ToList();
+
+            // 移除过期键
+            foreach (var key in expiredKeys)
+            {
+                _loggedMessages.TryRemove(key, out _);
+            }
+
+            _lastCleanupTime = now;
+        }
+        #endregion
+        public void String(string message)
+        {
+            logNet.WriteAnyString($"mes:{message}");// 写任意的数据，不受格式化影响
+        }
+        public void Debug(string message)
+        {
+            logNet.WriteDebug(message);
+        }
+        public void Info(string message)
+        {
+            logNet.WriteInfo(message);
+        }
+        public void Warn(string message)
+        {
+            logNet.WriteWarn(message);
+        }
+        public void Error(string message)
+        {
+            logNet.WriteError(message);
+        }
+        public void Fatal(string message)
+        {
+            logNet.WriteFatal(message);
+        }
+        public void Debug(string key, string message)
+        {
+            logNet.WriteDebug(key,message);
+        }
+        public void Info(string key, string message)
+        {
+            logNet.WriteInfo(key, message);
+        }
+        public  void Warn(string key, string message)
+        {
+            logNet.WriteWarn(key, message);
+        }
+        public  void Error(string key, string message)
+        {
+            logNet.WriteError(key, message);
+        }
+        public void Warn(string key, string message,bool log=true)
+        {
+            if (log)
+                logNet.WriteWarn(key, message);
+        }
+        public void Error(string key, string message, bool log = true)
+        {
+            if (log)
+                logNet.WriteError(key, message);
+        }
+        public void Fatal(string key, string message, bool log = true)
+        {
+            if (log)
+                logNet.WriteFatal(key, message);
+        }
+        /// <summary>
+        /// 获取日志文件列表
+        /// </summary>
+        /// <param name="folderPath"></param>
+        /// <param name="fileExtension"></param>
+        /// <returns></returns>
+        private List<string> GetFileNamesWithoutExtension(string folderPath, string fileExtension)
+        {
+            List<string> fileNames = new List<string>();
+
+            try
+            {
+                // 检查文件夹是否存在
+                if (Directory.Exists(folderPath))
+                {
+                    // 获取指定文件夹内指定后缀的所有文件
+                    string[] files = Directory.GetFiles(folderPath, $"*.{fileExtension}");
+
+                    foreach (string file in files)
+                    {
+                        // 获取不包含后缀的文件名
+                        string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(file);
+                        fileNames.Add(fileNameWithoutExtension);
+                    }
+                }
+                else
+                {
+                    Warn("日志","指定的文件夹不存在");
+                }
+            }
+            catch (Exception e)
+            {
+                Error("日志",$"发生错误:{e.Message}");
+            }
+
+            return fileNames;
+        }
+        /// <summary>
+        /// 读取日志
+        /// </summary>
+        /// <param name="filePath"></param>
+        /// <returns></returns>
+        private static List<string> ParseLogFile(string filePath)
+        {
+            List<string> logs = new List<string>();
+            string currentLog = string.Empty;
+
+            foreach (var line in File.ReadLines(filePath))
+            {
+                if (line.Contains("[信息]") || line.Contains("[错误]") || line.Contains("[调试]") || line.Contains("[警告]"))
+                {
+                    if (!string.IsNullOrEmpty(currentLog))
+                    {
+                        logs.Add(currentLog);
+                    }
+                    currentLog = line;
+                }
+                else
+                {
+                    if (!string.IsNullOrEmpty(currentLog))
+                    {
+                        currentLog += Environment.NewLine + line;
+                    }
+                }
+            }
+
+            // 添加最后一个日志条目
+            if (!string.IsNullOrEmpty(currentLog))
+            {
+                logs.Add(currentLog);
+            }
+
+            return logs;
+        }
+    }
+    /// <summary>
+    /// 日志配置模型
+    /// </summary>
+    public class LogConfigModel
+    {
+        // 日志文件的最大大小（以m为单位）
+        public int MaxFileSize { get; set; } = 1;
+
+        // 允许的最大存档文件数量
+        public int MaxArchiveFiles { get; set; } = 100;
+        /// <summary>
+        /// 日志文件路径
+        /// </summary>
+        public string LogFilePath { get; set; } = "logs";
+        // 日志记录的最低等级
+        public HslMessageDegree LogLevel { get; set; }= HslMessageDegree.DEBUG;
+    }
+}
diff --git a/Services/ServiceConfiguration.cs b/Services/ServiceConfiguration.cs
new file mode 100644
index 0000000..a521f61
--- /dev/null
+++ b/Services/ServiceConfiguration.cs
@@ -0,0 +1,30 @@
+using guoke;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace WpfApp.Services
+{
+    /// <summary>
+    /// 服务配置类
+    /// </summary>
+    public static class ServiceConfiguration
+    {
+        /// <summary>
+        /// 配置服务
+        /// </summary>
+        /// <returns>服务提供者</returns>
+        public static ServiceProvider ConfigureServices()
+        {
+            // 创建服务集合
+            var services = new ServiceCollection();
+            // 注册服务
+            services.AddSingleton<LogService>();//日志服务
+            services.AddSingleton(typeof(EventService<>));//事件服务
+            services.AddSingleton<DatabaseService>();//数据库服务
+            // 注册窗体
+            services.AddTransient<MainWindow>();
+
+            // 构建服务提供者
+            return services.BuildServiceProvider();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Utils/ConfigReader.cs b/Utils/ConfigReader.cs
new file mode 100644
index 0000000..a0ed27d
--- /dev/null
+++ b/Utils/ConfigReader.cs
@@ -0,0 +1,352 @@
+using System.ComponentModel;
+using System.IO;
+using System.Text.Json;
+
+namespace WinFormsApp.Utils
+{
+    /// <summary>
+    /// 配置文件读取工具类，支持泛型类型转换和默认值
+    /// </summary>
+    public static class ConfigReader
+    {
+        private static JsonDocument? _configDocument;
+        private static readonly object _lock = new object();
+        private static string _configFilePath = "appsettings.json";
+
+        /// <summary>
+        /// 设置配置文件路径
+        /// </summary>
+        /// <param name="filePath">配置文件路径</param>
+        public static void SetConfigPath(string filePath)
+        {
+            lock (_lock)
+            {
+                _configFilePath = filePath;
+                _configDocument?.Dispose();
+                _configDocument = null;
+            }
+        }
+
+        /// <summary>
+        /// 加载配置文件
+        /// </summary>
+        private static void LoadConfig()
+        {
+            if (_configDocument != null) return;
+
+            lock (_lock)
+            {
+                if (_configDocument != null) return;
+
+                try
+                {
+                    if (!File.Exists(_configFilePath))
+                    {
+                        Console.WriteLine($"配置文件不存在: {_configFilePath}");
+                        return;
+                    }
+
+                    string jsonString = File.ReadAllText(_configFilePath);
+                    _configDocument = JsonDocument.Parse(jsonString);
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"加载配置文件失败: {ex.Message}");
+                }
+            }
+        }
+
+        /// <summary>
+        /// 获取配置值（泛型方法）
+        /// </summary>
+        /// <typeparam name="T">目标类型</typeparam>
+        /// <param name="key">配置键，支持嵌套路径，如 "Module:Pattern"</param>
+        /// <param name="defaultValue">默认值</param>
+        /// <returns>配置值或默认值</returns>
+        public static T GetValue<T>(string key, T defaultValue = default(T))
+        {
+            try
+            {
+                LoadConfig();
+
+                if (_configDocument == null)
+                {
+                    return defaultValue;
+                }
+
+                JsonElement element = _configDocument.RootElement;
+                string[] keys = key.Split(':');
+
+                // 遍历嵌套路径
+                foreach (string k in keys)
+                {
+                    if (!element.TryGetProperty(k, out element))
+                    {
+                        return defaultValue;
+                    }
+                }
+
+                return ConvertValue<T>(element, defaultValue);
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"读取配置 '{key}' 时出错: {ex.Message}");
+                return defaultValue;
+            }
+        }
+
+        /// <summary>
+        /// 获取字符串配置值
+        /// </summary>
+        /// <param name="key">配置键</param>
+        /// <param name="defaultValue">默认值</param>
+        /// <returns>字符串值</returns>
+        public static string GetString(string key, string defaultValue = "")
+        {
+            return GetValue(key, defaultValue);
+        }
+
+        /// <summary>
+        /// 获取整数配置值
+        /// </summary>
+        /// <param name="key">配置键</param>
+        /// <param name="defaultValue">默认值</param>
+        /// <returns>整数值</returns>
+        public static int GetInt(string key, int defaultValue = 0)
+        {
+            return GetValue(key, defaultValue);
+        }
+
+        /// <summary>
+        /// 获取布尔配置值
+        /// </summary>
+        /// <param name="key">配置键</param>
+        /// <param name="defaultValue">默认值</param>
+        /// <returns>布尔值</returns>
+        public static bool GetBool(string key, bool defaultValue = false)
+        {
+            return GetValue(key, defaultValue);
+        }
+
+        /// <summary>
+        /// 获取双精度浮点数配置值
+        /// </summary>
+        /// <param name="key">配置键</param>
+        /// <param name="defaultValue">默认值</param>
+        /// <returns>双精度浮点数值</returns>
+        public static double GetDouble(string key, double defaultValue = 0.0)
+        {
+            return GetValue(key, defaultValue);
+        }
+
+        /// <summary>
+        /// 获取数组配置值
+        /// </summary>
+        /// <typeparam name="T">数组元素类型</typeparam>
+        /// <param name="key">配置键</param>
+        /// <param name="defaultValue">默认值</param>
+        /// <returns>数组值</returns>
+        public static T[] GetArray<T>(string key, T[] defaultValue = null)
+        {
+            try
+            {
+                LoadConfig();
+
+                if (_configDocument == null)
+                {
+                    return defaultValue ?? new T[0];
+                }
+
+                JsonElement element = _configDocument.RootElement;
+                string[] keys = key.Split(':');
+
+                // 遍历嵌套路径
+                foreach (string k in keys)
+                {
+                    if (!element.TryGetProperty(k, out element))
+                    {
+                        return defaultValue ?? new T[0];
+                    }
+                }
+
+                if (element.ValueKind != JsonValueKind.Array)
+                {
+                    return defaultValue ?? new T[0];
+                }
+
+                List<T> result = new List<T>();
+                foreach (JsonElement item in element.EnumerateArray())
+                {
+                    T convertedValue = ConvertValue<T>(item, default(T));
+                    result.Add(convertedValue);
+                }
+
+                return result.ToArray();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"读取数组配置 '{key}' 时出错: {ex.Message}");
+                return defaultValue ?? new T[0];
+            }
+        }
+
+        /// <summary>
+        /// 获取复杂对象配置值
+        /// </summary>
+        /// <typeparam name="T">目标类型</typeparam>
+        /// <param name="key">配置键</param>
+        /// <param name="defaultValue">默认值</param>
+        /// <returns>对象值</returns>
+        public static T GetObject<T>(string key, T defaultValue = default(T)) where T : class
+        {
+            try
+            {
+                LoadConfig();
+
+                if (_configDocument == null)
+                {
+                    return defaultValue;
+                }
+
+                JsonElement element = _configDocument.RootElement;
+                string[] keys = key.Split(':');
+
+                // 遍历嵌套路径
+                foreach (string k in keys)
+                {
+                    if (!element.TryGetProperty(k, out element))
+                    {
+                        return defaultValue;
+                    }
+                }
+
+                return JsonSerializer.Deserialize<T>(element.GetRawText()) ?? defaultValue;
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"读取对象配置 '{key}' 时出错: {ex.Message}");
+                return defaultValue;
+            }
+        }
+
+        /// <summary>
+        /// 类型转换方法
+        /// </summary>
+        /// <typeparam name="T">目标类型</typeparam>
+        /// <param name="element">JSON元素</param>
+        /// <param name="defaultValue">默认值</param>
+        /// <returns>转换后的值</returns>
+        private static T ConvertValue<T>(JsonElement element, T defaultValue)
+        {
+            try
+            {
+                Type targetType = typeof(T);
+                Type nullableType = Nullable.GetUnderlyingType(targetType);
+                
+                // 处理可空类型
+                if (nullableType != null)
+                {
+                    if (element.ValueKind == JsonValueKind.Null)
+                    {
+                        return defaultValue;
+                    }
+                    targetType = nullableType;
+                }
+
+                // 处理基本类型
+                switch (element.ValueKind)
+                {
+                    case JsonValueKind.String:
+                        if (targetType == typeof(string))
+                            return (T)(object)element.GetString();
+                        break;
+
+                    case JsonValueKind.Number:
+                        if (targetType == typeof(int))
+                            return (T)(object)element.GetInt32();
+                        if (targetType == typeof(long))
+                            return (T)(object)element.GetInt64();
+                        if (targetType == typeof(double))
+                            return (T)(object)element.GetDouble();
+                        if (targetType == typeof(float))
+                            return (T)(object)element.GetSingle();
+                        if (targetType == typeof(decimal))
+                            return (T)(object)element.GetDecimal();
+                        break;
+
+                    case JsonValueKind.True:
+                    case JsonValueKind.False:
+                        if (targetType == typeof(bool))
+                            return (T)(object)element.GetBoolean();
+                        break;
+
+                    case JsonValueKind.Null:
+                        return defaultValue;
+                }
+
+                // 使用TypeConverter进行转换
+                TypeConverter converter = TypeDescriptor.GetConverter(targetType);
+                if (converter.CanConvertFrom(typeof(string)))
+                {
+                    string stringValue = element.GetRawText().Trim('"');
+                    return (T)converter.ConvertFromString(stringValue);
+                }
+
+                // 尝试JSON反序列化
+                return JsonSerializer.Deserialize<T>(element.GetRawText()) ?? defaultValue;
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"类型转换失败: {ex.Message}");
+                return defaultValue;
+            }
+        }
+
+        /// <summary>
+        /// 检查配置键是否存在
+        /// </summary>
+        /// <param name="key">配置键</param>
+        /// <returns>如果存在返回true，否则返回false</returns>
+        public static bool HasKey(string key)
+        {
+            try
+            {
+                LoadConfig();
+
+                if (_configDocument == null)
+                {
+                    return false;
+                }
+
+                JsonElement element = _configDocument.RootElement;
+                string[] keys = key.Split(':');
+
+                foreach (string k in keys)
+                {
+                    if (!element.TryGetProperty(k, out element))
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 释放资源
+        /// </summary>
+        public static void Dispose()
+        {
+            lock (_lock)
+            {
+                _configDocument?.Dispose();
+                _configDocument = null;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Utils/HardwareInfo.cs b/Utils/HardwareInfo.cs
new file mode 100644
index 0000000..29c1110
--- /dev/null
+++ b/Utils/HardwareInfo.cs
@@ -0,0 +1,98 @@
+using System;
+using System.Management;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace WpfApp.Utils
+{
+    /// <summary>
+    /// 硬件信息工具类，用于获取主板和CPU序列号
+    /// </summary>
+    public static class HardwareInfo
+    {
+        /// <summary>
+        /// 获取主板序列号
+        /// </summary>
+        /// <returns>主板序列号</returns>
+        public static string GetMotherboardSerialNumber()
+        {
+            try
+            {
+                using (var searcher = new ManagementObjectSearcher("SELECT SerialNumber FROM Win32_BaseBoard"))
+                {
+                    foreach (var obj in searcher.Get())
+                    {
+                        return obj["SerialNumber"].ToString().Trim();
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"获取主板序列号时出错: {ex.Message}");
+            }
+            return string.Empty;
+        }
+
+        /// <summary>
+        /// 获取CPU序列号
+        /// </summary>
+        /// <returns>CPU序列号</returns>
+        public static string GetCpuSerialNumber()
+        {
+            try
+            {
+                using (var searcher = new ManagementObjectSearcher("SELECT ProcessorId FROM Win32_Processor"))
+                {
+                    foreach (var obj in searcher.Get())
+                    {
+                        return obj["ProcessorId"].ToString().Trim();
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"获取CPU序列号时出错: {ex.Message}");
+            }
+            return string.Empty;
+        }
+
+        /// <summary>
+        /// 获取硬件标识（主板序列号和CPU序列号的组合哈希值）
+        /// </summary>
+        /// <returns>硬件标识哈希值</returns>
+        public static string GetHardwareId()
+        {
+            string motherboardSn = GetMotherboardSerialNumber();
+            string cpuSn = GetCpuSerialNumber();
+            string combined = $"{motherboardSn}|{cpuSn}";
+            
+            // 计算组合值的SHA256哈希
+            using (SHA256 sha256 = SHA256.Create())
+            {
+                byte[] hashBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(combined));
+                StringBuilder builder = new StringBuilder();
+                for (int i = 0; i < hashBytes.Length; i++)
+                {
+                    builder.Append(hashBytes[i].ToString("x2"));
+                }
+                return builder.ToString();
+            }
+        }
+
+        /// <summary>
+        /// 验证硬件标识是否匹配
+        /// </summary>
+        /// <param name="storedHardwareId">存储的硬件标识</param>
+        /// <returns>如果匹配返回true，否则返回false</returns>
+        public static bool ValidateHardwareId(string storedHardwareId)
+        {
+            if (string.IsNullOrEmpty(storedHardwareId))
+            {
+                return false;
+            }
+
+            string currentHardwareId = GetHardwareId();
+            return string.Equals(currentHardwareId, storedHardwareId, StringComparison.OrdinalIgnoreCase);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Utils/guokeExtensionClass.cs b/Utils/guokeExtensionClass.cs
new file mode 100644
index 0000000..eea11b4
--- /dev/null
+++ b/Utils/guokeExtensionClass.cs
@@ -0,0 +1,254 @@
+using HslCommunication;
+using SqlSugar;
+using System.Text.RegularExpressions;
+
+namespace guoke
+{
+    /// <summary>
+    /// 扩展类 所有扩展写在这里
+    /// </summary>
+    public static class guokeExtensionClass
+    {
+        #region 数据库扩展
+        /// <summary>
+        /// 检查表是否存在，如果不存在则创建表
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="db"></param>
+        public static bool guokeCheckToCreate<T>(this SqlSugarScope db)
+        {
+            try
+            {
+                string tableName = db.guokeGetTableName(typeof(T));//获取表名
+
+                if (!db.guokeCheckTable(tableName))
+                {
+                    if (db.MappingTables == null)
+                    {
+                        db.MappingTables = new MappingTableList();
+                    }
+                    db.MappingTables.Add(typeof(T).Name, tableName); // 类名 表名
+                    db.CodeFirst.InitTables(typeof(T)); //创建表
+                    LogService.Log.Info("仓库", $"创建表:{tableName},模型:{typeof(T).Name}");
+                }
+                return true;
+            }
+            catch (Exception e)
+            {
+                LogService.Log.Error("数据库", $"检查创建表错误:{e.Message}");
+                return false;
+            }
+        }
+        /// <summary>
+        /// 检查表
+        /// </summary>
+        /// <param name="tableName"></param>
+        public static bool guokeCheckTable(this SqlSugarScope db, string tableName)
+        {
+            return db.DbMaintenance.IsAnyTable(tableName);//判断状态表是否存在
+        }
+        /// <summary>
+        /// 根据类型获取表名
+        /// </summary>
+        /// <param name="db"></param>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public static string guokeGetTableName(this SqlSugarScope db, Type type)
+        {
+            object[] attributes = type.GetCustomAttributes(typeof(SugarTable), false);
+            if (attributes.Length > 0)
+            {
+                SugarTable sugarTable = (SugarTable)attributes[0];
+                return sugarTable.TableName;
+            }
+            return type.Name;
+        }
+        /// <summary>
+        /// 检查表是否存在，如果不存在则创建表
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="db"></param>
+        public static bool guokeCheckToCreate<T>(this SqlSugarClient db)
+        {
+            try
+            {
+                string tableName = db.guokeGetTableName(typeof(T));//获取表名
+
+                if (!db.guokeCheckTable(tableName))
+                {
+                    if (db.MappingTables == null)
+                    {
+                        db.MappingTables = new MappingTableList();
+                    }
+                    db.MappingTables.Add(typeof(T).Name, tableName); // 类名 表名
+                    db.CodeFirst.InitTables(typeof(T)); //创建表
+                    LogService.Log.Info("仓库", $"创建表:{tableName},模型:{typeof(T).Name}");
+                }
+                return true;
+            }
+            catch (Exception e)
+            {
+                LogService.Log.Error("数据库", $"检查创建表错误:{e.Message}");
+                return false;
+            }
+        }
+        /// <summary>
+        /// 检查表
+        /// </summary>
+        /// <param name="tableName"></param>
+        public static bool guokeCheckTable(this SqlSugarClient db,string tableName)
+        {
+            return db.DbMaintenance.IsAnyTable(tableName);//判断状态表是否存在
+        }
+        /// <summary>
+        /// 根据类型获取表名
+        /// </summary>
+        /// <param name="db"></param>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public static string guokeGetTableName(this SqlSugarClient db,Type type)
+        {
+            object[] attributes = type.GetCustomAttributes(typeof(SugarTable), false);
+            if (attributes.Length > 0)
+            {
+                SugarTable sugarTable = (SugarTable)attributes[0];
+                return sugarTable.TableName;
+            }
+            return type.Name;
+        }
+        #endregion
+        #region 字节数组扩展
+        /// <summary>
+        /// 扩展方法，用于将一个 byte[] 追加到另一个 byte[] 后面
+        /// </summary>
+        /// <param name="originalArray"></param>
+        /// <param name="arrayToAppend"></param>
+        /// <returns>追加后的数组</returns>
+        public static byte[] Append(this byte[] originalArray, byte[] arrayToAppend)
+        {
+            if (originalArray == null)
+            {
+                return arrayToAppend;
+            }
+            if (arrayToAppend == null)
+            {
+                return originalArray;
+            }
+
+            // 创建一个 List<byte> 并将原始数组元素添加进去
+            List<byte> combinedList = new List<byte>(originalArray);
+            // 将待追加的数组元素添加到列表中
+            combinedList.AddRange(arrayToAppend);
+
+            // 将列表转换为 byte[] 数组并返回
+            return combinedList.ToArray();
+        }
+        #endregion
+
+        #region 字符串扩展
+        /// <summary>
+        /// 字符串转换为整数，失败时返回默认值
+        /// </summary>
+        /// <param name="str">字符串</param>
+        /// <param name="defaultValue">默认值</param>
+        /// <returns></returns>
+        public static int ToIntOrDefault(this string str, int defaultValue = 0)
+        {
+            return int.TryParse(str, out int result) ? result : defaultValue;
+        }
+        /// <summary>
+        /// 将字符串转换为长整数，失败时返回默认值
+        /// </summary>
+        /// <param name="str">字符串 </param>
+        /// <param name="defaultValue">默认值</param>
+        /// <returns></returns>
+        public static long ToLongOrDefault(this string str, long defaultValue = 0)
+        {
+            return long.TryParse(str, out long result) ? result : defaultValue;
+        }
+        /// <summary>
+        /// 将字符串转换为整数，带操作结果
+        /// </summary>
+        /// <param name="str"></param>
+        /// <returns></returns>
+        public static OperateResult<int> guokeToInt(this string str)
+        {
+            return int.TryParse(str, out int result) ? OperateResult.CreateSuccessResult(result) : OperateResult.CreateFailedResult<int>(new OperateResult("转换失败"));
+        }
+
+        /// <summary>
+        /// 使用正则表达式从字符串中提取匹配的部分,带操作结果
+        /// </summary>
+        /// <param name="input">输入字符串</param>
+        /// <param name="pattern">正则表达式模式</param>
+        /// <returns>返回结果</returns>
+        public static OperateResult<string> guokeExtractWithRegex(this string input, string pattern)
+        {
+            // 创建正则表达式对象
+            Regex regex = new Regex(pattern);
+
+            // 匹配输入字符串
+            Match match = regex.Match(input);
+
+            // 如果匹配成功，返回匹配的值
+            if (match.Success && match.Groups.Count > 1)
+            {
+                return OperateResult.CreateSuccessResult(match.Groups[1].Value);
+            }
+
+            // 如果没有匹配，返回空字符串
+            return OperateResult.CreateFailedResult<string>(new OperateResult("提取失败"));
+        }
+        /// <summary>
+        /// 提取字符串右边的连续数字,带操作结果
+        /// </summary>
+        /// <param name="input"></param>
+        /// <returns></returns>
+        public static OperateResult<int> guokeExtractRightNumbers(this string input)
+        {
+            // 定义正则表达式模式，用于匹配字符串右边的连续数字
+            string pattern = @"\d+$";
+            // 使用 Regex.Match 方法进行匹配
+            Match match = Regex.Match(input, pattern);
+
+            // 检查是否匹配成功
+            if (match.Success)
+            {
+                // 如果匹配成功，尝试将匹配到的字符串转换为 int 类型
+                if (int.TryParse(match.Value, out int result))
+                {
+                    return OperateResult.CreateSuccessResult(result);
+                }
+            }
+
+            // 如果没有匹配到或者转换失败，返回 0
+            return OperateResult.CreateFailedResult<int>(new OperateResult("提取失败"));
+        }
+        /// <summary>
+        /// 提取字符串左边的连续数字,带操作结果
+        /// </summary>
+        /// <param name="input"></param>
+        /// <returns></returns>
+        public static OperateResult<int> guokeExtractLeftNumbers(this string input)
+        {
+            // 定义正则表达式模式，用于匹配字符串右边的连续数字
+            string pattern = @"^\d+";
+            // 使用 Regex.Match 方法进行匹配
+            Match match = Regex.Match(input, pattern);
+
+            // 检查是否匹配成功
+            if (match.Success)
+            {
+                // 如果匹配成功，尝试将匹配到的字符串转换为 int 类型
+                if (int.TryParse(match.Value, out int result))
+                {
+                    return OperateResult.CreateSuccessResult(result);
+                }
+            }
+
+            // 如果没有匹配到或者转换失败，返回 0
+            return OperateResult.CreateFailedResult<int>(new OperateResult("提取失败"));
+        }
+        #endregion
+    }
+}
diff --git a/WpfApp.csproj b/WpfApp.csproj
new file mode 100644
index 0000000..d49af5f
--- /dev/null
+++ b/WpfApp.csproj
@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <UseWPF>true</UseWPF>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="HslCommunication" Version="12.5.1" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.0" />
+    <PackageReference Include="SqlSugarCore" Version="5.1.4.205" />
+    <PackageReference Include="System.Management" Version="8.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="appsettings.json">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+</Project>
diff --git a/WpfApp.csproj.user b/WpfApp.csproj.user
new file mode 100644
index 0000000..644b0a6
--- /dev/null
+++ b/WpfApp.csproj.user
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup />
+  <ItemGroup>
+    <ApplicationDefinition Update="App.xaml">
+      <SubType>Designer</SubType>
+    </ApplicationDefinition>
+  </ItemGroup>
+  <ItemGroup>
+    <Page Update="MainWindow.xaml">
+      <SubType>Designer</SubType>
+    </Page>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/WpfApp.sln b/WpfApp.sln
new file mode 100644
index 0000000..8b81998
--- /dev/null
+++ b/WpfApp.sln
@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.8.34511.84
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WpfApp", "WpfApp.csproj", "{6B6D9743-392F-41FB-92B6-D99EA4575D8C}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{6B6D9743-392F-41FB-92B6-D99EA4575D8C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{6B6D9743-392F-41FB-92B6-D99EA4575D8C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{6B6D9743-392F-41FB-92B6-D99EA4575D8C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{6B6D9743-392F-41FB-92B6-D99EA4575D8C}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {3AA9F1A3-A510-4342-8EAC-E607C5FB088E}
+	EndGlobalSection
+EndGlobal
diff --git a/appsettings.json b/appsettings.json
new file mode 100644
index 0000000..d831697
--- /dev/null
+++ b/appsettings.json
@@ -0,0 +1,18 @@
+{
+  "Logs": {
+    "LogLevel": 6,
+    "MaxArchiveFiles": 100,
+    "MaxFileSize": 1,
+    "LogFilePath": "logs"
+  },
+  "DB": [
+    {
+      "Name": "LocalData",
+      "Enabled": true,
+      "Type": 2,
+      "Connection": "DataSource=LocalData.db",
+      "Remarks": "",
+      "Print": false
+    }
+  ]
+}