数据库操作

wells.liu

2020-07-04 4cb676856f0c791ffcbef569c0ca8195bf8b0938

数据库操作

 src/Bro.Common.Model/Helper/EnumHelper.cs

@@ -447,7 +447,7 @@
        /// <summary>
        /// 马达/运动板卡运行模式
        /// </summary>
        public enum MotorMoveMode
        public enum MotionMode
        {
            /// <summary>
            /// 普通点位运动

 src/Bro.Common.Model/Model/MotionCardRelated.cs

@@ -216,11 +216,11 @@
            }
        }

        private MotorMoveMode moveMode = MotorMoveMode.Normal;
        private MotionMode moveMode = MotionMode.Normal;
        [Category("运动配置")]
        [DisplayName("运动模式")]
        [Description("MoveMode：运动模式")]
        public MotorMoveMode MoveMode
        public MotionMode MoveMode
        {
            get => moveMode;
            set

 src/Bro.Device.GTSCard/GTSCardDriver.cs

@@ -323,13 +323,13 @@
                    if (IConfig.AxisSettings.FirstOrDefault(a => a.AxisIndex == optionPara.AxisIndex)?.IsAxisEnabled ?? false)
                    {
                        string _position = "";
                        string motionType = optionPara.MoveMode == EnumHelper.MotorMoveMode.Normal ? (optionPara.IsAbsolute ? "Abs" : "Rel") : optionPara.MoveMode.ToString();
                        string motionType = optionPara.MoveMode == EnumHelper.MotionMode.Normal ? (optionPara.IsAbsolute ? "Abs" : "Rel") : optionPara.MoveMode.ToString();

                        _position = $"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff},{optionPara.AxisIndex},{motionType},{GetPosition(optionPara.AxisIndex)},{GetPrfPosition(optionPara.AxisIndex)},{optionPara.Destination},";

                        switch (optionPara.MoveMode)
                        {
                            case MotorMoveMode.Normal:
                            case MotionMode.Normal:
                                {
                                    if (_isResetting)
                                    {
@@ -348,12 +348,12 @@

                                }
                                break;
                            case MotorMoveMode.FindOri:
                            case MotionMode.FindOri:
                                {
                                    isSuccessAndStop = GoHome(optionPara);
                                }
                                break;
                            case MotorMoveMode.Jog:
                            case MotionMode.Jog:
                                {
                                    isSuccessAndStop = JogMove(optionPara);
                                }

 src/Bro.M071.Process.DBManager/App.config

@@ -1,9 +1,6 @@
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <configSections>
    <!-- For more information on Entity Framework configuration, visit http://go.microsoft.com/fwlink/?LinkID=237468 -->
    <!-- For more information on Entity Framework configuration, visit http://go.microsoft.com/fwlink/?LinkID=237468 -->
  <!-- For more information on Entity Framework configuration, visit http://go.microsoft.com/fwlink/?LinkID=237468 -->
  <section name="entityFramework" type="System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />
  </configSections>
  <system.data>

 src/Bro.M071.Process.DBManager/Bro.M071.DBManager.csproj

@@ -107,10 +107,13 @@
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="ProductionDetectionImageRecordsManager.cs" />
    <Compile Include="ProductionDetectionRecordsDetailManager.cs" />
    <Compile Include="ProductionDetectionRecordsManager.cs" />
    <Compile Include="KeyUnitDataManager.cs" />
    <Compile Include="MeasurementAndKeyDataRelationManager.cs" />
    <Compile Include="ModelManager.cs" />
    <Compile Include="ProductionMeasurementRecordsManager.cs" />
    <Compile Include="MeasurementUnitResultManager.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="SQLiteHelper.cs" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\Bro.Common.Model\Bro.Common.Model.csproj">

 src/Bro.M071.Process.DBManager/KeyUnitDataManager.cs

New file
@@ -0,0 +1,95 @@
using Bro.Common.Helper;
using Bro.M071.Model;
using Bro.M071.Model.Model;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Data.SQLite;
using System.Linq;
using System.Text;

namespace Bro.M071.DBManager
{
    public class KeyUnitDataManager : ModelManager<KeyUnitData>
    {
        DbProviderFactory Dbfactory = SQLiteFactory.Instance;
        protected override void ActionBeforeNewModel(DBModel context, KeyUnitData config)
        {
            CheckProductionCodeDuplicate(context, config);
        }

        protected override void ActionBeforeUpdateModel(DBModel context, KeyUnitData config)
        {
            CheckProductionCodeDuplicate(context, config);
        }

        private void CheckProductionCodeDuplicate(DBModel context, KeyUnitData config)
        {
        }

        public List<KeyUnitData> GetKeyUnitData()
        {
            using (DBModel context = new DBModel())
            {
                var list = context.KeyUnitData.Where(u => u.IS_DELETED == 0);

                //if (!string.IsNullOrWhiteSpace(productionBatchNO))
                //{
                //    list = list.Where(u => u.ProductionBatchNO.Contains(productionBatchNO));
                //}
                //if (!string.IsNullOrWhiteSpace(pid))
                //{
                //    list = list.Where(u => u.PId.Contains(pid));
                //}

                var resultList = list.ToList();
                return resultList;
            }
        }

        public void BatchAddKeyUnitData(List<KeyUnitData> records)
        {
            try
            {
                using (SQLiteConnection conn = new SQLiteConnection(ConnectionString))
                {
                    using (SQLiteCommand insertRngCmd = (SQLiteCommand)conn.CreateCommand())
                    {
                        StringBuilder strSql = new StringBuilder();
                        strSql.Append("insert into KeyUnitData (");
                        strSql.Append("ID,ProductionMeasurementRecordsId,Key,MeasurementItem,ItemValue,IS_DISABLED,IS_DELETED,CREATE_USER,CREATE_TIME, UPDATE_USER,UPDATE_TIME");
                        strSql.Append(")values (");
                        strSql.Append("@ID,@ProductionMeasurementRecordsId,@Key,@MeasurementItem,@ItemValue,@IS_DISABLED,@IS_DELETED,@CREATE_USER,@CREATE_TIME,@UPDATE_USER,@UPDATE_TIME)");

                        insertRngCmd.CommandText = strSql.ToString();
                        conn.Open();
                        var transaction = conn.BeginTransaction();

                        foreach (var record in records)
                        {
                            insertRngCmd.Parameters.AddWithValue("@ID", record.ID);
                            insertRngCmd.Parameters.AddWithValue("@ProductionMeasurementRecordsId", record.ProductionMeasurementRecordsId);
                            insertRngCmd.Parameters.AddWithValue("@Key", record.Key);
                            insertRngCmd.Parameters.AddWithValue("@MeasurementItem", record.MeasurementItem);
                            insertRngCmd.Parameters.AddWithValue("@ItemValue", record.ItemValue);
                            insertRngCmd.Parameters.AddWithValue("@IS_DISABLED", record.IS_DISABLED);
                            insertRngCmd.Parameters.AddWithValue("@IS_DELETED", record.IS_DELETED);
                            insertRngCmd.Parameters.AddWithValue("@CREATE_USER", record.CREATE_USER);
                            insertRngCmd.Parameters.AddWithValue("@CREATE_TIME", record.CREATE_TIME);
                            insertRngCmd.Parameters.AddWithValue("@UPDATE_USER", record.UPDATE_USER);
                            insertRngCmd.Parameters.AddWithValue("@UPDATE_TIME", record.UPDATE_TIME);
                            insertRngCmd.ExecuteNonQuery();
                        }
                        transaction.Commit();
                    }
                }
            }
            catch (Exception ex)
            {
                throw new ProcessException(ex.Message, null);
            }
        }
    }
}

 src/Bro.M071.Process.DBManager/MeasurementAndKeyDataRelationManager.cs

New file
@@ -0,0 +1,93 @@
using Bro.Common.Helper;
using Bro.M071.Model;
using Bro.M071.Model.Model;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Data.SQLite;
using System.Linq;
using System.Text;

namespace Bro.M071.DBManager
{
    public class MeasurementAndKeyDataRelationManager : ModelManager<MeasurementAndKeyDataRelation>
    {
        DbProviderFactory Dbfactory = SQLiteFactory.Instance;
        protected override void ActionBeforeNewModel(DBModel context, MeasurementAndKeyDataRelation config)
        {
            CheckProductionCodeDuplicate(context, config);
        }

        protected override void ActionBeforeUpdateModel(DBModel context, MeasurementAndKeyDataRelation config)
        {
            CheckProductionCodeDuplicate(context, config);
        }

        private void CheckProductionCodeDuplicate(DBModel context, MeasurementAndKeyDataRelation config)
        {
        }

        public List<MeasurementAndKeyDataRelation> GetMeasurementAndKeyDataRelation()
        {
            using (DBModel context = new DBModel())
            {
                var list = context.MeasurementAndKeyDataRelation.Where(u => u.IS_DELETED == 0);

                //if (!string.IsNullOrWhiteSpace(productionBatchNO))
                //{
                //    list = list.Where(u => u.ProductionBatchNO.Contains(productionBatchNO));
                //}
                //if (!string.IsNullOrWhiteSpace(pid))
                //{
                //    list = list.Where(u => u.PId.Contains(pid));
                //}

                var resultList = list.ToList();
                return resultList;
            }
        }

        public void BatchAddMeasurementAndKeyDataRelation(List<MeasurementAndKeyDataRelation> records)
        {
            try
            {
                using (SQLiteConnection conn = new SQLiteConnection(ConnectionString))
                {
                    using (SQLiteCommand insertRngCmd = (SQLiteCommand)conn.CreateCommand())
                    {
                        StringBuilder strSql = new StringBuilder();
                        strSql.Append("insert into MeasurementAndKeyDataRelation (");
                        strSql.Append("ID,KeyUnitDataId,MeasurementUnitResultId,IS_DISABLED,IS_DELETED,CREATE_USER,CREATE_TIME, UPDATE_USER,UPDATE_TIME");
                        strSql.Append(")values (");
                        strSql.Append("@ID,@KeyUnitDataId,@MeasurementUnitResultId,@IS_DISABLED,@IS_DELETED,@CREATE_USER,@CREATE_TIME,@UPDATE_USER,@UPDATE_TIME)");

                        insertRngCmd.CommandText = strSql.ToString();
                        conn.Open();
                        var transaction = conn.BeginTransaction();

                        foreach (var record in records)
                        {
                            insertRngCmd.Parameters.AddWithValue("@ID", record.ID);
                            insertRngCmd.Parameters.AddWithValue("@KeyUnitDataId", record.KeyUnitDataId);
                            insertRngCmd.Parameters.AddWithValue("@MeasurementUnitResultId", record.MeasurementUnitResultId);
                            insertRngCmd.Parameters.AddWithValue("@IS_DISABLED", record.IS_DISABLED);
                            insertRngCmd.Parameters.AddWithValue("@IS_DELETED", record.IS_DELETED);
                            insertRngCmd.Parameters.AddWithValue("@CREATE_USER", record.CREATE_USER);
                            insertRngCmd.Parameters.AddWithValue("@CREATE_TIME", record.CREATE_TIME);
                            insertRngCmd.Parameters.AddWithValue("@UPDATE_USER", record.UPDATE_USER);
                            insertRngCmd.Parameters.AddWithValue("@UPDATE_TIME", record.UPDATE_TIME);
                            insertRngCmd.ExecuteNonQuery();
                        }
                        transaction.Commit();
                    }
                }
            }
            catch (Exception ex)
            {
                throw new ProcessException(ex.Message, null);
            }
        }
    }
}

 src/Bro.M071.Process.DBManager/MeasurementUnitResultManager.cs

New file
@@ -0,0 +1,96 @@
using Bro.Common.Helper;
using Bro.M071.Model;
using Bro.M071.Model.Model;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Data.SQLite;
using System.Linq;
using System.Text;

namespace Bro.M071.DBManager
{
    public class MeasurementUnitResultManager : ModelManager<MeasurementUnitResult>
    {
        DbProviderFactory Dbfactory = SQLiteFactory.Instance;
        protected override void ActionBeforeNewModel(DBModel context, MeasurementUnitResult config)
        {
            CheckProductionCodeDuplicate(context, config);
        }

        protected override void ActionBeforeUpdateModel(DBModel context, MeasurementUnitResult config)
        {
            CheckProductionCodeDuplicate(context, config);
        }

        private void CheckProductionCodeDuplicate(DBModel context, MeasurementUnitResult config)
        {
        }

        public List<MeasurementUnitResult> GetMeasurementUnitResult()
        {
            using (DBModel context = new DBModel())
            {
                var list = context.MeasurementUnitResult.Where(u => u.IS_DELETED == 0);

                //if (!string.IsNullOrWhiteSpace(productionBatchNO))
                //{
                //    list = list.Where(u => u.ProductionBatchNO.Contains(productionBatchNO));
                //}
                //if (!string.IsNullOrWhiteSpace(pid))
                //{
                //    list = list.Where(u => u.PId.Contains(pid));
                //}

                var resultList = list.ToList();
                return resultList;
            }
        }

        public void BatchAddMeasurementUnitResult(List<MeasurementUnitResult> records)
        {
            try
            {
                using (SQLiteConnection conn = new SQLiteConnection(ConnectionString))
                {
                    using (SQLiteCommand insertRngCmd = (SQLiteCommand)conn.CreateCommand())
                    {
                        StringBuilder strSql = new StringBuilder();
                        strSql.Append("insert into MeasurementUnitResult (");
                        strSql.Append("ID,ProductionMeasurementRecordsId,MeasurementName,MeasurementType,MeasurementValue,MeasurementResult,IS_DISABLED,IS_DELETED,CREATE_USER,CREATE_TIME, UPDATE_USER,UPDATE_TIME");
                        strSql.Append(")values (");
                        strSql.Append("@ID,@ProductionMeasurementRecordsId,@MeasurementName,@MeasurementType,@MeasurementValue,@MeasurementResult,@IS_DISABLED,@IS_DELETED,@CREATE_USER,@CREATE_TIME,@UPDATE_USER,@UPDATE_TIME)");

                        insertRngCmd.CommandText = strSql.ToString();
                        conn.Open();
                        var transaction = conn.BeginTransaction();

                        foreach (var record in records)
                        {
                            insertRngCmd.Parameters.AddWithValue("@ID", record.ID);
                            insertRngCmd.Parameters.AddWithValue("@ProductionMeasurementRecordsId", record.ProductionMeasurementRecordsId);
                            insertRngCmd.Parameters.AddWithValue("@MeasurementName", record.MeasurementName);
                            insertRngCmd.Parameters.AddWithValue("@MeasurementType", record.MeasurementType);
                            insertRngCmd.Parameters.AddWithValue("@MeasurementValue", record.MeasurementValue);
                            insertRngCmd.Parameters.AddWithValue("@MeasurementResult", record.MeasurementResult);
                            insertRngCmd.Parameters.AddWithValue("@IS_DISABLED", record.IS_DISABLED);
                            insertRngCmd.Parameters.AddWithValue("@IS_DELETED", record.IS_DELETED);
                            insertRngCmd.Parameters.AddWithValue("@CREATE_USER", record.CREATE_USER);
                            insertRngCmd.Parameters.AddWithValue("@CREATE_TIME", record.CREATE_TIME);
                            insertRngCmd.Parameters.AddWithValue("@UPDATE_USER", record.UPDATE_USER);
                            insertRngCmd.Parameters.AddWithValue("@UPDATE_TIME", record.UPDATE_TIME);
                            insertRngCmd.ExecuteNonQuery();
                        }
                        transaction.Commit();
                    }
                }
            }
            catch (Exception ex)
            {
                throw new ProcessException(ex.Message, null);
            }
        }
    }
}

 src/Bro.M071.Process.DBManager/ModelManager.cs

New file
@@ -0,0 +1,108 @@
using Bro.M071.Model;
using System.Collections.Generic;
using System.Configuration;
using System.Data.Entity;
using System.Linq;
using System.Reflection;

namespace Bro.M071.DBManager
{
    public class ModelManager<T> where T : BaseModel, new()
    {
        private PropertyInfo TableProperty = null;
        public static string ConnectionString = ConfigurationManager.ConnectionStrings["DataBase"].ConnectionString;
        public ModelManager()
        {
            T t = new T();
            using (DBModel db = new DBModel())
            {
                TableProperty = db.GetType().GetProperties().FirstOrDefault(u => u.Name == t.GetType().Name);
            }
        }

        public void CreateModel(T t, string userId = "")
        {
            using (DBModel context = new DBModel())
            {
                ActionBeforeNewModel(context, t);

                t.Create(userId);
                (TableProperty.GetValue(context) as DbSet<T>).Add(t);

                context.SaveChanges();
            }
        }

        public void BatchAdd(List<T> t, string userId = "")
        {
            using (DBModel context = new DBModel())
            {
                (TableProperty.GetValue(context) as DbSet<T>).AddRange(t);
                context.SaveChanges();
            }
        }

        public void UpdateModel(T t, string userId = "")
        {
            using (DBModel context = new DBModel())
            {
                ActionBeforeUpdateModel(context, t);

                DbSet<T> set = TableProperty.GetValue(context) as DbSet<T>;
                T oldT = set.FirstOrDefault(u => u.ID == t.ID);

                oldT.DataTransfer(t);
                oldT.Update(userId);
                context.SaveChanges();
            }
        }

        public void DeleteModel(string id, bool isDelete = true, string userId = "")
        {
            using (DBModel context = new DBModel())
            {
                ActionBeforeDeleteModel(context, id);

                DbSet<T> set = TableProperty.GetValue(context) as DbSet<T>;
                T oldT = set.FirstOrDefault(u => u.ID == id);
                oldT.IS_DELETED = isDelete ? 1 : 0;
                oldT.Update(userId);

                context.SaveChanges();
            }
        }

        public void DisableModel(string id, bool isDisable = true, string userId = "")
        {
            using (DBModel context = new DBModel())
            {
                ActionBeforeEnableModel(context, id);

                DbSet<T> set = TableProperty.GetValue(context) as DbSet<T>;
                T oldT = set.FirstOrDefault(u => u.ID == id);
                oldT.IS_DISABLED = isDisable ? 1 : 0;
                oldT.Update(userId);

                context.SaveChanges();
            }
        }

        #region ""
        protected virtual void ActionBeforeNewModel(DBModel context, T t)
        {
        }

        protected virtual void ActionBeforeUpdateModel(DBModel context, T t)
        {
        }

        protected virtual void ActionBeforeDeleteModel(DBModel context, string id)
        {
        }

        protected virtual void ActionBeforeEnableModel(DBModel context, string id)
        {
        }
        #endregion
    }
}

 src/Bro.M071.Process.DBManager/ProductionDetectionImageRecordsManager.cs

File was deleted

 src/Bro.M071.Process.DBManager/ProductionDetectionRecordsDetailManager.cs

File was deleted

 src/Bro.M071.Process.DBManager/ProductionDetectionRecordsManager.cs

File was deleted

 src/Bro.M071.Process.DBManager/ProductionMeasurementRecordsManager.cs

New file
@@ -0,0 +1,96 @@
using Bro.Common.Helper;
using Bro.M071.Model;
using Bro.M071.Model.Model;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Data.SQLite;
using System.Linq;
using System.Text;

namespace Bro.M071.DBManager
{
    public class ProductionMeasurementRecordsManager : ModelManager<ProductionMeasurementRecords>
    {
        DbProviderFactory Dbfactory = SQLiteFactory.Instance;
        protected override void ActionBeforeNewModel(DBModel context, ProductionMeasurementRecords config)
        {
            CheckProductionCodeDuplicate(context, config);
        }

        protected override void ActionBeforeUpdateModel(DBModel context, ProductionMeasurementRecords config)
        {
            CheckProductionCodeDuplicate(context, config);
        }

        private void CheckProductionCodeDuplicate(DBModel context, ProductionMeasurementRecords config)
        {
        }

        public List<ProductionMeasurementRecords> GetProductionMeasurementRecords()
        {
            using (DBModel context = new DBModel())
            {
                var list = context.ProductionMeasurementRecords.Where(u => u.IS_DELETED == 0);

                //if (!string.IsNullOrWhiteSpace(productionBatchNO))
                //{
                //    list = list.Where(u => u.ProductionBatchNO.Contains(productionBatchNO));
                //}
                //if (!string.IsNullOrWhiteSpace(pid))
                //{
                //    list = list.Where(u => u.PId.Contains(pid));
                //}

                var resultList = list.ToList();
                return resultList;
            }
        }

        public void BatchAddProductionMeasurementRecords(List<ProductionMeasurementRecords> records)
        {
            try
            {
                using (SQLiteConnection conn = new SQLiteConnection(ConnectionString))
                {
                    using (SQLiteCommand insertRngCmd = (SQLiteCommand)conn.CreateCommand())
                    {
                        StringBuilder strSql = new StringBuilder();
                        strSql.Append("insert into ProductionMeasurementRecords (");
                        strSql.Append("ID,ProductionCode,ProductionBarcode,ProductionResult,OperationStartTime,OperationEndTime,IS_DISABLED,IS_DELETED,CREATE_USER,CREATE_TIME, UPDATE_USER,UPDATE_TIME");
                        strSql.Append(")values (");
                        strSql.Append("@ID,@ProductionCode,@ProductionBarcode,@ProductionResult,@OperationStartTime,@OperationEndTime,@IS_DISABLED,@IS_DELETED,@CREATE_USER,@CREATE_TIME,@UPDATE_USER,@UPDATE_TIME)");

                        insertRngCmd.CommandText = strSql.ToString();
                        conn.Open();
                        var transaction = conn.BeginTransaction();

                        foreach (var record in records)
                        {
                            insertRngCmd.Parameters.AddWithValue("@ID", record.ID);
                            insertRngCmd.Parameters.AddWithValue("@ProductionCode", record.ProductionCode);
                            insertRngCmd.Parameters.AddWithValue("@ProductionBarcode", record.ProductionBarcode);
                            insertRngCmd.Parameters.AddWithValue("@ProductionResult", record.ProductionResult);
                            insertRngCmd.Parameters.AddWithValue("@OperationStartTime", record.OperationStartTime);
                            insertRngCmd.Parameters.AddWithValue("@OperationEndTime", record.OperationEndTime);
                            insertRngCmd.Parameters.AddWithValue("@IS_DISABLED", record.IS_DISABLED);
                            insertRngCmd.Parameters.AddWithValue("@IS_DELETED", record.IS_DELETED);
                            insertRngCmd.Parameters.AddWithValue("@CREATE_USER", record.CREATE_USER);
                            insertRngCmd.Parameters.AddWithValue("@CREATE_TIME", record.CREATE_TIME);
                            insertRngCmd.Parameters.AddWithValue("@UPDATE_USER", record.UPDATE_USER);
                            insertRngCmd.Parameters.AddWithValue("@UPDATE_TIME", record.UPDATE_TIME);
                            insertRngCmd.ExecuteNonQuery();
                        }
                        transaction.Commit();
                    }
                }
            }
            catch (Exception ex)
            {
                throw new ProcessException(ex.Message, null);
            }
        }
    }
}

 src/Bro.M071.Process.DBManager/SQLiteHelper.cs

New file
@@ -0,0 +1,614 @@


using System;
using System.Collections;
using System.Collections.Specialized;
using System.Data;
using System.Data.SQLite;
using System.Configuration;

namespace Bro.Process.DataBase
{
    public class SQLiteHelper
    {
        //数据库连接字符串 
        public static string connectionString = ConfigurationManager.ConnectionStrings["DataBase"].ConnectionString;

        public SQLiteHelper() { }

        #region 公用方法

        public static int GetMaxID(string FieldName, string TableName)
        {
            string strsql = "select max(" + FieldName + ")+1 from " + TableName;
            object obj = GetSingle(strsql);
            if (obj == null)
            {
                return 1;
            }
            else
            {
                return int.Parse(obj.ToString());
            }
        }

        public static bool Exists(string strSql)
        {
            object obj = GetSingle(strSql);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        public static bool Exists(string strSql, params SQLiteParameter[] cmdParms)
        {
            object obj = GetSingle(strSql, cmdParms);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        #endregion

        #region 执行简单SQL语句

        /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string SQLString)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                using (SQLiteCommand cmd = new SQLiteCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        int rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (System.Data.SQLite.SQLiteException E)
                    {
                        connection.Close();
                        throw new Exception(E.Message);
                    }
                }
            }
        }

        /// <summary>
        /// 执行SQL语句，设置命令的执行等待时间
        /// </summary>
        /// <param name="SQLString"></param>
        /// <param name="Times"></param>
        /// <returns></returns>
        public static int ExecuteSqlByTime(string SQLString, int Times)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                using (SQLiteCommand cmd = new SQLiteCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        cmd.CommandTimeout = Times;
                        int rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (System.Data.SQLite.SQLiteException E)
                    {
                        connection.Close();
                        throw new Exception(E.Message);
                    }
                }
            }
        }

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">多条SQL语句</param> 
        public static bool ExecuteSqlTran(ArrayList SQLStringList)
        {
            bool isSuccess = false;
            using (SQLiteConnection conn = new SQLiteConnection(connectionString))
            {
                conn.Open();
                SQLiteCommand cmd = new SQLiteCommand();
                cmd.Connection = conn;
                cmd.CommandText = "PRAGMA synchronous = OFF;";
                cmd.ExecuteNonQuery();
                SQLiteTransaction tx = conn.BeginTransaction();
                cmd.Transaction = tx;
                try
                {
                    for (int n = 0; n < SQLStringList.Count; n++)
                    {
                        string strsql = SQLStringList[n].ToString();
                        if (strsql.Trim().Length > 1)
                        {
                            cmd.CommandText = strsql;
                            cmd.ExecuteNonQuery();
                        }
                    }
                    tx.Commit();
                    isSuccess = true;
                }
                catch (System.Data.SQLite.SQLiteException E)
                {
                    tx.Rollback();
                    isSuccess = false;
                    throw new Exception(E.Message);
                }
            }
            return isSuccess;
        }

        /// <summary>
        /// 执行带一个存储过程参数的的SQL语句。
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string SQLString, string content)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                SQLiteCommand cmd = new SQLiteCommand(SQLString, connection);
                SQLiteParameter myParameter = new SQLiteParameter("@content", DbType.String);
                myParameter.Value = content;
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (System.Data.SQLite.SQLiteException E)
                {
                    throw new Exception(E.Message);
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }

        /// <summary>
        /// 执行带一个存储过程参数的的SQL语句。
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
        /// <returns>影响的记录数</returns>
        public static object ExecuteSqlGet(string SQLString, string content)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                SQLiteCommand cmd = new SQLiteCommand(SQLString, connection);
                SQLiteParameter myParameter = new SQLiteParameter("@content", DbType.String);
                myParameter.Value = content;
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    object obj = cmd.ExecuteScalar();
                    if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                    {
                        return null;
                    }
                    else
                    {
                        return obj;
                    }
                }
                catch (System.Data.SQLite.SQLiteException E)
                {
                    throw new Exception(E.Message);
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }

        /// <summary>
        /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
        /// </summary>
        /// <param name="strSQL">SQL语句</param>
        /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSqlInsertImg(string strSQL, byte[] fs)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                SQLiteCommand cmd = new SQLiteCommand(strSQL, connection);
                SQLiteParameter myParameter = new SQLiteParameter("@fs", DbType.Binary);
                myParameter.Value = fs;
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (System.Data.SQLite.SQLiteException E)
                {
                    throw new Exception(E.Message);
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }

        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="SQLString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public static object GetSingle(string SQLString)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                using (SQLiteCommand cmd = new SQLiteCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        object obj = cmd.ExecuteScalar();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (System.Data.SQLite.SQLiteException e)
                    {
                        connection.Close();
                        throw new Exception(e.Message);
                    }
                }
            }
        }

        /// <summary>
        /// 执行查询语句，返回SQLiteDataReader(使用该方法切记要手工关闭SQLiteDataReader和连接)
        /// </summary>
        /// <param name="strSQL">查询语句</param>
        /// <returns>SQLiteDataReader</returns>
        public static SQLiteDataReader ExecuteReader(string strSQL)
        {
            SQLiteConnection connection = new SQLiteConnection(connectionString);
            SQLiteCommand cmd = new SQLiteCommand(strSQL, connection);
            try
            {
                connection.Open();
                SQLiteDataReader myReader = cmd.ExecuteReader();
                return myReader;
            }
            catch (System.Data.SQLite.SQLiteException e)
            {
                throw new Exception(e.Message);
            }
            //finally //不能在此关闭，否则，返回的对象将无法使用
            //{
            // cmd.Dispose();
            // connection.Close();
            //} 
        }

        /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="SQLString">查询语句</param>
        /// <returns>DataSet</returns>
        public static DataSet Query(string SQLString)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                DataSet ds = new DataSet();
                try
                {
                    connection.Open();
                    SQLiteDataAdapter command = new SQLiteDataAdapter(SQLString, connection);
                    command.Fill(ds, "ds");
                }
                catch (System.Data.SQLite.SQLiteException ex)
                {
                    throw new Exception(ex.Message);
                }
                return ds;
            }
        }

        public static DataSet Query(string SQLString, string TableName)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                DataSet ds = new DataSet();
                try
                {
                    connection.Open();
                    SQLiteDataAdapter command = new SQLiteDataAdapter(SQLString, connection);
                    command.Fill(ds, TableName);
                }
                catch (System.Data.SQLite.SQLiteException ex)
                {
                    throw new Exception(ex.Message);
                }
                return ds;
            }
        }

        /// <summary>
        /// 执行查询语句，返回DataSet,设置命令的执行等待时间
        /// </summary>
        /// <param name="SQLString"></param>
        /// <param name="Times"></param>
        /// <returns></returns>
        public static DataSet Query(string SQLString, int Times)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                DataSet ds = new DataSet();
                try
                {
                    connection.Open();
                    SQLiteDataAdapter command = new SQLiteDataAdapter(SQLString, connection);
                    command.SelectCommand.CommandTimeout = Times;
                    command.Fill(ds, "ds");
                }
                catch (System.Data.SQLite.SQLiteException ex)
                {
                    throw new Exception(ex.Message);
                }
                return ds;
            }
        }

        #endregion

        #region 执行带参数的SQL语句

        /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string SQLString, params SQLiteParameter[] cmdParms)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                using (SQLiteCommand cmd = new SQLiteCommand())
                {
                    try
                    {
                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                        int rows = cmd.ExecuteNonQuery();
                        cmd.Parameters.Clear();
                        return rows;
                    }
                    catch (System.Data.SQLite.SQLiteException E)
                    {
                        throw new Exception(E.Message);
                    }
                }
            }
        }

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SQLiteParameter[]）</param>
        public static void ExecuteSqlTran(Hashtable SQLStringList)
        {
            using (SQLiteConnection conn = new SQLiteConnection(connectionString))
            {
                conn.Open();
                using (SQLiteTransaction trans = conn.BeginTransaction())
                {
                    SQLiteCommand cmd = new SQLiteCommand();
                    try
                    {
                        //循环
                        foreach (DictionaryEntry myDE in SQLStringList)
                        {
                            string cmdText = myDE.Key.ToString();
                            SQLiteParameter[] cmdParms = (SQLiteParameter[])myDE.Value;
                            PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
                            int val = cmd.ExecuteNonQuery();
                            cmd.Parameters.Clear();
                        }
                        trans.Commit();
                    }
                    catch (System.Data.SQLite.SQLiteException e)
                    {
                        trans.Rollback();
                        throw new Exception(e.Message);
                    }
                }
            }
        }

        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="SQLString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public static object GetSingle(string SQLString, params SQLiteParameter[] cmdParms)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                using (SQLiteCommand cmd = new SQLiteCommand())
                {
                    try
                    {
                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                        object obj = cmd.ExecuteScalar();
                        cmd.Parameters.Clear();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (System.Data.SQLite.SQLiteException e)
                    {
                        throw new Exception(e.Message);
                    }
                }
            }
        }

        /// <summary>
        /// 执行查询语句，返回SQLiteDataReader (使用该方法切记要手工关闭SQLiteDataReader和连接)
        /// </summary>
        /// <param name="strSQL">查询语句</param>
        /// <returns>SQLiteDataReader</returns>
        public static SQLiteDataReader ExecuteReader(string SQLString, params SQLiteParameter[] cmdParms)
        {
            SQLiteConnection connection = new SQLiteConnection(connectionString);
            SQLiteCommand cmd = new SQLiteCommand();
            try
            {
                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                SQLiteDataReader myReader = cmd.ExecuteReader();
                cmd.Parameters.Clear();
                return myReader;
            }
            catch (System.Data.SQLite.SQLiteException e)
            {
                throw new Exception(e.Message);
            }
            //finally //不能在此关闭，否则，返回的对象将无法使用
            //{
            // cmd.Dispose();
            // connection.Close();
            //} 

        }

        /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="SQLString">查询语句</param>
        /// <returns>DataSet</returns>
        public static DataSet Query(string SQLString, params SQLiteParameter[] cmdParms)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                SQLiteCommand cmd = new SQLiteCommand();
                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                using (SQLiteDataAdapter da = new SQLiteDataAdapter(cmd))
                {
                    DataSet ds = new DataSet();
                    try
                    {
                        da.Fill(ds, "ds");
                        cmd.Parameters.Clear();
                    }
                    catch (System.Data.SQLite.SQLiteException ex)
                    {
                        throw new Exception(ex.Message);
                    }
                    return ds;
                }
            }
        }

        public static void PrepareCommand(SQLiteCommand cmd, SQLiteConnection conn,
        SQLiteTransaction trans, string cmdText, SQLiteParameter[] cmdParms)
        {
            if (conn.State != ConnectionState.Open)
                conn.Open();
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            if (trans != null)
                cmd.Transaction = trans;
            cmd.CommandType = CommandType.Text;//cmdType;
            if (cmdParms != null)
            {
                foreach (SQLiteParameter parameter in cmdParms)
                {
                    if ((parameter.Direction == ParameterDirection.InputOutput
                    || parameter.Direction == ParameterDirection.Input) &&
                    (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                    cmd.Parameters.Add(parameter);
                }
            }
        }

        #endregion

        #region 参数转换
        /// <summary>
        /// 放回一个SQLiteParameter
        /// </summary>
        /// <param name="name">参数名字</param>
        /// <param name="type">参数类型</param>
        /// <param name="size">参数大小</param>
        /// <param name="value">参数值</param>
        /// <returns>SQLiteParameter的值</returns>
        public static SQLiteParameter MakeSQLiteParameter(string name,
        DbType type, int size, object value)
        {
            SQLiteParameter parm = new SQLiteParameter(name, type, size);
            parm.Value = value;
            return parm;
        }

        public static SQLiteParameter MakeSQLiteParameter(string name, DbType type, object value)
        {
            SQLiteParameter parm = new SQLiteParameter(name, type);
            parm.Value = value;
            return parm;
        }

        #endregion
    }
}

 src/Bro.M071.Process.Model/BaseModel.cs

