SqlHelper

最新推荐文章于 2022-08-19 15:18:27 发布
最新推荐文章于 2022-08-19 15:18:27 发布
阅读量129 收藏
点赞数
分类专栏： .net 文章标签： .net sqlhelper
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suiersuier/article/details/84144109
版权

整理了一份sqlhelper类，包含增删改查和批量添加和修改方法

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.SqlClient;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Text;

namespace MyTest.Data
{
    public class SqllHelper
    {
        //=================================执行sql和存储过程===========================

        public static Object SqlScalar(string connectString, string sql)
        {
            return SqlScalar(connectString, sql, 1);
        }
        public static Object SqlScalar(string connectString, string sql, object parms)
        {
            return SqlScalar(connectString, sql, parms, 1);
        }
        public static int SqlExecute(string connectString, string sql)
        {
            return SqlExecute(connectString, sql, 1);
        }
        public static int SqlExecute(string connectString, string sql, object parms)
        {
            return SqlExecute(connectString, sql, parms, 1);
        }
        public static T SqlSingle<T>(string connectString, string sql)
        {
            return SqlSingle<T>(connectString, sql, 1);
        }
        public static T SqlSingle<T>(string connectString, string sql, object parms)
        {
            return SqlSingle<T>(connectString, sql, parms, 1);
        }
        public static List<T> SqlList<T>(string connectString, string sql)
        {
            return SqlList<T>(connectString, sql, 1);
        }
        public static List<T> SqlList<T>(string connectString, string sql, object parms)
        {
            return SqlList<T>(connectString, sql, parms, 1);
        }
        public static DataTable SqlDataTable(string connectString, string sql)
        {
            return SqlDataTable(connectString, sql, 1);
        }
        public static DataTable SqlDataTable(string connectString, string sql, object parms)
        {
            return SqlDataTable(connectString, sql, parms, 1);
        }



        public static Object ProScalar(string connectString, string proName)
        {
            return SqlScalar(connectString, proName, 4);
        }
        public static Object ProScalar(string connectString, string proName, object parms)
        {
            return SqlScalar(connectString, proName, parms, 4);
        }
        public static int ProExecute(string connectString, string proName)
        {
            return SqlExecute(connectString, proName, 4);
        }
        public static int ProExecute(string connectString, string proName, object parms)
        {
            return SqlExecute(connectString, proName, parms, 4);
        }
        public static T ProSingle<T>(string connectString, string proName)
        {
            return SqlSingle<T>(connectString, proName, 4);
        }
        public static T ProSingle<T>(string connectString, string proName, object parms)
        {
            return SqlSingle<T>(connectString, proName, parms, 4);
        }
        public static List<T> ProList<T>(string connectString, string proName)
        {
            return SqlList<T>(connectString, proName, 4);
        }
        public static List<T> ProList<T>(string connectString, string proName, object parms)
        {
            return SqlList<T>(connectString, proName, parms, 4);
        }
        public static DataTable ProDataTable(string connectString, string sql)
        {
            return SqlDataTable(connectString, sql, 4);
        }
        public static DataTable ProDataTable(string connectString, string sql, object parms)
        {
            return SqlDataTable(connectString, sql, parms, 4);
        }

        public static void BatchInsert(string connectString, DataTable dt, string tableName)
        {
            BatchInsertImpl(connectString, dt, tableName);
        }
        public static void BatchInsert<T>(string connectString, List<T> list, string tableName)
        {
            DataTable dt = GetBatchInsertDataTable(connectString, list, tableName);
            BatchInsertImpl(connectString, dt, tableName);
        }

