CNAS/CnasSynchronusDAL/DAL/SQLDAL.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using CnasSynchronousCommon;

namespace CnasSynchronusDAL
{
    public static class SqlServerDAL
    {
        /// <summary>
        /// 数据库连接字符串
        /// </summary>
        private static string connectionStr ="";
        public static void CreateConnection(string strHost,string strName,string strUserId,string strPwd)
        {
            SqlServerDAL.connectionStr =$"Data Source = {strHost}; Initial Catalog = {strName}; User Id = {strUserId}; Password = {strPwd};";
        }

        /// <summary>
        /// 查询操作
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public static DataTable GetDataTable(string sql, params SqlParameter[] sp)
        {
            using (SqlConnection conn = new SqlConnection(connectionStr))
            {
                conn.Open();
                using (SqlDataAdapter sda = new SqlDataAdapter(sql, conn))
                {
                    sda.SelectCommand.Parameters.AddRange(sp);
                    DataTable dt = new DataTable();
                    sda.Fill(dt);
                    return dt;
                }
            }
        }

        internal static DataTable GetDataStruct(string strTableName,string strViewName,string strViewSql)
        {
            string strSql = "";
            if (strViewName == strTableName && string.IsNullOrWhiteSpace(strViewName))
                strSql = strViewSql + $" where 1=0";
            else
                strSql = $"select * from {strTableName} where 1=0";
            return GetDataTable(strSql, new SqlParameter[] { });
        }

        /// <summary>
        /// 增删改操作
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <returns>执行后的条数</returns>
        public static int ExecuteNonQuery(string sql, params SqlParameter[] sp)
        {
            using (SqlConnection conn = new SqlConnection(connectionStr))
            {
                conn.Open();
                using (SqlCommand cmd = new SqlCommand(sql, conn))
                {
                    cmd.Parameters.AddRange(sp);
                    int i = cmd.ExecuteNonQuery();
                    return i;
                }
            }
        }
        /// <summary>
        /// 执行一条SQL语句,返回首行首列
        /// </summary>
        /// <param name="sql">sql语句</param>
        /// <returns>首行首列</returns>
        public static object ExecuteScalar(string sql, params SqlParameter[] sp)
        {
            using (SqlConnection conn = new SqlConnection(connectionStr))
            {
                conn.Open();
                using (SqlCommand cmd = new SqlCommand(sql, conn))
                {
                    cmd.Parameters.AddRange(sp);
                    return cmd.ExecuteScalar();
                }
            }
        }

        /// <summary>
        /// 根据表名获取数据
        /// </summary>
        /// <param name="strTableName"></param>
        /// <returns></returns>
        public static DataTable GetDataByTableName(string strTableName)
        {
            return GetDataTable($"select * from {strTableName}",new SqlParameter[] { });
        }

        /// <summary>
        /// 根据表名，时间列，时间值，获得表中所有大于该时间的行集合
        /// </summary>
        /// <param name="strTableName"></param>
        /// <param name="strColumnName"></param>
        /// <param name="strColumnValue"></param>
        /// <returns></returns>
        public static DataTable GetDataByDateColumn(string strViewName,string strViewSql,string strTableName, string strColumnName, string strColumnValue)
        {
            DataTable dtReturn = new DataTable();
            try
            {
                string strSql = "";
                if (strViewName == strTableName && string.IsNullOrWhiteSpace(strViewName))
                    strSql = strViewSql+ $" where {strColumnName} > '{strColumnValue}'";
                else
                    strSql = $"select * from {strTableName} where {strColumnName} > '{strColumnValue}'"; 
                DataTable dt = GetDataTable(strSql, new SqlParameter[] { });

                Dictionary<string, string> dictFiled = GetSpecialOperaField(strTableName);
                if (dictFiled.Count > 0)
                    dtReturn = DateAndTimeTypeOpera(dt, dictFiled);
                else
                    dtReturn = dt;
            }
            catch (Exception ex)
            {
                //发生异常，写入日志
                AppLog.Error(ex.Message);
                throw ex;
            }
            return dtReturn;
         }

