增加MySQL数据库产品信息的增删改查。

C3204

2026-01-07 c154cfddec4c770e58c23c28bdafa7a5c7b5a389

增加MySQL数据库产品信息的增删改查。

 LB_SmartVision/CSV/CsvRecordProductData.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,52 @@
using LB_SmartVisionCommon;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LB_SmartVision.CSV
{
    /// <summary>
    /// ç”¨äºŽCSV映射的类
    /// </summary>
    public class CsvRecordProductData
    {
        /// <summary>
        /// SKU  ç‰©æ–™å·æˆ–产品名称
        /// </summary>
        public string ProductName { get; set; }

        /// <summary>
        /// äº§å“SN号
        /// </summary>
        public string ProductSN { get; set; }

        /// <summary>
        /// æ£€æµ‹ä½œä¸šå‘˜
        /// </summary>
        public string InspectionOperator { get; set; }

        /// <summary>
        /// NG类型
        /// </summary>
        public string NGType { get; set; }

        /// <summary>
        /// NG大小
        /// </summary>
        public string NGSize { get; set; }

        /// <summary>
        /// æ£€æµ‹æ—¶é—´
        /// </summary>
        public string DetectionTime { get; set; }

        /// <summary>
        /// æ£€æµ‹ç›¸æœº
        /// </summary>
        public string CameraInspection { get; set; }
    }

}

 LB_SmartVision/Forms/CreateProductForm.cs

@@ -1,4 +1,5 @@

using LB_SmartVision.SQL;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using ReaLTaiizor.Forms;

 LB_SmartVision/LB_SmartVision.csproj

@@ -14,6 +14,7 @@
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\LB_SmartVisionCommon\LB_SmartVisionCommon.csproj" />
    <ProjectReference Include="..\LB_SmartVisionLoginUI\LB_SmartVisionLoginUI.csproj" />
    <ProjectReference Include="..\LB_VisionControl\LB_VisionControl.csproj" />
    <ProjectReference Include="..\LB_VisionFlowNode\LB_VisionFlowNode.csproj" />

 LB_SmartVision/LB_SqlCommand.cs

ÎļþÒÑɾ³ý

 LB_SmartVision/SQL/DatabaseRecordProductDataHelper.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,72 @@
using LB_SmartVisionCommon;
using MySql.Data.MySqlClient;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LB_SmartVision.SQL
{
    public class DatabaseRecordProductDataHelper
    {
        private static string connectionString = "Server=localhost;Database=product_db;Uid=root;Pwd=root;";
        private static object databaseRecordProductDataHelperObject = new object();
        public static MySqlConnection GetConnection()
        {
            return new MySqlConnection(connectionString);
        }
        // åˆ›å»ºæ•°æ®åº“和表
        public static void InitializeDatabase()
        {
            lock (databaseRecordProductDataHelperObject)
            {
                try
                {
                    using (var connection = GetConnection())
                    {
                        connection.Open();
                        // åˆ›å»ºæ•°æ®åº“
                        string createDbSql = @"CREATE DATABASE IF NOT EXISTS product_db;";
                        using (var cmd = new MySqlCommand(createDbSql, connection))
                        {
                            cmd.ExecuteNonQuery();
                        }
                        // ä½¿ç”¨æ•°æ®åº“
                        string useDbSql = @"USE product_db;";
                        using (var cmd = new MySqlCommand(useDbSql, connection))
                        {
                            cmd.ExecuteNonQuery();
                        }
                        // åˆ›å»ºè¡¨ï¼ˆå¢žåŠ ç´¢å¼•ä»¥æé«˜æŸ¥è¯¢æ€§èƒ½ï¼‰
                        string createTableSql = @"
                                                 CREATE TABLE IF NOT EXISTS RecordProductData (
                                                 Id INT AUTO_INCREMENT PRIMARY KEY,
                                                 ProductName VARCHAR(255) NOT NULL,
                                                 ProductSN VARCHAR(255) NOT NULL,
                                                 InspectionOperator VARCHAR(255),
                                                 NGType VARCHAR(255),
                                                 NGSize VARCHAR(255),
                                                 DetectionTime VARCHAR(255)),
                                                 CameraInspection VARCHAR(255),
                                                 CreatedDate DATETIME DEFAULT CURRENT_TIMESTAMP,
                                                 INDEX idx_created_date (CreatedDate),
                                                 INDEX idx_product_number (ProductSN),
                                                 INDEX idx_operator (InspectionOperator)
                                                 );";
                        using (var cmd = new MySqlCommand(createTableSql, connection))
                        {
                            cmd.ExecuteNonQuery();
                            AsyncLogHelper.Info("数据库和表创建成功！");
                        }
                    }
                }
                catch (Exception ex)
                {
                    AsyncLogHelper.Error($"数据库初始化失败: {ex.Message}");
                    throw;
                }
            }
        }
    }
}

 LB_SmartVision/SQL/LB_Collections.cs

ÎļþÃû´Ó LB_SmartVision/LB_Collections.cs ÐÞ¸Ä
@@ -5,7 +5,7 @@
using System.Text;
using System.Threading.Tasks;

namespace LB_SmartVision
namespace LB_SmartVision.SQL
{
    [Serializable]
    public class LB_Collections<T> : ICollection<CollectionItem<T>>