        /// <summary>
        /// 批量修改，使用了事务
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="connectString">数据库连接字符串</param>
        /// <param name="list">要修改的数据集</param>
        /// <param name="tableName">要修改表名</param>
        /// <param name="primaryKeyName">修改时的条件字段，一般修改是按照主键修改的比较多</param>
        /// <param name="columns">要修改的字段名称，
        /// 如果为空则把T类型中的除primaryKeyName属性之外的所有属性和数据库字段对应进行修改，
        /// 属性名称和数据库字段对应时不区分大小写</param>
        /// <param name="onceNum">一次性提交的最大数量，因为参数有2100个的限制，所以批量时会分多次进行提交，onceNum设置每次提交的数量</param>
        /// <returns>影响数据库的条数</returns>
        public static int BatchUpdate<T>(string connectString, List<T> list, string tableName, string primaryKeyName,string[] columns=null, int onceNum = 100)
        {
            if (list == null || list.Count == 0) return 0;
            int obj = 0;
            StringBuilder sqlBuiler = new StringBuilder();
            Type t = typeof(T);
            PropertyInfo[] propertys = t.GetProperties();
            if (propertys == null || propertys.Length == 0) return 0;
            PropertyInfo wherep = propertys.Where(s => s.Name.ToLower() == primaryKeyName.ToLower()).ToArray()[0]; //拼接修改条件
            List<PropertyInfo> propertys_update = new List<PropertyInfo>();
            if (columns==null|| columns.Length==0)
            {
                //指定修改字段为空时，默认修改实体中除了条件属性外的其他所有属性对应的字段
                propertys_update = propertys.Where(s => s.Name.ToLower() != primaryKeyName.ToLower()).ToList(); 
            }
            else
            {
                string[] columnsLower = string.Join(",", columns).ToLower().Split(',');
                foreach (var item in propertys)
                {
                    if (columnsLower.Contains(item.Name.ToLower())&& item.Name.ToLower()!=primaryKeyName.ToLower())
                    {
                        propertys_update.Add(item);
                    }
                }
            }
            int i = 0;
            using (SqlConnection conn = new SqlConnection(connectString))
            {
                conn.Open();
                SqlTransaction tran = conn.BeginTransaction(IsolationLevel.ReadCommitted);
                try
                {

                    using (SqlCommand cmd = new SqlCommand(sqlBuiler.ToString(), conn, tran))
                    {
                        foreach (T row in list)
                        {
                            i++;
                            sqlBuiler.Append($" update {tableName} Set ");
                            for (int j = 0; j < propertys_update.Count; j++)
                            {
                                if (j == propertys_update.Count - 1)
                                {
                                    sqlBuiler.Append($"{propertys_update[j].Name}=@{propertys_update[j].Name}_{i} ");
                                }
                                else
                                {
                                    sqlBuiler.Append($"{propertys_update[j].Name}=@{propertys_update[j].Name}_{i},");
                                }
                                cmd.Parameters.Add(new SqlParameter("@" + propertys_update[j].Name + "_" + i, propertys_update[j].GetValue(row)));
                            }
                            sqlBuiler.Append($" where {primaryKeyName}=@{primaryKeyName}_{i};");
                            cmd.Parameters.Add(new SqlParameter("@" + primaryKeyName + "_" + i, wherep.GetValue(row)));
                            if (i % onceNum == 0 || i == list.Count)
                            {
                                //执行sql
                                cmd.CommandText = sqlBuiler.ToString();
                                obj += cmd.ExecuteNonQuery();
                                sqlBuiler.Clear();
                                cmd.Parameters.Clear();
                            }
                        }
                    }
                    tran.Commit();
                }
                catch (Exception ex)
                {
                    tran.Rollback();
                    throw;
                }
            }
            return obj;
        }
        /// <summary>
        /// 批量修改，使用了事务
        /// </summary>
        /// <param name="connectString">数据库连接字符串</param>
        /// <param name="dt">要修改的数据源</param>
        /// <param name="tableName">要修改的表名</param>
        /// <param name="primaryKeyName">修改时的条件字段，一般是按照主键修改比较多</param>
        /// <param name="columns">要修改的字段名称
        /// 如果为空则把dt中所有列和数据表字段对应，修改除条件列外的所有列，
        /// 列明和数据库字段对应时不区分大小写</param>
        /// <param name="onceNum">一次性提交的最大数量，因为参数有2100个的限制，所以批量时会分多次进行提交，onceNum设置每次提交的数量</param>
        /// <returns></returns>
        public static int BatchUpdate(string connectString, DataTable dt, string tableName, string primaryKeyName, string[] columns = null, int onceNum = 100)
        {
            if (dt == null || dt.Rows == null || dt.Rows.Count == 0) return 0;
            int obj = 0;
            StringBuilder sqlBuiler = new StringBuilder();
            List<string> ufilds = new List<string>(); //所有要修改的字段
            DataColumnCollection coll = dt.Columns;
            string whereName = primaryKeyName;
            string[] columnsLower = null;
            if (columns!=null&& columns.Length>0)
            {
                columnsLower = string.Join(",", columns).ToLower().Split(',');
            }
           
            foreach (DataColumn item in coll)
            {
                if (item.ColumnName.ToLower() != primaryKeyName.ToLower())
                {
                    if (columnsLower!=null&& columnsLower.Length>0)
                    {
                        if (columnsLower.Contains(item.ColumnName.ToLower()))
                        {
                            ufilds.Add(item.ColumnName);
                        }
                    }
                    else
                    {
                        ufilds.Add(item.ColumnName);
                    }
                }
                else
                {
                    whereName = item.ColumnName;
                }
            }
            if (ufilds == null || ufilds.Count == 0)
            {
                return 0;
            }
            int i = 0;
            using (SqlConnection conn = new SqlConnection(connectString))
            {
                conn.Open();
                SqlTransaction tran = conn.BeginTransaction(IsolationLevel.ReadCommitted);
                try
                {
                    using (SqlCommand cmd = new SqlCommand(sqlBuiler.ToString(), conn, tran))
                    {
                        foreach (DataRow row in dt.Rows)
                        {
                            i++;
                            sqlBuiler.Append($" update {tableName} Set ");
                            for (int j = 0; j < ufilds.Count; j++)
                            {
                                if (j == ufilds.Count - 1)
                                {
                                    sqlBuiler.Append($"{ufilds[j]}=@{ufilds[j]}_{i} ");
                                }
                                else
                                {
                                    sqlBuiler.Append($"{ufilds[j]}=@{ufilds[j]}_{i},");
                                }
                                cmd.Parameters.Add(new SqlParameter("@" + ufilds[j] + "_" + i, row[ufilds[j]]));
                            }
                            sqlBuiler.Append($" where {primaryKeyName}=@{primaryKeyName}_{i};");
                            cmd.Parameters.Add(new SqlParameter("@" + primaryKeyName + "_" + i, row[whereName]));
                            if (i % onceNum == 0 || i == dt.Rows.Count)
                            {
                                cmd.CommandText = sqlBuiler.ToString();
                                obj += cmd.ExecuteNonQuery();
                                sqlBuiler.Clear();
                                cmd.Parameters.Clear();
                            }
                        }
                    }
                    tran.Commit();
                }
                catch (Exception ex)
                {
                    tran.Rollback();
                    throw;
                }

            }
            return obj;
        }