        public static Dictionary<string, DataTable> GetAllTableNameAndStructure()
        {
            Dictionary<string, DataTable> dictTables = new Dictionary<string, DataTable>();
            try
            {
                string sql = "";
                DataTable TablesName = GetDataTable("SELECT name FROM SysObjects Where XType='U' or XType='V' ORDER BY Name", new SqlParameter[] { });//得到所有表
                foreach (DataRow dr in TablesName.Rows)
                {
                    string strTableName = dr[0].ToString();

                    sql = string.Format("SELECT * FROM [{0}] where 1=0", strTableName); //查询字符串

                    dictTables.Add(strTableName.ToUpper(), GetDataTable(sql, new SqlParameter[] { }));
                }
            }
            catch (Exception ex)
            {
                //发生异常，写入日志
                AppLog.Error(ex.Message);
                //throw ex;
            }
            return dictTables;
        }

        public static bool TestSQLServerLink()
        {
            bool bIfSuccess = false;
            using (SqlConnection conn = new SqlConnection(connectionStr))
            {
                try
                {
                    conn.Open();
                    bIfSuccess = true;
                }
                catch (Exception ex)
                {
                    //这里写日志
                    bIfSuccess = false;
                    AppLog.Error(ex.Message);
                }
            }
            return bIfSuccess;
       }



        /// <summary>
        /// 获取所有数据字段，然后记录其中是否存在需要特殊处理的字段
        /// </summary>
        /// <returns></returns>
        private static Dictionary<string, string> GetSpecialOperaField(string strTableName)
        {
            Dictionary<string, string> DictFiled = new Dictionary<string, string>();
            DataTable dt = new DataTable();
            try
            {
                string sql = string.Format("SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME='{0}'", strTableName); //查询字符串
                dt = GetDataTable(sql, new SqlParameter[] { });

                foreach (DataRow dr in dt.Rows)
                {
                    if (dr["data_type"].ToString().ToLower() == "date" || dr["data_type"].ToString().ToLower() == "time")
                    {
                        DictFiled.Add(dr["column_name"].ToString(), dr["data_type"].ToString());
                    }
                }
            }
            catch (Exception ex)
            {
                //发生异常，写入日志
                AppLog.Error(ex.Message);
            }
            return DictFiled;
        }

        /// <summary>
        /// 获取数据时，单独处理某些（Date和Time）类型数据，并把数据类型转换为字符串类型
        /// </summary>
        private static DataTable DateAndTimeTypeOpera(DataTable dt, Dictionary<string, string> DictSpecialField)
        {
            DataTable dtNewFormat = new DataTable();

            //添加列
            foreach (DataColumn dc in dt.Columns)
            {
                if (DictSpecialField.ContainsKey(dc.ColumnName))
                {
                    string strDateType = DictSpecialField[dc.ColumnName];
                    switch (strDateType.ToUpper())
                    {
                        case "DATE":
                        case "TIME":
                            dtNewFormat.Columns.Add(dc.ColumnName, typeof(string));  //使用字符串来存储该字段，而不是采用它的数据库格式（C#无法区分Date, Time，DateTime，前两种格式会自动补充数据，导致数据的不准确）
                            break;
                        default:
                            dtNewFormat.Columns.Add(dc.ColumnName, dc.DataType);
                            break;
                    }
                }
                else
                {
                    dtNewFormat.Columns.Add(dc.ColumnName, dc.DataType);
                }
            }

            //添加数据行
            foreach (DataRow dr in dt.Rows)
            {
                DataRow drNewRow = dtNewFormat.NewRow();
                foreach (DataColumn dc in dtNewFormat.Columns)
                {
                    if (!DictSpecialField.ContainsKey(dc.ColumnName))
                        drNewRow[dc.ColumnName] = dr[dc.ColumnName];
                    else
                    {
                        switch (DictSpecialField[dc.ColumnName].ToUpper())
                        {
                            case "DATE":
                                if (dr[dc.ColumnName] != null && dr[dc.ColumnName].ToString() != "")
                                    drNewRow[dc.ColumnName] = Convert.ToDateTime(dr[dc.ColumnName]).ToString("yyyy-MM-dd");
                                break;
                            case "TIME":
                                if (dr[dc.ColumnName] != null && dr[dc.ColumnName].ToString() != "")
                                    drNewRow[dc.ColumnName] = Convert.ToDateTime(dr[dc.ColumnName].ToString()).ToString("HH:mm:ss");
                                break;
                            default:
                                drNewRow[dc.ColumnName] = dr[dc.ColumnName];
                                break;
                        }
                    }
                }
                dtNewFormat.Rows.Add(drNewRow);
            }

            //返回数据
            return dtNewFormat;
        }
    }
}