@@ -1,201 +1,179 @@
//using System;
//using System.Collections.Generic;
//using System.ComponentModel;
//using System.ComponentModel.DataAnnotations;
//using System.Linq;
//using System.Reflection;
//using System.Text;
//using System.Threading.Tasks;
using Bro.Common.Helper;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

//namespace Bro.M071.Model
//{
//    public class BaseModel
//    {
//        /// <summary>
//        /// 编号，唯一值,使用GUID
//        /// </summary>
//        [Key]
//        [Required(ErrorMessage = "编号不可为空！")]
//        [StringLength(50)]
//        public string ID { get; set; } = Guid.NewGuid().ToString().ToUpper();
namespace Bro.M071.Model
{
    public class BaseModel
    {
        /// <summary>
        /// 编号，唯一值,使用GUID
        /// </summary>
        [Key]
        [Required(ErrorMessage = "编号不可为空！")]
        [StringLength(64)]
        public string ID { get; set; } = Guid.NewGuid().ToString().ToUpper();

//        /// <summary>
//        /// 禁用状态 0 未禁用 1 已禁用
//        /// </summary>
//        [Required]
//        public int IS_DISABLED { get; set; } = 0;
        /// <summary>
        /// 禁用状态 0 未禁用 1 已禁用
        /// </summary>
        [Required]
        public int IS_DISABLED { get; set; } = 0;

//        /// <summary>
//        /// 删除状态 0 未删除 1 已删除
//        /// </summary>
//        [Required]
//        public int IS_DELETED { get; set; } = 0;
        /// <summary>
        /// 删除状态 0 未删除 1 已删除
        /// </summary>
        [Required]
        public int IS_DELETED { get; set; } = 0;

//        /// <summary>
//        /// 创建人信息
//        /// </summary>
//        //[Required]
//        [StringLength(50)]
//        public string CREATE_USER { get; set; }
        /// <summary>
        /// 创建人信息
        /// </summary>
        //[Required]
        [StringLength(64)]
        public string CREATE_USER { get; set; }

//        /// <summary>
//        /// 创建时间
//        /// </summary>
//        //[Required]
//        public DateTime? CREATE_TIME { get; set; } = DateTime.Now;
        /// <summary>
        /// 创建时间
        /// </summary>
        public DateTime CREATE_TIME { get; set; } = DateTime.Now;

//        /// <summary>
//        /// 更新人信息
//        /// </summary>
//        [StringLength(50)]
//        public string UPDATE_USER { get; set; }
        /// <summary>
        /// 更新人信息
        /// </summary>
        [StringLength(64)]
        public string UPDATE_USER { get; set; }

//        /// <summary>
//        /// 更新时间
//        /// </summary>
//        public DateTime? UPDATE_TIME { get; set; }
//    }
        /// <summary>
        /// 更新时间
        /// </summary>
        public DateTime? UPDATE_TIME { get; set; }
    }

//    public static class BaseModelHelper
//    {
//        public static void SetNew<T>(this T t, string userId) where T : BaseModel
//        {
//            //t.ID = Guid.NewGuid().ToString().ToUpper();
//            t.CREATE_USER = userId;
//            t.CREATE_TIME = DateTime.Now;
//        }
    public static class BaseModelHelper
    {
        public static void Create<T>(this T t, string userId) where T : BaseModel
        {
            t.CREATE_USER = userId;
            t.CREATE_TIME = DateTime.Now;
        }

//        public static void SetUpdate<T>(this T t, string userId) where T : BaseModel
//        {
//            t.UPDATE_USER = userId;
//            t.UPDATE_TIME = DateTime.Now;
//        }
        public static void Update<T>(this T t, string userId) where T : BaseModel
        {
            t.UPDATE_USER = userId;
            t.UPDATE_TIME = DateTime.Now;
        }

//        static List<string> NoTransferProps = new List<string>() { "ID", "CREATE_USER", "CREATE_TIME", "UPDATE_USER", "UPDATE_TIME", "IS_DELETED" };
//        public static void DataTransfer<T>(this T destT, T sourceT) where T : BaseModel
//        {
//            destT.DataFrom(sourceT, NoTransferProps);
//        }
        static List<string> NoTransferProps = new List<string>() { "ID", "CREATE_USER", "CREATE_TIME", "UPDATE_USER", "UPDATE_TIME", "IS_DELETED" };
        public static void DataTransfer<T>(this T destT, T sourceT) where T : BaseModel
        {
            destT.DataFrom(sourceT, NoTransferProps);
        }

//        public static void DataFrom<T1, T2>(this T1 destT, T2 sourceT, List<string> exceptionProps = null) where T1 : class where T2 : class
//        {
//            PropertyInfo[] propDest = destT.GetType().GetProperties().Where(p => !(p.GetMethod.IsVirtual && !p.GetMethod.IsFinal)).ToArray();
//            PropertyInfo[] propSource = sourceT.GetType().GetProperties();
        public static List<T> ToPagedList<T>(this IQueryable<T> orderQuery, BaseRequest request) where T : class
        {
            return orderQuery.Skip((request.PageNum - 1) * request.PageSize).Take(request.PageSize).ToList();
        }
    }

//            Array.ForEach(propDest, prop =>
//            {
//                if (exceptionProps == null || !exceptionProps.Contains(prop.Name))
//                {
//                    if (prop.CanWrite)
//                    {
//                        PropertyInfo propS = propSource.FirstOrDefault(p => p.Name == prop.Name);
//                        if (propS != null && propS.CanRead)
//                        {
//                            prop.SetValue(destT, propS.GetValue(sourceT));
//                        }
//                    }
//                }
//            });
//        }
    public class BaseRequest : INotifyPropertyChanged
    {

//        public static List<T> ToPagedList<T>(this IQueryable<T> orderQuery, BaseRequest request) where T : class
//        {
//            return orderQuery.Skip((request.PageNum - 1) * request.PageSize).Take(request.PageSize).ToList();
//        }
//    }
        private int pageNum = 1;
        /// <summary>
        /// 查询结果页数
        /// </summary>
        public int PageNum
        {
            get => pageNum;
            set
            {
                if (pageNum != value)
                {
                    pageNum = value;
                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("PageNum"), null, null);
                }
            }
        }

//    public class BaseRequest : INotifyPropertyChanged
//    {
        private int pageSize = 100;
        /// <summary>
        /// 每页的查询结果条数
        /// </summary>
        public int PageSize
        {
            get => pageSize;
            set
            {
                if (pageSize != value)
                {
                    pageSize = value;
                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("PageSize"), null, null);
                }
            }
        }