        //==========================方法实现================================

        #region SqlScalar

        /// <summary>
        /// 返回查询结果的第一行第一列
        /// </summary>
        /// <param name="connectString">数据库连接串</param>
        /// <param name="sql">sql语句，或者存储过程名称</param>
        /// <param name="commandType">sql语句</param>
        /// <returns></returns>
        private static Object SqlScalar(string connectString, string sql, int commandType = 1)
        {
            object obj = null;
            using (SqlConnection conn = new SqlConnection(connectString))
            {
                conn.Open();
                using (SqlCommand cmd = new SqlCommand(sql, conn))
                {
                    if (commandType == 1)
                    {
                        cmd.CommandType = CommandType.Text;
                    }
                    else
                    {
                        cmd.CommandType = CommandType.StoredProcedure;
                    }
                    obj = cmd.ExecuteScalar();
                }
            }
            return obj;
        }
        /// <summary>
        /// 返回查询结果的第一行第一列
        /// </summary>
        /// <param name="connectString">数据库连接串</param>
        /// <param name="sql">sql语句</param>
        /// <param name="parms">参数</param>
        /// <returns></returns>
        private static Object SqlScalar(string connectString, string sql, object parms, int commandType = 1)
        {
            List<SqlParameter> parmList = GetSqlCommandParams(parms);
            object obj = null;
            using (SqlConnection conn = new SqlConnection(connectString))
            {
                conn.Open();
                using (SqlCommand cmd = new SqlCommand(sql, conn))
                {
                    if (commandType == 1)
                    {
                        cmd.CommandType = CommandType.Text;
                    }
                    else
                    {
                        cmd.CommandType = CommandType.StoredProcedure;
                    }
                    if (parmList != null)
                    {
                        cmd.Parameters.AddRange(parmList.ToArray());
                    }
                    obj = cmd.ExecuteScalar();
                    cmd.Parameters.Clear();
                }
            }
            return obj;
        }

