SqlServer DbHelper
/// <summary>
/// 数据库通用操作类
/// </summary>
public abstract class DbHelper
{
#region " 连接字符串 "
//连接字符串
//public static string ConnString = ConfigurationManager.ConnectionStrings["CommonSqlConnectionString"].ConnectionString;
public static string DefaultConnString = string.Empty;
public const int defaultCommandTimeout = ;
public const int defaultdbconfig = ; #endregion #region " GetSqlCommand " /// <summary>
/// 获取初始化好的Command对象
/// </summary>
/// <param name="conn">Connection对象</param>
/// <param name="cmdText">命令文本</param>
/// <param name="cmdType">命令类型</param>
/// <param name="parameters">参数列表</param>
/// <returns>初始化好的Command对象</returns>
private static SqlCommand GetSqlCommand(SqlConnection conn, string cmdText, CommandType cmdType, SqlParameter[] parameters)
{
SqlCommand cmd = new SqlCommand(cmdText, conn);
cmd.CommandType = cmdType;
cmd.CommandTimeout = defaultCommandTimeout;
if (parameters != null)
{
cmd.Parameters.AddRange(parameters);
} return cmd;
} #endregion #region " ExecSqlDataSet " public static DataTable ExecSqlDataSet(string strSQL)
{
return ExecSqlDataSet(strSQL, null);
} public static DataTable ExecSqlDataSet(string strSQL, SqlParameter[] parameters)
{
return ExecSqlDataSet(strSQL, parameters, DefaultConnString);
} public static DataTable ExecSqlDataSet(string strSQL, SqlParameter[] parameters, string connStr)
{
if (string.IsNullOrWhiteSpace(connStr))
{
return new DataTable();
}
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
SqlCommand cmd = GetSqlCommand(conn, strSQL, CommandType.Text, parameters);
SqlDataAdapter da = new SqlDataAdapter(cmd);
DataSet ds = new DataSet();
da.Fill(ds);
cmd.Dispose();
da.Dispose();
return ds.Tables[];
}
} #endregion #region " ExecSqlNonQuerry " /// <summary>
/// 执行非查询SQL语句
/// </summary>
/// <param name="strSQL">待执行SQL语句</param>
/// <returns>受影响的行数</returns>
public static int ExecSqlNonQuerry(string strSQL)
{
return ExecSqlNonQuerry(strSQL, null);
} /// <summary>
/// 执行非查询的带参数的SQL语句
/// </summary>
/// <param name="strSQL">待执行SQL语句</param>
/// <returns>受影响的行数</returns>
public static int ExecSqlNonQuerry(string strSQL, SqlParameter[] parameters)
{
return ExecSqlNonQuerry(strSQL, parameters, DefaultConnString);
} public static int ExecSqlNonQuerry(string strSQL, SqlParameter[] parameters, string connStr)
{
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
SqlCommand cmd = GetSqlCommand(conn, strSQL, CommandType.Text, parameters);
cmd.CommandTimeout = ;
int result = cmd.ExecuteNonQuery();
cmd.Dispose();
return result;
}
} #endregion #region " ExecSqlScalar " /// <summary>
/// 执行统计查询
/// </summary>
/// <param name="strSQL">待执行SQL语句</param>
/// <returns>执行结果的第1行第1列的值</returns>
public static object ExecSqlScalar(string strSQL)
{
return ExecSqlScalar(strSQL, null);
} /// <summary>
/// 执行带参数的统计查询
/// </summary>
/// <param name="strSQL">待执行SQL语句</param>
/// <param name="parameters">参数数组</param>
/// <returns>执行结果的第1行第1列的值</returns>
public static object ExecSqlScalar(string strSQL, SqlParameter[] parameters)
{
return ExecSqlScalar(strSQL, parameters, DefaultConnString);
} /// <summary>
/// 执行带参数的统计查询
/// </summary>
/// <param name="strSQL">待执行SQL语句</param>
/// <param name="parameters">参数数组</param>
/// <returns>执行结果的第1行第1列的值</returns>
public static object ExecSqlScalar(string strSQL, SqlParameter[] parameters, string connStr)
{
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
SqlCommand cmd = GetSqlCommand(conn, strSQL, CommandType.Text, parameters);
object result = cmd.ExecuteScalar();
cmd.Dispose();
return result;
}
} #endregion #region " ExecProcDataSet " /// <summary>
/// 执行存储过程，返回执行结果
/// </summary>
/// <param name="procName">待执行存储过程</param>
/// <returns>查询结果</returns>
public static DataSet ExecProcDataSet(string procName)
{
return ExecProcDataSet(procName, null);
}
/// <summary>
/// 执行带参数的存储过程，返回执行结果
/// </summary>
/// <param name="procName">待执行存储过程</param>
/// <param name="parameters">参数数组</param>
/// <returns>查询结果</returns>
public static DataSet ExecProcDataSet(string procName, SqlParameter[] parameters)
{
return ExecProcDataSet(procName, parameters, DefaultConnString);
} /// <summary>
/// 执行带参数的存储过程，返回执行结果
/// </summary>
/// <param name="procName">待执行存储过程</param>
/// <param name="parameters">参数数组</param>
/// <returns>查询结果</returns>
public static DataSet ExecProcDataSet(string procName, SqlParameter[] parameters, string connStr)
{
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
SqlCommand cmd = GetSqlCommand(conn, procName, CommandType.StoredProcedure, parameters);
cmd.CommandTimeout = ;
SqlDataAdapter da = new SqlDataAdapter(cmd);
DataSet ds = new DataSet();
da.Fill(ds);
cmd.Dispose();
return ds;
}
} #endregion #region " ExecProcDataTable " /// <summary>
/// 执行存储过程，返回执行结果
/// </summary>
/// <param name="procName">待执行存储过程</param>
/// <returns>查询结果</returns>
public static DataTable ExecProcDataTable(string procName)
{
return ExecProcDataSet(procName).Tables[];
}
/// <summary>
/// 执行带参数的存储过程，返回执行结果
/// </summary>
/// <param name="procName">待执行存储过程</param>
/// <param name="parameters">参数数组</param>
/// <returns>查询结果</returns>
public static DataTable ExecProcDataTable(string procName, SqlParameter[] parameters)
{
return ExecProcDataSet(procName, parameters).Tables[];
} public static DataTable ExecProcDataTable(string procName, SqlParameter[] parameters, string connStr)
{
return ExecProcDataSet(procName, parameters, connStr).Tables[];
} #endregion #region " ExecProcNonQuerry " /// <summary>
/// 执行非查询存储过程
/// </summary>
/// <param name="procName">待执行存储过程</param>
/// <returns>受影响的行数</returns>
public static int ExecProcNonQuerry(string procName)
{
return ExecProcNonQuerry(procName);
} /// <summary>
/// 执行非查询的带参数的存储过程
/// </summary>
/// <param name="procName">待执行存储过程</param>
/// <returns>受影响的行数</returns>
public static int ExecProcNonQuerry(string procName, SqlParameter[] parameters)
{
return ExecProcNonQuerry(procName, parameters, DefaultConnString);
} /// <summary>
/// 执行非查询的带参数的存储过程
/// </summary>
/// <param name="procName">待执行存储过程</param>
/// <returns>受影响的行数</returns>
public static int ExecProcNonQuerry(string procName, SqlParameter[] parameters, string connStr)
{
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
SqlCommand cmd = GetSqlCommand(conn, procName, CommandType.StoredProcedure, parameters);
int result = cmd.ExecuteNonQuery();
cmd.Dispose();
return result;
}
} #endregion #region " ExecSqlDataReader " /// <summary>
/// 执行SQL语句，返回执行结果
/// </summary>
/// <param name="strSQL">待执行SQL语句</param>
/// <returns>查询结果</returns>
public static SqlDataReader ExecSqlDataReader(string strSQL)
{
return ExecSqlDataReader(strSQL, null);
} /// <summary>
/// 执行带参数的SQL语句，返回执行结果
/// </summary>
/// <param name="strSQL">待执行SQL语句</param>
/// <param name="parameters">参数数组</param>
/// <returns>查询结果</returns>
public static SqlDataReader ExecSqlDataReader(string strSQL, SqlParameter[] parameters)
{
return ExecSqlDataReader(strSQL, parameters, DefaultConnString);
} /// <summary>
/// 执行带参数的SQL语句，返回执行结果
/// </summary>
/// <param name="strSQL">待执行SQL语句</param>
/// <param name="parameters">参数数组</param>
/// <returns>查询结果</returns>
public static SqlDataReader ExecSqlDataReader(string strSQL, SqlParameter[] parameters, string connStr)
{
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open();
SqlCommand cmd = GetSqlCommand(conn, strSQL, CommandType.Text, parameters);
SqlDataReader result = cmd.ExecuteReader(CommandBehavior.CloseConnection);
cmd.Dispose();
return result;
}
} #endregion #region " ExecProcDataReader " /// <summary>
/// 执行存储过程，返回执行结果
/// </summary>
/// <param name="procName">待执行存储过程</param>
/// <returns>查询结果</returns>
public static SqlDataReader ExecProcDataReader(string procName)
{
return ExecProcDataReader(procName, null);
} /// <summary>
/// 执行带参数的存储过程，返回执行结果
/// </summary>
/// <param name="procName">待执行存储过程</param>
/// <param name="parameters">参数数组</param>
/// <returns>查询结果</returns>
public static SqlDataReader ExecProcDataReader(string procName, SqlParameter[] parameters)
{
return ExecProcDataReader(procName, parameters, DefaultConnString);
} /// <summary>
/// 执行带参数的存储过程，返回执行结果
/// </summary>
/// <param name="procName">待执行存储过程</param>
/// <param name="parameters">参数数组</param>
/// <returns>查询结果</returns>
public static SqlDataReader ExecProcDataReader(string procName, SqlParameter[] parameters, string connStr)
{
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open(); SqlCommand cmd = GetSqlCommand(conn, procName, CommandType.StoredProcedure, parameters);
SqlDataReader result = cmd.ExecuteReader(CommandBehavior.CloseConnection);
cmd.Dispose();
return result;
}
} #endregion #region " DtToSqlServer " /// <summary>
/// 将DataTable批量导入SqlServer
/// </summary>
/// <param name="dtExcel">数据表</param>
/// <param name="tableName">目标数据表名</param>
/// <param name="dtColName">对应列的数据集</param>
public static void DtToSqlServer(DataTable dtExcel, string tableName, DataTable dtColName)
{
DtToSqlServer(dtExcel, tableName, dtColName, DefaultConnString);
} /// <summary>
/// 将DataTable批量导入SqlServer
/// </summary>
/// <param name="dtExcel">数据表</param>
/// <param name="tableName">目标数据表名</param>
/// <param name="dtColName">对应列的数据集</param>
public static void DtToSqlServer(DataTable dtExcel, string tableName, DataTable dtColName, string connStr)
{
using (SqlConnection conn = new SqlConnection(connStr))
{
conn.Open(); using (SqlBulkCopy bulkCopy = new SqlBulkCopy(conn))
{
try
{
bulkCopy.DestinationTableName = tableName;//要插入的表的表名
for (int i = ; i < dtColName.Rows.Count; i++)
{
bulkCopy.ColumnMappings.Add(dtColName.Rows[i][].ToString().Trim(), dtColName.Rows[i][].ToString().Trim()); } bulkCopy.WriteToServer(dtExcel);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
} #endregion #region
/// <summary>
///
/// </summary>
/// <param name="dbconfig">目标连接字符</param>
/// <param name="tablename">目标表</param>
/// <param name="dt">源数据</param>
public static string SqlBulkCopyByDatatable(string tablename, DataTable table, string connStr, SqlConnection m_clsSqlConn)
{
string dataBaseStr = "";
if (tablename.Contains("."))
{
dataBaseStr = tablename.Substring(, tablename.LastIndexOf(".") + );
tablename = tablename.Substring(tablename.LastIndexOf(".") + );
} try
{
string result = "";
SqlBulkCopy sqlBulkCopy = null;
if (m_clsSqlConn != null)
{
sqlBulkCopy = new SqlBulkCopy(m_clsSqlConn);
if (m_clsSqlConn.State == ConnectionState.Closed)
{
m_clsSqlConn.Open();
}
}
else
{
sqlBulkCopy = new SqlBulkCopy(connStr);
} sqlBulkCopy.DestinationTableName = dataBaseStr + ((tablename.IndexOf("[") > - && tablename.IndexOf("]") > -) ? tablename : "[" + tablename + "]");
sqlBulkCopy.BulkCopyTimeout = ;
//sqlBulkCopy.BatchSize = 800; for (int i = ; i < table.Columns.Count; i++)
{
sqlBulkCopy.ColumnMappings.Add(table.Columns[i].ColumnName, table.Columns[i].ColumnName);
} if (table.Rows.Count > )
{
sqlBulkCopy.WriteToServer(table);
}
else
{
result = "表为空";
} sqlBulkCopy.Close();
return result;
}
catch (Exception e)
{
return e.Message;
}
finally
{
try
{
if (m_clsSqlConn != null)
{ try
{
if (m_clsSqlConn.State == ConnectionState.Open)
{
m_clsSqlConn.Close();
}
}
catch (Exception)
{ }
}
}
catch (Exception)
{ }
}
} public static string SqlBulkCopyByDatatable(string tablename, DataTable table, SqlConnection m_clsSqlConn)
{
return SqlBulkCopyByDatatable(tablename, table, string.Empty, m_clsSqlConn); }
public static string SqlBulkCopyByDatatable(string tablename, DataTable table, string connStr)
{
return SqlBulkCopyByDatatable(tablename, table, connStr, null);
} public static string SqlBulkCopyByDatatable(string tablename, DataTable table)
{
return SqlBulkCopyByDatatable(tablename, table, DefaultConnString, null);
} public static string CreateTempTable(string tablename, DataTable table, string connStr)
{
return CreateTempTable(tablename, table, new SqlConnection(connStr));
}
public static string CreateTempTable(string tablename, DataTable table, SqlConnection connStr)
{
try
{ string sqlstr = "CREATE TABLE [" + tablename + "](";
for (int i = ; i < table.Columns.Count; i++)
{
switch (table.Columns[i].DataType.FullName)
{
case "System.String":
{
sqlstr += "[" + table.Columns[i].ColumnName + "] [nvarchar](4000) NULL,";
}
break;
case "System.Int32":
{
sqlstr += "[" + table.Columns[i].ColumnName + "] [int] NULL,";
}
break;
case "System.Double":
{
sqlstr += "[" + table.Columns[i].ColumnName + "] [numeric](24,2) NULL,";
}
break;
case "System.DateTime":
{
sqlstr += "[" + table.Columns[i].ColumnName + "] [datetime] NULL,";
}
break;
default:
{
sqlstr += "[" + table.Columns[i].ColumnName + "] [nvarchar](4000) NULL,";
}
break;
}
}
sqlstr = sqlstr.Substring(, sqlstr.Length - ) + ")"; if (connStr.State != ConnectionState.Open)
{
connStr.Open();
} SqlCommand cmd = GetSqlCommand(connStr, sqlstr, CommandType.Text, null);
int result = cmd.ExecuteNonQuery();
cmd.Dispose();
return "";
}
catch (Exception e)
{
return e.ToString();
}
} #endregion }
SqlServer DbHelper的更多相关文章
- 通用权限底层研究：Web应用限制IP访问的功能实现
如果你的web应用受到恶意扫描或攻击,你会怎么处理呢?大多数时候从应用日志里可以看到恶意扫描或攻击,遇到此类情况,如有一个可以进行IP访问控制的功能就好些了. 现将在MVC下实现的一个IP访问限制功能 ...
- 通用超级强大的基于Oracle数据库的代码生成器
项目中使用了Oracle数据库,命名基本规范为表名和字段名全部大写,用下划线分割各个单词: 如“BASE_USER_LOGON_EXTEND”这个表表示用户登录的扩展表. 基于这个规范,通用权限管理系 ...
- using System.Reflection;
基础代码: public interface IDBHelper { void Query(); } public class DBHelper : IDBHelper { public int Id ...
- Reflect（反射）
反射.反射,程序员的快乐.反射是无处不在的. 那么什么是反射:通过反射,可以在运行时获得程序或程序集中每一个类型(包括类.结构.委托.接口和枚举等)的成员和成员的信息.有了反射,即可对每一个类型了如指 ...
- 第六节：反射（几种写法、好处和弊端、利用反射实现IOC）
一. 加载dll,读取相关信息 1. 加载程序集的三种方式 调用Assembly类下的三个方法:Load.LoadFile.LoadFrom. //1.1 Load方法:动态默认加载当前路径下的(bi ...
- 使用Code First建模自引用关系笔记 asp.net core上使用redis探索(1) asp.net mvc控制器激活全分析 语言入门必学的基础知识你还记得么？ 反射
使用Code First建模自引用关系笔记 原文链接 一.Has方法: A.HasRequired(a => a.B); HasOptional:前者包含后者一个实例或者为null HasR ...
- C# 反射简单介绍
原文:https://blog.csdn.net/wu1020300665/article/details/82958455 1.什么是反射 反射是.NET中的重要机制,通过反射,可以在运行时获得程序 ...
- 兼容SQLSERVER、Oracle、MYSQL、SQLITE的超级DBHelper
本示例代码的关键是利用.net库自带的DbProviderFactory来生产数据库操作对象. 从下图中,可以看到其的多个核心方法,这些方法将在我们的超级DBHelper中使用. 仔细研究,你会发现每 ...
- {T4模板}C# Net MVC+SqlServer=T4模板生成实体类并操作数据(DbHelper+DBManage)
1.ConnectionString,数据库链接 Web.config <configuration> <connectionStrings> <!-- 数据库 SQL ...
随机推荐
- Python 四大主流 Web 编程框架
Python 四大主流 Web 编程框架 目前Python的网络编程框架已经多达几十个,逐个学习它们显然不现实.但这些框架在系统架构和运行环境中有很多共通之处,本文带领读者学习基于Python网络框架 ...
- 使用 RxJava 进行嵌套串行网络请求的一种方法
需求 有这样一个列表数据,它包含了商店+订单的信息,获取订单列表时,订单实体中会包含商店的 ID,而列表显示时需要商店的名称和 logo,这时候就需要进行嵌套串行网络请求了. 关键词 flatMap ...
- alluxio源码解析-层次化存储(4)
层次化存储-特性介绍: https://www.alluxio.org/docs/1.6/cn/Tiered-Storage-on-Alluxio.html 引入分层存储后,Alluxio管理的数据块 ...
- LSTM+CRF维特比解码过程
题目:给定长度为n的序列,标签数为m(标签值表示为1,2,....,m),发射概率矩阵E(n * m),其中E[i][j]表示第i个词预测为标签j的发射概率,转移概率矩阵T(m*m),其中T[i][j ...
- 前端小知识-html5
一.伪类与伪元素 为什么css要引入伪元素和伪类:是为了格式化文档树以外的信息,也就是说,伪类和伪元素是用来修饰不在文档树中的部分 伪类用于当已有元素处于的某个状态时,为其添加对应的样式,这个状态是根 ...
- C语言编程入门之--第五章C语言基本运算和表达式-part3
5.3 挑几个运算符来讲 常用的运算符除了加减乘除(+-*/)外,还有如下: 注意:以下运算符之间用逗号隔开,C语言中也有逗号运算符,这里不讲逗号运算符. 1. 赋值运算符 =,+=,*= 2. 一 ...
- SpringBoot 配置 AOP 打印日志
在项目开发中,日志系统是必不可少的,用AOP在Web的请求做入参和出参的参数打印,同时对异常进行日志打印,避免重复的手写日志,完整案例见文末源码. 一.Spring AOP AOP(Aspect-Or ...
- rabbitmq生产者的消息确认
通过Publisher Confirms and Returns机制,生产者可以判断消息是否发送到了exchange及queue,而通过消费者确认机制,Rabbitmq可以决定是否重发消息给消费者,以 ...
- spring security中@PreAuthorize注解的使用
添加依赖<!-- oauth --><dependency> <groupId>org.springframework.cloud</groupId> ...
- Python笔记_类
1.类 1.1 类的定义 # 类的定义 class 类名: pass # pass是空语句,不具有任何意义,仅为了保持程序结构完整性 # 创建对象 对象名 = 类名() 1.2 成员变量 # 成员变量 ...