//        private int pageNum = 1;
//        /// <summary>
//        /// 查询结果页数
//        /// </summary>
//        public int PageNum
//        {
//            get => pageNum;
//            set
//            {
//                if (pageNum != value)
//                {
//                    pageNum = value;
//                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("PageNum"), null, null);
//                }
//            }
//        }
        /// <summary>
        /// 查询起始时间
        /// </summary>
        public DateTime? StartTime { get; set; }

//        private int pageSize = 100;
//        /// <summary>
//        /// 每页的查询结果条数
//        /// </summary>
//        public int PageSize
//        {
//            get => pageSize;
//            set
//            {
//                if (pageSize != value)
//                {
//                    pageSize = value;
//                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("PageSize"), null, null);
//                }
//            }
//        }
        /// <summary>
        /// 查询结束时间
        /// </summary>
        public DateTime? EndTime { get; set; }

//        /// <summary>
//        /// 查询起始时间
//        /// </summary>
//        public DateTime? StartTime { get; set; }
        /// <summary>
        /// 启用状态过滤器 1：仅未启用 0：仅启用 -1：全部
        /// </summary>
        public int DisableFilter { get; set; } = 0;

//        /// <summary>
//        /// 查询结束时间
//        /// </summary>
//        public DateTime? EndTime { get; set; }
        /// <summary>
        /// 查询字符串
        /// </summary>
        public string SearchTxt { get; set; }