        #endregion

        #region SqlExecute
        /// <summary>
        /// 返回影响数据库的条数
        /// </summary>
        /// <param name="connectString">数据库连接串</param>
        /// <param name="sql">要执行的sql</param>
        /// <returns></returns>
        private static int SqlExecute(string connectString, string sql, int commandType = 1)
        {
            int obj = 0;
            using (SqlConnection conn = new SqlConnection(connectString))
            {
                conn.Open();
                using (SqlCommand cmd = new SqlCommand(sql, conn))
                {
                    if (commandType == 1)
                    {
                        cmd.CommandType = CommandType.Text;
                    }
                    else
                    {
                        cmd.CommandType = CommandType.StoredProcedure;
                    }
                    obj = cmd.ExecuteNonQuery();
                }
            }
            return obj;
        }

        private static int SqlExecute(string connectString, string sql, object parms, int commandType = 1)
        {
            List<SqlParameter> parmList = GetSqlCommandParams(parms);
            int obj = 0;
            using (SqlConnection conn = new SqlConnection(connectString))
            {
                conn.Open();
                using (SqlCommand cmd = new SqlCommand(sql, conn))
                {
                    if (commandType == 1)
                    {
                        cmd.CommandType = CommandType.Text;
                    }
                    else
                    {
                        cmd.CommandType = CommandType.StoredProcedure;
                    }
                    if (parmList != null)
                    {
                        cmd.Parameters.AddRange(parmList.ToArray());
                    }
                    obj = cmd.ExecuteNonQuery();
                    cmd.Parameters.Clear();
                }
            }
            return obj;
        }
        #endregion

        #region SqlSingle
        /// <summary>
        /// 返回查询结果的第一行
        /// </summary>
        /// <typeparam name="T">要返回的类型</typeparam>
        /// <param name="connectString">数据库连接串</param>
        /// <param name="sql">要执行的sql</param>
        /// <returns></returns>
        private static T SqlSingle<T>(string connectString, string sql, int commandType = 1)
        {
            T obj = default(T);
            Type t = typeof(T);
            Assembly ass = t.Assembly;
            PropertyInfo p = null;
            using (SqlConnection conn = new SqlConnection(connectString))
            {
                conn.Open();
                using (SqlCommand cmd = new SqlCommand(sql, conn))
                {
                    if (commandType == 1)
                    {
                        cmd.CommandType = CommandType.Text;
                    }
                    else
                    {
                        cmd.CommandType = CommandType.StoredProcedure;
                    }
                    using (SqlDataReader dr = cmd.ExecuteReader())
                    {
                        if (dr != null)
                        {
                            Dictionary<string, PropertyInfo> propertysDic = GetFiles<T>(dr);
                            while (dr.Read())
                            {
                                obj = (T)ass.CreateInstance(t.FullName);
                                if (propertysDic != null && propertysDic.Count > 0)
                                {
                                    foreach (var key in propertysDic.Keys)
                                    {
                                        p = propertysDic[key];
                                        p.SetValue(obj, SqllHelper.ChangeType(dr[key], p.PropertyType));
                                    }
                                }
                                break;
                            }
                        }
                    }
                }
            }
            return obj;
        }


        private static T SqlSingle<T>(string connectString, string sql, object parms, int commandType = 1)
        {
            List<SqlParameter> parmList = GetSqlCommandParams(parms);
            T obj = default(T);
            Type t = typeof(T);
            Assembly ass = t.Assembly;
            PropertyInfo p = null;
            using (SqlConnection conn = new SqlConnection(connectString))
            {
                conn.Open();
                using (SqlCommand cmd = new SqlCommand(sql, conn))
                {
                    if (commandType == 1)
                    {
                        cmd.CommandType = CommandType.Text;
                    }
                    else
                    {
                        cmd.CommandType = CommandType.StoredProcedure;
                    }
                    if (parmList != null)
                    {
                        cmd.Parameters.AddRange(parmList.ToArray());
                    }
                    using (SqlDataReader dr = cmd.ExecuteReader())
                    {
                        if (dr != null)
                        {
                            Dictionary<string, PropertyInfo> propertysDic = GetFiles<T>(dr);
                            while (dr.Read())
                            {
                                obj = (T)ass.CreateInstance(t.FullName);
                                if (propertysDic != null && propertysDic.Count > 0)
                                {
                                    foreach (var key in propertysDic.Keys)
                                    {
                                        p = propertysDic[key];
                                        p.SetValue(obj, SqllHelper.ChangeType(dr[key], p.PropertyType));
                                    }
                                }
                                break;
                            }
                        }
                    }
                    cmd.Parameters.Clear();
                }
            }
            return obj;
        }
        #endregion