 LB_SmartVision/SQL/LB_SqlCommand.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,552 @@
using MySql.Data.MySqlClient;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LB_SmartVision.SQL
{
    public class LB_SqlCommand
    {
        /// <summary>
        /// è¿žæŽ¥å­—符串：指定 MySQL å®žä¾‹å’Œæ•°æ®åº“(实际会读取dll.config中的值来更新连接字符串)
        /// </summary>
        public static string ConnectionString = "Server=localhost;Database=product_mes;Uid=root;Pwd=root;";

        /// <summary>
        /// åˆ¤æ–­æŒ‡å®šåˆ—是否存在某值
        /// </summary>
        /// <param name="tableName">表名</param>
        /// <param name="columnName">指定列名</param>
        /// <param name="value">指定值</param>
        /// <param name="connectionString"></param>
        /// <returns>值存在True</returns>
        public static bool IsExist(string tableName, string columnName, string value, string connectionString = "")
        {
            if (string.IsNullOrEmpty(connectionString))
                connectionString = ConnectionString;

            // MySQL æŸ¥è¯¢è¯­å¥ï¼Œæ£€æŸ¥æŒ‡å®šåˆ—是否存在指定的值
            string sqlQuery = string.Format("SELECT CASE WHEN EXISTS (SELECT 1 FROM `{0}` " +
                "WHERE `{1}` = @Value) THEN 1 ELSE 0 END", tableName, columnName);

            // åˆ›å»º MySQL è¿žæŽ¥
            using (MySqlConnection connection = new MySqlConnection(connectionString))
            {
                // åˆ›å»º MySQL å‘½ä»¤
                using (MySqlCommand command = new MySqlCommand(sqlQuery, connection))
                {
                    // æ·»åŠ å‚数，防止 SQL æ³¨å…¥
                    command.Parameters.AddWithValue("@Value", value);

                    // æ‰“开连接
                    connection.Open();

                    // æ‰§è¡ŒæŸ¥è¯¢å¹¶èŽ·å–结果
                    int result = Convert.ToInt32(command.ExecuteScalar());

                    // å¦‚æžœ result == 1，表示存在该值；否则不存在
                    return result == 1;
                }
            }
        }

        /// <summary>
        /// åˆ¤æ–­æŒ‡å®šè¡¨æ˜¯å¦å­˜åœ¨
        /// </summary>
        /// <param name="tableName">表名</param>
        /// <param name="connectionString"></param>
        /// <returns>值存在True</returns>
        public static bool IsExistTable(string tableName, string connectionString = "")
        {
            if (string.IsNullOrEmpty(connectionString))
                connectionString = ConnectionString;

            // MySQL æŸ¥è¯¢è¯­å¥ï¼Œæ£€æŸ¥è¡¨æ˜¯å¦å­˜åœ¨
            string sqlQuery = $@"
                                SELECT COUNT(*)
                                FROM INFORMATION_SCHEMA.TABLES
                                WHERE TABLE_SCHEMA = DATABASE() 
                                  AND TABLE_NAME = @TableName";

            // åˆ›å»º MySQL è¿žæŽ¥
            using (MySqlConnection connection = new MySqlConnection(connectionString))
            {
                // åˆ›å»º MySQL å‘½ä»¤
                using (MySqlCommand command = new MySqlCommand(sqlQuery, connection))
                {
                    // æ·»åŠ è¡¨åå‚æ•°
                    command.Parameters.AddWithValue("@TableName", tableName);

                    // æ‰“开连接
                    connection.Open();

                    // æ‰§è¡ŒæŸ¥è¯¢å¹¶èŽ·å–结果
                    int result = Convert.ToInt32(command.ExecuteScalar());

                    // å¦‚æžœ result > 0，表示存在该表；否则不存在
                    return result > 0;
                }
            }
        }

        /// <summary>
        /// é‡å‘½åè¡¨
        /// </summary>
        /// <param name="oldTableName"></param>
        /// <param name="newTableName"></param>
        /// <param name="connectionString"></param>
        /// <returns></returns>
        public static bool RenameTable(string oldTableName, string newTableName, string connectionString = "")
        {
            if (string.IsNullOrEmpty(connectionString))
                connectionString = ConnectionString;

            if (!IsExistTable(oldTableName))
                return false;

            // MySQL é‡å‘½åè¡¨è¯­æ³•
            string sqlQuery = $"ALTER TABLE `{oldTableName}` RENAME TO `{newTableName}`";

            // åˆ›å»º MySQL è¿žæŽ¥
            using (MySqlConnection connection = new MySqlConnection(connectionString))
            {
                // åˆ›å»º MySQL å‘½ä»¤
                using (MySqlCommand command = new MySqlCommand(sqlQuery, connection))
                {
                    // æ‰“开连接
                    connection.Open();

                    try
                    {
                        // æ‰§è¡ŒæŸ¥è¯¢å¹¶èŽ·å–结果
                        command.ExecuteNonQuery();
                        return true;
                    }
                    catch
                    {
                        return false;
                    }
                }
            }
        }

        /// <summary>
        /// åˆ é™¤æŒ‡å®šè¡¨
        /// </summary>
        /// <param name="tableName">表名</param>
        /// <param name="connectionString"></param>
        /// <returns>删除成功True</returns>
        public static bool DeleteTable(string tableName, string connectionString = "")
        {
            if (string.IsNullOrEmpty(connectionString))
                connectionString = ConnectionString;

            // MySQL åˆ é™¤è¡¨è¯­å¥
            string sqlQuery = $"DROP TABLE IF EXISTS `{tableName}`";

            // åˆ›å»º MySQL è¿žæŽ¥
            using (MySqlConnection connection = new MySqlConnection(connectionString))
            {
                // åˆ›å»º MySQL å‘½ä»¤
                using (MySqlCommand command = new MySqlCommand(sqlQuery, connection))
                {
                    // æ‰“开连接
                    connection.Open();

                    try
                    {
                        // æ‰§è¡Œåˆ é™¤æ“ä½œ
                        command.ExecuteNonQuery();
                        return true;
                    }
                    catch
                    {
                        return false;
                    }
                }
            }
        }

        /// <summary>
        /// èŽ·å–所需的值通过索引指定列的指定值定位到所在行的指定列
        /// </summary>
        /// <param name="tableName">表名</param>
        /// <param name="indexName">指定列名</param>
        /// <param name="indexValue">指定列值</param>
        /// <param name="columnName">所需值的列名</param>
        /// <param name="connectionString"></param>
        /// <returns>所需列值</returns>
        public static string FindValueFromIndexName(string tableName, string indexName, string indexValue, string columnName, string connectionString = "")
        {
            try
            {
                if (string.IsNullOrEmpty(connectionString))
                    connectionString = ConnectionString;

                // MySQL æŸ¥è¯¢è¯­å¥
                string sqlQuery = $"SELECT `{columnName}` FROM `{tableName}` WHERE `{indexName}` = @IndexValue";
                string resultValue = string.Empty;

                // è¿žæŽ¥æ•°æ®åº“并执行查询
                using (MySqlConnection connection = new MySqlConnection(connectionString))
                {
                    using (MySqlCommand command = new MySqlCommand(sqlQuery, connection))
                    {
                        // æ·»åŠ å‚数以防止 SQL æ³¨å…¥
                        command.Parameters.AddWithValue("@IndexValue", indexValue);

                        // æ‰“开连接
                        connection.Open();

                        // æ‰§è¡ŒæŸ¥è¯¢å¹¶èŽ·å–结果
                        var result = command.ExecuteScalar();

                        if (result != null)
                        {
                            resultValue = result.ToString();
                        }
                    }
                }
                return resultValue;
            }
            catch
            {
                return string.Empty;
            }
        }

        /// <summary>
        /// åˆ é™¤æŒ‡å®šè¡Œé€šè¿‡ç´¢å¼•æŒ‡å®šåˆ—的指定值
        /// </summary>
        /// <param name="tableName">表名</param>
        /// <param name="indexName">指定列名</param>
        /// <param name="indexValue">指定列值</param>
        /// <param name="connectionString"></param>
        /// <returns>删除成功True</returns>
        public static bool DeleteRowFromIndexName(string tableName, string indexName, string indexValue, string connectionString = "")
        {
            try
            {
                if (string.IsNullOrEmpty(connectionString))
                    connectionString = ConnectionString;

                using (MySqlConnection conn = new MySqlConnection(connectionString))
                {
                    conn.Open();

                    // åˆ é™¤æŒ‡å®šè¡Œ
                    string deleteQuery = string.Format("DELETE FROM `{0}` WHERE `{1}` = @indexValue", tableName, indexName);
                    using (MySqlCommand cmd = new MySqlCommand(deleteQuery, conn))
                    {
                        cmd.Parameters.AddWithValue("@indexValue", indexValue);
                        cmd.ExecuteNonQuery();
                    }

                    // MySQL ä¸­æ›´æ–°è¡Œå·çš„写法（假设indexName是自增列）
                    string updateQuery = string.Format(@"
                        SET @row_number = 0;
                        UPDATE `{0}` 
                        SET `{1}` = @row_number := @row_number + 1 
                        ORDER BY `{1}`;", tableName, indexName);

                    using (MySqlCommand cmd = new MySqlCommand(updateQuery, conn))
                    {
                        cmd.ExecuteNonQuery();
                    }
                    return true;
                }
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// äº¤æ¢æŒ‡å®šè¡Œçš„所有值通过索引指定列的指定值
        /// </summary>
        /// <param name="tableName">表名</param>
        /// <param name="swapName">列名</param>
        /// <param name="swapValue1">交换的列值</param>
        /// <param name="swapValue2">被交换的列值</param>
        /// <param name="connectionString"></param>
        /// <returns>交换成功True</returns>
        public static bool SwapRowFromIndexName(string tableName, string swapName, string swapValue1, string swapValue2, string connectionString = "")
        {
            if (string.IsNullOrEmpty(connectionString))
                connectionString = ConnectionString;

            using (MySqlConnection conn = new MySqlConnection(connectionString))
            {
                conn.Open();

                // å¼€å§‹äº‹åŠ¡
                MySqlTransaction transaction = conn.BeginTransaction();
                try
                {
                    // MySQL äº¤æ¢è¡Œå€¼çš„写法
                    string swapQuery = string.Format(@"
                        UPDATE `{0}` 
                        SET `{1}` = CASE 
                            WHEN `{1}` = @SwapValue1 THEN @SwapTempValue
                            WHEN `{1}` = @SwapValue2 THEN @SwapValue1
                            WHEN `{1}` = @SwapTempValue THEN @SwapValue2
                        END
                        WHERE `{1}` IN (@SwapValue1, @SwapValue2, @SwapTempValue);", tableName, swapName);

                    using (MySqlCommand cmd = new MySqlCommand(swapQuery, conn, transaction))
                    {
                        // æ·»åŠ å‚æ•°
                        cmd.Parameters.AddWithValue("@SwapValue1", swapValue1);
                        cmd.Parameters.AddWithValue("@SwapValue2", swapValue2);
                        cmd.Parameters.AddWithValue("@SwapTempValue", Guid.NewGuid().ToString());

                        // æ‰§è¡ŒæŸ¥è¯¢
                        cmd.ExecuteNonQuery();
                    }

                    // æäº¤äº‹åŠ¡
                    transaction.Commit();
                    return true;
                }
                catch (Exception ex)
                {
                    Debug.WriteLine("交换失败,原因是:" + ex.Message.ToString());
                    // å‡ºçŽ°å¼‚常时回滚事务
                    transaction.Rollback();
                    return false;
                }
            }
        }

        /// <summary>
        /// æ›´æ–°æŒ‡å®šåˆ—的值通过索引指定列的指定值
        /// </summary>
        /// <param name="tableName"></param>
        /// <param name="oriValue"></param>
        /// <param name="newValue"></param>
        /// <param name="columnName"></param>
        /// <param name="connectionString"></param>
        /// <returns></returns>
        public static bool UpdateValueFromIndexName(string tableName, string oriValue, string newValue, string columnName, string connectionString = "")
        {
            // ä¿®æ­£åŽŸæ–¹æ³•åæ‹¼å†™é”™è¯¯ Updata -> Update
            if (string.IsNullOrEmpty(connectionString))
                connectionString = ConnectionString;

            // MySQL æ›´æ–°è¯­å¥
            string sqlQuery = string.Format("UPDATE `{0}` SET `{1}` = @NewValue WHERE `{1}` = @OriValue", tableName, columnName);

            // è¿žæŽ¥æ•°æ®åº“并执行查询
            using (MySqlConnection connection = new MySqlConnection(connectionString))
            {
                using (MySqlCommand command = new MySqlCommand(sqlQuery, connection))
                {
                    // å‚数化查询，防止 SQL æ³¨å…¥
                    command.Parameters.AddWithValue("@OriValue", oriValue);  // è¦æ›¿æ¢çš„原始值
                    command.Parameters.AddWithValue("@NewValue", newValue);  // æ›¿æ¢åŽçš„新值

                    // æ‰“开连接
                    connection.Open();

                    // æ‰§è¡Œæ›´æ–°æ“ä½œ
                    int rowsAffected = command.ExecuteNonQuery();

                    return rowsAffected > 0;
                }
            }
        }

        /// <summary>
        /// æ£€æŸ¥æ•°æ®åº“是否存在
        /// </summary>
        /// <param name="connectionString"></param>
        /// <param name="databaseName"></param>
        /// <returns></returns>
        public static bool DatabaseExists(string connectionString, string databaseName)
        {
            string query = "SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = @databaseName";

            using (MySqlConnection connection = new MySqlConnection(connectionString))
            {
                connection.Open();
                using (MySqlCommand command = new MySqlCommand(query, connection))
                {
                    command.Parameters.AddWithValue("@databaseName", databaseName);
                    var result = command.ExecuteScalar();
                    return result != null;
                }
            }
        }

        /// <summary>
        /// åˆ›å»ºæ•°æ®åº“
        /// </summary>
        /// <param name="connectionString"></param>
        /// <param name="databaseName"></param>
        /// <returns></returns>
        public static bool CreateDatabase(string connectionString, string databaseName)
        {
            if (string.IsNullOrEmpty(connectionString))
                connectionString = ConnectionString;

            try
            {
                string createQuery = $"CREATE DATABASE IF NOT EXISTS `{databaseName}` CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci";

                using (MySqlConnection connection = new MySqlConnection(connectionString))
                {
                    connection.Open();
                    using (MySqlCommand command = new MySqlCommand(createQuery, connection))
                    {
                        command.ExecuteNonQuery();
                    }
                }
                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// åˆ é™¤æ•°æ®åº“
        /// </summary>
        /// <param name="databaseName"></param>
        /// <param name="connectionString"></param>
        /// <returns></returns>
        public static bool DeleteDatabase(string databaseName, string connectionString)
        {
            if (string.IsNullOrEmpty(connectionString))
                connectionString = ConnectionString;

            // MySQL åˆ é™¤æ•°æ®åº“语句
            string dropDatabaseQuery = $"DROP DATABASE IF EXISTS `{databaseName}`";

            using (MySqlConnection connection = new MySqlConnection(connectionString))
            {
                try
                {
                    // æ‰“开数据库连接
                    connection.Open();

                    // åˆ›å»º MySqlCommand å¯¹è±¡
                    using (MySqlCommand cmd = new MySqlCommand(dropDatabaseQuery, connection))
                    {
                        // æ‰§è¡Œåˆ é™¤æ•°æ®åº“操作
                        cmd.ExecuteNonQuery();
                        Debug.WriteLine("Database dropped successfully.");
                        return true;
                    }
                }
                catch (Exception ex)
                {
                    Debug.WriteLine("Error: " + ex.Message);
                    return false;
                }
            }
        }

        /// <summary>
        /// å¤åˆ¶è¡¨ç»“构和数据
        /// </summary>
        /// <param name="connectionString"></param>
        /// <param name="sourceDatabase"></param>
        /// <param name="targetDatabase"></param>
        /// <returns></returns>
        public static bool CopyDatabaseData(string connectionString, string sourceDatabase, string targetDatabase)
        {
            if (string.IsNullOrEmpty(connectionString))
                connectionString = ConnectionString;

            try
            {
                // å…ˆåˆ›å»ºç›®æ ‡æ•°æ®åº“（如果不存在）
                CreateDatabase(connectionString, targetDatabase);

                using (var connection = new MySqlConnection(connectionString))
                {
                    connection.Open();

                    // èŽ·å–源数据库中所有表的列表
                    string getTablesQuery = $"SELECT table_name FROM INFORMATION_SCHEMA.TABLES WHERE table_schema = @sourceDb";
                    using (var cmd = new MySqlCommand(getTablesQuery, connection))
                    {
                        cmd.Parameters.AddWithValue("@sourceDb", sourceDatabase);
                        using (var reader = cmd.ExecuteReader())
                        {
                            while (reader.Read())
                            {
                                string tableName = reader.GetString(0);
                                Debug.WriteLine($"复制表: {tableName}");

                                // å…³é—­reader才能执行后续操作
                                reader.Close();

                                // å¤åˆ¶è¡¨ç»“构和数据（MySQL ç®€åŒ–写法）
                                string copyTableQuery = $"CREATE TABLE `{targetDatabase}`.`{tableName}` LIKE `{sourceDatabase}`.`{tableName}`; " +
                                                       $"INSERT INTO `{targetDatabase}`.`{tableName}` SELECT * FROM `{sourceDatabase}`.`{tableName}`;";

                                using (var cmdCopy = new MySqlCommand(copyTableQuery, connection))
                                {
                                    cmdCopy.ExecuteNonQuery();
                                }

                                // é‡æ–°æ‰“å¼€reader继续读取下一个表
                                reader.NextResult();
                            }
                        }
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                Debug.WriteLine($"复制失败: {ex.Message}");
                return false;
            }
        }

        /// <summary>
        /// èŽ·å–用户数据库列表
        /// </summary>
        /// <returns></returns>
        public static List<string> GetUserDatabases()
        {
            List<string> databases = new List<string>();
            string connectionString = "Server=localhost;Database=user_pt;Uid=root;Pwd=root;";

            using (MySqlConnection connection = new MySqlConnection(connectionString))
            {
                try
                {
                    connection.Open();
                    string query = @"
                        SELECT SCHEMA_NAME 
                        FROM INFORMATION_SCHEMA.SCHEMATA 
                        WHERE SCHEMA_NAME NOT IN ('mysql', 'information_schema', 'performance_schema', 'sys')";

                    using (MySqlCommand command = new MySqlCommand(query, connection))
                    using (MySqlDataReader reader = command.ExecuteReader())
                    {
                        while (reader.Read())
                        {
                            databases.Add(reader["SCHEMA_NAME"]?.ToString());
                        }
                    }
                }
                catch (MySqlException ex)
                {
                    Debug.WriteLine($"数据库查询失败: {ex.Message}");
                }
            }
            return databases;
        }
    }
}

 LB_SmartVision/SQL/RecordProductData.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,75 @@
using LB_SmartVisionCommon;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LB_SmartVision.SQL
{
    /// <summary>
    /// è®°å½•ç”Ÿäº§æ•°æ®
    /// </summary>
    [JsonObject(MemberSerialization.OptOut)]
    [TypeConverter(typeof(PropertySorter))]
    public class RecordProductData
    {
        /// <summary>
        /// SKU  ç‰©æ–™å·æˆ–产品名称
        /// </summary>
        [Category("RecordProductData"), PropertyOrder(0)]
        [DisplayName("SKU")]
        [Browsable(true)]
        public string ProductName { get; set; }

        /// <summary>
        /// äº§å“SN号
        /// </summary>
        [Category("RecordProductData"), PropertyOrder(1)]
        [DisplayName("SN")]
        [Browsable(true)]
        public string ProductSN { get; set; }

        /// <summary>
        /// æ£€æµ‹ä½œä¸šå‘˜
        /// </summary>
        [Category("RecordProductData"), PropertyOrder(2)]
        [DisplayName("检测作业员")]
        [Browsable(true)]
        public string InspectionOperator { get; set; }

        /// <summary>
        /// NG类型
        /// </summary>
        [Category("RecordProductData"), PropertyOrder(3)]
        [DisplayName("NG类型")]
        [Browsable(true)]
        public string NGType {  get; set; }

        /// <summary>
        /// NG大小
        /// </summary>
        [Category("RecordProductData"), PropertyOrder(4)]
        [DisplayName("NG大小")]
        [Browsable(true)]
        public string NGSize { get; set; }

        /// <summary>
        /// æ£€æµ‹æ—¶é—´
        /// </summary>
        [Category("RecordProductData"), PropertyOrder(5)]
        [DisplayName("检测时间")]
        [Browsable(true)]
        public string DetectionTime { get; set; }

        /// <summary>
        /// æ£€æµ‹ç›¸æœº
        /// </summary>
        [Category("RecordProductData"), PropertyOrder(6)]
        [DisplayName("检测相机")]
        [Browsable(true)]
        public string CameraInspection { get; set; }
    }
}

 LB_SmartVision/SQL/RecordProductDataRepository.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,419 @@
using LB_SmartVisionCommon;
using MySql.Data.MySqlClient;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LB_SmartVision.SQL
{
    /// <summary>
    /// æ•°æ®è®¿é—®å±‚
    /// </summary>
    public class RecordProductDataRepository
    {
        private static object recordProductDataRepositoryObject = new object();
        /// <summary>
        /// æ·»åŠ æ•°æ®
        /// </summary>
        /// <param name="record">生产数据记录</param>
        /// <returns>是否添加成功</returns>
        public static bool AddRecord(RecordProductData record)
        {
            Stopwatch stopwatch = Stopwatch.StartNew();
            lock (recordProductDataRepositoryObject)
            {
                stopwatch.Start();
                try
                {
                    using (var connection = DatabaseRecordProductDataHelper.GetConnection())
                    {
                        connection.Open();
                        string sql = @"
                                     INSERT INTO RecordProductData 
                                     (ProductName, ProductSN, InspectionOperator, NGType, NGSize,DetectionTime,CameraInspection)
                                     VALUES 
                                     (@ProductName, @ProductSN, @InspectionOperator, @NGType, @NGSize, @DetectionTime, @CameraInspection)";
                        using (var cmd = new MySqlCommand(sql, connection))
                        {
                            cmd.Parameters.AddWithValue("@ProductName", record.ProductName);
                            cmd.Parameters.AddWithValue("@ProductSN", record.ProductSN);
                            cmd.Parameters.AddWithValue("@InspectionOperator", record.InspectionOperator);
                            cmd.Parameters.AddWithValue("@NGType", record.NGType);
                            cmd.Parameters.AddWithValue("@NGSize", record.NGSize);
                            cmd.Parameters.AddWithValue("@DetectionTime", record.DetectionTime);
                            cmd.Parameters.AddWithValue("@CameraInspection", record.CameraInspection);
                            int rowsAffected = cmd.ExecuteNonQuery();
                            stopwatch.Stop();
                            Task.Factory.StartNew(() =>
                            {
                                LogHelper.Info($"添加信息耗时: {stopwatch.ElapsedMilliseconds}ms");
                            });
                            return rowsAffected > 0;
                        }
                    }
                }
                catch (Exception ex)
                {
                    AsyncLogHelper.Error($"添加记录失败: {ex.Message}");
                    return false;
                }
            }
        }
        /// <summary>
        /// æŸ¥è¯¢æ‰€æœ‰æ•°æ®
        /// </summary>
        /// <returns>List<RecordProductData></returns>
        public static List<RecordProductData> GetAllRecords()
        {
            lock (recordProductDataRepositoryObject)
            {
                var records = new List<RecordProductData>();
                try
                {
                    using (var connection = DatabaseRecordProductDataHelper.GetConnection())
                    {
                        connection.Open();
                        string sql = "SELECT * FROM RecordProductData ORDER BY CreatedDate DESC";
                        using (var cmd = new MySqlCommand(sql, connection))
                        using (var reader = cmd.ExecuteReader())
                        {
                            while (reader.Read())
                            {
                                records.Add(MapReaderToRecord(reader));
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    AsyncLogHelper.Error($"查询记录失败: {ex.Message}");
                }
                return records;
            }
        }
        /// <summary>
        /// æ ¹æ®äº§å“ç¼–号查询
        /// </summary>
        /// <param name="productSN">产品编号</param>
        /// <returns>List<RecordProductData></returns>
        public static List<RecordProductData> GetRecordsByProductNumber(string productSN)
        {
            lock (recordProductDataRepositoryObject)
            {
                var records = new List<RecordProductData>();
                try
                {
                    using (var connection = DatabaseRecordProductDataHelper.GetConnection())
                    {
                        connection.Open();
                        string sql = "SELECT * FROM RecordProductData WHERE productSN = @productSN ORDER BY CreatedDate DESC";
                        using (var cmd = new MySqlCommand(sql, connection))
                        {
                            cmd.Parameters.AddWithValue("@productSN", productSN);
                            using (var reader = cmd.ExecuteReader())
                            {
                                while (reader.Read())
                                {
                                    records.Add(MapReaderToRecord(reader));
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    AsyncLogHelper.Error($"根据产品编号查询失败: {ex.Message}");
                }
                return records;
            }
        }
        /// <summary>
        /// æ ¹æ®æ“ä½œè€…查询
        /// </summary>
        /// <param name="inspectionOperator">操作者</param>
        /// <returns>List<RecordProductData></returns>
        public static List<RecordProductData> GetRecordsByOperator(string inspectionOperator)
        {
            lock (recordProductDataRepositoryObject)
            {
                var records = new List<RecordProductData>();
                try
                {
                    using (var connection = DatabaseRecordProductDataHelper.GetConnection())
                    {
                        connection.Open();
                        string sql = "SELECT * FROM RecordProductData WHERE InspectionOperator = @InspectionOperator ORDER BY CreatedDate DESC";
                        using (var cmd = new MySqlCommand(sql, connection))
                        {
                            cmd.Parameters.AddWithValue("@InspectionOperator", inspectionOperator);
                            using (var reader = cmd.ExecuteReader())
                            {
                                while (reader.Read())
                                {
                                    records.Add(MapReaderToRecord(reader));
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    AsyncLogHelper.Error($"根据操作者查询失败: {ex.Message}");
                }
                return records;
            }
        }
        /// <summary>
        /// æ ¹æ®æ—¶é—´æ®µæŸ¥è¯¢ - ä½¿ç”¨CreatedDate
        /// </summary>
        /// <param name="startTime">起始时间</param>
        /// <param name="endTime">结束时间</param>
        /// <returns>List<RecordProductData></returns>
        public static List<RecordProductData> GetRecordsByTimeRange(DateTime startTime, DateTime endTime)
        {
            lock (recordProductDataRepositoryObject)
            {
                var records = new List<RecordProductData>();
                try
                {
                    using (var connection = DatabaseRecordProductDataHelper.GetConnection())
                    {
                        connection.Open();
                        string sql = @"
                                     SELECT * FROM RecordProductData 
                                     WHERE CreatedDate BETWEEN @StartTime AND @EndTime 
                                     ORDER BY CreatedDate DESC";
                        using (var cmd = new MySqlCommand(sql, connection))
                        {
                            cmd.Parameters.AddWithValue("@StartTime", startTime);
                            cmd.Parameters.AddWithValue("@EndTime", endTime.AddDays(1).AddSeconds(-1)); // åŒ…含结束日期的全天
                            using (var reader = cmd.ExecuteReader())
                            {
                                while (reader.Read())
                                {
                                    records.Add(MapReaderToRecord(reader));
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    AsyncLogHelper.Error($"根据时间段查询失败: {ex.Message}");
                }
                return records;
            }
        }

        /// <summary>
        /// ç»„合查询：产品编号 + æ—¶é—´æ®µ
        /// </summary>
        /// <param name="productSN">产品编号</param>
        /// <param name="startTime">起始时间</param>
        /// <param name="endTime">结束时间</param>
        /// <returns>List<RecordProductData></returns>
        public static List<RecordProductData> GetRecordsByProductAndTimeRange(string productSN, DateTime startTime, DateTime endTime)
        {
            lock (recordProductDataRepositoryObject)
            {
                var records = new List<RecordProductData>();
                try
                {
                    using (var connection = DatabaseRecordProductDataHelper.GetConnection())
                    {
                        connection.Open();
                        string sql = @"
                                     SELECT * FROM RecordProductData 
                                     WHERE productSN = @productSN 
                                     AND CreatedDate BETWEEN @StartTime AND @EndTime 
                                     ORDER BY CreatedDate DESC";
                        using (var cmd = new MySqlCommand(sql, connection))
                        {
                            cmd.Parameters.AddWithValue("@productSN", productSN);
                            cmd.Parameters.AddWithValue("@StartTime", startTime);
                            cmd.Parameters.AddWithValue("@EndTime", endTime.AddDays(1).AddSeconds(-1));
                            using (var reader = cmd.ExecuteReader())
                            {
                                while (reader.Read())
                                {
                                    records.Add(MapReaderToRecord(reader));
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    AsyncLogHelper.Error($"组合查询失败: {ex.Message}");
                }
                return records;
            }
        }
        /// <summary>
        /// ç»„合查询：操作者 + æ—¶é—´æ®µ
        /// </summary>
        /// <param name="inspectionOperator">操作者</param>
        /// <param name="startTime">起始时间</param>
        /// <param name="endTime">结束时间</param>
        /// <returns>List<RecordProductData></returns>
        public static List<RecordProductData> GetRecordsByOperatorAndTimeRange(string inspectionOperator, DateTime startTime, DateTime endTime)
        {
            lock (recordProductDataRepositoryObject)
            {
                var records = new List<RecordProductData>();
                try
                {
                    using (var connection = DatabaseRecordProductDataHelper.GetConnection())
                    {
                        connection.Open();
                        string sql = @"
                                     SELECT * FROM RecordProductData 
                                     WHERE InspectionOperator = @InspectionOperator 
                                     AND CreatedDate BETWEEN @StartTime AND @EndTime 
                                     ORDER BY CreatedDate DESC";
                        using (var cmd = new MySqlCommand(sql, connection))
                        {
                            cmd.Parameters.AddWithValue("@InspectionOperator", inspectionOperator);
                            cmd.Parameters.AddWithValue("@StartTime", startTime);
                            cmd.Parameters.AddWithValue("@EndTime", endTime.AddDays(1).AddSeconds(-1));
                            using (var reader = cmd.ExecuteReader())
                            {
                                while (reader.Read())
                                {
                                    records.Add(MapReaderToRecord(reader));
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    AsyncLogHelper.Error($"组合查询失败: {ex.Message}");
                }
                return records;
            }
        }
        /// <summary>
        /// é«˜çº§ç»„合查询：支持多个条件
        /// </summary>
        /// <param name="productSN">产品编号</param>
        /// <param name="operatorName">操作者</param>
        /// <param name="startTime">起始时间</param>
        /// <param name="endTime">结束时间</param>
        /// <returns>List<RecordProductData></returns>
        public static List<RecordProductData> GetRecordsByMultipleConditions(
            string productSN = null,
            string operatorName = null,
            DateTime? startTime = null,
            DateTime? endTime = null)
        {
            lock (recordProductDataRepositoryObject)
            {
                var records = new List<RecordProductData>();
                try
                {
                    using (var connection = DatabaseRecordProductDataHelper.GetConnection())
                    {
                        connection.Open();
                        var sql = "SELECT * FROM RecordProductData WHERE 1=1";
                        var parameters = new List<MySqlParameter>();
                        if (!string.IsNullOrEmpty(productSN))
                        {
                            sql += " AND ProductSN = @ProductSN";
                            parameters.Add(new MySqlParameter("@ProductSN", productSN));
                        }
                        if (!string.IsNullOrEmpty(operatorName))
                        {
                            sql += " AND MeasurementOperator = @InspectionOperator";
                            parameters.Add(new MySqlParameter("@InspectionOperator", operatorName));
                        }
                        if (startTime.HasValue)
                        {
                            sql += " AND CreatedDate >= @StartTime";
                            parameters.Add(new MySqlParameter("@StartTime", startTime.Value));
                        }
                        if (endTime.HasValue)
                        {
                            sql += " AND CreatedDate <= @EndTime";
                            parameters.Add(new MySqlParameter("@EndTime", endTime.Value.AddDays(1).AddSeconds(-1)));
                        }
                        sql += " ORDER BY CreatedDate DESC";
                        using (var cmd = new MySqlCommand(sql, connection))
                        {
                            foreach (var param in parameters)
                            {
                                cmd.Parameters.Add(param);
                            }
                            using (var reader = cmd.ExecuteReader())
                            {
                                while (reader.Read())
                                {
                                    records.Add(MapReaderToRecord(reader));
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    AsyncLogHelper.Error($"高级组合查询失败: {ex.Message}");
                }
                return records;
            }
        }
        /// <summary>
        /// ç»Ÿè®¡æŸ¥è¯¢ï¼šèŽ·å–某个时间段内的记录数量
        /// </summary>
        /// <param name="startTime">起始时间</param>
        /// <param name="endTime">结束时间</param>
        /// <returns>记录数量</returns>
        public static int GetRecordCountByTimeRange(DateTime startTime, DateTime endTime)
        {
            lock (recordProductDataRepositoryObject)
            {
                try
                {
                    using (var connection = DatabaseRecordProductDataHelper.GetConnection())
                    {
                        connection.Open();
                        string sql = @"
                                     SELECT COUNT(*) FROM RecordProductData 
                                     WHERE CreatedDate BETWEEN @StartTime AND @EndTime";
                        using (var cmd = new MySqlCommand(sql, connection))
                        {
                            cmd.Parameters.AddWithValue("@StartTime", startTime);
                            cmd.Parameters.AddWithValue("@EndTime", endTime.AddDays(1).AddSeconds(-1));
                            return Convert.ToInt32(cmd.ExecuteScalar());
                        }
                    }
                }
                catch (Exception ex)
                {
                    AsyncLogHelper.Error($"统计查询失败: {ex.Message}");
                    return 0;
                }
            }
        }
        /// <summary>
        /// è¾…助方法：将数据读取器映射到RecordProductData对象
        /// </summary>
        /// <param name="reader">MySqlDataReader reader</param>
        /// <returns>RecordProductData</returns>
        private static RecordProductData MapReaderToRecord(MySqlDataReader reader)
        {
            return new RecordProductData
            {
                ProductName = reader["ProductName"]?.ToString() ?? string.Empty,
                ProductSN = reader["ProductSN"]?.ToString() ?? string.Empty,
                InspectionOperator = reader["InspectionOperator"]?.ToString() ?? string.Empty,
                NGType = reader["NGType"]?.ToString() ?? string.Empty,
                NGSize = reader["NGSize"]?.ToString() ?? string.Empty,
                DetectionTime = reader["DetectionTime"]?.ToString() ?? string.Empty,
                CameraInspection = reader["CameraInspection"]?.ToString() ?? string.Empty,
            };
        }
    }
}

 LB_SmartVisionCommon/UserData.cs

@@ -33,12 +33,14 @@
        /// å‘˜å·¥è´¦å·
        /// </summary>
        [Category("RecordUserData"), PropertyOrder(3)]
        [DisplayName("账号")]
        [DisplayName("员工账号")]
        [Browsable(true)]
        public string EmployeeAccount { get; set; }
        /// <summary>
        /// å‘˜å·¥å¯†ç 
        /// </summary>
        [Category("RecordUserData"), PropertyOrder(4)]
        [DisplayName("员工密码")]
        [Browsable(false)]
        public string EmployeePassword { get; set; }
        /// <summary>

 LB_VisionProcesses/Communicators/SiemensS7/SiemensLBS7.cs

@@ -32,6 +32,7 @@
                short slot;
                short.TryParse(CommunicatorConnections["端口"].ToString(), out slot);
                S7.Net.CpuType cpuType = (CpuType)CommunicatorConnections["型号"];
                variable = CommunicatorConnections["变量地址"].ToString();
                plc = new Plc(cpuType, IP, 0, slot);
                plc.Open();
                return true;
@@ -60,8 +61,19 @@
        {
            try
            {
                plc.Write(variable, message);
                return true;
                if (plc!=null)
                {
                    if (string.IsNullOrEmpty(variable))
                    {
                        variable = CommunicatorConnections["变量地址"].ToString();
                    }
                    plc.Write(variable, message);
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch
            {