//        /// <summary>
//        /// 启用状态过滤器 1：仅未启用 0：仅启用 -1：全部
//        /// </summary>
//        public int DisableFilter { get; set; } = 0;
        private int totalNum = 0;
        /// <summary>
        /// 数据总数
        /// </summary>
        public int TotalNum
        {
            get => totalNum;
            set
            {
                if (totalNum != value)
                {
                    totalNum = value;
                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("TotalNum"), null, null);
                }
                TotalPage = (int)Math.Ceiling((double)TotalNum / PageSize);
            }
        }

//        /// <summary>
//        /// 查询字符串
//        /// </summary>
//        public string SearchTxt { get; set; }
        private int totalPage = 0;
        /// <summary>
        /// 总页数
        /// </summary>
        public int TotalPage
        {
            get => totalPage;
            set
            {
                if (totalPage != value)
                {
                    totalPage = value;
                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("TotalPage"), null, null);
                }
            }
        }

//        private int totalNum = 0;
//        /// <summary>
//        /// 数据总数
//        /// </summary>
//        public int TotalNum
//        {
//            get => totalNum;
//            set
//            {
//                if (totalNum != value)
//                {
//                    totalNum = value;
//                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("TotalNum"), null, null);
//                }
//                TotalPage = (int)Math.Ceiling((double)TotalNum / PageSize);
//            }
//        }

//        private int totalPage = 0;
//        /// <summary>
//        /// 总页数
//        /// </summary>
//        public int TotalPage
//        {
//            get => totalPage;
//            set
//            {
//                if (totalPage != value)
//                {
//                    totalPage = value;
//                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("TotalPage"), null, null);
//                }
//            }
//        }

//        public event PropertyChangedEventHandler PropertyChanged;
//    }
//}
        public event PropertyChangedEventHandler PropertyChanged;
    }
}

 src/Bro.M071.Process.Model/Bro.M071.Model.csproj

@@ -109,9 +109,10 @@
    <Compile Include="BaseModel.cs" />
    <Compile Include="DBModel.cs" />
    <Compile Include="Migrations\Configuration.cs" />
    <Compile Include="Model\ManualDetectionRecords.cs" />
    <Compile Include="Model\EventTimeRecords.cs" />
    <Compile Include="Model\OperationRecords.cs" />
    <Compile Include="Model\KeyUnitData.cs" />
    <Compile Include="Model\MeasurementUnitResult.cs" />
    <Compile Include="Model\ProductionMeasurementRecords.cs" />
    <Compile Include="Model\MeasurementAndKeyDataRelation.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
  </ItemGroup>
  <ItemGroup>
@@ -121,7 +122,12 @@
    </None>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup />
  <ItemGroup>
    <ProjectReference Include="..\Bro.Common.Model\Bro.Common.Model.csproj">
      <Project>{1A3CBFE7-3F78-42C3-95C5-10360450DBEA}</Project>
      <Name>Bro.Common.Model</Name>
    </ProjectReference>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>

 src/Bro.M071.Process.Model/DBModel.cs

@@ -1,67 +1,53 @@
//using Bro.Process.Model.Migrations;
//using Bro.Process.Model.Model;
//using System;
//using System.Data.Entity;
//using System.Data.Entity.ModelConfiguration.Conventions;
//using System.Linq;
using Bro.M071.Model.Migrations;
using Bro.M071.Model.Model;
using System.Data.Entity;
using System.Data.Entity.ModelConfiguration.Conventions;

//namespace Bro.M071.Model
//{
//    public class DBModel : DbContext
//    {
//        //您的上下文已配置为从您的应用程序的配置文件(App.config 或 Web.config)
//        //使用“DBModel”连接字符串。默认情况下，此连接字符串针对您的 LocalDb 实例上的
//        //“Bro.Process.Model.DBModel”数据库。
//        // 
//        //如果您想要针对其他数据库和/或数据库提供程序，请在应用程序配置文件中修改“DBModel”
//        //连接字符串。
//        public DBModel()
//            : base("name=DataBase")
//        {
//            ////数据库迁移检查暂时放在构造函数中，回头会放到程序初始化中
//            //Database.SetInitializer(new MigrateDatabaseToLatestVersion<DBModel, Configuration>());
//        }
namespace Bro.M071.Model
{
    public class DBModel : DbContext
    {
        //您的上下文已配置为从您的应用程序的配置文件(App.config 或 Web.config)
        //使用“DBModel”连接字符串。默认情况下，此连接字符串针对您的 LocalDb 实例上的
        //“Bro.Process.Model.DBModel”数据库。
        // 
        //如果您想要针对其他数据库和/或数据库提供程序，请在应用程序配置文件中修改“DBModel”
        //连接字符串。
        public DBModel()
            : base("name=DataBase")
        {
            ////数据库迁移检查暂时放在构造函数中，回头会放到程序初始化中
            //Database.SetInitializer(new MigrateDatabaseToLatestVersion<DBModel, Configuration>());
        }

//        //为您要在模型中包含的每种实体类型都添加 DbSet。有关配置和使用 Code First  模型
//        //的详细信息，请参阅 http://go.microsoft.com/fwlink/?LinkId=390109。

//        // public virtual DbSet<MyEntity> MyEntities { get; set; }
//        //public virtual DbSet<PRODUCTION_SECRETKEY> PRODUCTION_SECRETKEY { get; set; }
//        //public virtual DbSet<PRODUCTION_CONFIG> PRODUCTION_CONFIG { get; set; }
        //为您要在模型中包含的每种实体类型都添加 DbSet。有关配置和使用 Code First  模型
        //的详细信息，请参阅 http://go.microsoft.com/fwlink/?LinkId=390109。


//        public virtual DbSet<ProductionDetectionRecords> ProductionDetectionRecords { get; set; }
//        public virtual DbSet<ProductionDetectionRecordsDetail> ProductionDetectionRecordsDetail { get; set; }
//        public virtual DbSet<OperationRecords> OperationRecords { get; set; }
//        public virtual DbSet<ProductionDetectionImageRecords> ProductionDetectionImageRecords { get; set; }
//        public virtual DbSet<ManualDetectionRecords> ManualDetectionRecords { get; set; }
//        public virtual DbSet<EventTimeRecords> EventTimeRecords { get; set; }
        public virtual DbSet<KeyUnitData> KeyUnitData { get; set; }
        public virtual DbSet<MeasurementAndKeyDataRelation> MeasurementAndKeyDataRelation { get; set; }
        public virtual DbSet<MeasurementUnitResult> MeasurementUnitResult { get; set; }
        public virtual DbSet<ProductionMeasurementRecords> ProductionMeasurementRecords { get; set; }

//        protected override void OnModelCreating(DbModelBuilder modelBuilder)
//        {
//            //base.OnModelCreating(modelBuilder);
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            //base.OnModelCreating(modelBuilder);
            #region for sqlite db
            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
            modelBuilder.Configurations.AddFromAssembly(typeof(DBModel).Assembly);
            #endregion
        }
    }

//            #region for sqlite db
//            modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
//            modelBuilder.Configurations.AddFromAssembly(typeof(DBModel).Assembly);
//            #endregion
//        }
//    }

//    public static class DatabaseInitialize
//    {
//        public static void Initialize()
//        {
//            Database.SetInitializer(new MigrateDatabaseToLatestVersion<DBModel, Configuration>());
//            using (DbContext dbContext = new DBModel())
//            {
//                dbContext.Database.Initialize(true);
//            }
//        }
//    }
//    //public class MyEntity
//    //{
//    //    public int Id { get; set; }
//    //    public string Name { get; set; }
//    //}
//}
    public static class DatabaseInitialize
    {
        public static void Initialize()
        {
            Database.SetInitializer(new MigrateDatabaseToLatestVersion<DBModel, Configuration>());
            using (DbContext dbContext = new DBModel())
            {
                dbContext.Database.Initialize(true);
            }
        }
    }
}

 src/Bro.M071.Process.Model/Migrations/Configuration.cs

@@ -1,37 +1,36 @@
//namespace Bro.M071.Model.Migrations
//{
//    using System;
//    using System.Data.Entity;
//    using System.Data.Entity.Migrations;
//    using System.Data.SQLite.EF6.Migrations;
//    using System.Linq;

//    public sealed class Configuration : DbMigrationsConfiguration<Bro.Process.Model.DBModel>
//    {
//        public Configuration()
//        {
//            AutomaticMigrationsEnabled = true;
//            AutomaticMigrationDataLossAllowed = true;
using System.Data.Entity.Migrations;
using System.Data.SQLite.EF6.Migrations;

//            #region for sqlite db
//            SetSqlGenerator("System.Data.SQLite", new SQLiteMigrationSqlGenerator());
//            #endregion
//        }
namespace Bro.M071.Model.Migrations
{

//        protected override void Seed(Bro.Process.Model.DBModel context)
//        {
//            //  This method will be called after migrating to the latest version.
    public sealed class Configuration : DbMigrationsConfiguration<DBModel>
    {
        public Configuration()
        {
            AutomaticMigrationsEnabled = true;
            AutomaticMigrationDataLossAllowed = true;

//            //  You can use the DbSet<T>.AddOrUpdate() helper extension method 
//            //  to avoid creating duplicate seed data. E.g.
//            //
//            //    context.People.AddOrUpdate(
//            //      p => p.FullName,
//            //      new Person { FullName = "Andrew Peters" },
//            //      new Person { FullName = "Brice Lambson" },
//            //      new Person { FullName = "Rowan Miller" }
//            //    );
//            //
//        }
//    }
//}
            #region for sqlite db
            SetSqlGenerator("System.Data.SQLite", new SQLiteMigrationSqlGenerator());
            #endregion
        }

        protected override void Seed(DBModel context)
        {
            //  This method will be called after migrating to the latest version.

            //  You can use the DbSet<T>.AddOrUpdate() helper extension method 
            //  to avoid creating duplicate seed data. E.g.
            //
            //    context.People.AddOrUpdate(
            //      p => p.FullName,
            //      new Person { FullName = "Andrew Peters" },
            //      new Person { FullName = "Brice Lambson" },
            //      new Person { FullName = "Rowan Miller" }
            //    );
            //
        }
    }
}

 src/Bro.M071.Process.Model/Model/EventTimeRecords.cs

File was deleted

 src/Bro.M071.Process.Model/Model/KeyUnitData.cs