        #region SqlList
        /// <summary>
        /// 返回列表集合
        /// </summary>
        /// <typeparam name="T">要返回的对象类型</typeparam>
        /// <param name="connectString">数据库连接串</param>
        /// <param name="sql">要执行的sql</param>
        /// <returns></returns>
        private static List<T> SqlList<T>(string connectString, string sql, int commandType = 1)
        {
            List<T> list = new List<T>();
            Type t = typeof(T);
            Assembly ass = t.Assembly;

            PropertyInfo p = null;
            using (SqlConnection conn = new SqlConnection(connectString))
            {
                conn.Open();
                using (SqlCommand cmd = new SqlCommand(sql, conn))
                {
                    if (commandType == 1)
                    {
                        cmd.CommandType = CommandType.Text;
                    }
                    else
                    {
                        cmd.CommandType = CommandType.StoredProcedure;
                    }
                    using (SqlDataReader dr = cmd.ExecuteReader())
                    {
                        if (dr != null)
                        {
                            Dictionary<string, PropertyInfo> propertysDic = GetFiles<T>(dr);
                            while (dr.Read())
                            {
                                T obj = default(T);
                                obj = (T)ass.CreateInstance(t.FullName);
                                if (propertysDic != null && propertysDic.Count > 0)
                                {
                                    foreach (var key in propertysDic.Keys)
                                    {
                                        p = propertysDic[key];
                                        p.SetValue(obj, SqllHelper.ChangeType(dr[key], p.PropertyType));
                                    }
                                }
                                list.Add(obj);
                            }

                        }

                    }
                }
            }
            return list;
        }

        /// <summary>
        /// 返回列表集合
        /// </summary>
        /// <typeparam name="T">要返回的对象类型</typeparam>
        /// <param name="connectString">数据库连接串</param>
        /// <param name="sql">要执行的sql</param>
        /// <param name="parms">sql中用到的参数</param>
        /// <returns></returns>
        private static List<T> SqlList<T>(string connectString, string sql, object parms, int commandType = 1)
        {
            List<SqlParameter> parmList = GetSqlCommandParams(parms);
            List<T> list = new List<T>();
            Type t = typeof(T);
            Assembly ass = t.Assembly;
            PropertyInfo p = null;
            using (SqlConnection conn = new SqlConnection(connectString))
            {
                conn.Open();
                using (SqlCommand cmd = new SqlCommand(sql, conn))
                {
                    if (commandType == 1)
                    {
                        cmd.CommandType = CommandType.Text;
                    }
                    else
                    {
                        cmd.CommandType = CommandType.StoredProcedure;
                    }
                    if (parmList != null)
                    {
                        cmd.Parameters.AddRange(parmList.ToArray());
                    }
                    using (SqlDataReader dr = cmd.ExecuteReader())
                    {
                        if (dr != null)
                        {
                            Dictionary<string, PropertyInfo> propertysDic = GetFiles<T>(dr);
                            while (dr.Read())
                            {
                                T obj = default(T);
                                obj = (T)ass.CreateInstance(t.FullName);
                                if (propertysDic != null && propertysDic.Count > 0)
                                {
                                    foreach (var key in propertysDic.Keys)
                                    {
                                        p = propertysDic[key];
                                        p.SetValue(obj, SqllHelper.ChangeType(dr[key], p.PropertyType));
                                    }
                                }
                                list.Add(obj);
                            }

                        }
                    }
                    cmd.Parameters.Clear();
                }
            }
            return list;
        }
        #endregion

