本文转自:http://www.cnblogs.com/lzrabbit/p/3287155.html

自用的SQLHelper和MySqlHelper,除一些通用方法外,封装了一些很实用的批量操作方法,简单介绍下

SqlHelper

  • ExecuteEmptyDataTable 获取空表结构,主要用于需要构造DataTable进行大批量数据插入时使用
  • BulkInsert 大批量数据插入,使用SqlBulkCopy进行大批量数据导入,仅提供了DataTable方式,需要DataReader的请自行重载
  • BatchUpdate 批量数据更新、插入,使用SqlDataAdapter实现,需要进行较大数据量更新、插入时可以使用此方法,性能还不错
  • BatchUpdate,BatchDelete 分批次批量删除、更新数据,此方法应用场景较少,用于需要删除、更新大量数据的同时不造成数据库阻塞且不影响数据库订阅、复制延时等
  • ExecutePageDataTable 通用的分页方法,提供了CTE表达式的支持
  • SqlHelperExtension.cs(ExecuteObject、ExecuteObjects) 提供了泛型获取对象方法支持,依赖依赖AutoMapper.dll实现,非常在意性能的慎用
  • SqlHelperSchemaExtension.cs SqlServer获取数据库、表、索引信息的封装,可以用来辅助写自己的代码生成器,查看数据库索引之类的