New file
@@ -0,0 +1,41 @@

using System;
using System.ComponentModel.DataAnnotations;

namespace Bro.M071.Model.Model
{
    /// <summary>
    /// 键单元 的检测结果
    /// </summary>
    public class KeyUnitData : BaseModel
    {
        /// <summary>
        /// 产品测量记录Id
        /// </summary>
        [StringLength(64)]
        public string ProductionMeasurementRecordsId { get; set; }

        /// <summary>
        /// 键单元
        /// </summary>
        [StringLength(64)]
        public string Key { get; set; }

        /// <summary>
        /// 检测项
        /// </summary>
        [StringLength(64)]
        public string MeasurementItem { get; set; }

        /// <summary>
        /// 该键 检测项 的值
        /// </summary>
        [StringLength(64)]
        public string ItemValue { get; set; }
    }

    public class KeyUnitDataRequest : BaseRequest
    {
    }

}

 src/Bro.M071.Process.Model/Model/ManualDetectionRecords.cs

File was deleted

 src/Bro.M071.Process.Model/Model/MeasurementAndKeyDataRelation.cs

New file
@@ -0,0 +1,22 @@

using System;
using System.ComponentModel.DataAnnotations;

namespace Bro.M071.Model.Model
{
    public class MeasurementAndKeyDataRelation : BaseModel
    {
        /// <summary>
        /// 键单元 的检测结果 id
        /// </summary>
        [StringLength(64)]
        public string KeyUnitDataId { get; set; }

        /// <summary>
        ///  检测结果 id
        /// </summary>
        [StringLength(64)]
        public string MeasurementUnitResultId { get; set; }
    }

}

 src/Bro.M071.Process.Model/Model/MeasurementUnitResult.cs

New file
@@ -0,0 +1,56 @@

using System;
using System.ComponentModel.DataAnnotations;

namespace Bro.M071.Model.Model
{
    /// <summary>
    /// 检测结果
    /// </summary>
    public class MeasurementUnitResult : BaseModel
    {
        /// <summary>
        /// 产品测量记录Id
        /// </summary>
        [StringLength(64)]
        public string ProductionMeasurementRecordsId { get; set; }

        /// <summary>
        /// 检测名称
        /// </summary>
        [StringLength(64)]
        public string MeasurementName { get; set; }

        /// <summary>
        ///  检测结果类型 (Slant Alignment... )
        /// </summary>
        [StringLength(64)] 
        public string MeasurementType { get; set; }

        /// <summary>
        ///  检测结果值
        /// </summary>
        [StringLength(64)]
        public string MeasurementValue { get; set; }

        /// <summary>
        ///  检测结果 ok ng
        /// </summary>
        [StringLength(64)]
        public string MeasurementResult { get; set; }
    }

    public class MeasurementUnitResultRequest : BaseRequest
    {
        /// <summary>
        /// 检测名称
        /// </summary>
        public string MeasurementName { get; set; }

        /// <summary>
        ///  检测和标准类型
        /// </summary>
        public string MeasureType { get; set; }
    }

}

 src/Bro.M071.Process.Model/Model/OperationRecords.cs

File was deleted

 src/Bro.M071.Process.Model/Model/ProductionMeasurementRecords.cs

New file
@@ -0,0 +1,61 @@

using System;
using System.ComponentModel.DataAnnotations;
using static Bro.Common.Helper.EnumHelper;

namespace Bro.M071.Model.Model
{
    /// <summary>
    /// 产品测量记录
    /// </summary>
    public class ProductionMeasurementRecords : BaseModel
    {
        /// <summary>
        /// 产品编码
        /// </summary>
        [StringLength(64)]
        public string ProductionCode { get; set; }

        /// <summary>
        /// 产品条码
        /// </summary>
        [StringLength(64)]
        public string ProductionBarcode { get; set; }

        /// <summary>
        ///  产品结果 ok  ng
        /// </summary>
        [StringLength(64)]
        public string ProductionResult { get; set; }

        /// <summary>
        /// 操作开始时间
        /// </summary>
        public DateTime OperationStartTime { get; set; }

        /// <summary>
        /// 操作结束时间
        /// </summary>
        public DateTime OperationEndTime { get; set; }

    }

    public class ProductionMeasurementRecordsRequest : BaseRequest
    {
        /// <summary>
        /// 产品编码
        /// </summary>
        public string ProductionCode { get; set; }

        /// <summary>
        /// 产品条码
        /// </summary>
        public string ProductionBarcode { get; set; }

        /// <summary>
        ///  产品结果
        /// </summary>
        public OutputResult ProductionResult { get; set; }
    }

}

 src/Bro.M071.Process/App.config

New file
@@ -0,0 +1,43 @@
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <configSections>
    <!-- For more information on Entity Framework configuration, visit http://go.microsoft.com/fwlink/?LinkID=237468 -->
    <section name="entityFramework" type="System.Data.Entity.Internal.ConfigFile.EntityFrameworkSection, EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />
  </configSections>
  <entityFramework>
    <defaultConnectionFactory type="System.Data.Entity.Infrastructure.SqlConnectionFactory, EntityFramework" />
    <providers>
      <provider invariantName="System.Data.SQLite" type="System.Data.SQLite.EF6.SQLiteProviderServices, System.Data.SQLite.EF6" />
      <provider invariantName="System.Data.SQLite.EF6" type="System.Data.SQLite.EF6.SQLiteProviderServices, System.Data.SQLite.EF6" />
      <!--<provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" />-->
    </providers>
  </entityFramework>
  <connectionStrings>
    <!--<add name="DBSet" connectionString="data source=(LocalDb)\MSSQLLocalDB;initial catalog=Bro.Process.Model.Model;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework" providerName="System.Data.SqlClient" />-->
    <!--<add name="DataBase" connectionString="data source=(LocalDb)\MSSQLLocalDB;initial catalog=Bro.Process.Model.DBModel;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework" providerName="System.Data.SqlClient" />-->
    <add name="DataBase" connectionString="data source=D:\PROJECTS\M071\DataBase\M071.db;BinaryGUID=False" providerName="System.Data.SQLite" />
  </connectionStrings>
  <system.data>
    <DbProviderFactories>
      <remove invariant="System.Data.SQLite.EF6" />
      <add name="SQLite Data Provider (Entity Framework 6)" invariant="System.Data.SQLite.EF6" description=".NET Framework Data Provider for SQLite (Entity Framework 6)" type="System.Data.SQLite.EF6.SQLiteProviderFactory, System.Data.SQLite.EF6" />
      <remove invariant="System.Data.SQLite" />
      <add name="SQLite Data Provider" invariant="System.Data.SQLite" description=".NET Framework Data Provider for SQLite" type="System.Data.SQLite.SQLiteFactory, System.Data.SQLite" />
    </DbProviderFactories>
  </system.data>
  <runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
      <dependentAssembly>
        <assemblyIdentity name="System.Data.SQLite" publicKeyToken="db937bc2d44ff139" culture="neutral" />
        <bindingRedirect oldVersion="0.0.0.0-1.0.112.0" newVersion="1.0.112.0" />
      </dependentAssembly>
      <dependentAssembly>
        <assemblyIdentity name="System.Data.SQLite.EF6" publicKeyToken="db937bc2d44ff139" culture="neutral" />
        <bindingRedirect oldVersion="0.0.0.0-1.0.112.0" newVersion="1.0.112.0" />
      </dependentAssembly>
    </assemblyBinding>
  </runtime>
  <startup>
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1" />
  </startup>
</configuration>

 src/Bro.M071.Process/Bro.M071.Process.csproj

@@ -138,6 +138,10 @@
    <EmbeddedResource Include="UI\M071_MainForm.resx">
      <DependentUpon>M071_MainForm.cs</DependentUpon>
    </EmbeddedResource>
    <None Include="App.config">
      <SubType>Designer</SubType>
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </None>
    <None Include="packages.config" />
    <None Include="Properties\Settings.settings">
      <Generator>SettingsSingleFileGenerator</Generator>
@@ -158,6 +162,10 @@
      <Project>{1A3CBFE7-3F78-42C3-95C5-10360450DBEA}</Project>
      <Name>Bro.Common.Model</Name>
    </ProjectReference>
    <ProjectReference Include="..\Bro.M071.Process.Model\Bro.M071.Model.csproj">
      <Project>{AD645C48-5811-4B1E-B81F-D35D5E6B577F}</Project>
      <Name>Bro.M071.Model</Name>
    </ProjectReference>
    <ProjectReference Include="..\Bro.Process\Bro.Process.csproj">
      <Project>{197C5AA8-9609-4D1C-B1E3-5879006EAAF4}</Project>
      <Name>Bro.Process</Name>

 src/Bro.M071.Process/M071Config.cs

@@ -64,8 +64,8 @@
        [Category("检测设置")]
        [Description("检测配置集合")]
        [TypeConverter(typeof(CollectionCountConvert))]
        [Editor(typeof(ComplexCollectionEditor<MeasurementUint>), typeof(UITypeEditor))]
        public List<MeasurementUint> MeasurementUnitCollection { get; set; } = new List<MeasurementUint>();
        [Editor(typeof(ComplexCollectionEditor<MeasurementUnit>), typeof(UITypeEditor))]
        public List<MeasurementUnit> MeasurementUnitCollection { get; set; } = new List<MeasurementUnit>();

        [Category("图片保存配置")]
        [Description("单键图片保存配置")]

 src/Bro.M071.Process/M071Models.cs

