数据库访问的

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data;
using System.Data.Common;
using System.IO;
using System.Text;
using System.Data.SqlClient;

namespace AdvWeiXin.API
{
/// <summary>
/// 通用数据库访问类，封装了对数据库的常见操作
///</summary>
public sealed class DbUtility
{
public string ConnectionString { get; set; }
public bool Log { get; set; }
private DbProviderFactory providerFactory;
/// <summary>
/// 构造函数
/// </summary>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="providerType">数据库类型枚举，参见<paramref name="providerType"/></param>
public DbUtility(string connectionString, DbProviderType providerType)
{
InitProvider(connectionString, providerType);
}

public DbUtility()
{
InitProvider(@"Data Source=ZCL\SQLEXPRESS;Initial Catalog=weixin;User ID=sa;Password=123", DbProviderType.SqlServer);
//InitProvider("server=192.168.0.1;uid=nhb;pwd=sa123;database=weixin", DbProviderType.SqlServer);
}

public DbUtility(int type)
{
switch (type)
{
case 1:
InitProvider("server=127.0.0.1;uid=sa;pwd=123;database=weixin", DbProviderType.SqlServer);
break;
case 2:
InitProvider("server=127.0.0.1;uid=sa;pwd=123;database=qc", DbProviderType.SqlServer);
break;
case 3:
InitProvider("server=127.0.0.1;uid=sa;pwd=123;database=fangchan", DbProviderType.SqlServer);
break;
case 4:
InitProvider("server=127.0.0.1;uid=sa;pwd=123;database=jobdb1", DbProviderType.SqlServer);
break;
}

//InitProvider("server=192.168.0.1;uid=nhb;pwd=sa123;database=weixin", DbProviderType.SqlServer);
}
/// <summary>
/// 构造函数 SqlServer类型的简写
/// </summary>
/// <param name="connectionString"></param>
public DbUtility(string connectionString)
{
InitProvider(connectionString, DbProviderType.SqlServer);
}
/// <summary>
/// 实例化数据库链接类
/// </summary>
/// <param name="connectionString"></param>
/// <param name="providerType"></param>
private void InitProvider(string connectionString, DbProviderType providerType)
{
ConnectionString = connectionString;
providerFactory = ProviderFactory.GetDbProviderFactory(providerType);
if (providerFactory == null && Log)
{
OnOnExecute(new ExecuteArgument("Can't load DbProviderFactory for given value of providerType"));
}
}
/// <summary>
/// 创建存储过程参数
/// </summary>
/// <param name="ParamName">参数名</param>
/// <param name="DbType">参数类型</param>
/// <param name="Size">参数大小</param>
/// <param name="Direction">参数的方向(输入/输出)</param>
/// <param name="Value">参数值</param>
/// <returns>新参数对象</returns>
public SqlParameter CreatSqlParam(string ParamName, SqlDbType DbType, Int32 Size, ParameterDirection Direction, object Value)
{
SqlParameter param;
if (Size > 0)
{
param = new SqlParameter(ParamName, DbType, Size);
}
else
{
param = new SqlParameter(ParamName, DbType);
}
param.Direction = Direction;
if (!(Direction == ParameterDirection.Output && Value == null))
{
param.Value = Value;
}
return param;
}
/// <summary>
///创建Command对象用于访问存储过程
/// </summary>
/// <param name="procName">存储过程的名字</param>
/// <param name="prams">存储过程的输入参数列表</param>
/// <returns>Command对象</returns>
private SqlCommand CreateSqlCommand(string proName, SqlParameter[] prams)
{
SqlConnection sqlconn = new SqlConnection();
sqlconn.ConnectionString = ConnectionString;
sqlconn.Open();
SqlCommand cmd = new SqlCommand();
cmd.Connection = sqlconn;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = proName;
if (prams != null)
{
foreach (SqlParameter parameter in prams)
{
cmd.Parameters.Add(parameter);
}
}
return cmd;
}

///<summary>
///运行存储过程返回DataSet
/// </summary>
/// <param name="proname">存储过程名称</param>
/// <param name="prams">存储过程参数</param>
public DataSet ExecProDataSet(string proname, SqlParameter[] prams)
{
using (SqlCommand cmd = CreateSqlCommand(proname, prams))
{
try
{
using (DbDataAdapter adapter = providerFactory.CreateDataAdapter())
{
adapter.SelectCommand = cmd;
DataSet ds = new DataSet();
adapter.Fill(ds);
return ds;
}
}
catch (Exception ex)
{
OnOnExecute(new ExecuteArgument(ex.Message, cmd.CommandText, prams));
throw new ArgumentException("ExecuteDataSet Error.");
}

}
}
///<summary>
///运行存储过程无返回值
/// </summary>
/// <param name="proname">存储过程名称</param>
/// <param name="prams">存储过程参数</param>
public void ExecPro(string proname, SqlParameter[] prams)
{
SqlCommand cmd = CreateSqlCommand(proname, prams);
cmd.ExecuteNonQuery();
//int i = (int)cmd.Parameters["ReturnValue"].Value;
cmd.Connection.Close();
}

///<summary>
///运行存储过程有返回值
/// </summary>
/// <param name="proname">存储过程名称</param>
/// <param name="prams">存储过程参数</param>
public int ExecProInt(string proname, SqlParameter[] prams)
{
SqlCommand cmd = CreateSqlCommand(proname, prams);
cmd.ExecuteNonQuery();
int i = (int)cmd.Parameters["ReturnValue"].Value;
cmd.Connection.Close();
return i;
}
///<summary>
///运行存储过程有返回值
/// </summary>
/// <param name="proname">存储过程名称</param>
/// <param name="prams">存储过程参数</param>
public string ExecProString(string proname, SqlParameter[] prams)
{
SqlCommand cmd = CreateSqlCommand(proname, prams);
cmd.ExecuteNonQuery();
string i = (string)cmd.Parameters["ReturnValue"].Value;
cmd.Connection.Close();
return i;
}
public DataSet SP_viewPage(string tablename,string fieldlist,string primarykey,string where,string order,int sorttype,int recordercount,int pagesize,int pageindex,ref int totalcount,ref int totalpagecount)
{
DataSet ds = new DataSet();
SqlParameter p1 = CreatSqlParam("tablename", SqlDbType.VarChar, 200, ParameterDirection.Input, tablename);
SqlParameter p2 = CreatSqlParam("fieldlist", SqlDbType.VarChar, 2000, ParameterDirection.Input, fieldlist);
SqlParameter p3 = CreatSqlParam("primarykey", SqlDbType.VarChar, 100, ParameterDirection.Input, primarykey);
SqlParameter p4 = CreatSqlParam("where", SqlDbType.VarChar, 2000, ParameterDirection.Input, where);
SqlParameter p5 = CreatSqlParam("order", SqlDbType.VarChar, 1000, ParameterDirection.Input, order);
SqlParameter p6 = CreatSqlParam("sorttype", SqlDbType.Int, 100, ParameterDirection.Input, sorttype);
SqlParameter p7 = CreatSqlParam("recordercount", SqlDbType.Int, 100, ParameterDirection.Input, recordercount);
SqlParameter p8 = CreatSqlParam("pagesize", SqlDbType.Int, 100, ParameterDirection.Input, pagesize);
SqlParameter p9 = CreatSqlParam("pageindex", SqlDbType.Int, 100, ParameterDirection.Input, pageindex);
SqlParameter p10 = CreatSqlParam("totalcount", SqlDbType.Int, 100, ParameterDirection.Output, totalcount);
SqlParameter p11 = CreatSqlParam("totalpagecount", SqlDbType.Int, 100, ParameterDirection.Output, totalpagecount);
SqlParameter[] prams= new SqlParameter[] { p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11 };
using (SqlCommand cmd = CreateSqlCommand("SP_viewPage",prams ))
{
try
{
using (DbDataAdapter adapter = providerFactory.CreateDataAdapter())
{
adapter.SelectCommand = cmd;
adapter.Fill(ds);
totalcount =(int) cmd.Parameters["TotalCount"].Value;
totalpagecount=(int)cmd.Parameters["TotalPageCount"].Value;
return ds;
}
}
catch (Exception ex)
{
OnOnExecute(new ExecuteArgument(ex.Message, cmd.CommandText, prams));
throw new ArgumentException("ExecuteDataSet Error.");
}

}
}
/// <summary>
/// 对数据库执行增删改操作，返回受影响的行数。
/// </summary>
/// <param name="sql">要执行的增删改的SQL语句</param>
/// <param name="parameters">执行增删改语句所需要的参数</param>
/// <returns></returns>
public int ExecuteNonQuery(string sql, IList<DbParameter> parameters)
{
return ExecuteNonQuery(sql, parameters, CommandType.Text);
}
/// <summary>
/// 对数据库执行增删改操作，返回受影响的行数。
/// </summary>
/// <param name="sql">要执行的增删改的SQL语句</param>
/// <param name="parameters">执行增删改语句所需要的参数</param>
/// <param name="commandType">执行的SQL语句的类型</param>
/// <returns></returns>
public int ExecuteNonQuery(string sql, IList<DbParameter> parameters, CommandType commandType)
{
using (DbCommand command = CreateDbCommand(sql, parameters, commandType))
{
try
{
command.Connection.Open();
int affectedRows = command.ExecuteNonQuery();
command.Connection.Close();
return affectedRows;
}
catch (Exception ex)
{
OnOnExecute(new ExecuteArgument(ex.Message, command.CommandText, parameters));
throw new ArgumentException("ExecuteNonQuery Error.");
}
}
}

/// <summary>
/// 执行一个查询语句，返回一个关联的DataReader实例
/// </summary>
/// <param name="sql">要执行的查询语句</param>
/// <param name="parameters">执行SQL查询语句所需要的参数</param>
/// <returns></returns>
public DbDataReader ExecuteReader(string sql, IList<DbParameter> parameters)
{
return ExecuteReader(sql, parameters, CommandType.Text);
}

/// <summary>
/// 执行一个查询语句，返回一个关联的DataReader实例
/// </summary>
/// <param name="sql">要执行的查询语句</param>
/// <param name="parameters">执行SQL查询语句所需要的参数</param>
/// <param name="commandType">执行的SQL语句的类型</param>
/// <returns></returns>
public DbDataReader ExecuteReader(string sql, IList<DbParameter> parameters, CommandType commandType)
{
DbCommand command = CreateDbCommand(sql, parameters, commandType);
try
{
command.Connection.Open();
return command.ExecuteReader(CommandBehavior.CloseConnection);
}
catch (Exception ex)
{
OnOnExecute(new ExecuteArgument(ex.Message, command.CommandText, parameters));
throw new ArgumentException("ExecuteReader Error.");
}
}

/// <summary>
/// 执行一个查询语句，返回一个包含查询结果的DataTable
/// </summary>
/// <param name="sql">要执行的查询语句</param>
/// <param name="parameters">执行SQL查询语句所需要的参数</param>
/// <returns></returns>
public DataTable ExecuteDataTable(string sql, IList<DbParameter> parameters)
{
return ExecuteDataTable(sql, parameters, CommandType.Text);
}
/// <summary>
/// 执行一个查询语句，返回一个包含查询结果的DataTable
/// </summary>
/// <param name="sql">要执行的查询语句</param>
/// <param name="parameters">执行SQL查询语句所需要的参数</param>
/// <param name="commandType">执行的SQL语句的类型</param>
/// <returns></returns>
public DataTable ExecuteDataTable(string sql, IList<DbParameter> parameters, CommandType commandType)
{
using (DbCommand command = CreateDbCommand(sql, parameters, commandType))
{
try
{
using (DbDataAdapter adapter = providerFactory.CreateDataAdapter())
{
adapter.SelectCommand = command;
DataTable data = new DataTable();
adapter.Fill(data);
return data;
}
}
catch (Exception ex)
{
OnOnExecute(new ExecuteArgument(ex.Message, command.CommandText, parameters));
throw new ArgumentException("ExecuteDataTable Error.");
}
}
}

/// <summary>
/// 执行一个查询语句，返回查询结果的第一行第一列
/// </summary>
/// <param name="sql">要执行的查询语句</param>
/// <param name="parameters">执行SQL查询语句所需要的参数</param>
/// <returns></returns>
public Object ExecuteScalar(string sql, IList<DbParameter> parameters)
{
return ExecuteScalar(sql, parameters, CommandType.Text);
}

/// <summary>
/// 执行一个查询语句，返回查询结果的第一行第一列
/// </summary>
/// <param name="sql">要执行的查询语句</param>
/// <param name="parameters">执行SQL查询语句所需要的参数</param>
/// <param name="commandType">执行的SQL语句的类型</param>
/// <returns></returns>
public Object ExecuteScalar(string sql, IList<DbParameter> parameters, CommandType commandType)
{
using (DbCommand command = CreateDbCommand(sql, parameters, commandType))
{
try
{
command.Connection.Open();
object result = command.ExecuteScalar();
command.Connection.Close();
return result;
}
catch (Exception ex)
{
OnOnExecute(new ExecuteArgument(ex.Message, command.CommandText, parameters));
throw new ArgumentException("ExecuteScalar Error.");
}
}
}
/// <summary>
/// 执行一个查询语句，返回查询结果的DataSet
/// </summary>
/// <param name="sql">要执行的查询语句</param>
/// <param name="parameters">执行SQL查询语句所需要的参数</param>
/// <returns></returns>
public DataSet ExecuteDataSet(string sql, IList<DbParameter> parameters)
{
return ExecuteDataSet(sql, parameters, CommandType.Text);
}
/// <summary>
/// 执行一个查询语句，返回查询结果的DataSet
/// </summary>
/// <param name="sql">要执行的查询语句</param>
/// <param name="parameters">执行SQL查询语句所需要的参数</param>
/// <param name="commandType">执行的SQL语句的类型</param>
/// <returns></returns>
public DataSet ExecuteDataSet(string sql, IList<DbParameter> parameters, CommandType commandType)
{
using (DbCommand command = CreateDbCommand(sql, parameters, commandType))
{
try
{
using (DbDataAdapter adapter = providerFactory.CreateDataAdapter())
{
adapter.SelectCommand = command;
DataSet ds = new DataSet();
adapter.Fill(ds);
return ds;
}
}
catch (Exception ex)
{
OnOnExecute(new ExecuteArgument(ex.Message, command.CommandText, parameters));
throw new ArgumentException("ExecuteDataSet Error.");
}

}
}

public DbParameter CreateDbParameter(string name, object value)
{
return CreateDbParameter(name, ParameterDirection.Input, value);
}

public DbParameter CreateDbParameter(string name, ParameterDirection parameterDirection, object value)
{
DbParameter parameter = providerFactory.CreateParameter();
parameter.ParameterName = name;
parameter.Value = value;
parameter.Direction = parameterDirection;
return parameter;
}

/// <summary>
/// 创建一个DbCommand对象
/// </summary>
/// <param name="sql">要执行的查询语句</param>
/// <param name="parameters">执行SQL查询语句所需要的参数</param>
/// <param name="commandType">执行的SQL语句的类型</param>
/// <returns></returns>
private DbCommand CreateDbCommand(string sql, IList<DbParameter> parameters, CommandType commandType)
{
DbConnection connection = providerFactory.CreateConnection();
DbCommand command = providerFactory.CreateCommand();
connection.ConnectionString = ConnectionString;
command.CommandText = sql;
command.CommandType = commandType;
command.Connection = connection;
if (!(parameters == null || parameters.Count == 0))
{
foreach (DbParameter parameter in parameters)
{
command.Parameters.Add(parameter);
}
}
return command;
}
/// <summary>
/// ExecuteArgument
/// </summary>
public class ExecuteArgument : EventArgs
{
public ExecuteArgument(string message)
{
this.message = message;
}

public ExecuteArgument(string message, string sql)
{
this.message = message;
this.sql = sql;
}

public ExecuteArgument(string message, string sql, IList<DbParameter> parameters)
{
this.message = message;
this.sql = sql;
this.parameters = parameters;
}

private string sql;
public string Sql
{
get { return sql; }
}

private string message;
public string Message
{
get { return message; }
}

private IList<DbParameter> parameters;
public IList<DbParameter> Parameters
{
get { return parameters; }
}
}

public delegate void ExecuteErrorHandler(object sender, ExecuteArgument e);

public event ExecuteErrorHandler ExecuteError;

public void OnOnExecute(ExecuteArgument e)
{
if (!Log)
{
return;
}
if (Log && ExecuteError == null)
{
ExecuteError = ExecuteLog.FileLog;
}
ExecuteErrorHandler errorHandler = ExecuteError;
if (errorHandler != null) errorHandler(this, e);
}
}
/// <summary>
/// 数据库类型枚举
/// </summary>
public enum DbProviderType : byte
{
SqlServer,
MySql,
SQLite,
Oracle,
ODBC,
OleDb,
Firebird,
PostgreSql,
DB2,
Informix,
SqlServerCe
}
/// <summary>
/// DbProviderFactory工厂类
/// </summary>
public class ProviderFactory
{
private static Dictionary<DbProviderType, string> providerInvariantNames = new Dictionary<DbProviderType, string>();
private static Dictionary<DbProviderType, DbProviderFactory> providerFactoies = new Dictionary<DbProviderType, DbProviderFactory>(20);
static ProviderFactory()
{
//加载已知的数据库访问类的程序集
providerInvariantNames.Add(DbProviderType.SqlServer, "System.Data.SqlClient");
providerInvariantNames.Add(DbProviderType.OleDb, "System.Data.OleDb");
providerInvariantNames.Add(DbProviderType.ODBC, "System.Data.ODBC");
providerInvariantNames.Add(DbProviderType.Oracle, "Oracle.DataAccess.Client");
providerInvariantNames.Add(DbProviderType.MySql, "MySql.Data.MySqlClient");
providerInvariantNames.Add(DbProviderType.SQLite, "System.Data.SQLite");
providerInvariantNames.Add(DbProviderType.Firebird, "FirebirdSql.Data.Firebird");
providerInvariantNames.Add(DbProviderType.PostgreSql, "Npgsql");
providerInvariantNames.Add(DbProviderType.DB2, "IBM.Data.DB2.iSeries");
providerInvariantNames.Add(DbProviderType.Informix, "IBM.Data.Informix");
providerInvariantNames.Add(DbProviderType.SqlServerCe, "System.Data.SqlServerCe");
}
/// <summary>
/// 获取指定数据库类型对应的程序集名称
/// </summary>
/// <param name="providerType">数据库类型枚举</param>
/// <returns></returns>
public static string GetProviderInvariantName(DbProviderType providerType)
{
return providerInvariantNames[providerType];
}

/// <summary>
/// 获取指定类型的数据库对应的DbProviderFactory
/// </summary>
/// <param name="providerType">数据库类型枚举</param>
/// <returns></returns>
public static DbProviderFactory GetDbProviderFactory(DbProviderType providerType)
{
//如果还没有加载，则加载该DbProviderFactory
if (!providerFactoies.ContainsKey(providerType))
{
providerFactoies.Add(providerType, ImportDbProviderFactory(providerType));
}
return providerFactoies[providerType];
}
/// <summary>
/// 加载指定数据库类型的DbProviderFactory
/// </summary>
/// <param name="providerType">数据库类型枚举</param>
/// <returns></returns>
private static DbProviderFactory ImportDbProviderFactory(DbProviderType providerType)
{
string providerName = providerInvariantNames[providerType];
DbProviderFactory factory = null;
try
{
//从全局程序集中查找
factory = DbProviderFactories.GetFactory(providerName);
}
catch (ArgumentException e)
{
factory = null;
}
return factory;
}
}
/// <summary>
/// 日志类
/// </summary>
public class ExecuteLog
{
private static readonly object ThreadSafeLogLock = new object();
/// <summary>
/// 将日志输出到文本
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public static void FileLog(object sender, DbUtility.ExecuteArgument e)
{
lock (ThreadSafeLogLock)
{
using (
var sw = new StreamWriter(AppDomain.CurrentDomain.BaseDirectory + "/data/DbExecuteLog.log", true,Encoding.UTF8))
{
sw.WriteLine(DateTime.Now.ToString("[yyyy-MM-dd HH:mm:ss]"));
sw.WriteLine("SQL:" + e.Sql);
if (e.Parameters != null)
{
sw.WriteLine("parameters:");
foreach (DbParameter parameter in e.Parameters)
{
sw.WriteLine(parameter.ParameterName + ": " + parameter.Value);
}
}
sw.WriteLine("Message:" + e.Message);
sw.WriteLine("");
sw.WriteLine("");
}
}
}
}
}

转载于:https://www.cnblogs.com/BlackCherry/p/4555362.html