        #region SqlDataTable
        private static DataTable SqlDataTable(string connectString, string sql, int commandType = 1)
        {
            DataTable dt = null;
            DataSet ds = new DataSet();
            using (SqlConnection conn = new SqlConnection(connectString))
            {
                conn.Open();
                using (SqlCommand cmd = new SqlCommand(sql, conn))
                {
                    if (commandType == 1)
                    {
                        cmd.CommandType = CommandType.Text;
                    }
                    else
                    {
                        cmd.CommandType = CommandType.StoredProcedure;
                    }
                    using (SqlDataAdapter da = new SqlDataAdapter(cmd))
                    {
                        da.Fill(ds);
                    }
                }
            }
            if (ds != null && ds.Tables != null && ds.Tables.Count > 0)
            {
                dt = ds.Tables[0];
            }
            return dt;
        }
        private static DataTable SqlDataTable(string connectString, string sql, object parms, int commandType = 1)
        {
            List<SqlParameter> parmList = GetSqlCommandParams(parms);
            DataTable dt = null;
            DataSet ds = new DataSet();
            using (SqlConnection conn = new SqlConnection(connectString))
            {
                conn.Open();
                using (SqlCommand cmd = new SqlCommand(sql, conn))
                {
                    if (commandType == 1)
                    {
                        cmd.CommandType = CommandType.Text;
                    }
                    else
                    {
                        cmd.CommandType = CommandType.StoredProcedure;
                    }
                    if (parmList != null)
                    {
                        cmd.Parameters.AddRange(parmList.ToArray());
                    }
                    using (SqlDataAdapter da = new SqlDataAdapter(cmd))
                    {
                        da.Fill(ds);
                    }
                }
            }
            if (ds != null && ds.Tables != null && ds.Tables.Count > 0)
            {
                dt = ds.Tables[0];
            }
            return dt;
        } 
        #endregion

        #region BatchInsert
        /// <summary>
        /// 批插入
        /// </summary>
        /// <param name="connectString"></param>
        /// <param name="tableName"></param>
        /// <param name="dt">数据源的各列名称必须和数据表保持一致才行，且区分大小写</param>
        private static void BatchInsertImpl(string connectString, DataTable dt, string tableName)
        {
            Stopwatch watch = new Stopwatch();
            watch.Start();
            using (SqlConnection conn = new SqlConnection(connectString))
            {
                using (SqlBulkCopy bulkcopy = new SqlBulkCopy(conn))
                {
                    bulkcopy.DestinationTableName = tableName;
                    bulkcopy.BatchSize = dt.Rows.Count;
                    foreach (DataColumn item in dt.Columns)
                    {
                        //设置要插入的字段映射，映射了哪个插入哪个,而且区分大小写
                        bulkcopy.ColumnMappings.Add(new SqlBulkCopyColumnMapping(item.ColumnName, item.ColumnName));
                    }
                    conn.Open();
                    if (dt != null && dt.Rows.Count > 0)
                    {
                        bulkcopy.WriteToServer(dt);
                    }
                }
                long time = watch.ElapsedMilliseconds;
            }
        }


        #endregion


        #region GetSqlCommandParams
        /// <summary>
        /// 获取sqlcommand参数
        /// </summary>
        /// <param name="parms"></param>
        /// <returns></returns>
        private static List<SqlParameter> GetSqlCommandParams(object parms)
        {
            List<SqlParameter> parmList = null;
            PropertyInfo[] propertys = parms.GetType().GetProperties();
            if (propertys != null && propertys.Length > 0)
            {
                parmList = new List<SqlParameter>();
                foreach (var item in propertys)
                {
                    if (!item.CanRead)
                    {
                        continue;
                    }
                    parmList.Add(new SqlParameter("@" + item.Name, item.GetValue(parms)));
                }
            }
            return parmList;
        }
        #endregion

        #region GetFiles
        /// <summary>
        /// 获取泛型中的类型属性和数据库datareder中的属性共有部分
        /// </summary>
        /// <typeparam name="T">要返回的类型</typeparam>
        /// <param name="reader">SqlDataReader</param>
        /// <returns></returns>
        private static Dictionary<string, PropertyInfo> GetFiles<T>(SqlDataReader reader)
        {
            Dictionary<string, PropertyInfo> result = new Dictionary<string, PropertyInfo>();
            int cloumFiles = reader == null ? 0 : reader.FieldCount;
            Type t = typeof(T);
            PropertyInfo[] propertys = t.GetProperties();
            if (propertys != null && cloumFiles > 0)
            {
                List<string> readerFilesList = new List<string>(); //存储当前reader中的所有列名称
                for (int i = 0; i < cloumFiles; i++)
                {
                    readerFilesList.Add(reader.GetName(i).ToLower());
                }
                //取reder中和T类型中都有属性
                List<PropertyInfo> resultList = propertys.Where(s => s.CanRead && readerFilesList.Contains(s.Name.ToLower())).ToList();
                if (resultList != null && resultList.Count > 0)
                {
                    foreach (var item in resultList)
                    {
                        result.Add(item.Name, item);
                    }
                }
            }
            return result;
        }
        #endregion