@@ -205,7 +205,7 @@
    {
        public string Barcode;

        public List<MeasurementUint> Measurements = new List<MeasurementUint>();
        public List<MeasurementUnit> Measurements = new List<MeasurementUnit>();

        public List<IShapeElement> ElementList = new List<IShapeElement>();

@@ -235,7 +235,7 @@
        }
    }

    public class MeasurementUint : IComplexDisplay, INotifyPropertyChanged, IDisposable
    public class MeasurementUnit : IComplexDisplay, INotifyPropertyChanged, IDisposable
    {
        public string Id = Guid.NewGuid().ToString();


 src/Bro.M071.Process/M071Process.cs

@@ -2,6 +2,7 @@
using Bro.Common.Helper;
using Bro.Common.Interface;
using Bro.Common.Model;
using Bro.M071.Model;
using Bro.Process;
using HalconDotNet;
using System;
@@ -56,6 +57,9 @@

        private void InitialSetting()
        {
            //数据库迁移检查
            DatabaseInitialize.Initialize();

            Config.SnapshotPointCollection.ForEach(u =>
            {
                u.GetHalconToolPathList().ForEach(path =>
@@ -335,7 +339,7 @@
            }
        }

        private void SaveKeyImages(string barCode, MeasurementUint measureUnit)
        private void SaveKeyImages(string barCode, MeasurementUnit measureUnit)
        {
            string measureName = measureUnit.GetDisplayText();
            if (Config.ImageSaveOption.IsSaveOriginImage)
@@ -366,7 +370,7 @@
            }
        }

        private async void SaveKeyImages(MeasurementUint measureUnit, string measureName, string dir)
        private async void SaveKeyImages(MeasurementUnit measureUnit, string measureName, string dir)
        {
            await Task.Run(() =>
            {
@@ -386,7 +390,7 @@
        }
        #endregion

        private async void RunImageHandle(CameraBase camera, IOperationConfig opConfig, HImage hImage, string snapshotId, string snapshotName, List<MeasurementUint> measureList)
        private async void RunImageHandle(CameraBase camera, IOperationConfig opConfig, HImage hImage, string snapshotId, string snapshotName, List<MeasurementUnit> measureList)
        {
            await Task.Run(() =>
             {

 src/Bro.Process.DBManager/BaseModel.cs

@@ -1,200 +1,200 @@
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
//using System;
//using System.Collections.Generic;
//using System.ComponentModel;
//using System.ComponentModel.DataAnnotations;
//using System.Linq;
//using System.Reflection;
//using System.Text;
//using System.Threading.Tasks;

namespace Bro.Process.DataBase
{
    public class BaseModel
    {
        /// <summary>
        /// 编号，唯一值,使用GUID
        /// </summary>
        [Key]
        [Required(ErrorMessage = "编号不可为空！")]
        [StringLength(64)]
        public string ID { get; set; } = Guid.NewGuid().ToString().ToUpper();
//namespace Bro.Process.DataBase
//{
//    public class BaseModel
//    {
//        /// <summary>
//        /// 编号，唯一值,使用GUID
//        /// </summary>
//        [Key]
//        [Required(ErrorMessage = "编号不可为空！")]
//        [StringLength(64)]
//        public string ID { get; set; } = Guid.NewGuid().ToString().ToUpper();

        /// <summary>
        /// 禁用状态 0 未禁用 1 已禁用
        /// </summary>
        [Required]
        public int IS_DISABLED { get; set; } = 0;
//        /// <summary>
//        /// 禁用状态 0 未禁用 1 已禁用
//        /// </summary>
//        [Required]
//        public int IS_DISABLED { get; set; } = 0;

        /// <summary>
        /// 删除状态 0 未删除 1 已删除
        /// </summary>
        [Required]
        public int IS_DELETED { get; set; } = 0;
//        /// <summary>
//        /// 删除状态 0 未删除 1 已删除
//        /// </summary>
//        [Required]
//        public int IS_DELETED { get; set; } = 0;

        /// <summary>
        /// 创建人信息
        /// </summary>
        //[Required]
        [StringLength(64)]
        public string CREATE_USER { get; set; }
//        /// <summary>
//        /// 创建人信息
//        /// </summary>
//        //[Required]
//        [StringLength(64)]
//        public string CREATE_USER { get; set; }

        /// <summary>
        /// 创建时间
        /// </summary>
        //[Required]
        public DateTime? CREATE_TIME { get; set; } = DateTime.Now;
//        /// <summary>
//        /// 创建时间
//        /// </summary>
//        //[Required]
//        public DateTime? CREATE_TIME { get; set; } = DateTime.Now;

        /// <summary>
        /// 更新人信息
        /// </summary>
        [StringLength(64)]
        public string UPDATE_USER { get; set; }
//        /// <summary>
//        /// 更新人信息
//        /// </summary>
//        [StringLength(64)]
//        public string UPDATE_USER { get; set; }

        /// <summary>
        /// 更新时间
        /// </summary>
        public DateTime? UPDATE_TIME { get; set; }
    }
//        /// <summary>
//        /// 更新时间
//        /// </summary>
//        public DateTime? UPDATE_TIME { get; set; }
//    }

    public static class BaseModelHelper
    {
        public static void SetNew<T>(this T t, string userId) where T : BaseModel
        {
            t.CREATE_USER = userId;
            t.CREATE_TIME = DateTime.Now;
        }
//    public static class BaseModelHelper
//    {
//        public static void SetNew<T>(this T t, string userId) where T : BaseModel
//        {
//            t.CREATE_USER = userId;
//            t.CREATE_TIME = DateTime.Now;
//        }

        public static void SetUpdate<T>(this T t, string userId) where T : BaseModel
        {
            t.UPDATE_USER = userId;
            t.UPDATE_TIME = DateTime.Now;
        }
//        public static void SetUpdate<T>(this T t, string userId) where T : BaseModel
//        {
//            t.UPDATE_USER = userId;
//            t.UPDATE_TIME = DateTime.Now;
//        }

        static List<string> NoTransferProps = new List<string>() { "ID", "CREATE_USER", "CREATE_TIME", "UPDATE_USER", "UPDATE_TIME", "IS_DELETED" };
        public static void DataTransfer<T>(this T destT, T sourceT) where T : BaseModel
        {
            destT.DataFrom(sourceT, NoTransferProps);
        }
//        static List<string> NoTransferProps = new List<string>() { "ID", "CREATE_USER", "CREATE_TIME", "UPDATE_USER", "UPDATE_TIME", "IS_DELETED" };
//        public static void DataTransfer<T>(this T destT, T sourceT) where T : BaseModel
//        {
//            destT.DataFrom(sourceT, NoTransferProps);
//        }

        public static void DataFrom<T1, T2>(this T1 destT, T2 sourceT, List<string> exceptionProps = null) where T1 : class where T2 : class
        {
            PropertyInfo[] propDest = destT.GetType().GetProperties().Where(p => !(p.GetMethod.IsVirtual && !p.GetMethod.IsFinal)).ToArray();
            PropertyInfo[] propSource = sourceT.GetType().GetProperties();
//        public static void DataFrom<T1, T2>(this T1 destT, T2 sourceT, List<string> exceptionProps = null) where T1 : class where T2 : class
//        {
//            PropertyInfo[] propDest = destT.GetType().GetProperties().Where(p => !(p.GetMethod.IsVirtual && !p.GetMethod.IsFinal)).ToArray();
//            PropertyInfo[] propSource = sourceT.GetType().GetProperties();

            Array.ForEach(propDest, prop =>
            {
                if (exceptionProps == null || !exceptionProps.Contains(prop.Name))
                {
                    if (prop.CanWrite)
                    {
                        PropertyInfo propS = propSource.FirstOrDefault(p => p.Name == prop.Name);
                        if (propS != null && propS.CanRead)
                        {
                            prop.SetValue(destT, propS.GetValue(sourceT));
                        }
                    }
                }
            });
        }
//            Array.ForEach(propDest, prop =>
//            {
//                if (exceptionProps == null || !exceptionProps.Contains(prop.Name))
//                {
//                    if (prop.CanWrite)
//                    {
//                        PropertyInfo propS = propSource.FirstOrDefault(p => p.Name == prop.Name);
//                        if (propS != null && propS.CanRead)
//                        {
//                            prop.SetValue(destT, propS.GetValue(sourceT));
//                        }
//                    }
//                }
//            });
//        }

        public static List<T> ToPagedList<T>(this IQueryable<T> orderQuery, BaseRequest request) where T : class
        {
            return orderQuery.Skip((request.PageNum - 1) * request.PageSize).Take(request.PageSize).ToList();
        }
    }
//        public static List<T> ToPagedList<T>(this IQueryable<T> orderQuery, BaseRequest request) where T : class
//        {
//            return orderQuery.Skip((request.PageNum - 1) * request.PageSize).Take(request.PageSize).ToList();
//        }
//    }

    public class BaseRequest : INotifyPropertyChanged
    {
//    public class BaseRequest : INotifyPropertyChanged
//    {

        private int pageNum = 1;
        /// <summary>
        /// 查询结果页数
        /// </summary>
        public int PageNum
        {
            get => pageNum;
            set
            {
                if (pageNum != value)
                {
                    pageNum = value;
                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("PageNum"), null, null);
                }
            }
        }
//        private int pageNum = 1;
//        /// <summary>
//        /// 查询结果页数
//        /// </summary>
//        public int PageNum
//        {
//            get => pageNum;
//            set
//            {
//                if (pageNum != value)
//                {
//                    pageNum = value;
//                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("PageNum"), null, null);
//                }
//            }
//        }

        private int pageSize = 100;
        /// <summary>
        /// 每页的查询结果条数
        /// </summary>
        public int PageSize
        {
            get => pageSize;
            set
            {
                if (pageSize != value)
                {
                    pageSize = value;
                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("PageSize"), null, null);
                }
            }
        }
//        private int pageSize = 100;
//        /// <summary>
//        /// 每页的查询结果条数
//        /// </summary>
//        public int PageSize
//        {
//            get => pageSize;
//            set
//            {
//                if (pageSize != value)
//                {
//                    pageSize = value;
//                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("PageSize"), null, null);
//                }
//            }
//        }

        /// <summary>
        /// 查询起始时间
        /// </summary>
        public DateTime? StartTime { get; set; }
//        /// <summary>
//        /// 查询起始时间
//        /// </summary>
//        public DateTime? StartTime { get; set; }

        /// <summary>
        /// 查询结束时间
        /// </summary>
        public DateTime? EndTime { get; set; }
//        /// <summary>
//        /// 查询结束时间
//        /// </summary>
//        public DateTime? EndTime { get; set; }

        /// <summary>
        /// 启用状态过滤器 1：仅未启用 0：仅启用 -1：全部
        /// </summary>
        public int DisableFilter { get; set; } = 0;
//        /// <summary>
//        /// 启用状态过滤器 1：仅未启用 0：仅启用 -1：全部
//        /// </summary>
//        public int DisableFilter { get; set; } = 0;

        /// <summary>
        /// 查询字符串
        /// </summary>
        public string SearchTxt { get; set; }
//        /// <summary>
//        /// 查询字符串
//        /// </summary>
//        public string SearchTxt { get; set; }

        private int totalNum = 0;
        /// <summary>
        /// 数据总数
        /// </summary>
        public int TotalNum
        {
            get => totalNum;
            set
            {
                if (totalNum != value)
                {
                    totalNum = value;
                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("TotalNum"), null, null);
                }
                TotalPage = (int)Math.Ceiling((double)TotalNum / PageSize);
            }
        }
//        private int totalNum = 0;
//        /// <summary>
//        /// 数据总数
//        /// </summary>
//        public int TotalNum
//        {
//            get => totalNum;
//            set
//            {
//                if (totalNum != value)
//                {
//                    totalNum = value;
//                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("TotalNum"), null, null);
//                }
//                TotalPage = (int)Math.Ceiling((double)TotalNum / PageSize);
//            }
//        }

        private int totalPage = 0;
        /// <summary>
        /// 总页数
        /// </summary>
        public int TotalPage
        {
            get => totalPage;
            set
            {
                if (totalPage != value)
                {
                    totalPage = value;
                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("TotalPage"), null, null);
                }
            }
        }
//        private int totalPage = 0;
//        /// <summary>
//        /// 总页数
//        /// </summary>
//        public int TotalPage
//        {
//            get => totalPage;
//            set
//            {
//                if (totalPage != value)
//                {
//                    totalPage = value;
//                    PropertyChanged?.BeginInvoke(this, new PropertyChangedEventArgs("TotalPage"), null, null);
//                }
//            }
//        }

        public event PropertyChangedEventHandler PropertyChanged;
    }
}
//        public event PropertyChangedEventHandler PropertyChanged;
//    }
//}

 src/Bro.Process.DBManager/SQLiteHelper.cs

@@ -1,614 +1,614 @@


using System;
using System.Collections;
using System.Collections.Specialized;
using System.Data;
using System.Data.SQLite;
using System.Configuration;
//using System;
//using System.Collections;
//using System.Collections.Specialized;
//using System.Data;
//using System.Data.SQLite;
//using System.Configuration;

namespace Bro.Process.DataBase
{
    public class SQLiteHelper
    {
        //数据库连接字符串 
        public static string connectionString = ConfigurationManager.ConnectionStrings["DataBase"].ConnectionString;
//namespace Bro.Process.DataBase
//{
//    public class SQLiteHelper
//    {
//        //数据库连接字符串 
//        public static string connectionString = ConfigurationManager.ConnectionStrings["DataBase"].ConnectionString;

        public SQLiteHelper() { }
//        public SQLiteHelper() { }

        #region 公用方法
//        #region 公用方法

        public static int GetMaxID(string FieldName, string TableName)
        {
            string strsql = "select max(" + FieldName + ")+1 from " + TableName;
            object obj = GetSingle(strsql);
            if (obj == null)
            {
                return 1;
            }
            else
            {
                return int.Parse(obj.ToString());
            }
        }
//        public static int GetMaxID(string FieldName, string TableName)
//        {
//            string strsql = "select max(" + FieldName + ")+1 from " + TableName;
//            object obj = GetSingle(strsql);
//            if (obj == null)
//            {
//                return 1;
//            }
//            else
//            {
//                return int.Parse(obj.ToString());
//            }
//        }

        public static bool Exists(string strSql)
        {
            object obj = GetSingle(strSql);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
//        public static bool Exists(string strSql)
//        {
//            object obj = GetSingle(strSql);
//            int cmdresult;
//            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
//            {
//                cmdresult = 0;
//            }
//            else
//            {
//                cmdresult = int.Parse(obj.ToString());
//            }
//            if (cmdresult == 0)
//            {
//                return false;
//            }
//            else
//            {
//                return true;
//            }
//        }

        public static bool Exists(string strSql, params SQLiteParameter[] cmdParms)
        {
            object obj = GetSingle(strSql, cmdParms);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
//        public static bool Exists(string strSql, params SQLiteParameter[] cmdParms)
//        {
//            object obj = GetSingle(strSql, cmdParms);
//            int cmdresult;
//            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
//            {
//                cmdresult = 0;
//            }
//            else
//            {
//                cmdresult = int.Parse(obj.ToString());
//            }
//            if (cmdresult == 0)
//            {
//                return false;
//            }
//            else
//            {
//                return true;
//            }
//        }

        #endregion
//        #endregion

        #region 执行简单SQL语句
//        #region 执行简单SQL语句

        /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string SQLString)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                using (SQLiteCommand cmd = new SQLiteCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        int rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (System.Data.SQLite.SQLiteException E)
                    {
                        connection.Close();
                        throw new Exception(E.Message);
                    }
                }
            }
        }
//        /// <summary>
//        /// 执行SQL语句，返回影响的记录数
//        /// </summary>
//        /// <param name="SQLString">SQL语句</param>
//        /// <returns>影响的记录数</returns>
//        public static int ExecuteSql(string SQLString)
//        {
//            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
//            {
//                using (SQLiteCommand cmd = new SQLiteCommand(SQLString, connection))
//                {
//                    try
//                    {
//                        connection.Open();
//                        int rows = cmd.ExecuteNonQuery();
//                        return rows;
//                    }
//                    catch (System.Data.SQLite.SQLiteException E)
//                    {
//                        connection.Close();
//                        throw new Exception(E.Message);
//                    }
//                }
//            }
//        }

        /// <summary>
        /// 执行SQL语句，设置命令的执行等待时间
        /// </summary>
        /// <param name="SQLString"></param>
        /// <param name="Times"></param>
        /// <returns></returns>
        public static int ExecuteSqlByTime(string SQLString, int Times)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                using (SQLiteCommand cmd = new SQLiteCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        cmd.CommandTimeout = Times;
                        int rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (System.Data.SQLite.SQLiteException E)
                    {
                        connection.Close();
                        throw new Exception(E.Message);
                    }
                }
            }
        }
//        /// <summary>
//        /// 执行SQL语句，设置命令的执行等待时间
//        /// </summary>
//        /// <param name="SQLString"></param>
//        /// <param name="Times"></param>
//        /// <returns></returns>
//        public static int ExecuteSqlByTime(string SQLString, int Times)
//        {
//            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
//            {
//                using (SQLiteCommand cmd = new SQLiteCommand(SQLString, connection))
//                {
//                    try
//                    {
//                        connection.Open();
//                        cmd.CommandTimeout = Times;
//                        int rows = cmd.ExecuteNonQuery();
//                        return rows;
//                    }
//                    catch (System.Data.SQLite.SQLiteException E)
//                    {
//                        connection.Close();
//                        throw new Exception(E.Message);
//                    }
//                }
//            }
//        }

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">多条SQL语句</param> 
        public static bool ExecuteSqlTran(ArrayList SQLStringList)
        {
            bool isSuccess = false;
            using (SQLiteConnection conn = new SQLiteConnection(connectionString))
            {
                conn.Open();
                SQLiteCommand cmd = new SQLiteCommand();
                cmd.Connection = conn;
                cmd.CommandText = "PRAGMA synchronous = OFF;";
                cmd.ExecuteNonQuery();
                SQLiteTransaction tx = conn.BeginTransaction();
                cmd.Transaction = tx;
                try
                {
                    for (int n = 0; n < SQLStringList.Count; n++)
                    {
                        string strsql = SQLStringList[n].ToString();
                        if (strsql.Trim().Length > 1)
                        {
                            cmd.CommandText = strsql;
                            cmd.ExecuteNonQuery();
                        }
                    }
                    tx.Commit();
                    isSuccess = true;
                }
                catch (System.Data.SQLite.SQLiteException E)
                {
                    tx.Rollback();
                    isSuccess = false;
                    throw new Exception(E.Message);
                }
            }
            return isSuccess;
        }
//        /// <summary>
//        /// 执行多条SQL语句，实现数据库事务。
//        /// </summary>
//        /// <param name="SQLStringList">多条SQL语句</param> 
//        public static bool ExecuteSqlTran(ArrayList SQLStringList)
//        {
//            bool isSuccess = false;
//            using (SQLiteConnection conn = new SQLiteConnection(connectionString))
//            {
//                conn.Open();
//                SQLiteCommand cmd = new SQLiteCommand();
//                cmd.Connection = conn;
//                cmd.CommandText = "PRAGMA synchronous = OFF;";
//                cmd.ExecuteNonQuery();
//                SQLiteTransaction tx = conn.BeginTransaction();
//                cmd.Transaction = tx;
//                try
//                {
//                    for (int n = 0; n < SQLStringList.Count; n++)
//                    {
//                        string strsql = SQLStringList[n].ToString();
//                        if (strsql.Trim().Length > 1)
//                        {
//                            cmd.CommandText = strsql;
//                            cmd.ExecuteNonQuery();
//                        }
//                    }
//                    tx.Commit();
//                    isSuccess = true;
//                }
//                catch (System.Data.SQLite.SQLiteException E)
//                {
//                    tx.Rollback();
//                    isSuccess = false;
//                    throw new Exception(E.Message);
//                }
//            }
//            return isSuccess;
//        }

        /// <summary>
        /// 执行带一个存储过程参数的的SQL语句。
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string SQLString, string content)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                SQLiteCommand cmd = new SQLiteCommand(SQLString, connection);
                SQLiteParameter myParameter = new SQLiteParameter("@content", DbType.String);
                myParameter.Value = content;
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (System.Data.SQLite.SQLiteException E)
                {
                    throw new Exception(E.Message);
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }
//        /// <summary>
//        /// 执行带一个存储过程参数的的SQL语句。
//        /// </summary>
//        /// <param name="SQLString">SQL语句</param>
//        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
//        /// <returns>影响的记录数</returns>
//        public static int ExecuteSql(string SQLString, string content)
//        {
//            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
//            {
//                SQLiteCommand cmd = new SQLiteCommand(SQLString, connection);
//                SQLiteParameter myParameter = new SQLiteParameter("@content", DbType.String);
//                myParameter.Value = content;
//                cmd.Parameters.Add(myParameter);
//                try
//                {
//                    connection.Open();
//                    int rows = cmd.ExecuteNonQuery();
//                    return rows;
//                }
//                catch (System.Data.SQLite.SQLiteException E)
//                {
//                    throw new Exception(E.Message);
//                }
//                finally
//                {
//                    cmd.Dispose();
//                    connection.Close();
//                }
//            }
//        }

        /// <summary>
        /// 执行带一个存储过程参数的的SQL语句。
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
        /// <returns>影响的记录数</returns>
        public static object ExecuteSqlGet(string SQLString, string content)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                SQLiteCommand cmd = new SQLiteCommand(SQLString, connection);
                SQLiteParameter myParameter = new SQLiteParameter("@content", DbType.String);
                myParameter.Value = content;
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    object obj = cmd.ExecuteScalar();
                    if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                    {
                        return null;
                    }
                    else
                    {
                        return obj;
                    }
                }
                catch (System.Data.SQLite.SQLiteException E)
                {
                    throw new Exception(E.Message);
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }
//        /// <summary>
//        /// 执行带一个存储过程参数的的SQL语句。
//        /// </summary>
//        /// <param name="SQLString">SQL语句</param>
//        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
//        /// <returns>影响的记录数</returns>
//        public static object ExecuteSqlGet(string SQLString, string content)
//        {
//            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
//            {
//                SQLiteCommand cmd = new SQLiteCommand(SQLString, connection);
//                SQLiteParameter myParameter = new SQLiteParameter("@content", DbType.String);
//                myParameter.Value = content;
//                cmd.Parameters.Add(myParameter);
//                try
//                {
//                    connection.Open();
//                    object obj = cmd.ExecuteScalar();
//                    if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
//                    {
//                        return null;
//                    }
//                    else
//                    {
//                        return obj;
//                    }
//                }
//                catch (System.Data.SQLite.SQLiteException E)
//                {
//                    throw new Exception(E.Message);
//                }
//                finally
//                {
//                    cmd.Dispose();
//                    connection.Close();
//                }
//            }
//        }

        /// <summary>
        /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
        /// </summary>
        /// <param name="strSQL">SQL语句</param>
        /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSqlInsertImg(string strSQL, byte[] fs)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                SQLiteCommand cmd = new SQLiteCommand(strSQL, connection);
                SQLiteParameter myParameter = new SQLiteParameter("@fs", DbType.Binary);
                myParameter.Value = fs;
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (System.Data.SQLite.SQLiteException E)
                {
                    throw new Exception(E.Message);
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }
//        /// <summary>
//        /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
//        /// </summary>
//        /// <param name="strSQL">SQL语句</param>
//        /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
//        /// <returns>影响的记录数</returns>
//        public static int ExecuteSqlInsertImg(string strSQL, byte[] fs)
//        {
//            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
//            {
//                SQLiteCommand cmd = new SQLiteCommand(strSQL, connection);
//                SQLiteParameter myParameter = new SQLiteParameter("@fs", DbType.Binary);
//                myParameter.Value = fs;
//                cmd.Parameters.Add(myParameter);
//                try
//                {
//                    connection.Open();
//                    int rows = cmd.ExecuteNonQuery();
//                    return rows;
//                }
//                catch (System.Data.SQLite.SQLiteException E)
//                {
//                    throw new Exception(E.Message);
//                }
//                finally
//                {
//                    cmd.Dispose();
//                    connection.Close();
//                }
//            }
//        }

        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="SQLString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public static object GetSingle(string SQLString)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                using (SQLiteCommand cmd = new SQLiteCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        object obj = cmd.ExecuteScalar();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (System.Data.SQLite.SQLiteException e)
                    {
                        connection.Close();
                        throw new Exception(e.Message);
                    }
                }
            }
        }
