C# sqlite数据库操作类

1、引用程序集System.Data.SQLite

2、创建数据访问基础类(基于SQLite) DbHelperSqlite

3、创建数据库操作类DataHelper

4、创建共同函数类CommonHelper

    /// <summary>
    /// 数据访问基础类(基于SQLite)
    /// </summary>
    public class DbHelperSqlite
    {
        /// <summary>
        /// 提示信息
        /// </summary>
        public static string StrLastError = string.Empty;

        /// <summary>
        /// 命令
        /// </summary>
        public enum SdaCmd
        {
            /// <summary>
            /// 查询
            /// </summary>
            Select,

            /// <summary>
            /// 删除
            /// </summary>
            Delete,

            /// <summary>
            /// 更新
            /// </summary>
            Update,

            /// <summary>
            /// 插入
            /// </summary>
            Insert
        }

        /// <summary>
        /// 连接字符串
        /// </summary>
        /// <value>
        /// The connection string.
        /// </value>
        public static string ConnString = @"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=MoviesDemo;Integrated Security=True;";

        /// <summary>
        /// 创建数据库文件及数据库表
        /// </summary>
        /// <param name="strDbpath">数据库文件包含文件名的全路径信息</param>
        /// <param name="sql">创建数据库表的SQL语句</param>
        /// <param name="alwaysCreate">if set to <c>true</c> [always create].</param>
        public static void CreateDbTable(string strDbpath, string sql, bool alwaysCreate = false)
        {
            if (!File.Exists(strDbpath) || alwaysCreate)
            {
                //ConnString = $"Data Source={strDbpath};Pooling=false;FailIfMissing=false;syncchronous=normal;";
                SQLiteConnection conn = new SQLiteConnection(ConnString);
                SQLiteCommand cmd = new SQLiteCommand();
                conn.Open();
                cmd.CommandText = sql;
                cmd.Connection = conn;
                cmd.ExecuteNonQuery();
                conn.Close();
                FileInfo fileInfo = new FileInfo(strDbpath);
                if (fileInfo.Length == 0)
                {
                    File.Delete(strDbpath);
                    conn = new SQLiteConnection(ConnString);
                    cmd = new SQLiteCommand();
                    conn.Open();
                    cmd.CommandText = sql;
                    cmd.Connection = conn;
                    cmd.ExecuteNonQuery();
                    conn.Close();
                }
            }
            else
            {
                ConnString = $"Data Source={strDbpath};Pooling=false;FailIfMissing=false;syncchronous=normal;";
            }
        }

        /// <summary>
        /// DataAdapter方法 返回DataSet数据集
        /// </summary>
        /// <param name="sSqlCmd">SQL语句</param>
        /// <param name="command">操作参数 枚举类型</param>
        /// <param name="tabName">DataSet中的表名</param>
        /// <param name="paraList">命令参数集合</param>
        /// <returns></returns>
        public static DataSet DataAdapter(string sSqlCmd, SdaCmd command, string tabName, params SQLiteParameter[] paraList)
        {
            DataSet ds = new DataSet();
            try
            {
                SQLiteConnection con = new SQLiteConnection(ConnString);
                SQLiteCommand cmd = new SQLiteCommand
                {
                    Connection = con,
                    CommandText = sSqlCmd
                };
                if (paraList != null)
                {
                    cmd.CommandType = CommandType.Text;
                    foreach (SQLiteParameter para in paraList)
                    {
                        cmd.Parameters.Add(para);
                    }
                }

                SQLiteDataAdapter sda = new SQLiteDataAdapter();
                switch (command)
                {
                    case SdaCmd.Select:
                        sda.SelectCommand = cmd;
                        break;
                    case SdaCmd.Insert:
                        sda.InsertCommand = cmd;
                        break;
                    case SdaCmd.Update:
                        sda.UpdateCommand = cmd;
                        break;
                    case SdaCmd.Delete:
                        sda.DeleteCommand = cmd;
                        break;
                }

                sda.Fill(ds, tabName);
                con.Close();
                SQLiteConnection.ClearAllPools();
            }
            catch (Exception ex)
            {
                LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{sSqlCmd}");
                StrLastError = ex.Message;
            }

            return ds;
        }

        /// <summary>
        /// 执行一个查询语句，返回一个包含查询结果的DataTable
        /// </summary>
        /// <param name="strSql">要执行的查询语句</param>
        /// <param name="parameters">执行SQL查询语句所需要的参数，参数必须以它们在SQL语句中的顺序为准</param>
        /// <returns></returns>
        public static DataTable ExecuteDataTable(string strSql, SQLiteParameter[] parameters)
        {
            try
            {
                using (SQLiteConnection connection = new SQLiteConnection(ConnString))
                {
                    using (SQLiteCommand command = new SQLiteCommand(strSql, connection))
                    {
                        if (parameters != null)
                        {
                            command.Parameters.AddRange(parameters);
                        }

                        SQLiteDataAdapter adapter = new SQLiteDataAdapter(command);
                        DataTable data = new DataTable();
                        adapter.Fill(data);
                        SQLiteConnection.ClearAllPools();
                        return data;
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{strSql}");
                StrLastError = ex.Message;
                return null;
            }
        }

        /// <summary>
        /// 执行一个查询语句，返回一个包含查询结果的DataTable
        /// </summary>
        /// <param name="strSql">要执行的查询语句</param>
        /// <returns></returns>
        public static DataTable ExecuteDataTable(string strSql)
        {
            try
            {
                using (SQLiteConnection connection = new SQLiteConnection(ConnString))
                {
                    using (SQLiteCommand command = new SQLiteCommand(strSql, connection))
                    {
                        SQLiteDataAdapter adapter = new SQLiteDataAdapter(command);
                        DataTable data = new DataTable("ResultData");
                        adapter.Fill(data);
                        SQLiteConnection.ClearAllPools();
                        return data;
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{strSql}");
                StrLastError = ex.Message;
                return null;
            }
        }

        /// <summary>
        /// 对SQLite数据库执行增删改操作，返回受影响的行数。
        /// </summary>
        /// <param name="strSql">要执行的增删改的SQL语句</param>
        /// <param name="parameters">&gt;执行增删改语句所需要的参数，参数必须以它们在SQL语句中的顺序为准</param>
        /// <returns></returns>
        public static int ExecuteNonQuery(string strSql, SQLiteParameter[] parameters)
        {
            try
            {
                int affectedRows;
                using (SQLiteConnection connection = new SQLiteConnection(ConnString))
                {
                    connection.Open();
                    using (DbTransaction transaction = connection.BeginTransaction())
                    {
                        using (SQLiteCommand command = new SQLiteCommand(connection))
                        {
                            command.CommandText = strSql;
                            if (parameters != null && parameters.Length > 0)
                            {
                                command.Parameters.AddRange(parameters);
                            }

                            affectedRows = command.ExecuteNonQuery();
                        }

                        transaction.Commit();
                    }
                }

                SQLiteConnection.ClearAllPools();
                return affectedRows;
            }
            catch (Exception ex)
            {
                LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{strSql}");
                StrLastError = ex.Message;
                return 0;
            }
        }

        /// <summary>
        /// 对SQLite数据库执行增删改操作，返回受影响的行数。
        /// </summary>
        /// <param name="strSql">要执行的增删改的SQL语句</param>
        /// <returns></returns>
        public static int ExecuteNonQuery(string strSql)
        {
            try
            {
                int affectedRows;
                using (SQLiteConnection connection = new SQLiteConnection(ConnString))
                {
                    connection.Open();
                    using (DbTransaction transaction = connection.BeginTransaction())
                    {
                        using (SQLiteCommand command = new SQLiteCommand(connection))
                        {
                            command.CommandText = strSql;
                            affectedRows = command.ExecuteNonQuery();
                        }

                        transaction.Commit();
                    }
                }

                SQLiteConnection.ClearAllPools();
                return affectedRows;
            }
            catch (Exception ex)
            {
                LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{strSql}");
                StrLastError = ex.Message;
                return 0;
            }
        }

        /// <summary>
        /// 执行一个查询语句，返回一个关联的SQLiteDataReader实例
        /// </summary>
        /// <param name="strSql">要执行的查询语句</param>
        /// <param name="parameters">执行SQL查询语句所需要的参数，参数必须以它们在SQL语句中的顺序为准</param>
        /// <returns></returns>
        public static SQLiteDataReader ExecuteReader(string strSql, SQLiteParameter[] parameters)
        {
            try
            {
                using (SQLiteConnection connection = new SQLiteConnection(ConnString))
                {
                    SQLiteCommand command = new SQLiteCommand(strSql, connection);
                    if (parameters != null)
                    {
                        command.Parameters.AddRange(parameters);
                    }

                    connection.Open();
                    return command.ExecuteReader(CommandBehavior.CloseConnection);
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{strSql}");
                StrLastError = ex.Message;
                return null;
            }
        }

        /// <summary>
        /// 执行一个查询语句，返回一个关联的SQLiteDataReader实例
        /// </summary>
        /// <param name="strSql">要执行的查询语句</param>
        /// <returns></returns>
        public static SQLiteDataReader ExecuteReader(string strSql)
        {
            try
            {
                using (SQLiteConnection connection = new SQLiteConnection(ConnString))
                {
                    SQLiteCommand command = new SQLiteCommand(strSql, connection);
                    connection.Open();
                    return command.ExecuteReader(CommandBehavior.CloseConnection);
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{strSql}");
                StrLastError = ex.Message;
                return null;
            }
        }

        /// <summary>
        /// 执行一个查询语句，返回查询结果的第一行第一列
        /// </summary>
        /// <param name="strSql">要执行的查询语句</param>
        /// <param name="parameters">执行SQL查询语句所需要的参数，参数必须以它们在SQL语句中的顺序为准</param>
        /// <returns></returns>
        public static object ExecuteScalar(string strSql, SQLiteParameter[] parameters)
        {
            try
            {
                using (SQLiteConnection connection = new SQLiteConnection(ConnString))
                {
                    using (SQLiteCommand command = new SQLiteCommand(strSql, connection))
                    {
                        if (parameters != null)
                        {
                            command.Parameters.AddRange(parameters);
                        }

                        SQLiteDataAdapter adapter = new SQLiteDataAdapter(command);
                        DataTable data = new DataTable();
                        adapter.Fill(data);
                        SQLiteConnection.ClearAllPools();
                        return data;
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{strSql}");
                StrLastError = ex.Message;
                return null;
            }
        }

        /// <summary>
        /// 执行一个查询语句，返回查询结果的第一行第一列
        /// </summary>
        /// <param name="strSql">要执行的查询语句</param>
        /// <returns></returns>
        public static object ExecuteScalar(string strSql)
        {
            try
            {
                using (SQLiteConnection connection = new SQLiteConnection(ConnString))
                {
                    using (SQLiteCommand command = new SQLiteCommand(strSql, connection))
                    {
                        SQLiteDataAdapter adapter = new SQLiteDataAdapter(command);
                        DataTable data = new DataTable();
                        adapter.Fill(data);
                        SQLiteConnection.ClearAllPools();
                        return data;
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{strSql}");
                StrLastError = ex.Message;
                return null;
            }
        }

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="sqlStringList">SQL语句的哈希表（key为strSql语句，value是该语句的SQLiteParameter[]）</param>
        /// <returns></returns>
        public static bool ExecuteSqlTran(Hashtable sqlStringList)
        {
            SQLiteConnection conn = new SQLiteConnection(ConnString);
            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);
                        cmd.ExecuteNonQuery();
                        cmd.Parameters.Clear();
                    }

                    trans.Commit();
                    return true;
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    StrLastError = ex.Message;
                    LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{sqlStringList}");
                    return false;
                }
                finally
                {
                    conn.Close();
                }
            }
        }

        /// <summary>
        /// 执行压缩数据库
        /// </summary>
        public static void ExecuteZip()
        {
            using (SQLiteConnection connection = new SQLiteConnection(ConnString))
            {
                using (SQLiteCommand cmd = new SQLiteCommand("VACUUM", connection))
                {
                    try
                    {
                        connection.Open();
                        cmd.ExecuteNonQuery();
                    }
                    catch (SQLiteException e)
                    {
                        connection.Close();
                        StrLastError = e.Message;
                    }
                }
            }
        }

        /// <summary>
        /// 取dataset
        /// </summary>
        /// <param name="strSql">strSql语句</param>
        /// <returns>
        /// 返回dataset
        /// </returns>
        public static DataSet GetDataSet(string strSql)
        {
            DataSet ds = null;
            try
            {
                using (SQLiteConnection connection = new SQLiteConnection(ConnString))
                {
                    using (SQLiteCommand cmd = new SQLiteCommand(strSql, connection))
                    {
                        try
                        {
                            SQLiteDataAdapter dao = new SQLiteDataAdapter(cmd);
                            ds = new DataSet();
                            dao.Fill(ds);
                            connection.Close();
                        }
                        catch (SQLiteException e)
                        {
                            connection.Close();
                            StrLastError = e.Message;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                StrLastError = ex.Message;
                LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{strSql}");
            }
            finally
            {
                SQLiteConnection.ClearAllPools();
            }

            return ds;
        }

        /// <summary>
        /// 取dataset
        /// </summary>
        /// <param name="strSql">strSql语句</param>
        /// <param name="paraList">命令参数集合</param>
        /// <returns>
        /// 返回dataset
        /// </returns>
        public static DataSet GetDataSet(string strSql, params SQLiteParameter[] paraList)
        {
            DataSet ds = null;
            try
            {
                using (SQLiteConnection connection = new SQLiteConnection(ConnString))
                {
                    using (SQLiteCommand cmd = new SQLiteCommand(strSql, connection))
                    {
                        try
                        {
                            if (paraList != null && paraList.Length > 0)
                            {
                                cmd.Parameters.AddRange(paraList);
                            }

                            SQLiteDataAdapter dao = new SQLiteDataAdapter(cmd);
                            ds = new DataSet();
                            dao.Fill(ds);
                            connection.Close();
                        }
                        catch (SQLiteException e)
                        {
                            connection.Close();
                            StrLastError = e.Message;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{strSql}");
                StrLastError = ex.Message;
            }
            finally
            {
                SQLiteConnection.ClearAllPools();
            }

            return ds;
        }

        /// <summary>
        /// 取datatable
        /// </summary>
        /// <param name="strSql">SQL语句</param>
        /// <returns>
        /// 返回DataTable
        /// </returns>
        public static DataTable GetDataTable(string strSql)
        {
            DataTable dt = null;
            try
            {
                using (SQLiteConnection connection = new SQLiteConnection(ConnString))
                {
                    using (SQLiteCommand cmd = new SQLiteCommand(strSql, connection))
                    {
                        try
                        {
                            SQLiteDataAdapter dao = new SQLiteDataAdapter(cmd);
                            dt = new DataTable();
                            dao.Fill(dt);
                            connection.Close();
                        }
                        catch (SQLiteException e)
                        {
                            connection.Close();
                            StrLastError = e.Message;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{strSql}");
                StrLastError = ex.Message;
            }
            finally
            {
                SQLiteConnection.ClearAllPools();
            }

            return dt;
        }

        /// <summary>
        /// 取datatable
        /// </summary>
        /// <param name="strSql">SQL语句</param>
        /// <param name="paraList">命令参数集合</param>
        /// <returns>
        /// 返回DataTable
        /// </returns>
        public static DataTable GetDataTable(string strSql, params SQLiteParameter[] paraList)
        {
            DataTable dt = null;
            try
            {
                using (SQLiteConnection connection = new SQLiteConnection(ConnString))
                {
                    using (SQLiteCommand cmd = new SQLiteCommand(strSql, connection))
                    {
                        try
                        {
                            if (paraList != null && paraList.Length > 0)
                            {
                                cmd.Parameters.AddRange(paraList);
                            }

                            SQLiteDataAdapter dao = new SQLiteDataAdapter(cmd);
                            dt = new DataTable();
                            dao.Fill(dt);
                            connection.Close();
                        }
                        catch (SQLiteException e)
                        {
                            connection.Close();
                            StrLastError = e.Message;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{strSql}");
                StrLastError = ex.Message;
            }
            finally
            {
                SQLiteConnection.ClearAllPools();
            }

            return dt;
        }

        /// <summary>
        /// 取最大的ID
        /// </summary>
        /// <param name="sKeyField">字段</param>
        /// <param name="sTableName">表名</param>
        /// <returns></returns>
        public static int GetMaxId(string sKeyField, string sTableName)
        {
            DataTable dt = GetDataTable("select ifnull(max([" + sKeyField + "]),0) as MaxID from [" + sTableName + "]");
            if (dt != null && dt.Rows.Count > 0)
            {
                return Convert.ToInt32(dt.Rows[0][0].ToString());
            }

            return 0;
        }

        /// <summary>
        /// 取最大的ID
        /// </summary>
        /// <param name="sKeyField">字段</param>
        /// <param name="sTableName">表名</param>
        /// <param name="paraList">命令参数集合</param>
        /// <returns></returns>
        public static int GetMaxId(string sKeyField, string sTableName, params SQLiteParameter[] paraList)
        {
            DataTable dt = GetDataTable("select ifnull(max([" + sKeyField + "]),0) as MaxID from [" + sTableName + "]",
                paraList);
            if (dt != null && dt.Rows.Count > 0)
            {
                return Convert.ToInt32(dt.Rows[0][0].ToString());
            }

            return 0;
        }

        /// <summary>
        /// 查询数据库中的所有数据类型信息
        /// </summary>
        /// <returns></returns>
        public static DataTable GetSchema()
        {
            using (SQLiteConnection connection = new SQLiteConnection(ConnString))
            {
                connection.Open();
                DataTable data = connection.GetSchema("TABLES");
                connection.Close();
                SQLiteConnection.ClearAllPools();
                return data;
            }
        }

        /// <summary>
        /// 取某个单一的元素
        /// </summary>
        /// <param name="strSql">strSql语句</param>
        /// <param name="paraList">命令参数集合</param>
        /// <returns>
        /// 返回dataset的第一行第一列的元素
        /// </returns>
        public static object GetSingle(string strSql, params SQLiteParameter[] paraList)
        {
            DataTable dt = GetDataTable(strSql, paraList);
            if (dt != null && dt.Rows.Count > 0)
            {
                return dt.Rows[0][0];
            }

            return null;
        }

        /// <summary>
        /// 取某个单一的元素
        /// </summary>
        /// <param name="strSql">strSql语句</param>
        /// <returns>
        /// 返回dataset的第一行第一列的元素
        /// </returns>
        public static object GetSingle(string strSql)
        {
            DataTable dt = GetDataTable(strSql);
            if (dt != null && dt.Rows.Count > 0)
            {
                return dt.Rows[0][0];
            }

            return null;
        }

        /// <summary>
        /// 判断是否存在
        /// </summary>
        /// <param name="strSql">SQL</param>
        /// <param name="paraList">命令参数集合</param>
        /// <returns>
        ///   <c>true</c> if the specified string SQL is exist; otherwise, <c>false</c>.
        /// </returns>
        public static bool IsExist(string strSql, params SQLiteParameter[] paraList)
        {
            DataTable dt;
            try
            {
                using (SQLiteConnection connection = new SQLiteConnection(ConnString))
                {
                    SQLiteCommand cmd = new SQLiteCommand
                    {
                        CommandText = strSql
                    };
                    if (paraList != null && paraList.Length > 0)
                    {
                        cmd.Parameters.AddRange(paraList);
                    }

                    cmd.Connection = connection;
                    SQLiteDataAdapter dao = new SQLiteDataAdapter(cmd);
                    dt = new DataTable();
                    dao.Fill(dt);
                    connection.Close();
                    SQLiteConnection.ClearAllPools();
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{strSql}");
                StrLastError = ex.Message;
                return false;
            }

            if (dt.Rows.Count > 0)
            {
                if (Convert.ToInt32(dt.Rows[0][0]) > 0)
                {
                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// 执行insert,update,delete 动作，也可以使用事务
        /// </summary>
        /// <param name="strSql">strSql语句</param>
        /// <param name="bUseTransaction">是否使用事务，默认不使用事务</param>
        /// <returns></returns>
        public static bool UpdateData(string strSql, bool bUseTransaction)
        {
            int iResult;
            if (!bUseTransaction)
            {
                try
                {
                    using (SQLiteConnection connection = new SQLiteConnection(ConnString))
                    {
                        SQLiteCommand comm = new SQLiteCommand(connection)
                        {
                            CommandText = strSql
                        };
                        iResult = comm.ExecuteNonQuery();
                        connection.Close();
                    }
                }
                catch (Exception ex)
                {
                    LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{strSql}");
                    StrLastError = ex.Message;
                    iResult = -1;
                }
            }
            else // 使用事务 
            {
                SQLiteConnection conn = new SQLiteConnection(ConnString);
                conn.Open();
                DbTransaction trans = conn.BeginTransaction();
                try
                {
                    SQLiteCommand comm = new SQLiteCommand(conn)
                    {
                        CommandText = strSql
                    };
                    iResult = comm.ExecuteNonQuery();
                    trans.Commit();
                    conn.Close();
                }

                catch (Exception ex)
                {
                    LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{strSql}");
                    iResult = -1;
                    trans.Rollback();
                    StrLastError = ex.Message;
                }
            }

            SQLiteConnection.ClearAllPools();
            return iResult > 0;
        }

        /// <summary>
        /// 执行insert,update,delete 动作，也可以使用事务
        /// </summary>
        /// <param name="strSql">strSql语句</param>
        /// <param name="bUseTransaction">是否使用事务，默认不使用事务</param>
        /// <param name="paraList">命令参数集合</param>
        /// <returns></returns>
        public static bool UpdateData(string strSql, bool bUseTransaction, params SQLiteParameter[] paraList)
        {
            int iResult;
            if (!bUseTransaction)
            {
                try
                {
                    SQLiteConnection conn = new SQLiteConnection(ConnString);
                    conn.Open();
                    SQLiteCommand cmd = new SQLiteCommand(conn)
                    {
                        CommandText = strSql
                    };
                    if (paraList != null && paraList.Length > 0)
                    {
                        cmd.Parameters.AddRange(paraList);
                    }

                    iResult = cmd.ExecuteNonQuery();
                    conn.Close();
                }
                catch (Exception ex)
                {
                    LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{strSql}");
                    iResult = -1;
                    StrLastError = ex.Message;
                }
            }

            else // 使用事务 
            {
                SQLiteConnection conn = new SQLiteConnection(ConnString);
                conn.Open();
                DbTransaction trans = conn.BeginTransaction();
                try
                {
                    SQLiteCommand cmd = new SQLiteCommand(conn)
                    {
                        CommandText = strSql
                    };
                    if (paraList != null && paraList.Length > 0)
                    {
                        cmd.Parameters.AddRange(paraList);
                    }

                    iResult = cmd.ExecuteNonQuery();
                    trans.Commit();
                    conn.Close();
                }

                catch (Exception ex)
                {
                    LogHelper.Error($"执行sql输出错误：{ex.Message}\r\nSql语句：{strSql}");
                    iResult = -1;
                    trans.Rollback();
                    StrLastError = ex.Message;
                }
            }

            SQLiteConnection.ClearAllPools();
            return iResult > 0;
        }

        /// <summary>
        /// Prepares the command.
        /// </summary>
        /// <param name="cmd">The command.</param>
        /// <param name="conn">The connection.</param>
        /// <param name="trans">The trans.</param>
        /// <param name="cmdText">The command text.</param>
        /// <param name="cmdParms">The command parms.</param>
        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;
            if (cmdParms != null)
            {
                foreach (SQLiteParameter parm in cmdParms)
                {
                    cmd.Parameters.Add(parm);
                }
            }
        }

        /// <summary>
        /// Existses the specified string SQL.
        /// </summary>
        /// <param name="strSql">The string SQL.</param>
        /// <returns></returns>
        public static bool Exists(string strSql)
        {
            object obj = GetSingle(strSql);
            int cmdresult;
            if (Equals(obj, null) || Equals(obj, DBNull.Value))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }

            if (cmdresult == 0)
            {
                return false;
            }

            return true;
        }

        /// <summary>
        /// Existses the specified string SQL.
        /// </summary>
        /// <param name="strSql">The string SQL.</param>
        /// <param name="cmdParms">The command parms.</param>
        /// <returns></returns>
        public static bool Exists(string strSql, params SQLiteParameter[] cmdParms)
        {
            object obj = GetSingle(strSql, cmdParms);
            int cmdresult;
            if (Equals(obj, null) || Equals(obj, DBNull.Value))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }

            if (cmdresult == 0)
            {
                return false;
            }

            return true;
        }

        /// <summary>
        /// Adds the column.
        /// </summary>
        /// <param name="tableName">Name of the table.</param>
        /// <param name="columnName">Name of the column.</param>
        /// <param name="dataType">Type of the data.</param>
        /// <returns></returns>
        public static bool AddColumn(string tableName, string columnName, string dataType)
        {
            string pragmaSql = $"PRAGMA table_info(\"{tableName}\")";
            DataSet ds = GetDataSet(pragmaSql);
            List<string> nameList = new List<string>();
            if (!Equals(ds, null) && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
            {
                foreach (DataRow dataRow in ds.Tables[0].Rows)
                {
                    if (dataRow["name"] != null)
                    {
                        nameList.Add(dataRow["name"].ToString());
                    }
                }
            }

            if (!nameList.Contains(columnName))
            {
                string alterSql = $"ALTER TABLE {tableName} ADD {columnName} {dataType}";
                int iResult = ExecuteNonQuery(alterSql);
                return iResult > 0;
            }

            return true;
        }

        /// <summary>
        /// Exists the column.
        /// </summary>
        /// <param name="fieldname">The fieldname.</param>
        /// <returns></returns>
        public static bool ExistColumn(string fieldname)
        {
            string sql = $"select * from sqlite_master where name='tablename' and sql like '%{fieldname}%'; ";
            DataTable dataTable = ExecuteDataTable(sql);
            if (!dataTable.Equals(null))
            {
                return dataTable.Rows.Count > 0;
            }

            return false;
        }
        /// <summary>
        /// Exists the column.
        /// </summary>
        /// <param name="fieldname">The fieldname.</param>
        /// <returns></returns>
        public static bool ExistColumn(string tablename, string fieldname)
        {
            string sql = $"select * from sqlite_master where name='{tablename}' and sql like '%{fieldname}%'; ";
            DataTable dataTable = ExecuteDataTable(sql);
            if (!dataTable.Equals(null))
            {
                return dataTable.Rows.Count > 0;
            }
            return false;
        }
        /// <summary>
        /// Adds the colum.
        /// </summary>
        /// <param name="tabel">The tabel.</param>
        /// <param name="column">The column.</param>
        /// <param name="type">The type.</param>
        /// <returns></returns>
        public static bool AddColum(string tabel, string column, string type)
        {
            string sql = $"ALTER TABLE {tabel} ADD {column} {type};";
            return ExecuteNonQuery(sql) > 0;
        }
    }

----------------------------------------------------------------------------------------------------------------------------------------------

    /// <summary>
    /// 数据库操作类
    /// </summary>
    public partial class DataHelper
    {
       static string _createTableStudent = "CREATE TABLE [student]([id] NVARCHAR(50) PRIMARY KEY,[name] NVARCHAR(50)," +
        "[sex] INT DEFAULT 男, [age] INT DEFAULT 30, [dept] NVARCHAR(50));";

        /// <summary>
        /// Initializes static members of the <see cref="Client.Data.DataHelper"/> class.
        /// </summary>
        static DataHelper()
        {
            try
            {
                string strDbSql = _createTableStudent;
                DbHelperSqlite.CreateDbTable(CommonHelper.GetFilePathAtCurrentDirectory("CoreData.dll"), strDbSql);
                if (!DbHelperSqlite.ExistColumn("student", "score"))
                {
                    DbHelperSqlite.AddColum("student", "score", "INT");
                }
            }
            catch (Exception exception)
            {
                LogHelper.Error("创建数据文件出现错误：" + exception.Message);
            }
        }

        /// <summary>
        /// 是否存在该记录
        /// </summary>
        public static bool ExistsStudent()
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("select count(1) from student");
            return DbHelperSqlite.Exists(strSql.ToString(), null);
        }

        /// <summary>
        /// 增加一条数据
        /// </summary>
        public static bool InsertStudent(Student model)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("insert into student(");
            strSql.Append("name,sex,age,dept,score)");
            strSql.Append(" values (");
            strSql.Append("@Name,@Sex,@Age,@Dept,@Score)");
            SQLiteParameter[] parameters = {
                new SQLiteParameter("@Name", DbType.String,4),
                new SQLiteParameter("@Sex", DbType.Int32,4),
                new SQLiteParameter("@Age", DbType.String,4),
                new SQLiteParameter("@Dept", DbType.String,4),
                new SQLiteParameter("@Score", DbType.Decimal)
            };
            parameters[0].Value = model.Name;
            parameters[1].Value = model.Age;
            parameters[2].Value = model.Sex;
            parameters[3].Value = model.Dept;
            parameters[4].Value = model.Score;

            int rows = DbHelperSqlite.ExecuteNonQuery(strSql.ToString(), parameters);
            return rows > 0;
        }

        /// <summary>
        /// 更新一条数据
        /// </summary>
        public static bool UpdateStudent(Student model)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("update config set ");
            strSql.Append("Name=@Name,");
            strSql.Append("Age=@Age,");
            strSql.Append("Sex=@Sex,");
            strSql.Append("Dept=@Dept,");
            strSql.Append("Score=@Score,");
            SQLiteParameter[] parameters = {
                new SQLiteParameter("@Name", DbType.String,4),
                new SQLiteParameter("@Age", DbType.Int32,4),
                new SQLiteParameter("@Sex", DbType.String,4),
                new SQLiteParameter("@Dept", DbType.String,4),
                new SQLiteParameter("@Score", DbType.Decimal)
            };
            parameters[0].Value = model.Name;
            parameters[1].Value = model.Age;
            parameters[2].Value = model.Sex;
            parameters[3].Value = model.Dept;
            parameters[4].Value = model.Score;

            int rows = DbHelperSqlite.ExecuteNonQuery(strSql.ToString(), parameters);
            return rows > 0;
        }

        /// <summary>
        /// 得到一个对象实体
        /// </summary>
        public static Student GetModelStudent()
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("select name,sex,age,dept,score from student ");
            DataSet ds = DbHelperSqlite.GetDataSet(strSql.ToString(), null);
            return ds.Tables[0].Rows.Count > 0 ? DataRowToModelStudent(ds.Tables[0].Rows[0]) : new Student();
        }

        /// <summary>
        /// 得到一个对象实体
        /// </summary>
        public static Student DataRowToModelStudent(DataRow row)
        {
            Student model = new Student();
            if (row != null)
            {
                if (row["name"] != null && row["name"].ToString() != "")
                {
                    model.Name = row["name"].ToString();
                }
                if (row["sex"] != null && row["sex"].ToString() != "")
                {
                    model.Sex = row["sex"].ToString();
                }
                if (row["age"] != null && row["age"].ToString() != "")
                {
                    model.Age = int.Parse(row["age"].ToString());
                }
                if (row["dept"] != null && row["dept"].ToString() != "")
                {
                    model.Dept = row["dept"].ToString();
                }
                if (row["score"] != null)
                {
                    model.Score = decimal.Parse(row["score"].ToString());
                }
            }
            return model;
        }
    }

----------------------------------------------------------------------------------------------------------------------------------------------

3、通用方法类

  /// <summary>
    /// 通用工具函数类
    /// </summary>
    public class CommonHelper
    {
        /// <summary>
        /// Converts the string to decimal.
        /// </summary>
        /// <param name="strValue">The string value.</param>
        /// <returns></returns>
        public static decimal ConvertStringToDecimal(string strValue)
        {
            decimal decimalValue;
            try
            {
                decimalValue = Convert.ToDecimal(strValue);
            }
            catch
            {
                decimalValue = 0;
            }
            return decimalValue;
        }

        /// <summary>
        /// 获取公用桌面路径
        /// </summary>
        /// <returns></returns>
        public static string GetAllUsersDesktopFolderPath()
        {
            LogHelper.Info("###open注册表");
            RegistryKey folders = OpenRegistryPath(Registry.LocalMachine, @"/software/microsoft/windows/currentversion/explorer/shell folders");
            LogHelper.Info("###注册表open完成");
            string desktopPath = folders.GetValue("Common Desktop").ToString();
            LogHelper.Info("###退出【获取公用桌面路径】方法");
            return desktopPath;
        }

        /// <summary>
        /// 根据Xpath获取CDATA中的值
        /// </summary>
        /// <param name="strXmlText">xml字符串</param>
        /// <param name="strXpath">Xpath表达式</param>
        /// <returns></returns>
        public static string GetCDataInnerText(string strXmlText, string strXpath)
        {
            string strResult = string.Empty;
            XmlDocument doc = new XmlDocument
            {
                InnerXml = strXmlText
            };
            XmlNode nDataNode = doc.SelectSingleNode(strXpath);
            if (!Equals(nDataNode, null))
            {
                if (nDataNode.HasChildNodes)
                {
                    if (nDataNode.FirstChild is XmlCDataSection nDataSection)
                    {
                        strResult = nDataSection.InnerText;
                    }
                }
            }
            return strResult;
        }

        /// <summary>
        /// 获得当前工作路径
        /// </summary>
        /// <returns></returns>
        public static string GetCurrentDirectory()
        {
            AssemblyName assemblyName = Assembly.GetExecutingAssembly().GetName();
            string fullAppName = assemblyName.CodeBase;
            string fullAppPath = Path.GetDirectoryName(fullAppName);
            if (string.IsNullOrEmpty(fullAppPath))
            {
                return string.Empty;
            }
            if (fullAppPath.StartsWith("file:", StringComparison.Ordinal))
            {
                fullAppPath = fullAppPath.Substring(6);
            }
            return fullAppPath + "\\";
        }

        /// <summary>
        /// 获取执行路径的文件名和扩展名
        /// </summary>
        /// <param name="fileFullPath">The file full path.</param>
        /// <returns></returns>
        public static string GetFileName(string fileFullPath)
        {
            return Path.GetFileName(fileFullPath);
        }

        /// <summary>
        /// 获取文件路径
        /// </summary>
        /// <param name="filename">文件名称</param>
        /// <returns></returns>
        public static string GetFilePathAtCurrentDirectory(string filename)
        {
            return GetCurrentDirectory() + filename;
        }

        /// <summary>
        /// 执行程序名称
        /// </summary>
        /// <returns></returns>
        public static string GetMainExeName()
        {
            return AppDomain.CurrentDomain.FriendlyName;
        }

        /// <summary>
        /// 根据Xpath获取CDATA中的值
        /// </summary>
        /// <param name="strXmlText">xml字符串</param>
        /// <param name="strCdataXpath">查找CDATA</param>
        /// <param name="strNodeXpath">查找NODE</param>
        /// <returns></returns>
        public static string GetNodeFromCDataInnerText(string strXmlText, string strCdataXpath, string strNodeXpath)
        {
            try
            {
                string nodeValue = string.Empty;
                string strResult = GetCDataInnerText(strXmlText, strCdataXpath);
                if (!string.IsNullOrEmpty(strResult))
                {
                    XmlDocument doc = new XmlDocument
                    {
                        InnerXml = strResult
                    };
                    XmlNode nDataNode = doc.SelectSingleNode(strNodeXpath);
                    if (!Equals(nDataNode, null))
                    {
                        nodeValue = nDataNode.InnerXml;
                    }
                }
                return nodeValue;
            }
            catch
            {
                return string.Empty;
            }
        }

        /// <summary>
        /// 获取节点的值
        /// </summary>
        /// <param name="strXmlText">The string XML text.</param>
        /// <param name="xpath">The xpath.</param>
        /// <returns></returns>
        public static string GetNodeInnerTextByXpath(string strXmlText, string xpath)
        {
            string strReslt = string.Empty;
            if (!string.IsNullOrEmpty(strXmlText))
            {
                XmlDocument doc = new XmlDocument
                {
                    InnerXml = strXmlText
                };
                XmlNode node = doc.SelectSingleNode(xpath);
                if (!Equals(node, null))
                {
                    strReslt = node.InnerText;
                }
            }
            return strReslt;
        }

        /// <summary>
        /// 获取节点的值
        /// </summary>
        /// <param name="strXmlText">The string XML text.</param>
        /// <param name="xpath">The xpath.</param>
        /// <returns></returns>
        public static string GetNodeOuterXmlByXpath(string strXmlText, string xpath)
        {
            string strReslt = string.Empty;
            if (!string.IsNullOrEmpty(strXmlText))
            {
                XmlDocument doc = new XmlDocument
                {
                    InnerXml = strXmlText
                };
                XmlNode node = doc.SelectSingleNode(xpath);
                if (!Equals(node, null))
                {
                    strReslt = node.InnerText;
                }
            }
            return strReslt;
        }

        /// <summary>
        /// 获取节点的值
        /// </summary>
        /// <param name="strXmlText">The string XML text.</param>
        /// <param name="xpath">The xpath.</param>
        /// <returns></returns>
        public static XmlNode GetNodeByXpath(string strXmlText, string xpath)
        {
            if (!string.IsNullOrEmpty(strXmlText))
            {
                XmlDocument doc = new XmlDocument
                {
                    InnerXml = strXmlText
                };
                XmlNode node = doc.SelectSingleNode(xpath);
                return node;
            }
            return null;
        }

        /// <summary>
        /// 获取节点的值
        /// </summary>
        /// <param name="nodeVNode">The node v node.</param>
        /// <param name="xpath">The xpath.</param>
        /// <returns></returns>
        public static object GetNodeInnerTextFromNodeByXpath(XmlNode nodeVNode, string xpath)
        {
            object strReslt = string.Empty;
            if (!Equals(nodeVNode, null))
            {
                XmlDocument doc = new XmlDocument
                {
                    InnerXml = nodeVNode.OuterXml
                };
                XmlNode node = doc.SelectSingleNode(xpath);
                if (!Equals(node, null))
                {
                    strReslt = node.InnerText;
                }
            }
            return strReslt;
        }

        /// <summary>
        /// 获取目录信息
        /// </summary>
        /// <param name="fileFullPath">The file full path.</param>
        /// <returns></returns>
        public static string GetPath(string fileFullPath)
        {
            return Path.GetDirectoryName(fileFullPath);
        }

       

        /// <summary>
        /// 获得临时数据目录
        /// </summary>
        /// <returns></returns>
        public static string GetTempDirectory()
        {
            string path = GetCurrentDirectory();
            path = path + "tempfiles";
            if (!Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }
            return path;
        }

        /// <summary>
        /// 启动新实例
        /// </summary>
        /// <param name="appName">Name of the application.</param>
        public static void StartExe(string appName)
        {
            if (!string.IsNullOrEmpty(appName))
            {
                string path = Path.GetDirectoryName(appName);
                if (path != null)
                {
                    Process ps = new Process
                    {
                        StartInfo = new ProcessStartInfo
                        {
                            FileName = appName,
                            Arguments = "T",
                            CreateNoWindow = true,
                            WorkingDirectory = path
                        }
                    };
                    ps.Start();
                }
            }
        }

        /// <summary>
        /// Opens the registry path.
        /// </summary>
        /// <param name="root">The root.</param>
        /// <param name="s">The s.</param>
        /// <returns></returns>
        private static RegistryKey OpenRegistryPath(RegistryKey root, string s)
        {
            s = s.Remove(0, 1) + @"/";
            while (s.IndexOf(@"/", StringComparison.Ordinal) != -1)
            {
                if (root != null)
                {
                    root = root.OpenSubKey(s.Substring(0, s.IndexOf(@"/", StringComparison.Ordinal)));
                    s = s.Remove(0, s.IndexOf(@"/", StringComparison.Ordinal) + 1);
                }
            }
            return root;
        }

        /// <summary>
        /// Gets the quarter.
        /// </summary>
        /// <returns></returns>
        public static string GetQuarter()
        {
            string period = string.Empty;
            switch (DateTime.Now.Month)
            {
                case 1:
                    period = DateTime.Now.AddYears(-1).ToString("yyyy-04");
                    break;
                case 4:
                    period = DateTime.Now.ToString("yyyy-01");
                    break;
                case 7:
                    period = DateTime.Now.ToString("yyyy-02");
                    break;
                case 10:
                    period = DateTime.Now.ToString("yyyy-03");
                    break;
            }
            return period;
        }

        /// <summary>
        /// Checks the quarter.
        /// </summary>
        /// <returns></returns>
        public static string CheckQuarter()
        {
            switch (DateTime.Now.Month)
            {
                case 1:
                    return DateTime.Now.AddYears(-1).ToString("yyyy年第四季度");
                case 4:
                    return DateTime.Now.ToString("yyyy年第一季度");
                case 7:
                    return DateTime.Now.ToString("yyyy年第二季度");
                case 10:
                    return DateTime.Now.ToString("yyyy年第三季度");
            }
            return "当前不是纳税期";
        }

        /// <summary>
        /// 当前是否为整季度
        /// </summary>
        /// <returns>
        ///   <c>true</c> if this instance is quarter; otherwise, <c>false</c>.
        /// </returns>
        public static bool IsQuarter()
        {
            int month = DateTime.Now.Month;
            return month == 1 || month == 4 || month == 7 || month == 10;
        }

        /// <summary>
        /// 获取html页面
        /// </summary>
        /// <param name="url">The URL.</param>
        /// <param name="encoding">The encoding.</param>
        /// <param name="message">The message.</param>
        /// <returns></returns>
        public static string GetWebPageData(string url, Encoding encoding, out string message)
        {
            string sRslt = null;
            message = string.Empty;
            WebResponse oWebRps = null;
            WebRequest oWebRqst = WebRequest.Create(url);
            oWebRqst.Timeout = 50000;
            try
            {
                oWebRps = oWebRqst.GetResponse();
            }
            catch (WebException e)
            {
                message = e.Message;
            }
            catch (Exception e)
            {
                message = e.ToString();
            }
            finally
            {
                if (oWebRps != null)
                {
                    StreamReader oStreamRd = new StreamReader(oWebRps.GetResponseStream() ?? throw new InvalidOperationException(), encoding);
                    sRslt = oStreamRd.ReadToEnd();
                    oStreamRd.Close();
                    oWebRps.Close();
                }
            }
            return sRslt;
        }
        /// <summary>  
        /// 运行DOS命令  
        /// DOS关闭进程命令(ntsd -c q -p PID )PID为进程的ID  
        /// </summary>  
        /// <param name="command"></param>  
        /// <returns></returns>  
        public static string RunCmd(string command)
        {
            Process p = new Process();
            p.StartInfo.FileName = "cmd.exe";
            p.StartInfo.Arguments = "/c " + command;
            p.StartInfo.UseShellExecute = false;
            p.StartInfo.RedirectStandardInput = true;
            p.StartInfo.RedirectStandardOutput = true;
            p.StartInfo.RedirectStandardError = true;
            p.StartInfo.CreateNoWindow = true;
            p.Start();
            return p.StandardOutput.ReadToEnd();
        }
        /// <summary>
        /// 关闭应用程序
        /// </summary>
        /// <param name="applicationName">应用程序名称，不包含.exe后缀</param>
        /// <returns></returns>
        public static bool ExitProcess(string applicationName)
        {
            try
            {
                Process[] processList = Process.GetProcessesByName(applicationName);
                foreach (Process item in processList)
                {
                    if (item.MainModule.FileName.EndsWith(applicationName + ".exe"))
                    {
                        RunCmd("taskkill /im " + applicationName + ".exe" + " /f ");
                    }
                }
                return true;
            }
            catch (Exception exception)
            {
                LogHelper.Info($"关闭进程出现错误：{exception}");
                return false;
            }
        }

        /// <summary>
        /// 获取时间戳
        /// </summary>
        /// <returns></returns>
        public static string GetTimeStamp()
        {
            TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
            return Convert.ToInt64(ts.TotalSeconds).ToString();
        }

        public static string ReturnResult(object data, int code, string message)
        {
            Result result = new Result
            {
                Code = code,
                Data = data,
                Message = message
            };
            string strResult = JsonConvert.SerializeObject(result);
            //LogHelper.Info(strResult);
            return strResult;
        }

        public static string ReturnResult(object data, int code)
        {
            return ReturnResult(data, code, string.Empty);
        }

        public static string ReturnResult(object data)
        {
            return ReturnResult(data, 0, string.Empty);
        }

        public static string ReturnResultError(int code, string message)
        {
            return ReturnResult(null, code, message);
        }

        public static string ReturnResultError(string message)
        {
            return ReturnResult(null, -99, message);
        }

        /// <summary>
        /// Automatics the reg COM.
        /// </summary>
        /// <param name="strCmd">The string command.</param>
        /// <returns></returns>
        public static string AutoRegCom(string strCmd)
        {
            try
            {
                Process myProcess = new Process();
                ProcessStartInfo myProcessStartInfo = new ProcessStartInfo("cmd.exe")
                {
                    UseShellExecute = false,
                    CreateNoWindow = true,
                    RedirectStandardOutput = true
                };
                myProcess.StartInfo = myProcessStartInfo;
                myProcessStartInfo.Arguments = "/c " + strCmd;
                myProcess.Start();
                StreamReader myStreamReader = myProcess.StandardOutput;
                string rInfo = myStreamReader.ReadToEnd();
                myProcess.Close();
                rInfo = strCmd + "\r\n" + rInfo;
                return rInfo;
            }
            catch (Exception ex)
            {
                return ex.Message;
            }
        }

        /// <summary>
        /// 运行控制台程序，获取程序的输出结果
        /// </summary>
        /// <param name="exePath">The executable path.</param>
        /// <param name="parameters">The parameters.</param>
        /// <returns></returns>
        public static string GetRunOtherApplicationResult(string exePath, string parameters)
        {
            ProcessStartInfo psi = new ProcessStartInfo
            {
                RedirectStandardOutput = true,
                RedirectStandardError = true,
                WindowStyle = ProcessWindowStyle.Hidden,
                UseShellExecute = false,
                FileName = exePath,
                Arguments = parameters
            };
            Process process = Process.Start(psi);
            if (process != null)
            {
                StreamReader outputStreamReader = process.StandardOutput;
                StreamReader errStreamReader = process.StandardError;
                process.WaitForExit(2000);
                if (process.HasExited)
                {
                    string output = outputStreamReader.ReadToEnd();
                    string error = errStreamReader.ReadToEnd();
                    return output.Replace("\r\n", string.Empty);
                }
            }
            return string.Empty;
        }

        /// <summary>
        /// 根据进程名，关闭系统
        /// add by shenxue 
        /// </summary>
        /// <param name="name">进行名</param>
        public static void KillProcess(string name)
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                return;
            }
            Process[] arrayProcess = Process.GetProcessesByName(name);
            foreach (Process v in arrayProcess)
            {
                LogHelper.Info(v.ProcessName);
                v.Kill();
            }
        }

        internal class NsrsbhEntity
        {
            public string msg { get; set; }
            public string code { get; set; }
            public IList<Datum> data { get; set; }
        }

        internal class Datum
        {
            public string id { get; set; }
            public string enterpriseName { get; set; }
            public string taxpayerNum { get; set; }
            public bool registry { get; set; }
            public long ts { get; set; }
        }
    }

    /// <summary>
    /// 通用结果类
    /// </summary>
    public class Result<T>
    {
        #region 数据属性

        /// <summary>
        /// 状态码
        /// </summary>
        public int Code { get; set; }

        /// <summary>
        /// 消息
        /// </summary>
        public string Message { get; set; }

        /// <summary>
        /// 数据
        /// </summary>
        public T Data { get; set; }

        #endregion
    }

    /// <summary>
    /// 默认结果类
    /// </summary>
    public class Result : Result<object>
    {
    }