        #region ChangeType
        /// <summary>
        /// 将数据库中查询出来的值转化为T类型中想要的类型，这样避免直接赋值object类型装箱时的性能消耗
        /// </summary>
        /// <param name="value">数据库中查出来的value值</param>
        /// <param name="type">要转化的类型</param>
        /// <returns></returns>
        private static object ChangeType(object value, Type type)
        {
            if (type.FullName == typeof(string).FullName)
            {
                return Convert.ChangeType(Convert.IsDBNull(value) ? null : value, type);
            }
            if (type.IsGenericType && type.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
            {
                NullableConverter convertor = new NullableConverter(type);
                return Convert.IsDBNull(value) ? null : convertor.ConvertFrom(value);
            }
            return Convert.IsDBNull(value) ? null : value;
        }
        #endregion

        #region GetBatchInsertDataTable

        private static DataTable GetBatchInsertDataTable<T>(string connectString, List<T> list, string tableName)
        {
            string[] columns = null;
            List<SpColumnsEntity> addafter = new List<SpColumnsEntity>();
            List<SpColumnsEntity> columns_table = ProList<SpColumnsEntity>(connectString, "sp_columns", new { table_name = tableName });
            if (columns_table == null || columns_table.Count == 0) return null;
            columns = columns_table.Select(s => s.Column_Name).ToArray();
            if (columns == null || columns.Length == 0) return null;
            DataTable dt = new DataTable();
            Type t = typeof(T);
            PropertyInfo[] propertys = t.GetProperties();
            foreach (var item in propertys)
            {
                string[] c_table_list = columns.Where(s => s.ToUpper() == item.Name.ToUpper()).ToArray();
                if (c_table_list != null && c_table_list.Length > 0)
                {
                    dt.Columns.Add(c_table_list[0]);
                }
            }
            foreach (var item in list)
            {
                ArrayList tempList = new ArrayList();
                foreach (var p in propertys)
                {
                    string[] c_table_list = columns.Where(s => s.ToUpper() == p.Name.ToUpper()).ToArray();
                    if (c_table_list != null && c_table_list.Length > 0)
                    {
                        object obj = p.GetValue(item);
                        tempList.Add(obj);
                    }
                }
                dt.LoadDataRow(tempList.ToArray(), true);
            }
            return dt;
        }
        #endregion

    }



    public class SpColumnsEntity
    {
        /// <summary>
        /// 列名
        /// </summary>
        public string Column_Name { set; get; }
        /// <summary>
        /// 列对应的位置
        /// </summary>