//        /// <summary>
//        /// 执行一条计算查询结果语句，返回查询结果（object）。
//        /// </summary>
//        /// <param name="SQLString">计算查询结果语句</param>
//        /// <returns>查询结果（object）</returns>
//        public static object GetSingle(string SQLString)
//        {
//            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
//            {
//                using (SQLiteCommand cmd = new SQLiteCommand(SQLString, connection))
//                {
//                    try
//                    {
//                        connection.Open();
//                        object obj = cmd.ExecuteScalar();
//                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
//                        {
//                            return null;
//                        }
//                        else
//                        {
//                            return obj;
//                        }
//                    }
//                    catch (System.Data.SQLite.SQLiteException e)
//                    {
//                        connection.Close();
//                        throw new Exception(e.Message);
//                    }
//                }
//            }
//        }

        /// <summary>
        /// 执行查询语句，返回SQLiteDataReader(使用该方法切记要手工关闭SQLiteDataReader和连接)
        /// </summary>
        /// <param name="strSQL">查询语句</param>
        /// <returns>SQLiteDataReader</returns>
        public static SQLiteDataReader ExecuteReader(string strSQL)
        {
            SQLiteConnection connection = new SQLiteConnection(connectionString);
            SQLiteCommand cmd = new SQLiteCommand(strSQL, connection);
            try
            {
                connection.Open();
                SQLiteDataReader myReader = cmd.ExecuteReader();
                return myReader;
            }
            catch (System.Data.SQLite.SQLiteException e)
            {
                throw new Exception(e.Message);
            }
            //finally //不能在此关闭，否则，返回的对象将无法使用
            //{
            // cmd.Dispose();
            // connection.Close();
            //} 
        }
//        /// <summary>
//        /// 执行查询语句，返回SQLiteDataReader(使用该方法切记要手工关闭SQLiteDataReader和连接)
//        /// </summary>
//        /// <param name="strSQL">查询语句</param>
//        /// <returns>SQLiteDataReader</returns>
//        public static SQLiteDataReader ExecuteReader(string strSQL)
//        {
//            SQLiteConnection connection = new SQLiteConnection(connectionString);
//            SQLiteCommand cmd = new SQLiteCommand(strSQL, connection);
//            try
//            {
//                connection.Open();
//                SQLiteDataReader myReader = cmd.ExecuteReader();
//                return myReader;
//            }
//            catch (System.Data.SQLite.SQLiteException e)
//            {
//                throw new Exception(e.Message);
//            }
//            //finally //不能在此关闭，否则，返回的对象将无法使用
//            //{
//            // cmd.Dispose();
//            // connection.Close();
//            //} 
//        }

        /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="SQLString">查询语句</param>
        /// <returns>DataSet</returns>
        public static DataSet Query(string SQLString)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                DataSet ds = new DataSet();
                try
                {
                    connection.Open();
                    SQLiteDataAdapter command = new SQLiteDataAdapter(SQLString, connection);
                    command.Fill(ds, "ds");
                }
                catch (System.Data.SQLite.SQLiteException ex)
                {
                    throw new Exception(ex.Message);
                }
                return ds;
            }
        }
//        /// <summary>
//        /// 执行查询语句，返回DataSet
//        /// </summary>
//        /// <param name="SQLString">查询语句</param>
//        /// <returns>DataSet</returns>
//        public static DataSet Query(string SQLString)
//        {
//            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
//            {
//                DataSet ds = new DataSet();
//                try
//                {
//                    connection.Open();
//                    SQLiteDataAdapter command = new SQLiteDataAdapter(SQLString, connection);
//                    command.Fill(ds, "ds");
//                }
//                catch (System.Data.SQLite.SQLiteException ex)
//                {
//                    throw new Exception(ex.Message);
//                }
//                return ds;
//            }
//        }

        public static DataSet Query(string SQLString, string TableName)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                DataSet ds = new DataSet();
                try
                {
                    connection.Open();
                    SQLiteDataAdapter command = new SQLiteDataAdapter(SQLString, connection);
                    command.Fill(ds, TableName);
                }
                catch (System.Data.SQLite.SQLiteException ex)
                {
                    throw new Exception(ex.Message);
                }
                return ds;
            }
        }
//        public static DataSet Query(string SQLString, string TableName)
//        {
//            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
//            {
//                DataSet ds = new DataSet();
//                try
//                {
//                    connection.Open();
//                    SQLiteDataAdapter command = new SQLiteDataAdapter(SQLString, connection);
//                    command.Fill(ds, TableName);
//                }
//                catch (System.Data.SQLite.SQLiteException ex)
//                {
//                    throw new Exception(ex.Message);
//                }
//                return ds;
//            }
//        }

        /// <summary>
        /// 执行查询语句，返回DataSet,设置命令的执行等待时间
        /// </summary>
        /// <param name="SQLString"></param>
        /// <param name="Times"></param>
        /// <returns></returns>
        public static DataSet Query(string SQLString, int Times)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                DataSet ds = new DataSet();
                try
                {
                    connection.Open();
                    SQLiteDataAdapter command = new SQLiteDataAdapter(SQLString, connection);
                    command.SelectCommand.CommandTimeout = Times;
                    command.Fill(ds, "ds");
                }
                catch (System.Data.SQLite.SQLiteException ex)
                {
                    throw new Exception(ex.Message);
                }
                return ds;
            }
        }
//        /// <summary>
//        /// 执行查询语句，返回DataSet,设置命令的执行等待时间
//        /// </summary>
//        /// <param name="SQLString"></param>
//        /// <param name="Times"></param>
//        /// <returns></returns>
//        public static DataSet Query(string SQLString, int Times)
//        {
//            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
//            {
//                DataSet ds = new DataSet();
//                try
//                {
//                    connection.Open();
//                    SQLiteDataAdapter command = new SQLiteDataAdapter(SQLString, connection);
//                    command.SelectCommand.CommandTimeout = Times;
//                    command.Fill(ds, "ds");
//                }
//                catch (System.Data.SQLite.SQLiteException ex)
//                {
//                    throw new Exception(ex.Message);
//                }
//                return ds;
//            }
//        }

        #endregion
