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 ...
随机推荐
- cogs 1254. 最难的任务 Dijkstra + 重边处理
1254. 最难的任务 ★ 输入文件:hardest.in 输出文件:hardest.out 简单对比时间限制:1 s 内存限制:128 MB [题目描述] 这个真的很难.算出 123 ...
- Caffeine Cache-高性能Java本地缓存组件
前面刚说到Guava Cache,他的优点是封装了get,put操作:提供线程安全的缓存操作:提供过期策略:提供回收策略:缓存监控.当缓存的数据超过最大值时,使用LRU算法替换.这一篇我们将要谈到一个 ...
- jmh源码解析-整体架构
我理解的jmh运行架构图 生成字节码,字节码负责维护测试的状态和调用被测试的方法 默认在fork的进程中进行测试,可以配置多个fork进程,以减少误差 通过线程池,提交每个迭代的测试任务,任务执行后, ...
- Java 安全之：csrf攻击总结
最近在维护一些老项目,调试时发现请求屡屡被拒绝,仔细看了一下项目的源码,发现有csrf token校验,借这个机会把csrf攻击学习了一下,总结成文.本文主要总结什么是csrf攻击以及有哪些方法来防范 ...
- linux下实现并发逻辑
################shell 模拟实现并发跑数#################有时候我们知道一些程序是可以同时跑的,互不影响,为了提高效率不得不使用并发跑脚本 #1.思路一我们都知道在 ...
- 整合-flowable-modeler，第一篇
BPMN流程想必大家都不陌生,经过这十几年的不断发展完善,在处理业务流程操作已经相当完善,我这里先不进行流程引擎的具体描述,单对集成流程设计器这块进行笔记,如有不对,跪求指出.
- 搭建nuget 服务器
前言 搭建nuget服务器,这是上家公司进行类库管理的方式,其实优点很明显, 1.代码保密 2.代码重复利用效率高,这样不管任何项目只要知道nuget服务器地址就能直接调用 3.可进行版本任意切换提高 ...
- Memcached的原理分析与配置
一.Why Memcached? • 高并发访问数据库的痛楚:死锁! • 硬盘IO之痛:本机:AspNet:HttpRuntime.Cache • 多客户端共享缓存 • Net+Memory>& ...
- 一文了解Python常见的序列化操作
关于我 一个有思想的程序猿,终身学习实践者,目前在一个创业团队任team lead,技术栈涉及Android.Python.Java和Go,这个也是我们团队的主要技术栈. Github:https:/ ...
- Web前端和Web后端的区分
版权声明:本文为CSDN博主「十豆三展」的原创文章,遵循CC 4.0 by-sa版权协议,转载请附上原文出处链接及本声明.原文链接:https://blog.csdn.net/zz1399590022 ...