MySqlHelper

  • ExecuteEmptyDataTable 获取空表结构,主要用于需要构造DataTable进行大批量数据插入时使用
  • BulkInsert 使用MySqlBulkLoader进行大批量数据导入,仅提供了DataTable方式,需要DataReader的请自行重载
  • BatchUpdate 批量数据更新、插入,使用MySqlDataAdapter实现,需要进行较大数据量更新、插入时可以使用此方法,性能还不错
  • MySqlHelperExtension.csExecuteObject、ExecuteObjects 提供了泛型获取对象方法支持,依赖依赖AutoMapper.dll实现,非常在意性能的慎用
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
using System.Data;
using System.Text.RegularExpressions; namespace Helpers
{
/// <summary>
/// SqlHelper操作类
/// </summary>
public sealed partial class SqlHelper
{
/// <summary>
/// 批量操作每批次记录数
/// </summary>
public static int BatchSize = 2000; /// <summary>
/// 超时时间
/// </summary>
public static int CommandTimeOut = 600; /// <summary>
///初始化SqlHelper实例
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
public SqlHelper(string connectionString)
{
this.ConnectionString = connectionString;
} /// <summary>
/// 数据库连接字符串
/// </summary>
public string ConnectionString { get; set; } #region 实例方法 #region ExecuteNonQuery /// <summary>
/// 执行SQL语句,返回影响的行数
/// </summary>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回影响的行数</returns>
public int ExecuteNonQuery(string commandText, params SqlParameter[] parms)
{
return ExecuteNonQuery(ConnectionString, CommandType.Text, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回影响的行数
/// </summary>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回影响的行数</returns>
public int ExecuteNonQuery(CommandType commandType, string commandText, params SqlParameter[] parms)
{
return ExecuteNonQuery(ConnectionString, commandType, commandText, parms);
} #endregion ExecuteNonQuery #region ExecuteScalar /// <summary>
/// 执行SQL语句,返回结果集中的第一行第一列
/// </summary>
/// <typeparam name="T">返回对象类型</typeparam>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行第一列</returns>
public T ExecuteScalar<T>(string commandText, params SqlParameter[] parms)
{
return ExecuteScalar<T>(ConnectionString, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行第一列
/// </summary>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行第一列</returns>
public object ExecuteScalar(string commandText, params SqlParameter[] parms)
{
return ExecuteScalar(ConnectionString, CommandType.Text, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行第一列
/// </summary>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行第一列</returns>
public object ExecuteScalar(CommandType commandType, string commandText, params SqlParameter[] parms)
{
return ExecuteScalar(ConnectionString, commandType, commandText, parms);
} #endregion ExecuteScalar #region ExecuteDataReader /// <summary>
/// 执行SQL语句,返回只读数据集
/// </summary>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回只读数据集</returns>
private SqlDataReader ExecuteDataReader(string commandText, params SqlParameter[] parms)
{
return ExecuteDataReader(ConnectionString, CommandType.Text, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回只读数据集
/// </summary>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回只读数据集</returns>
private SqlDataReader ExecuteDataReader(CommandType commandType, string commandText, params SqlParameter[] parms)
{
return ExecuteDataReader(ConnectionString, commandType, commandText, parms);
}
#endregion #region ExecuteDataRow /// <summary>
/// 执行SQL语句,返回结果集中的第一行
/// </summary>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行</returns>
public DataRow ExecuteDataRow(string commandText, params SqlParameter[] parms)
{
return ExecuteDataRow(ConnectionString, CommandType.Text, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行
/// </summary>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行</returns>
public DataRow ExecuteDataRow(CommandType commandType, string commandText, params SqlParameter[] parms)
{
return ExecuteDataRow(ConnectionString, commandType, commandText, parms);
} #endregion ExecuteDataRow #region ExecuteDataTable /// <summary>
/// 执行SQL语句,返回结果集中的第一个数据表
/// </summary>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一个数据表</returns>
public DataTable ExecuteDataTable(string commandText, params SqlParameter[] parms)
{
return ExecuteDataTable(ConnectionString, CommandType.Text, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集中的第一个数据表
/// </summary>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一个数据表</returns>
public DataTable ExecuteDataTable(CommandType commandType, string commandText, params SqlParameter[] parms)
{
return ExecuteDataSet(ConnectionString, commandType, commandText, parms).Tables[0];
} /// <summary>
/// 执行SQL语句,返回结果集中的第一个数据表
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="order">排序SQL,如"ORDER BY ID DESC"</param>
/// <param name="pageSize">每页记录数</param>
/// <param name="pageIndex">页索引</param>
/// <param name="parms">查询参数</param>
/// <param name="query">查询SQL</param>
/// <returns></returns>
public DataTable ExecutePageDataTable(string sql, string order, int pageSize, int pageIndex, SqlParameter[] parms = null, string query = null, string cte = null)
{
return ExecutePageDataTable(sql, order, pageSize, pageIndex, parms, query, cte);
}
#endregion ExecuteDataTable #region ExecuteDataSet /// <summary>
/// 执行SQL语句,返回结果集
/// </summary>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集</returns>
public DataSet ExecuteDataSet(string commandText, params SqlParameter[] parms)
{
return ExecuteDataSet(ConnectionString, CommandType.Text, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集
/// </summary>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集</returns>
public DataSet ExecuteDataSet(CommandType commandType, string commandText, params SqlParameter[] parms)
{
return ExecuteDataSet(ConnectionString, commandType, commandText, parms);
} #endregion ExecuteDataSet #region 批量操作 /// <summary>
/// 大批量数据插入
/// </summary>
/// <param name="table">数据表</param>
public void BulkInsert(DataTable table)
{
BulkInsert(ConnectionString, table);
} /// <summary>
/// 使用MySqlDataAdapter批量更新数据
/// </summary>
/// <param name="table">数据表</param>
public void BatchUpdate(DataTable table)
{
BatchUpdate(ConnectionString, table);
} /// <summary>
/// 分批次批量删除数据
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="batchSize">每批次删除记录行数</param>
/// <param name="interval">批次执行间隔(秒)</param>
public void BatchDelete(string sql, int batchSize = 1000, int interval = 1)
{
BatchDelete(ConnectionString, sql, batchSize, interval);
} /// <summary>
/// 分批次批量更新数据
/// </summary>
/// <param name="sql">SQL语句</param>
/// <param name="batchSize">每批次更新记录行数</param>
/// <param name="interval">批次执行间隔(秒)</param>
public void BatchUpdate(string sql, int batchSize = 1000, int interval = 1)
{
BatchUpdate(ConnectionString, sql, batchSize, interval);
} #endregion 批量操作 #endregion 实例方法 #region 静态方法 private static void PrepareCommand(SqlCommand command, SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] parms)
{
if (connection.State != ConnectionState.Open) connection.Open(); command.Connection = connection;
command.CommandTimeout = CommandTimeOut;
// 设置命令文本(存储过程名或SQL语句)
command.CommandText = commandText;
// 分配事务
if (transaction != null)
{
command.Transaction = transaction;
}
// 设置命令类型.
command.CommandType = commandType;
if (parms != null && parms.Length > 0)
{
//预处理SqlParameter参数数组,将为NULL的参数赋值为DBNull.Value;
foreach (SqlParameter parameter in parms)
{
if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) && (parameter.Value == null))
{
parameter.Value = DBNull.Value;
}
}
command.Parameters.AddRange(parms);
}
} #region ExecuteNonQuery /// <summary>
/// 执行SQL语句,返回影响的行数
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回影响的行数</returns>
public static int ExecuteNonQuery(string connectionString, string commandText, params SqlParameter[] parms)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
return ExecuteNonQuery(connection, CommandType.Text, commandText, parms);
}
} /// <summary>
/// 执行SQL语句,返回影响的行数
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回影响的行数</returns>
public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params SqlParameter[] parms)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
return ExecuteNonQuery(connection, commandType, commandText, parms);
}
} /// <summary>
/// 执行SQL语句,返回影响的行数
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回影响的行数</returns>
public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] parms)
{
return ExecuteNonQuery(connection, null, commandType, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回影响的行数
/// </summary>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回影响的行数</returns>
public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
{
return ExecuteNonQuery(transaction.Connection, transaction, commandType, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回影响的行数
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回影响的行数</returns>
private static int ExecuteNonQuery(SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
{
SqlCommand command = new SqlCommand();
PrepareCommand(command, connection, transaction, commandType, commandText, parms);
int retval = command.ExecuteNonQuery();
command.Parameters.Clear();
return retval;
} #endregion ExecuteNonQuery #region ExecuteScalar /// <summary>
/// 执行SQL语句,返回结果集中的第一行第一列
/// </summary>
/// <typeparam name="T">返回对象类型</typeparam>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行第一列</returns>
public static T ExecuteScalar<T>(string connectionString, string commandText, params SqlParameter[] parms)
{
object result = ExecuteScalar(connectionString, commandText, parms);
if (result != null)
{
return (T)Convert.ChangeType(result, typeof(T)); ;
}
return default(T);
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行第一列
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行第一列</returns>
public static object ExecuteScalar(string connectionString, string commandText, params SqlParameter[] parms)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
return ExecuteScalar(connection, CommandType.Text, commandText, parms);
}
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行第一列
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行第一列</returns>
public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params SqlParameter[] parms)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
return ExecuteScalar(connection, commandType, commandText, parms);
}
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行第一列
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行第一列</returns>
public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] parms)
{
return ExecuteScalar(connection, null, commandType, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行第一列
/// </summary>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行第一列</returns>
public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
{
return ExecuteScalar(transaction.Connection, transaction, commandType, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行第一列
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行第一列</returns>
private static object ExecuteScalar(SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
{
SqlCommand command = new SqlCommand();
PrepareCommand(command, connection, transaction, commandType, commandText, parms);
object retval = command.ExecuteScalar();
command.Parameters.Clear();
return retval;
} #endregion ExecuteScalar #region ExecuteDataReader /// <summary>
/// 执行SQL语句,返回只读数据集
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回只读数据集</returns>
private static SqlDataReader ExecuteDataReader(string connectionString, string commandText, params SqlParameter[] parms)
{
SqlConnection connection = new SqlConnection(connectionString);
return ExecuteDataReader(connection, null, CommandType.Text, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回只读数据集
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回只读数据集</returns>
private static SqlDataReader ExecuteDataReader(string connectionString, CommandType commandType, string commandText, params SqlParameter[] parms)
{
SqlConnection connection = new SqlConnection(connectionString);
return ExecuteDataReader(connection, null, commandType, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回只读数据集
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回只读数据集</returns>
private static SqlDataReader ExecuteDataReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] parms)
{
return ExecuteDataReader(connection, null, commandType, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回只读数据集
/// </summary>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回只读数据集</returns>
private static SqlDataReader ExecuteDataReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
{
return ExecuteDataReader(transaction.Connection, transaction, commandType, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回只读数据集
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回只读数据集</returns>
private static SqlDataReader ExecuteDataReader(SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
{
SqlCommand command = new SqlCommand();
PrepareCommand(command, connection, transaction, commandType, commandText, parms);
return command.ExecuteReader(CommandBehavior.CloseConnection);
} #endregion #region ExecuteDataRow /// <summary>
/// 执行SQL语句,返回结果集中的第一行
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>,返回结果集中的第一行</returns>
public static DataRow ExecuteDataRow(string connectionString, string commandText, params SqlParameter[] parms)
{
DataTable dt = ExecuteDataTable(connectionString, CommandType.Text, commandText, parms);
return dt.Rows.Count > 0 ? dt.Rows[0] : null;
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>,返回结果集中的第一行</returns>
public static DataRow ExecuteDataRow(string connectionString, CommandType commandType, string commandText, params SqlParameter[] parms)
{
DataTable dt = ExecuteDataTable(connectionString, commandType, commandText, parms);
return dt.Rows.Count > 0 ? dt.Rows[0] : null;
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>,返回结果集中的第一行</returns>
public static DataRow ExecuteDataRow(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] parms)
{
DataTable dt = ExecuteDataTable(connection, commandType, commandText, parms);
return dt.Rows.Count > 0 ? dt.Rows[0] : null;
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行
/// </summary>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>,返回结果集中的第一行</returns>
public static DataRow ExecuteDataRow(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
{
DataTable dt = ExecuteDataTable(transaction, commandType, commandText, parms);
return dt.Rows.Count > 0 ? dt.Rows[0] : null;
} #endregion ExecuteDataRow #region ExecuteDataTable /// <summary>
/// 执行SQL语句,返回结果集中的第一个数据表
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一个数据表</returns>
public static DataTable ExecuteDataTable(string connectionString, string commandText, params SqlParameter[] parms)
{
return ExecuteDataSet(connectionString, CommandType.Text, commandText, parms).Tables[0];
} /// <summary>
/// 执行SQL语句,返回结果集中的第一个数据表
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一个数据表</returns>
public static DataTable ExecuteDataTable(string connectionString, CommandType commandType, string commandText, params SqlParameter[] parms)
{
return ExecuteDataSet(connectionString, commandType, commandText, parms).Tables[0];
} /// <summary>
/// 执行SQL语句,返回结果集中的第一个数据表
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一个数据表</returns>
public static DataTable ExecuteDataTable(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] parms)
{
return ExecuteDataSet(connection, commandType, commandText, parms).Tables[0];
} /// <summary>
/// 执行SQL语句,返回结果集中的第一个数据表
/// </summary>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一个数据表</returns>
public static DataTable ExecuteDataTable(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
{
return ExecuteDataSet(transaction, commandType, commandText, parms).Tables[0];
} /// <summary>
/// 获取空表结构
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="tableName">数据表名称</param>
/// <returns>返回结果集中的第一个数据表</returns>
public static DataTable ExecuteEmptyDataTable(string connectionString, string tableName)
{
return ExecuteDataSet(connectionString, CommandType.Text, string.Format("select * from {0} where 1=-1", tableName)).Tables[0];
} /// <summary>
/// 执行SQL语句,返回结果集中的第一个数据表
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="sql">SQL语句</param>
/// <param name="order">排序SQL,如"ORDER BY ID DESC"</param>
/// <param name="pageSize">每页记录数</param>
/// <param name="pageIndex">页索引</param>
/// <param name="parms">查询参数</param>
/// <param name="query">查询SQL</param>
/// <param name="cte">CTE表达式</param>
/// <returns></returns>
public static DataTable ExecutePageDataTable(string connectionString, string sql, string order, int pageSize, int pageIndex, SqlParameter[] parms = null, string query = null, string cte = null)
{
string psql = string.Format(@"
{3}
SELECT *
FROM (
SELECT ROW_NUMBER() OVER (ORDER BY {1}) RowNumber,*
FROM (
{0}
) t
WHERE 1 = 1 {2}
) t
WHERE RowNumber BETWEEN @RowNumber_Begin
AND @RowNumber_End", sql, order, query, cte); List<SqlParameter> paramlist = new List<SqlParameter>()
{
new SqlParameter("@RowNumber_Begin", SqlDbType.Int){ Value = (pageIndex - 1) * pageSize + 1 },
new SqlParameter("@RowNumber_End", SqlDbType.Int){ Value = pageIndex * pageSize }
};
if (parms != null) paramlist.AddRange(parms);
return ExecuteDataTable(connectionString, psql, paramlist.ToArray());
} #endregion ExecuteDataTable #region ExecuteDataSet /// <summary>
/// 执行SQL语句,返回结果集
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集</returns>
public static DataSet ExecuteDataSet(string connectionString, string commandText, params SqlParameter[] parms)
{
return ExecuteDataSet(connectionString, CommandType.Text, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集</returns>
public static DataSet ExecuteDataSet(string connectionString, CommandType commandType, string commandText, params SqlParameter[] parms)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
return ExecuteDataSet(connection, commandType, commandText, parms);
}
} /// <summary>
/// 执行SQL语句,返回结果集
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集</returns>
public static DataSet ExecuteDataSet(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] parms)
{
return ExecuteDataSet(connection, null, commandType, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集
/// </summary>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集</returns>
public static DataSet ExecuteDataSet(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
{
return ExecuteDataSet(transaction.Connection, transaction, commandType, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集</returns>
private static DataSet ExecuteDataSet(SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] parms)
{
SqlCommand command = new SqlCommand(); PrepareCommand(command, connection, transaction, commandType, commandText, parms);
SqlDataAdapter adapter = new SqlDataAdapter(command); DataSet ds = new DataSet();
adapter.Fill(ds);
if (commandText.IndexOf("@") > 0)
{
commandText = commandText.ToLower();
int index = commandText.IndexOf("where ");
if (index < 0)
{
index = commandText.IndexOf("\nwhere");
}
if (index > 0)
{
ds.ExtendedProperties.Add("SQL", commandText.Substring(0, index - 1)); //将获取的语句保存在表的一个附属数组里,方便更新时生成CommandBuilder
}
else
{
ds.ExtendedProperties.Add("SQL", commandText); //将获取的语句保存在表的一个附属数组里,方便更新时生成CommandBuilder
}
}
else
{
ds.ExtendedProperties.Add("SQL", commandText); //将获取的语句保存在表的一个附属数组里,方便更新时生成CommandBuilder
} foreach (DataTable dt in ds.Tables)
{
dt.ExtendedProperties.Add("SQL", ds.ExtendedProperties["SQL"]);
} command.Parameters.Clear();
return ds;
} #endregion ExecuteDataSet #region 批量操作 /// <summary>
/// 大批量数据插入
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="table">数据表</param>
public static void BulkInsert(string connectionString, DataTable table)
{
if (string.IsNullOrEmpty(table.TableName)) throw new Exception("DataTable.TableName属性不能为空");
using (SqlBulkCopy bulk = new SqlBulkCopy(connectionString))
{
bulk.BatchSize = BatchSize;
bulk.BulkCopyTimeout = CommandTimeOut;
bulk.DestinationTableName = table.TableName;
foreach (DataColumn col in table.Columns)
{
bulk.ColumnMappings.Add(col.ColumnName, col.ColumnName);
}
bulk.WriteToServer(table);
bulk.Close();
}
} /// <summary>
/// 使用MySqlDataAdapter批量更新数据
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="table">数据表</param>
public static void BatchUpdate(string connectionString, DataTable table)
{
SqlConnection connection = new SqlConnection(connectionString); SqlCommand command = connection.CreateCommand();
command.CommandTimeout = CommandTimeOut;
command.CommandType = CommandType.Text;
SqlDataAdapter adapter = new SqlDataAdapter(command);
SqlCommandBuilder commandBulider = new SqlCommandBuilder(adapter);
commandBulider.ConflictOption = ConflictOption.OverwriteChanges; SqlTransaction transaction = null;
try
{
connection.Open();
transaction = connection.BeginTransaction();
//设置批量更新的每次处理条数
adapter.UpdateBatchSize = BatchSize;
//设置事物
adapter.SelectCommand.Transaction = transaction; if (table.ExtendedProperties["SQL"] != null)
{
adapter.SelectCommand.CommandText = table.ExtendedProperties["SQL"].ToString();
}
adapter.Update(table);
transaction.Commit();/////提交事务
}
catch (SqlException ex)
{
if (transaction != null) transaction.Rollback();
throw ex;
}
finally
{
connection.Close();
connection.Dispose();
}
} /// <summary>
/// 分批次批量删除数据
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="sql">SQL语句</param>
/// <param name="batchSize">每批次更新记录行数</param>
/// <param name="interval">批次执行间隔(秒)</param>
public static void BatchDelete(string connectionString, string sql, int batchSize = 1000, int interval = 1)
{
sql = sql.ToLower(); if (batchSize < 1000) batchSize = 1000;
if (interval < 1) interval = 1;
while (ExecuteScalar(connectionString, sql.Replace("delete", "select top 1 1")) != null)
{
ExecuteNonQuery(connectionString, CommandType.Text, sql.Replace("delete", string.Format("delete top ({0})", batchSize)));
System.Threading.Thread.Sleep(interval * 1000);
}
} /// <summary>
/// 分批次批量更新数据
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="sql">SQL语句</param>
/// <param name="batchSize">每批次更新记录行数</param>
/// <param name="interval">批次执行间隔(秒)</param>
public static void BatchUpdate(string connectionString, string sql, int batchSize = 1000, int interval = 1)
{
if (batchSize < 1000) batchSize = 1000;
if (interval < 1) interval = 1;
string existsSql = Regex.Replace(sql, @"[\w\s.=,']*from", "select top 1 1 from", RegexOptions.IgnoreCase);
existsSql = Regex.Replace(existsSql, @"set[\w\s.=,']* where", "where", RegexOptions.IgnoreCase);
existsSql = Regex.Replace(existsSql, @"update", "select top 1 1 from", RegexOptions.IgnoreCase);
while (ExecuteScalar<int>(connectionString, existsSql) != 0)
{
ExecuteNonQuery(connectionString, CommandType.Text, Regex.Replace(sql, "update", string.Format("update top ({0})", batchSize), RegexOptions.IgnoreCase));
System.Threading.Thread.Sleep(interval * 1000);
}
} #endregion 批量操作 #endregion 静态方法
}
}

SqlHelper.cs

using System;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Collections.Generic;
using System.Threading;
using System.Text.RegularExpressions;
namespace Helpers
{
/// <summary>
/// SqlHelper扩展(依赖AutoMapper.dll)
/// </summary>
public sealed partial class SqlHelper
{ #region 实例方法 public T ExecuteObject<T>(string commandText, params SqlParameter[] parms)
{
return ExecuteObject<T>(this.ConnectionString, commandText, parms);
} public List<T> ExecuteObjects<T>(string commandText, params SqlParameter[] parms)
{
return ExecuteObjects<T>(this.ConnectionString, commandText, parms);
} #endregion #region 静态方法 public static T ExecuteObject<T>(string connectionString, string commandText, params SqlParameter[] parms)
{
//DataTable dt = ExecuteDataTable(connectionString, commandText, parms);
//return AutoMapper.Mapper.DynamicMap<List<T>>(dt.CreateDataReader()).FirstOrDefault();
using (SqlDataReader reader = ExecuteDataReader(connectionString, commandText, parms))
{
return AutoMapper.Mapper.DynamicMap<List<T>>(reader).FirstOrDefault();
}
} public static List<T> ExecuteObjects<T>(string connectionString, string commandText, params SqlParameter[] parms)
{
//DataTable dt = ExecuteDataTable(connectionString, commandText, parms);
//return AutoMapper.Mapper.DynamicMap<List<T>>(dt.CreateDataReader());
using (SqlDataReader reader = ExecuteDataReader(connectionString, commandText, parms))
{
return AutoMapper.Mapper.DynamicMap<List<T>>(reader);
}
} #endregion
} }

SqlHelperExtension.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SqlClient; namespace Helpers
{
public sealed partial class SqlHelper
{
#region Schema 数据库结构
/// <summary>
/// 执行指定数据库连接字符串的命令,返回服务器数据库名称数组
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <returns></returns>
public string[] GetDatabases(string connectionString)
{
string sql = "select name from sys.databases where name not in ('master','model','msdb','tempdb')";
DataTable dt = ExecuteDataTable(connectionString, sql);
return dt.Rows.Cast<DataRow>().Select(row => row["name"].ToString()).ToArray();
}
/// <summary>
/// 执行指定数据库连接字符串的命令,返回指定数据库的表信息
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="database"></param>
/// <returns></returns>
public List<DbTable> GetDbTables(string connectionString, string database)
{
#region SQL
string sql = string.Format(@"SELECT
obj.name tablename,
schem.name schemname,
idx.rows,
CAST
(
CASE
WHEN (SELECT COUNT(1) FROM sys.indexes WHERE object_id= obj.OBJECT_ID AND is_primary_key=1) >=1 THEN 1
ELSE 0
END
AS BIT) HasPrimaryKey
from {0}.sys.objects obj
inner join {0}.dbo.sysindexes idx on obj.object_id=idx.id and idx.indid<=1
INNER JOIN {0}.sys.schemas schem ON obj.schema_id=schem.schema_id
where type='U'
order by obj.name", database);
#endregion
DataTable dt = ExecuteDataTable(connectionString.Replace("master", database), sql);
return dt.Rows.Cast<DataRow>().Select(row => new DbTable
{
TableName = row.Field<string>("tablename"),
SchemaName = row.Field<string>("schemname"),
Rows = row.Field<int>("rows"),
HasPrimaryKey = row.Field<bool>("HasPrimaryKey")
}).ToList();
}
/// <summary>
/// 执行指定数据库连接字符串的命令,返回指定数据库、表的字段信息
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="database"></param>
/// <param name="tableName"></param>
/// <param name="schema"></param>
/// <returns></returns>
public List<DbColumn> GetDbColumns(string connectionString, string database, string tableName, string schema = "dbo")
{
#region SQL
string sql = string.Format(@"
WITH indexCTE AS
(
SELECT
ic.column_id,
ic.index_column_id,
ic.object_id
FROM {0}.sys.indexes idx
INNER JOIN {0}.sys.index_columns ic ON idx.index_id = ic.index_id AND idx.object_id = ic.object_id
WHERE idx.object_id =OBJECT_ID(@tableName) AND idx.is_primary_key=1
)
select
colm.column_id ColumnID,
CAST(CASE WHEN indexCTE.column_id IS NULL THEN 0 ELSE 1 END AS BIT) IsPrimaryKey,
colm.name ColumnName,
systype.name ColumnType,
colm.is_identity IsIdentity,
colm.is_nullable IsNullable,
cast(colm.max_length as int) ByteLength,
(
case
when systype.name='nvarchar' and colm.max_length>0 then colm.max_length/2
when systype.name='nchar' and colm.max_length>0 then colm.max_length/2
when systype.name='ntext' and colm.max_length>0 then colm.max_length/2
else colm.max_length
end
) CharLength,
cast(colm.precision as int) Precision,
cast(colm.scale as int) Scale,
prop.value Remark
from {0}.sys.columns colm
inner join {0}.sys.types systype on colm.system_type_id=systype.system_type_id and colm.user_type_id=systype.user_type_id
left join {0}.sys.extended_properties prop on colm.object_id=prop.major_id and colm.column_id=prop.minor_id
LEFT JOIN indexCTE ON colm.column_id=indexCTE.column_id AND colm.object_id=indexCTE.object_id
where colm.object_id=OBJECT_ID(@tableName)
order by colm.column_id", database);
#endregion
SqlParameter param = new SqlParameter("@tableName", SqlDbType.NVarChar, 100) { Value = string.Format("{0}.{1}.{2}", database, schema, tableName) };
DataTable dt = ExecuteDataTable(connectionString, sql, param);
return dt.Rows.Cast<DataRow>().Select(row => new DbColumn()
{
ColumnID = row.Field<int>("ColumnID"),
IsPrimaryKey = row.Field<bool>("IsPrimaryKey"),
ColumnName = row.Field<string>("ColumnName"),
ColumnType = row.Field<string>("ColumnType"),
IsIdentity = row.Field<bool>("IsIdentity"),
IsNullable = row.Field<bool>("IsNullable"),
ByteLength = row.Field<int>("ByteLength"),
CharLength = row.Field<int>("CharLength"),
Scale = row.Field<int>("Scale"),
Remark = row["Remark"].ToString()
}).ToList();
}
/// <summary>
/// 执行指定数据库连接字符串的命令,返回指定数据库、表的索引信息
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="database"></param>
/// <param name="tableName"></param>
/// <param name="schema"></param>
/// <returns></returns>
public List<DbIndex> GetDbIndexs(string connectionString, string database, string tableName, string schema = "dbo")
{
#region SQL
string sql = string.Format(@"
select
idx.name IndexName
,idx.type_desc IndexType
,idx.is_primary_key IsPrimaryKey
,idx.is_unique IsUnique
,idx.is_unique_constraint IsUniqueConstraint
,STUFF(
(
SELECT ','+c.name from {0}.sys.index_columns ic
inner join {0}.sys.columns c on ic.column_id=c.column_id and ic.object_id=c.object_id
WHERE ic.is_included_column = 0 and ic.index_id=idx.index_id AND ic.object_id=idx.object_id
ORDER BY ic.key_ordinal
FOR XML PATH('')
),1,1,'') IndexColumns
,STUFF(
(
SELECT ','+c.name from {0}.sys.index_columns ic
inner join {0}.sys.columns c on ic.column_id=c.column_id and ic.object_id=c.object_id
WHERE ic.is_included_column = 1 and ic.index_id=idx.index_id AND ic.object_id=idx.object_id
ORDER BY ic.key_ordinal
FOR XML PATH('')
),1,1,'') IncludeColumns
from {0}.sys.indexes idx
where object_id =OBJECT_ID(@tableName)", database);
#endregion
SqlParameter param = new SqlParameter("@tableName", SqlDbType.NVarChar, 100) { Value = string.Format("{0}.{1}.{2}", database, schema, tableName) };
DataTable dt = ExecuteDataTable(connectionString, sql, param);
return dt.Rows.Cast<DataRow>().Select(row => new DbIndex()
{
IndexName = row.Field<string>("IndexName"),
IndexType = row.Field<string>("IndexType"),
IsPrimaryKey = row.Field<bool>("IsPrimaryKey"),
IsUnique = row.Field<bool>("IsUnique"),
IsUniqueConstraint = row.Field<bool>("IsUniqueConstraint"),
IndexColumns = row.Field<string>("IndexColumns"),
IncludeColumns = row.Field<string>("IncludeColumns")
}).ToList();
}
#endregion
} /// <summary>
/// 表索引结构
/// </summary>
public sealed class DbIndex
{
/// <summary>
/// 索引名称
/// </summary>
public string IndexName { get; set; }
/// <summary>
/// 索引类型
/// </summary>
public string IndexType { get; set; }
/// <summary>
/// 是否为主键
/// </summary>
public bool IsPrimaryKey { get; set; } /// <summary>
/// 是否唯一索引
/// </summary>
public bool IsUnique { get; set; }
/// <summary>
/// 是否唯一约束
/// </summary>
public bool IsUniqueConstraint { get; set; }
/// <summary>
/// 索引列
/// </summary>
public string IndexColumns { get; set; } /// <summary>
/// 覆盖索引列
/// </summary>
public string IncludeColumns { get; set; }
} /// <summary>
/// 表结构
/// </summary>
public sealed class DbTable
{
/// <summary>
/// 表名称
/// </summary>
public string TableName { get; set; }
/// <summary>
/// 表的架构
/// </summary>
public string SchemaName { get; set; }
/// <summary>
/// 表的记录数
/// </summary>
public int Rows { get; set; } /// <summary>
/// 是否含有主键
/// </summary>
public bool HasPrimaryKey { get; set; }
} /// <summary>
/// 表字段结构
/// </summary>
public sealed class DbColumn
{
/// <summary>
/// 字段ID
/// </summary>
public int ColumnID { get; set; } /// <summary>
/// 是否主键
/// </summary>
public bool IsPrimaryKey { get; set; } /// <summary>
/// 字段名称
/// </summary>
public string ColumnName { get; set; } /// <summary>
/// 字段类型
/// </summary>
public string ColumnType { get; set; } /// <summary>
/// 数据库类型对应的C#类型
/// </summary>
public string CSharpType
{
get
{
return SqlMap.MapCsharpType(ColumnType);
}
} /// <summary>
///
/// </summary>
public Type CommonType
{
get
{
return SqlMap.MapCommonType(ColumnType);
}
} /// <summary>
/// 字节长度
/// </summary>
public int ByteLength { get; set; } /// <summary>
/// 字符长度
/// </summary>
public int CharLength { get; set; } /// <summary>
/// 小数位
/// </summary>
public int Scale { get; set; } /// <summary>
/// 是否自增列
/// </summary>
public bool IsIdentity { get; set; } /// <summary>
/// 是否允许空
/// </summary>
public bool IsNullable { get; set; } /// <summary>
/// 描述
/// </summary>
public string Remark { get; set; }
} public class SqlMap
{
public static string MapCsharpType(string dbtype)
{
if (string.IsNullOrEmpty(dbtype)) return dbtype;
dbtype = dbtype.ToLower();
string csharpType = "object";
switch (dbtype)
{
case "bigint": csharpType = "long"; break;
case "binary": csharpType = "byte[]"; break;
case "bit": csharpType = "bool"; break;
case "char": csharpType = "string"; break;
case "date": csharpType = "DateTime"; break;
case "datetime": csharpType = "DateTime"; break;
case "datetime2": csharpType = "DateTime"; break;
case "datetimeoffset": csharpType = "DateTimeOffset"; break;
case "decimal": csharpType = "decimal"; break;
case "float": csharpType = "double"; break;
case "image": csharpType = "byte[]"; break;
case "int": csharpType = "int"; break;
case "money": csharpType = "decimal"; break;
case "nchar": csharpType = "string"; break;
case "ntext": csharpType = "string"; break;
case "numeric": csharpType = "decimal"; break;
case "nvarchar": csharpType = "string"; break;
case "real": csharpType = "Single"; break;
case "smalldatetime": csharpType = "DateTime"; break;
case "smallint": csharpType = "short"; break;
case "smallmoney": csharpType = "decimal"; break;
case "sql_variant": csharpType = "object"; break;
case "sysname": csharpType = "object"; break;
case "text": csharpType = "string"; break;
case "time": csharpType = "TimeSpan"; break;
case "timestamp": csharpType = "byte[]"; break;
case "tinyint": csharpType = "byte"; break;
case "uniqueidentifier": csharpType = "Guid"; break;
case "varbinary": csharpType = "byte[]"; break;
case "varchar": csharpType = "string"; break;
case "xml": csharpType = "string"; break;
default: csharpType = "object"; break;
}
return csharpType;
} public static Type MapCommonType(string dbtype)
{
if (string.IsNullOrEmpty(dbtype)) return Type.Missing.GetType();
dbtype = dbtype.ToLower();
Type commonType = typeof(object);
switch (dbtype)
{
case "bigint": commonType = typeof(long); break;
case "binary": commonType = typeof(byte[]); break;
case "bit": commonType = typeof(bool); break;
case "char": commonType = typeof(string); break;
case "date": commonType = typeof(DateTime); break;
case "datetime": commonType = typeof(DateTime); break;
case "datetime2": commonType = typeof(DateTime); break;
case "datetimeoffset": commonType = typeof(DateTimeOffset); break;
case "decimal": commonType = typeof(decimal); break;
case "float": commonType = typeof(double); break;
case "image": commonType = typeof(byte[]); break;
case "int": commonType = typeof(int); break;
case "money": commonType = typeof(decimal); break;
case "nchar": commonType = typeof(string); break;
case "ntext": commonType = typeof(string); break;
case "numeric": commonType = typeof(decimal); break;
case "nvarchar": commonType = typeof(string); break;
case "real": commonType = typeof(Single); break;
case "smalldatetime": commonType = typeof(DateTime); break;
case "smallint": commonType = typeof(short); break;
case "smallmoney": commonType = typeof(decimal); break;
case "sql_variant": commonType = typeof(object); break;
case "sysname": commonType = typeof(object); break;
case "text": commonType = typeof(string); break;
case "time": commonType = typeof(TimeSpan); break;
case "timestamp": commonType = typeof(byte[]); break;
case "tinyint": commonType = typeof(byte); break;
case "uniqueidentifier": commonType = typeof(Guid); break;
case "varbinary": commonType = typeof(byte[]); break;
case "varchar": commonType = typeof(string); break;
case "xml": commonType = typeof(string); break;
default: commonType = typeof(object); break;
}
return commonType;
}
}
}

SqlHelperSchemaExtension.cs

using System;
using System.Data;
using System.IO;
using System.Linq;
using System.Text;
using MySql.Data.MySqlClient; namespace Helpers
{
/// <summary>
/// MySqlHelper操作类
/// </summary>
public sealed partial class MySqlHelper
{
/// <summary>
/// 批量操作每批次记录数
/// </summary>
public static int BatchSize = 2000; /// <summary>
/// 超时时间
/// </summary>
public static int CommandTimeOut = 600; /// <summary>
///初始化MySqlHelper实例
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
public MySqlHelper(string connectionString)
{
this.ConnectionString = connectionString;
} /// <summary>
/// 数据库连接字符串
/// </summary>
public string ConnectionString { get; set; } #region 实例方法 #region ExecuteNonQuery /// <summary>
/// 执行SQL语句,返回影响的行数
/// </summary>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回影响的行数</returns>
public int ExecuteNonQuery(string commandText, params MySqlParameter[] parms)
{
return ExecuteNonQuery(ConnectionString, CommandType.Text, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回影响的行数
/// </summary>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回影响的行数</returns>
public int ExecuteNonQuery(CommandType commandType, string commandText, params MySqlParameter[] parms)
{
return ExecuteNonQuery(ConnectionString, commandType, commandText, parms);
} #endregion ExecuteNonQuery #region ExecuteScalar /// <summary>
/// 执行SQL语句,返回结果集中的第一行第一列
/// </summary>
/// <typeparam name="T">返回对象类型</typeparam>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行第一列</returns>
public T ExecuteScalar<T>(string commandText, params MySqlParameter[] parms)
{
return ExecuteScalar<T>(ConnectionString, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行第一列
/// </summary>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行第一列</returns>
public object ExecuteScalar(string commandText, params MySqlParameter[] parms)
{
return ExecuteScalar(ConnectionString, CommandType.Text, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行第一列
/// </summary>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行第一列</returns>
public object ExecuteScalar(CommandType commandType, string commandText, params MySqlParameter[] parms)
{
return ExecuteScalar(ConnectionString, commandType, commandText, parms);
} #endregion ExecuteScalar #region ExecuteDataReader /// <summary>
/// 执行SQL语句,返回只读数据集
/// </summary>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回只读数据集</returns>
private MySqlDataReader ExecuteDataReader(string commandText, params MySqlParameter[] parms)
{
return ExecuteDataReader(ConnectionString, CommandType.Text, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回只读数据集
/// </summary>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回只读数据集</returns>
private MySqlDataReader ExecuteDataReader(CommandType commandType, string commandText, params MySqlParameter[] parms)
{
return ExecuteDataReader(ConnectionString, commandType, commandText, parms);
}
#endregion #region ExecuteDataRow /// <summary>
/// 执行SQL语句,返回结果集中的第一行
/// </summary>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行</returns>
public DataRow ExecuteDataRow(string commandText, params MySqlParameter[] parms)
{
return ExecuteDataRow(ConnectionString, CommandType.Text, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行
/// </summary>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行</returns>
public DataRow ExecuteDataRow(CommandType commandType, string commandText, params MySqlParameter[] parms)
{
return ExecuteDataRow(ConnectionString, commandType, commandText, parms);
} #endregion ExecuteDataRow #region ExecuteDataTable /// <summary>
/// 执行SQL语句,返回结果集中的第一个数据表
/// </summary>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一个数据表</returns>
public DataTable ExecuteDataTable(string commandText, params MySqlParameter[] parms)
{
return ExecuteDataTable(ConnectionString, CommandType.Text, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集中的第一个数据表
/// </summary>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一个数据表</returns>
public DataTable ExecuteDataTable(CommandType commandType, string commandText, params MySqlParameter[] parms)
{
return ExecuteDataSet(ConnectionString, commandType, commandText, parms).Tables[0];
} #endregion ExecuteDataTable #region ExecuteDataSet /// <summary>
/// 执行SQL语句,返回结果集
/// </summary>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集</returns>
public DataSet ExecuteDataSet(string commandText, params MySqlParameter[] parms)
{
return ExecuteDataSet(ConnectionString, CommandType.Text, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集
/// </summary>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集</returns>
public DataSet ExecuteDataSet(CommandType commandType, string commandText, params MySqlParameter[] parms)
{
return ExecuteDataSet(ConnectionString, commandType, commandText, parms);
} #endregion ExecuteDataSet #region 批量操作 /// <summary>
/// 使用MySqlDataAdapter批量更新数据
/// </summary>
/// <param name="table">数据表</param>
public void BatchUpdate(DataTable table)
{
BatchUpdate(ConnectionString, table);
} /// <summary>
///大批量数据插入,返回成功插入行数
/// </summary>
/// <param name="table">数据表</param>
/// <returns>返回成功插入行数</returns>
public int BulkInsert(DataTable table)
{
return BulkInsert(ConnectionString, table);
} #endregion 批量操作 #endregion 实例方法 #region 静态方法 private static void PrepareCommand(MySqlCommand command, MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, MySqlParameter[] parms)
{
if (connection.State != ConnectionState.Open) connection.Open(); command.Connection = connection;
command.CommandTimeout = CommandTimeOut;
// 设置命令文本(存储过程名或SQL语句)
command.CommandText = commandText;
// 分配事务
if (transaction != null)
{
command.Transaction = transaction;
}
// 设置命令类型.
command.CommandType = commandType;
if (parms != null && parms.Length > 0)
{
//预处理MySqlParameter参数数组,将为NULL的参数赋值为DBNull.Value;
foreach (MySqlParameter parameter in parms)
{
if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) && (parameter.Value == null))
{
parameter.Value = DBNull.Value;
}
}
command.Parameters.AddRange(parms);
}
} #region ExecuteNonQuery /// <summary>
/// 执行SQL语句,返回影响的行数
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回影响的行数</returns>
public static int ExecuteNonQuery(string connectionString, string commandText, params MySqlParameter[] parms)
{
using (MySqlConnection connection = new MySqlConnection(connectionString))
{
return ExecuteNonQuery(connection, CommandType.Text, commandText, parms);
}
} /// <summary>
/// 执行SQL语句,返回影响的行数
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回影响的行数</returns>
public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
using (MySqlConnection connection = new MySqlConnection(connectionString))
{
return ExecuteNonQuery(connection, commandType, commandText, parms);
}
} /// <summary>
/// 执行SQL语句,返回影响的行数
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回影响的行数</returns>
public static int ExecuteNonQuery(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
return ExecuteNonQuery(connection, null, commandType, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回影响的行数
/// </summary>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回影响的行数</returns>
public static int ExecuteNonQuery(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
return ExecuteNonQuery(transaction.Connection, transaction, commandType, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回影响的行数
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回影响的行数</returns>
private static int ExecuteNonQuery(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
MySqlCommand command = new MySqlCommand();
PrepareCommand(command, connection, transaction, commandType, commandText, parms);
int retval = command.ExecuteNonQuery();
command.Parameters.Clear();
return retval;
} #endregion ExecuteNonQuery #region ExecuteScalar /// <summary>
/// 执行SQL语句,返回结果集中的第一行第一列
/// </summary>
/// <typeparam name="T">返回对象类型</typeparam>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行第一列</returns>
public static T ExecuteScalar<T>(string connectionString, string commandText, params MySqlParameter[] parms)
{
object result = ExecuteScalar(connectionString, commandText, parms);
if (result != null)
{
return (T)Convert.ChangeType(result, typeof(T)); ;
}
return default(T);
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行第一列
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行第一列</returns>
public static object ExecuteScalar(string connectionString, string commandText, params MySqlParameter[] parms)
{
using (MySqlConnection connection = new MySqlConnection(connectionString))
{
return ExecuteScalar(connection, CommandType.Text, commandText, parms);
}
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行第一列
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行第一列</returns>
public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
using (MySqlConnection connection = new MySqlConnection(connectionString))
{
return ExecuteScalar(connection, commandType, commandText, parms);
}
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行第一列
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行第一列</returns>
public static object ExecuteScalar(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
return ExecuteScalar(connection, null, commandType, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行第一列
/// </summary>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行第一列</returns>
public static object ExecuteScalar(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
return ExecuteScalar(transaction.Connection, transaction, commandType, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行第一列
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一行第一列</returns>
private static object ExecuteScalar(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
MySqlCommand command = new MySqlCommand();
PrepareCommand(command, connection, transaction, commandType, commandText, parms);
object retval = command.ExecuteScalar();
command.Parameters.Clear();
return retval;
} #endregion ExecuteScalar #region ExecuteDataReader /// <summary>
/// 执行SQL语句,返回只读数据集
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回只读数据集</returns>
private static MySqlDataReader ExecuteDataReader(string connectionString, string commandText, params MySqlParameter[] parms)
{
MySqlConnection connection = new MySqlConnection(connectionString);
return ExecuteDataReader(connection, null, CommandType.Text, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回只读数据集
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回只读数据集</returns>
private static MySqlDataReader ExecuteDataReader(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
MySqlConnection connection = new MySqlConnection(connectionString);
return ExecuteDataReader(connection, null, commandType, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回只读数据集
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回只读数据集</returns>
private static MySqlDataReader ExecuteDataReader(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
return ExecuteDataReader(connection, null, commandType, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回只读数据集
/// </summary>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回只读数据集</returns>
private static MySqlDataReader ExecuteDataReader(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
return ExecuteDataReader(transaction.Connection, transaction, commandType, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回只读数据集
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回只读数据集</returns>
private static MySqlDataReader ExecuteDataReader(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
MySqlCommand command = new MySqlCommand();
PrepareCommand(command, connection, transaction, commandType, commandText, parms);
return command.ExecuteReader(CommandBehavior.CloseConnection);
} #endregion #region ExecuteDataRow /// <summary>
/// 执行SQL语句,返回结果集中的第一行
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>,返回结果集中的第一行</returns>
public static DataRow ExecuteDataRow(string connectionString, string commandText, params MySqlParameter[] parms)
{
DataTable dt = ExecuteDataTable(connectionString, CommandType.Text, commandText, parms);
return dt.Rows.Count > 0 ? dt.Rows[0] : null;
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>,返回结果集中的第一行</returns>
public static DataRow ExecuteDataRow(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
DataTable dt = ExecuteDataTable(connectionString, commandType, commandText, parms);
return dt.Rows.Count > 0 ? dt.Rows[0] : null;
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>,返回结果集中的第一行</returns>
public static DataRow ExecuteDataRow(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
DataTable dt = ExecuteDataTable(connection, commandType, commandText, parms);
return dt.Rows.Count > 0 ? dt.Rows[0] : null;
} /// <summary>
/// 执行SQL语句,返回结果集中的第一行
/// </summary>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>,返回结果集中的第一行</returns>
public static DataRow ExecuteDataRow(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
DataTable dt = ExecuteDataTable(transaction, commandType, commandText, parms);
return dt.Rows.Count > 0 ? dt.Rows[0] : null;
} #endregion ExecuteDataRow #region ExecuteDataTable /// <summary>
/// 执行SQL语句,返回结果集中的第一个数据表
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一个数据表</returns>
public static DataTable ExecuteDataTable(string connectionString, string commandText, params MySqlParameter[] parms)
{
return ExecuteDataSet(connectionString, CommandType.Text, commandText, parms).Tables[0];
} /// <summary>
/// 执行SQL语句,返回结果集中的第一个数据表
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一个数据表</returns>
public static DataTable ExecuteDataTable(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
return ExecuteDataSet(connectionString, commandType, commandText, parms).Tables[0];
} /// <summary>
/// 执行SQL语句,返回结果集中的第一个数据表
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一个数据表</returns>
public static DataTable ExecuteDataTable(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
return ExecuteDataSet(connection, commandType, commandText, parms).Tables[0];
} /// <summary>
/// 执行SQL语句,返回结果集中的第一个数据表
/// </summary>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集中的第一个数据表</returns>
public static DataTable ExecuteDataTable(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
return ExecuteDataSet(transaction, commandType, commandText, parms).Tables[0];
} /// <summary>
/// 执行SQL语句,返回结果集中的第一个数据表
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="tableName">数据表名称</param>
/// <returns>返回结果集中的第一个数据表</returns>
public static DataTable ExecuteEmptyDataTable(string connectionString, string tableName)
{
return ExecuteDataSet(connectionString, CommandType.Text, string.Format("select * from {0} where 1=-1", tableName)).Tables[0];
} #endregion ExecuteDataTable #region ExecuteDataSet /// <summary>
/// 执行SQL语句,返回结果集
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandText">SQL语句</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集</returns>
public static DataSet ExecuteDataSet(string connectionString, string commandText, params MySqlParameter[] parms)
{
return ExecuteDataSet(connectionString, CommandType.Text, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集</returns>
public static DataSet ExecuteDataSet(string connectionString, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
using (MySqlConnection connection = new MySqlConnection(connectionString))
{
return ExecuteDataSet(connection, commandType, commandText, parms);
}
} /// <summary>
/// 执行SQL语句,返回结果集
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集</returns>
public static DataSet ExecuteDataSet(MySqlConnection connection, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
return ExecuteDataSet(connection, null, commandType, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集
/// </summary>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集</returns>
public static DataSet ExecuteDataSet(MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
return ExecuteDataSet(transaction.Connection, transaction, commandType, commandText, parms);
} /// <summary>
/// 执行SQL语句,返回结果集
/// </summary>
/// <param name="connection">数据库连接</param>
/// <param name="transaction">事务</param>
/// <param name="commandType">命令类型(存储过程,命令文本, 其它.)</param>
/// <param name="commandText">SQL语句或存储过程名称</param>
/// <param name="parms">查询参数</param>
/// <returns>返回结果集</returns>
private static DataSet ExecuteDataSet(MySqlConnection connection, MySqlTransaction transaction, CommandType commandType, string commandText, params MySqlParameter[] parms)
{
MySqlCommand command = new MySqlCommand(); PrepareCommand(command, connection, transaction, commandType, commandText, parms);
MySqlDataAdapter adapter = new MySqlDataAdapter(command); DataSet ds = new DataSet();
adapter.Fill(ds);
if (commandText.IndexOf("@") > 0)
{
commandText = commandText.ToLower();
int index = commandText.IndexOf("where ");
if (index < 0)
{
index = commandText.IndexOf("\nwhere");
}
if (index > 0)
{
ds.ExtendedProperties.Add("SQL", commandText.Substring(0, index - 1)); //将获取的语句保存在表的一个附属数组里,方便更新时生成CommandBuilder
}
else
{
ds.ExtendedProperties.Add("SQL", commandText); //将获取的语句保存在表的一个附属数组里,方便更新时生成CommandBuilder
}
}
else
{
ds.ExtendedProperties.Add("SQL", commandText); //将获取的语句保存在表的一个附属数组里,方便更新时生成CommandBuilder
} foreach (DataTable dt in ds.Tables)
{
dt.ExtendedProperties.Add("SQL", ds.ExtendedProperties["SQL"]);
} command.Parameters.Clear();
return ds;
} #endregion ExecuteDataSet #region 批量操作 /// <summary>
///使用MySqlDataAdapter批量更新数据
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="table">数据表</param>
public static void BatchUpdate(string connectionString, DataTable table)
{
MySqlConnection connection = new MySqlConnection(connectionString); MySqlCommand command = connection.CreateCommand();
command.CommandTimeout = CommandTimeOut;
command.CommandType = CommandType.Text;
MySqlDataAdapter adapter = new MySqlDataAdapter(command);
MySqlCommandBuilder commandBulider = new MySqlCommandBuilder(adapter);
commandBulider.ConflictOption = ConflictOption.OverwriteChanges; MySqlTransaction transaction = null;
try
{
connection.Open();
transaction = connection.BeginTransaction();
//设置批量更新的每次处理条数
adapter.UpdateBatchSize = BatchSize;
//设置事物
adapter.SelectCommand.Transaction = transaction; if (table.ExtendedProperties["SQL"] != null)
{
adapter.SelectCommand.CommandText = table.ExtendedProperties["SQL"].ToString();
}
adapter.Update(table);
transaction.Commit();/////提交事务
}
catch (MySqlException ex)
{
if (transaction != null) transaction.Rollback();
throw ex;
}
finally
{
connection.Close();
connection.Dispose();
}
} /// <summary>
///大批量数据插入,返回成功插入行数
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="table">数据表</param>
/// <returns>返回成功插入行数</returns>
public static int BulkInsert(string connectionString, DataTable table)
{
if (string.IsNullOrEmpty(table.TableName)) throw new Exception("请给DataTable的TableName属性附上表名称");
if (table.Rows.Count == 0) return 0;
int insertCount = 0;
string tmpPath = Path.GetTempFileName();
string csv = DataTableToCsv(table);
File.WriteAllText(tmpPath, csv);
using (MySqlConnection conn = new MySqlConnection(connectionString))
{
MySqlTransaction tran = null;
try
{
conn.Open();
tran = conn.BeginTransaction();
MySqlBulkLoader bulk = new MySqlBulkLoader(conn)
{
FieldTerminator = ",",
FieldQuotationCharacter = '"',
EscapeCharacter = '"',
LineTerminator = "\r\n",
FileName = tmpPath,
NumberOfLinesToSkip = 0,
TableName = table.TableName,
};
bulk.Columns.AddRange(table.Columns.Cast<DataColumn>().Select(colum => colum.ColumnName).ToList());
insertCount = bulk.Load();
tran.Commit();
}
catch (MySqlException ex)
{
if (tran != null) tran.Rollback();
throw ex;
}
}
File.Delete(tmpPath);
return insertCount;
} /// <summary>
///将DataTable转换为标准的CSV
/// </summary>
/// <param name="table">数据表</param>
/// <returns>返回标准的CSV</returns>
private static string DataTableToCsv(DataTable table)
{
//以半角逗号(即,)作分隔符,列为空也要表达其存在。
//列内容如存在半角逗号(即,)则用半角引号(即"")将该字段值包含起来。
//列内容如存在半角引号(即")则应替换成半角双引号("")转义,并用半角引号(即"")将该字段值包含起来。
StringBuilder sb = new StringBuilder();
DataColumn colum;
foreach (DataRow row in table.Rows)
{
for (int i = 0; i < table.Columns.Count; i++)
{
colum = table.Columns[i];
if (i != 0) sb.Append(",");
if (colum.DataType == typeof(string) && row[colum].ToString().Contains(","))
{
sb.Append("\"" + row[colum].ToString().Replace("\"", "\"\"") + "\"");
}
else sb.Append(row[colum].ToString());
}
sb.AppendLine();
} return sb.ToString();
} #endregion 批量操作 #endregion 静态方法
}
}

MySqlHelper.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MySql.Data.MySqlClient;
using System.Data; namespace Helpers
{
/// <summary>
/// MySqlHelper扩展(依赖AutoMapper.dll)
/// </summary>
public sealed partial class MySqlHelper
{
#region 实例方法 public T ExecuteObject<T>(string commandText, params MySqlParameter[] parms)
{
return ExecuteObject<T>(this.ConnectionString, commandText, parms);
} public List<T> ExecuteObjects<T>(string commandText, params MySqlParameter[] parms)
{
return ExecuteObjects<T>(this.ConnectionString, commandText, parms);
} #endregion #region 静态方法 public static T ExecuteObject<T>(string connectionString, string commandText, params MySqlParameter[] parms)
{
//DataTable dt = ExecuteDataTable(connectionString, commandText, parms);
//return AutoMapper.Mapper.DynamicMap<List<T>>(dt.CreateDataReader()).FirstOrDefault();
using (MySqlDataReader reader = ExecuteDataReader(connectionString, commandText, parms))
{
return AutoMapper.Mapper.DynamicMap<List<T>>(reader).FirstOrDefault();
}
} public static List<T> ExecuteObjects<T>(string connectionString, string commandText, params MySqlParameter[] parms)
{
//DataTable dt = ExecuteDataTable(connectionString, commandText, parms);
//return AutoMapper.Mapper.DynamicMap<List<T>>(dt.CreateDataReader());
using (MySqlDataReader reader = ExecuteDataReader(connectionString, commandText, parms))
{
return AutoMapper.Mapper.DynamicMap<List<T>>(reader);
}
} #endregion
} }

MySqlHelperExtension.cs

最后附上文件源码及相关DLL:SQL.rar

注:此文章属懒惰的肥兔原创,版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接

若您觉得这篇文章还不错请点击下右下角的推荐,有了您的支持才能激发作者更大的写作热情,非常感谢。

如有问题,可以通过lzrabbit@126.com联系我。

[转]自用类库整理之SqlHelper和MySqlHelper的更多相关文章

  1. 自用类库整理之SqlHelper和MySqlHelper

    自用类库整理之SqlHelper和MySqlHelper 自用的SQLHelper和MySqlHelper,除一些通用方法外,封装了一些很实用的批量操作方法,简单介绍下 SqlHelper Execu ...

  2. iOS 常用三方类库整理

    iOS 常用三方类库整理 1:基于响应式编程思想的oc 地址:https://github.com/ReactiveCocoa/ReactiveCocoa 2:hud提示框 地址:https://gi ...

  3. JS-JavaScript类库整理 [更新中...]

    老大.jQuery插件库 ——收集最全最新最好的jQuery插件 http://www.jq22.com/ 一.Moment.js ——JavaScript 日期处理类库 http://momentj ...

  4. 有关C,C++,C#, Java的图形图像处理类库 整理(未完待续)

    1.Java相关 1.1 Jzy3D Jzy3D 是一个Java的类库,用来绘制各种各样的三维图形,如下图所示: 下载地址:jzy3d-api,官网 1.2 Proscene 是一个用于创建交互式3D ...

  5. C#通用类库整理--字符串处理类

    在程序开发中通常需要将字符串转为自己想要的结果,以下三个类库主要实现: 1.GetStrArray(string str, char speater, bool toLower)  把字符串按照分隔符 ...

  6. C#通用类库整理--日志记录

    日志的记录是将程序过程中的一些行为数据记录下来,方便开发.运维迅速的找到问题的所在,节省时间.使用时在 站点的web.config 中的<appSettings></appSetti ...

  7. C#通用类库整理--序列化类

    程序员在编写应用程序的时候往往要将程序的某些数据存储在内存中,然后将其写入某个文件或是将它传输到网络中的另一台计算机上 以实现通讯.这个将程序数据转化成能被存储并传输的格式的过程被称为"序列 ...

  8. java 与大数据学习较好的网站

    C# C#中 Thread,Task,Async/Await,IAsyncResult 的那些事儿!https://www.cnblogs.com/doforfuture/p/6293926.html ...

  9. C# 基于MySQL的数据层基类(MySQLHelper)

    这里介绍下比较简单的方式,引用MySql.Data.dll然后添加一个MySqlHelper类来对MySql数据库进行访问和操作. 1.将MySql.Data.dll引用到你的项目中 下载地址:MyS ...

随机推荐

  1. jdbc操作数据库以及防止sql注入

    public class pr { public static void main(String[] args) { Connection conn = null; Statement st = nu ...

  2. 自动化运维之saltstack的使用安装

    SaltStack 简介 SaltStack是一个服务器基础架构集中化管理平台,具备配置管理.远程执行.监控等功能,基于Python语言实现,结合轻量级消息队列(ZeroMQ)与Python第三方模块 ...

  3. git reset用法

    git 删除 错误 提交的 commit 方法:         根据–soft –mixed –hard,会对working tree和index和HEAD进行重置:    git reset -- ...

  4. PHP生成随机字符串与唯一字符串

    代码如下: <?php /* * 生成随机字符串 * @param int $length 生成随机字符串的长度 * @param string $char 组成随机字符串的字符串 * @ret ...

  5. CentOS7下Samba的安装与配置

    一.Samba简介 Samba是在Linux和UNIX系统上实现SMB协议的一个免费软件,由服务器及客户端程序构成.SMB(Server Messages Block,信息服务块)是一种在局域网上共享 ...

  6. oracle 11g安装教程

    oracle 11g安装教程 第1步 第2步 第3步 第4步 第5步 第6步 第7步 第8步 第9步 第10步 第11步 第12步 第13步 第14步 第15步 第16步 第17步 第18步 第19步 ...

  7. pytho中pickle、json模块

    pickle & json 模块 json,用于字符串 和 python数据类型间进行转换 pickle,用于python特有的类型 和 python的数据类型间进行转换 json模块提供了四 ...

  8. 680. Valid Palindrome II【Easy】【双指针-可以删除一个字符,判断是否能构成回文字符串】

    Given a non-empty string s, you may delete at most one character. Judge whether you can make it a pa ...

  9. Git常用命令速查手册

    Git组成 1.初始化仓库 git init 2.将文件添加到仓库 git add 文件名 # 将工作区的某个文件添加到暂存区 git add -u # 添加所有被tracked文件中被修改或删除的文 ...

  10. Vue 2.0 Application Sample

    ===搭建Demo=== http://blog.csdn.net/wangjiaohome/article/details/51728217 ===单页Application=== http://b ...