//        #endregion

        #region 执行带参数的SQL语句
//        #region 执行带参数的SQL语句

        /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string SQLString, params SQLiteParameter[] cmdParms)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                using (SQLiteCommand cmd = new SQLiteCommand())
                {
                    try
                    {
                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                        int rows = cmd.ExecuteNonQuery();
                        cmd.Parameters.Clear();
                        return rows;
                    }
                    catch (System.Data.SQLite.SQLiteException E)
                    {
                        throw new Exception(E.Message);
                    }
                }
            }
        }
//        /// <summary>
//        /// 执行SQL语句，返回影响的记录数
//        /// </summary>
//        /// <param name="SQLString">SQL语句</param>
//        /// <returns>影响的记录数</returns>
//        public static int ExecuteSql(string SQLString, params SQLiteParameter[] cmdParms)
//        {
//            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
//            {
//                using (SQLiteCommand cmd = new SQLiteCommand())
//                {
//                    try
//                    {
//                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
//                        int rows = cmd.ExecuteNonQuery();
//                        cmd.Parameters.Clear();
//                        return rows;
//                    }
//                    catch (System.Data.SQLite.SQLiteException E)
//                    {
//                        throw new Exception(E.Message);
//                    }
//                }
//            }
//        }

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SQLiteParameter[]）</param>
        public static void ExecuteSqlTran(Hashtable SQLStringList)
        {
            using (SQLiteConnection conn = new SQLiteConnection(connectionString))
            {
                conn.Open();
                using (SQLiteTransaction trans = conn.BeginTransaction())
                {
                    SQLiteCommand cmd = new SQLiteCommand();
                    try
                    {
                        //循环
                        foreach (DictionaryEntry myDE in SQLStringList)
                        {
                            string cmdText = myDE.Key.ToString();
                            SQLiteParameter[] cmdParms = (SQLiteParameter[])myDE.Value;
                            PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
                            int val = cmd.ExecuteNonQuery();
                            cmd.Parameters.Clear();
                        }
                        trans.Commit();
                    }
                    catch (System.Data.SQLite.SQLiteException e)
                    {
                        trans.Rollback();
                        throw new Exception(e.Message);
                    }
                }
            }
        }
//        /// <summary>
//        /// 执行多条SQL语句，实现数据库事务。
//        /// </summary>
//        /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SQLiteParameter[]）</param>
//        public static void ExecuteSqlTran(Hashtable SQLStringList)
//        {
//            using (SQLiteConnection conn = new SQLiteConnection(connectionString))
//            {
//                conn.Open();
//                using (SQLiteTransaction trans = conn.BeginTransaction())
//                {
//                    SQLiteCommand cmd = new SQLiteCommand();
//                    try
//                    {
//                        //循环
//                        foreach (DictionaryEntry myDE in SQLStringList)
//                        {
//                            string cmdText = myDE.Key.ToString();
//                            SQLiteParameter[] cmdParms = (SQLiteParameter[])myDE.Value;
//                            PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
//                            int val = cmd.ExecuteNonQuery();
//                            cmd.Parameters.Clear();
//                        }
//                        trans.Commit();
//                    }
//                    catch (System.Data.SQLite.SQLiteException e)
//                    {
//                        trans.Rollback();
//                        throw new Exception(e.Message);
//                    }
//                }
//            }
//        }

        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="SQLString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public static object GetSingle(string SQLString, params SQLiteParameter[] cmdParms)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                using (SQLiteCommand cmd = new SQLiteCommand())
                {
                    try
                    {
                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                        object obj = cmd.ExecuteScalar();
                        cmd.Parameters.Clear();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (System.Data.SQLite.SQLiteException e)
                    {
                        throw new Exception(e.Message);
                    }
                }
            }
        }
//        /// <summary>
//        /// 执行一条计算查询结果语句，返回查询结果（object）。
//        /// </summary>
//        /// <param name="SQLString">计算查询结果语句</param>
//        /// <returns>查询结果（object）</returns>
//        public static object GetSingle(string SQLString, params SQLiteParameter[] cmdParms)
//        {
//            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
//            {
//                using (SQLiteCommand cmd = new SQLiteCommand())
//                {
//                    try
//                    {
//                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
//                        object obj = cmd.ExecuteScalar();
//                        cmd.Parameters.Clear();
//                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
//                        {
//                            return null;
//                        }
//                        else
//                        {
//                            return obj;
//                        }
//                    }
//                    catch (System.Data.SQLite.SQLiteException e)
//                    {
//                        throw new Exception(e.Message);
//                    }
//                }
//            }
//        }

        /// <summary>
        /// 执行查询语句，返回SQLiteDataReader (使用该方法切记要手工关闭SQLiteDataReader和连接)
        /// </summary>
        /// <param name="strSQL">查询语句</param>
        /// <returns>SQLiteDataReader</returns>
        public static SQLiteDataReader ExecuteReader(string SQLString, params SQLiteParameter[] cmdParms)
        {
            SQLiteConnection connection = new SQLiteConnection(connectionString);
            SQLiteCommand cmd = new SQLiteCommand();
            try
            {
                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                SQLiteDataReader myReader = cmd.ExecuteReader();
                cmd.Parameters.Clear();
                return myReader;
            }
            catch (System.Data.SQLite.SQLiteException e)
            {
                throw new Exception(e.Message);
            }
            //finally //不能在此关闭，否则，返回的对象将无法使用
            //{
            // cmd.Dispose();
            // connection.Close();
            //} 
//        /// <summary>
//        /// 执行查询语句，返回SQLiteDataReader (使用该方法切记要手工关闭SQLiteDataReader和连接)
//        /// </summary>
//        /// <param name="strSQL">查询语句</param>
//        /// <returns>SQLiteDataReader</returns>
//        public static SQLiteDataReader ExecuteReader(string SQLString, params SQLiteParameter[] cmdParms)
//        {
//            SQLiteConnection connection = new SQLiteConnection(connectionString);
//            SQLiteCommand cmd = new SQLiteCommand();
//            try
//            {
//                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
//                SQLiteDataReader myReader = cmd.ExecuteReader();
//                cmd.Parameters.Clear();
//                return myReader;
//            }
//            catch (System.Data.SQLite.SQLiteException e)
//            {
//                throw new Exception(e.Message);
//            }
//            //finally //不能在此关闭，否则，返回的对象将无法使用
//            //{
//            // cmd.Dispose();
//            // connection.Close();
//            //} 

        }
//        }

        /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="SQLString">查询语句</param>
        /// <returns>DataSet</returns>
        public static DataSet Query(string SQLString, params SQLiteParameter[] cmdParms)
        {
            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
            {
                SQLiteCommand cmd = new SQLiteCommand();
                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                using (SQLiteDataAdapter da = new SQLiteDataAdapter(cmd))
                {
                    DataSet ds = new DataSet();
                    try
                    {
                        da.Fill(ds, "ds");
                        cmd.Parameters.Clear();
                    }
                    catch (System.Data.SQLite.SQLiteException ex)
                    {
                        throw new Exception(ex.Message);
                    }
                    return ds;
                }
            }
        }
//        /// <summary>
//        /// 执行查询语句，返回DataSet
//        /// </summary>
//        /// <param name="SQLString">查询语句</param>
//        /// <returns>DataSet</returns>
//        public static DataSet Query(string SQLString, params SQLiteParameter[] cmdParms)
//        {
//            using (SQLiteConnection connection = new SQLiteConnection(connectionString))
//            {
//                SQLiteCommand cmd = new SQLiteCommand();
//                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
//                using (SQLiteDataAdapter da = new SQLiteDataAdapter(cmd))
//                {
//                    DataSet ds = new DataSet();
//                    try
//                    {
//                        da.Fill(ds, "ds");
//                        cmd.Parameters.Clear();
//                    }
//                    catch (System.Data.SQLite.SQLiteException ex)
//                    {
//                        throw new Exception(ex.Message);
//                    }
//                    return ds;
//                }
//            }
//        }

        public static void PrepareCommand(SQLiteCommand cmd, SQLiteConnection conn,
        SQLiteTransaction trans, string cmdText, SQLiteParameter[] cmdParms)
        {
            if (conn.State != ConnectionState.Open)
                conn.Open();
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            if (trans != null)
                cmd.Transaction = trans;
            cmd.CommandType = CommandType.Text;//cmdType;
            if (cmdParms != null)
            {
                foreach (SQLiteParameter parameter in cmdParms)
                {
                    if ((parameter.Direction == ParameterDirection.InputOutput
                    || parameter.Direction == ParameterDirection.Input) &&
                    (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                    cmd.Parameters.Add(parameter);
                }
            }
        }
//        public static void PrepareCommand(SQLiteCommand cmd, SQLiteConnection conn,
//        SQLiteTransaction trans, string cmdText, SQLiteParameter[] cmdParms)
//        {
//            if (conn.State != ConnectionState.Open)
//                conn.Open();
//            cmd.Connection = conn;
//            cmd.CommandText = cmdText;
//            if (trans != null)
//                cmd.Transaction = trans;
//            cmd.CommandType = CommandType.Text;//cmdType;
//            if (cmdParms != null)
//            {
//                foreach (SQLiteParameter parameter in cmdParms)
//                {
//                    if ((parameter.Direction == ParameterDirection.InputOutput
//                    || parameter.Direction == ParameterDirection.Input) &&
//                    (parameter.Value == null))
//                    {
//                        parameter.Value = DBNull.Value;
//                    }
//                    cmd.Parameters.Add(parameter);
//                }
//            }
//        }

        #endregion
//        #endregion

        #region 参数转换
        /// <summary>
        /// 放回一个SQLiteParameter
        /// </summary>
        /// <param name="name">参数名字</param>
        /// <param name="type">参数类型</param>
        /// <param name="size">参数大小</param>
        /// <param name="value">参数值</param>
        /// <returns>SQLiteParameter的值</returns>
        public static SQLiteParameter MakeSQLiteParameter(string name,
        DbType type, int size, object value)
        {
            SQLiteParameter parm = new SQLiteParameter(name, type, size);
            parm.Value = value;
            return parm;
        }
//        #region 参数转换
//        /// <summary>
//        /// 放回一个SQLiteParameter
//        /// </summary>
//        /// <param name="name">参数名字</param>
//        /// <param name="type">参数类型</param>
//        /// <param name="size">参数大小</param>
//        /// <param name="value">参数值</param>
//        /// <returns>SQLiteParameter的值</returns>
//        public static SQLiteParameter MakeSQLiteParameter(string name,
//        DbType type, int size, object value)
//        {
//            SQLiteParameter parm = new SQLiteParameter(name, type, size);
//            parm.Value = value;
//            return parm;
//        }

        public static SQLiteParameter MakeSQLiteParameter(string name, DbType type, object value)
        {
            SQLiteParameter parm = new SQLiteParameter(name, type);
            parm.Value = value;
            return parm;
        }
//        public static SQLiteParameter MakeSQLiteParameter(string name, DbType type, object value)
//        {
//            SQLiteParameter parm = new SQLiteParameter(name, type);
//            parm.Value = value;
//            return parm;
//        }

        #endregion
    }
}
//        #endregion
//    }
//}

 src/Bro.UI.Config/MenuForms/FrmOperation.resx

@@ -125,7 +125,7 @@
        AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w
        LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0
        ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAADm
        CgAAAk1TRnQBSQFMAgEBAgEAAeABAAHgAQABGAEAARgBAAT/AQkBAAj/AUIBTQE2AQQGAAE2AQQCAAEo
        CgAAAk1TRnQBSQFMAgEBAgEAAegBAAHoAQABGAEAARgBAAT/AQkBAAj/AUIBTQE2AQQGAAE2AQQCAAEo
        AwABYAMAARgDAAEBAQABCAYAAQkYAAGAAgABgAMAAoABAAGAAwABgAEAAYABAAKAAgADwAEAAcAB3AHA
        AQAB8AHKAaYBAAEzBQABMwEAATMBAAEzAQACMwIAAxYBAAMcAQADIgEAAykBAANVAQADTQEAA0IBAAM5
        AQABgAF8Af8BAAJQAf8BAAGTAQAB1gEAAf8B7AHMAQABxgHWAe8BAAHWAucBAAGQAakBrQIAAf8BMwMA
@@ -182,7 +182,7 @@
        AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj00LjAuMC4w
        LCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0
        ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAAD4
        CAAAAk1TRnQBSQFMAwEBAAHgAQAB4AEAARgBAAEYAQAE/wEJAQAI/wFCAU0BNgEEBgABNgEEAgABKAMA
        CAAAAk1TRnQBSQFMAwEBAAHoAQAB6AEAARgBAAEYAQAE/wEJAQAI/wFCAU0BNgEEBgABNgEEAgABKAMA
        AWADAAEYAwABAQEAAQgGAAEJGAABgAIAAYADAAKAAQABgAMAAYABAAGAAQACgAIAA8ABAAHAAdwBwAEA
        AfABygGmAQABMwUAATMBAAEzAQABMwEAAjMCAAMWAQADHAEAAyIBAAMpAQADVQEAA00BAANCAQADOQEA
        AYABfAH/AQACUAH/AQABkwEAAdYBAAH/AewBzAEAAcYB1gHvAQAB1gLnAQABkAGpAa0CAAH/ATMDAAFm