        public int Ordinal_Position { set; get; }
    }

}

 

suiersuier
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SqlHelper，增加返回实体集合
韩盼盼的小窝
10-20 4403
using System; using System.Data; using System.Xml; using System.Data.SqlClient; using System.Collections; using System.Configuration; namespace BookDAL { /// /// SqlServer数据访问帮助类
SqlSever帮助类
Smile丶不忘初心
11-30 153
/// <summary> /// 数据库访问接口 /// internal 只有同一命名空间才能访问，防止逻辑层调用此接口 /// </summary> public class AgentDBHelper { /// <summary> /// 数据库连接字符串 /// </summary> internal static string connecti...
Mybatis-plus批量操作
热门推荐
小哥哥的博客
08-19 4万+
使用Mybatis-plus可以很方便的实现批量新增和批量修改，不仅比自己写foreach遍历方便很多，而且性能也更加优秀。但是Mybatis-plus官方提供的批量修改和批量新增都是根据id来修改的，有时候我们需求其他字段，所以就需要我们自己修改一下
sql批量修改数据
weixin_43167662的博客
04-06 7333
123113
使用SqlBulkCopy批量插入，批量更新数据解决方案
fyshk的专栏
11-01 1万+
最近重构公司的一个老项目，需要从指定库中批量获取更新数据，一条条插入实在太慢，搜寻了一下解决方案，有说使用sqlbulkcopy实现的，果然快很多。但是SqlBulkCopy有其局限性，字段顺序及名称必须完全对应，遂想了一个解决方案 特记录如下：  思路：    1） 根据取过来的数据（DataTable）字段创建临时表 ‘ tmp_表名‘     2）SqlBulkCopy数据导入临时表...
SqlHelper类的使用
炸丸儿
02-13 2076
机房重构进行了一小阶段，刚开始敲代码的时候，实现每一个功能都要在D层类中写一次数据据库连接（SqlConnection）,SqlCommand,SqlDataReader语句，感到相当地麻烦。遇到这个问题后，就想到了面向对象的封装性，把D层中重复的SQL语句封装起来，以提高代码的复用性。通过上网查资料，知道了SqlHelper类和其使用方法。     SqlHelper类将数据库连接（SqlCo
SqlHelper.zip
05-27
SqlHelper是C#编程语言中常见的一种用于简化数据库操作的辅助类库，它为开发者提供了方便的接口，以便更高效地执行SQL语句。在.NET框架下，开发人员经常使用SqlHelper来代替直接操作ADO.NET组件，以提高代码的可读性...
SqlHelper.cs
03-17
SqlHelper是一个基于.NETFrameWork的数据库操作组件，组件中包含操作数据库的各种方法，他封装的目的无疑是简化重复写的数据库连接，当SqlHelper封装以后，只需要给方法传入一些参数，就可以实现对数据库的访问。...
SQLHelper.rar
04-23
SQLHelper是一个常用的数据库操作工具，它为开发者提供了一种便捷的方式来执行SQL语句，而无需编写大量的数据库连接和处理代码。这个"SQLHelper.rar"压缩包包含了一个名为"SQLHelper"的源码文件，可能是一个Java或...
sqlhelper
06-17
SQLHelper类(含完整中文注释)-免费共享
C# SqlHelper类
01-23
SqlHelper类是.NET框架中一个非常实用的辅助类，用于简化数据库操作。它位于System.Data.SqlClient命名空间下，不过在标准的.NET框架库中并没有提供这个类，通常是由开发者自定义实现的，以封装常见的数据库操作，...
sqlHelper的增删改查
脚步不停，信念不息！
10-31 1891
当一件事情被重复做了多次后，会想找一种办法来代替自己去做这个重复的动作。写程序也一样。 在程序中，对于重复的部分，如果是完全相同，那我们就会想着将其写成一个方法（过程、函数），放在一个具有权限的需求者都能够得着的地儿。如果需求者在同一项目中，那么就把这个方法写成一个类，如果需求者在同一类中，那么就在本类中单独建一个方法写它。将相同的东西抽象出来，供多用户调用，就是用的抽象的思想。
SQLServer（mssql）批量修改数据库表中的数据
weixin_42344597的博客
09-26 5413
SQLServer进行批量修改数据表中数据 今天就因为写错了SQL脚本批量修改的语句导致6万多条数据出错 直接上sqlserver脚本 update 表名 set 表名.修改字段=导入进去的新表.字段 from 导进去的新表 where 导进去的新表.id=表名.id 表名→是我需要修改这里面表中的数据 表名.修改字段→是我最终目的需要修改的字段 导入进去的新表→是我根据需要修改的数据做一个exc...
通用mapper——功能拓展
qq_41505160的博客
04-16 1292
前提 通用mapper——自定义搭配继承Mapper 正文 通过查阅官方文档，发现并没有通过id批量修改和删除的mapper，现在扩展通过id批量修改和删除的mapper 使用的基础方法 实体类 来源 方法名 参数 返回值 作用 MapperTemplate xxProvider继承 getEntityClass MappedStatement ms Class<?> 获取返回值类型 - 实体类型 MapperTemplate xxProvider继承 tableName C
全国计算机三级（网络技术）做题技巧
最新发布
07-22
全国计算机三级（网络技术）做题技巧
微软SqlHelper类详解：高效数据库操作
"这篇文章主要探讨了微软官方的SqlHelper类，这是一个用于数据库辅助操作的类，可以帮助开发者快速进行数据库访问。作者强调了使用成熟类库的便利性，并以微软的PetShop4.0项目中的SqlHelper类为例，介绍了其常用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值