C#编写一个支持Mysql,Acces,SQL数据库类（支持存储过程）
2009-07-18 11:45
447 查看
数据类型转换工具类：
using System;
using System.Data;
using System.Text.RegularExpressions;
namespace EXSystem.Data
{
public sealed class ConverValue
{
public static string ToValidId(string input)
{
if (!string.IsNullOrEmpty(input))
{
string[] strArray = input.Split(new char[] { ',' });
string str = "";
for (int i = 0; i < strArray.GetLength(0); i++)
{
if (IsNumeric(strArray[i]))
{
str = str + strArray[i] + ",";
}
}
if (str.Length > 0)
{
return str.Substring(0, str.Length - 1);
}
}
return "0";
}
/// <summary>
/// 判断字符串是否由数字组成
/// </summary>
public static bool IsNumeric(string s)
{
if (s.Trim() != null || !string.IsNullOrEmpty(s.Trim()))
{
string pattern = @"^/-?[0-9]+$";
return Regex.IsMatch(s.Trim(), pattern);
}
else
{
return false;
}
}
public static int ObjectToInt32(object value)
{
int result = 0;
if ((!object.Equals(value, null) && !object.Equals(value, DBNull.Value)) && !int.TryParse(value.ToString(), out result))
{
result = 0;
}
return result;
}
public static bool IsDBNull(IDataReader Reader, string name)
{
bool ok = false;
if (string.IsNullOrEmpty(name))
{
ok = true;
}
else
{
try
{
ok = Reader.IsDBNull(Reader.GetOrdinal(name));
}
catch
{
ok = true;
}
}
return ok;
}
public static string GetString(IDataReader Reader, string name)
{
string str = string.Empty;
if (!IsDBNull(Reader, name))
{
str = Reader.GetString(Reader.GetOrdinal(name));
}
return str;
}
public static int GetInt32(IDataReader Reader, string name)
{
if (IsDBNull(Reader, name))
{
return 0;
}
else
{
return Reader.GetInt32(Reader.GetOrdinal(name));
}
}
public static DateTime GetDateTime(IDataReader Reader, string name)
{
if (IsDBNull(Reader, name))
{
return DateTime.Now;
}
return Reader.GetDateTime(Reader.GetOrdinal(name));
}
/// <summary>
/// 将对象转换为float型
/// </summary>
/// <param name="strValue">要转换的字符串</param>
/// <param name="defValue">缺省值</param>
/// <returns>转换后的int类型结果</returns>
private static float StrToFloat(object strValue, float defValue)
{
if ((strValue == null) || (strValue.ToString().Length > 10))
{
return defValue;
}
float intValue = defValue;
if (strValue != null)
{
bool IsFloat = Regex.IsMatch(strValue.ToString(), @"^([-]|[0-9])[0-9]*(/./w*)?$");
if (IsFloat)
{
intValue = Convert.ToSingle(strValue);
}
}
return intValue;
}
/// <summary>
/// 将对象转换为Int32类型
/// </summary>
/// <param name="strValue">要转换的字符串</param>
/// <param name="defValue">缺省值</param>
/// <returns>转换后的int类型结果</returns>
private static int StrToInt(object Expression, int defValue)
{
if (Expression != null)
{
string str = Expression.ToString();
if (str.Length > 0 && str.Length <= 11 && Regex.IsMatch(str, @"^[-]?[0-9]*$"))
{
if ((str.Length < 10) || (str.Length == 10 && str[0] == '1') || (str.Length == 11 && str[0] == '-' && str[1] == '1'))
{
return Convert.ToInt32(str);
}
}
}
return defValue;
}
/// <summary>
/// 检查一个字符串是否可以转化为日期，一般用于验证用户输入日期的合法性。
/// </summary>
/// <param name="_value">需验证的字符串。</param>
/// <returns>是否可以转化为日期的bool值。</returns>
private static bool IsDateTime(string _value)
{
if (string.IsNullOrEmpty(_value))
{
return false;
}
else
{
try
{
DateTime d = DateTime.Parse(_value);
return true;
}
catch (FormatException)
{
return false;
}
}
}
/// <summary>
/// 返回标准时间格式string
/// </summary>
private static string GetDateTime()
{
return DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
}
/// <summary>
/// 返回标准时间
/// </summary>
/// <param name="fDateTime"></param>
/// <returns></returns>
private static string GetStandardDateTime(string fDateTime)
{
if (IsDateTime(fDateTime))
{
return Convert.ToDateTime(fDateTime).ToString("yyyy-MM-dd HH:mm:ss");
}
else
{
return GetDateTime();
}
}
/// <summary>
/// 转换某些值符合数据库能够接受的值
/// </summary>
/// <param name="DbType"></param>
/// <param name="Value"></param>
/// <returns></returns>
public static object ToStrValue(DbType dbType, object Value)
{
object _Value = null;
if (Value != null)
{
switch (dbType)
{
case DbType.Int32:
{
_Value = (object)StrToInt(Value, 0);
break;
}
case DbType.Double:
{
_Value = (object)StrToFloat(Value, 0);
break;
}
case DbType.DateTime:
{
_Value = (object)GetStandardDateTime(Value.ToString());
break;
}
default:
_Value = Value;
break;
}
}
return _Value;
}
}
}IDbProvider接口：
using System;
using System.Xml;
using System.Data;
using System.Data.Common;
namespace EXSystem.Data
{
public interface IDbProvider
{
DbConnection CreateConnection(string ConnectionString);
DbDataAdapter CreateDataAdapter();
string GetLastIdSql();
//XmlReader ExecuteXmlReader(DbCommand command);
DbParameter GetParameter(string ParameterName, DbType Type, int Size);
string ToParameterName(string ParamName);
string ToSql(string Sql);
}
}Access类：
using System;
using System.Data;
using System.Data.Common;
using System.Data.OleDb;
using System.Configuration;
using System.Web;
namespace EXSystem.Data
{
public class Access : IDbProvider
{
private readonly string getConnectionString = "provider=microsoft.jet.oledb.4.0;data source=" + HttpContext.Current.Server.MapPath(ConfigurationManager.AppSettings["AccessString"].ToString());
public Access()
{ }
#region IDbProvider 成员
public DbConnection CreateConnection(string ConnectionString)
{
if (string.IsNullOrEmpty(ConnectionString))
{
return new OleDbConnection(this.getConnectionString);
}
else
{
return new OleDbConnection(ConnectionString);
}
}
public DbDataAdapter CreateDataAdapter()
{
return new OleDbDataAdapter();
}
public string GetLastIdSql()
{
return "SELECT @@IDENTITY";
}
public DbParameter GetParameter(string ParameterName, DbType Type, int Size)
{
OleDbParameter param;
if (Size > 0)
param = new OleDbParameter(ToParameterName(ParameterName), ToDbType(Type), Size);
else
param = new OleDbParameter(ToParameterName(ParameterName), ToDbType(Type));
return param;
}
private OleDbType ToDbType(DbType setType)
{
OleDbType ReturnType = 0;
switch (setType)
{
case DbType.AnsiString:
{
ReturnType = OleDbType.VarChar;
break;
}
case DbType.Binary:
{
ReturnType = OleDbType.VarBinary;
break;
}
case DbType.Byte:
{
ReturnType = OleDbType.UnsignedTinyInt;
break;
}
case DbType.Boolean:
{
ReturnType = OleDbType.Boolean;
break;
}
case DbType.Currency:
{
ReturnType = OleDbType.Currency;
break;
}
case DbType.Date:
{
ReturnType = OleDbType.DBDate;
break;
}
case DbType.DateTime:
{
ReturnType = OleDbType.DBTimeStamp;
break;
}
case DbType.Decimal:
{
ReturnType = OleDbType.Decimal;
break;
}
case DbType.Double:
{
ReturnType = OleDbType.Double;
break;
}
case DbType.Guid:
{
ReturnType = OleDbType.Guid;
break;
}
case DbType.Int16:
{
ReturnType = OleDbType.SmallInt;
break;
}
case DbType.Int32:
{
ReturnType = OleDbType.Integer;
break;
}
case DbType.Int64:
{
ReturnType = OleDbType.BigInt;
break;
}
case DbType.Object:
{
ReturnType = OleDbType.Variant;
break;
}
case DbType.SByte:
{
ReturnType = OleDbType.TinyInt;
break;
}
case DbType.Single:
{
ReturnType = OleDbType.Single;
break;
}
case DbType.String:
{
ReturnType = OleDbType.VarWChar;
break;
}
case DbType.Time:
{
ReturnType = OleDbType.DBTime;
break;
}
case DbType.UInt16:
{
ReturnType = OleDbType.UnsignedSmallInt;
break;
}
case DbType.UInt32:
{
ReturnType = OleDbType.UnsignedInt;
break;
}
case DbType.UInt64:
{
ReturnType = OleDbType.UnsignedBigInt;
break;
}
case DbType.VarNumeric:
{
ReturnType = OleDbType.VarNumeric;
break;
}
case DbType.AnsiStringFixedLength:
{
ReturnType = OleDbType.Char;
break;
}
case DbType.StringFixedLength:
{
ReturnType = OleDbType.WChar;
break;
}
case DbType.Xml:
{
ReturnType = OleDbType.IUnknown;
break;
}
}
return ReturnType;
}
public string ToParameterName(string ParamName)
{
string sParamName = string.Empty;
if (ParamName != string.Empty)
{
sParamName = ParamName.Replace("?", "@");
}
return sParamName;
}
public string ToSql(string Sql)
{
string sSql = string.Empty;
if (!string.IsNullOrEmpty(Sql))
{
sSql = Sql;
}
return sSql;
}
#endregion
}
}SqlServer类：
using System;
using System.Data;
using System.Data.Common;
using System.Data.SqlClient;
using System.Configuration;
namespace EXSystem.Data
{
public class SqlServer : IDbProvider
{
private readonly string getConnectionString = ConfigurationManager.AppSettings["SqlServerString"].ToString();
public SqlServer()
{ }
#region IDbProvider 成员
public DbConnection CreateConnection(string ConnectionString)
{
if (string.IsNullOrEmpty(ConnectionString))
{
return new SqlConnection(this.getConnectionString);
}
else
{
return new SqlConnection(ConnectionString);
}
}
public DbDataAdapter CreateDataAdapter()
{
return new SqlDataAdapter();
}
public string GetLastIdSql()
{
return "SELECT SCOPE_IDENTITY()";
}
public DbParameter GetParameter(string ParameterName, DbType Type, int Size)
{
SqlParameter param;
if (Size > 0)
param = new SqlParameter(ParameterName, ToDbType(Type), Size);
else
param = new SqlParameter(ParameterName, ToDbType(Type));
return param;
}
private SqlDbType ToDbType(DbType settype)
{
SqlDbType ReturnType = 0;
switch (settype)
{
case DbType.AnsiString:
ReturnType = SqlDbType.VarChar;
break;
case DbType.Binary:
ReturnType = SqlDbType.VarBinary;
break;
case DbType.Byte:
ReturnType = SqlDbType.TinyInt;
break;
case DbType.Boolean:
ReturnType = SqlDbType.Bit;
break;
case DbType.Currency:
ReturnType = SqlDbType.Money;
break;
case DbType.Date:
case DbType.DateTime:
ReturnType = SqlDbType.DateTime;
break;
case DbType.Decimal:
ReturnType = SqlDbType.Decimal;
break;
case DbType.Double:
ReturnType = SqlDbType.Float;
break;
case DbType.Guid:
ReturnType = SqlDbType.UniqueIdentifier;
break;
case DbType.Int16:
ReturnType = SqlDbType.SmallInt;
break;
case DbType.Int32:
ReturnType = SqlDbType.Int;
break;
case DbType.Int64:
ReturnType = SqlDbType.BigInt;
break;
case DbType.Object:
ReturnType = SqlDbType.Variant;
break;
case DbType.Single:
ReturnType = SqlDbType.Real;
break;
case DbType.String:
ReturnType = SqlDbType.VarChar;
break;
case DbType.Time:
ReturnType = SqlDbType.DateTime;
break;
case DbType.AnsiStringFixedLength:
ReturnType = SqlDbType.Text;
break;
case DbType.StringFixedLength:
ReturnType = SqlDbType.Text;
break;
case DbType.Xml:
ReturnType = SqlDbType.Xml;
break;
}
return ReturnType;
}
public string ToParameterName(string ParamName)
{
string sParamName = string.Empty;
if (ParamName != string.Empty)
{
sParamName = ParamName.Replace("?", "@");
}
return sParamName;
}
public string ToSql(string Sql)
{
string sSql = string.Empty;
if (!string.IsNullOrEmpty(Sql))
{
sSql = Sql.Replace("[", "").Replace("]", "").Replace("?","@");
}
return sSql;
}
#endregion
}
}MySql类（需引用MySql.Data.dll）
using System;
using System.Data;
using System.Data.Common;
using MySql.Data.MySqlClient;
using System.Configuration;
namespace EXSystem.Data
{
public class MySql :IDbProvider
{
private readonly string getConnectionString = ConfigurationManager.AppSettings["MySqlString"].ToString();
#region IDbProvider 成员
public MySql()
{ }
public DbConnection CreateConnection(string ConnectionString)
{
if (string.IsNullOrEmpty(ConnectionString))
{
return new MySqlConnection(this.getConnectionString);
}
else
{
return new MySqlConnection(ConnectionString);
}
}
public DbDataAdapter CreateDataAdapter()
{
return new MySqlDataAdapter();
}
public string GetLastIdSql()
{
return "SELECT SCOPE_IDENTITY()";
}
public DbParameter GetParameter(string ParameterName, DbType Type, int Size)
{
MySqlParameter param;
if (Size > 0)
param = new MySqlParameter(ToParameterName(ParameterName), ToDbType(Type), Size);
else
param = new MySqlParameter(ToParameterName(ParameterName), ToDbType(Type));
return param;
}
private MySqlDbType ToDbType(DbType dbType)
{
MySqlDbType ReturnType = 0;
switch (dbType)
{
case DbType.AnsiString:
case DbType.Guid:
case DbType.String:
{
ReturnType = MySqlDbType.VarString;
break;
}
case DbType.Byte:
case DbType.Boolean:
{
ReturnType = MySqlDbType.UByte;
break;
}
case DbType.Currency:
case DbType.Decimal:
{
ReturnType = MySqlDbType.Decimal;
break;
}
case DbType.Date:
{
ReturnType = MySqlDbType.Date;
break;
}
case DbType.DateTime:
{
ReturnType = MySqlDbType.Datetime;
break;
}
case DbType.Double:
{
ReturnType = MySqlDbType.Double;
break;
}
case DbType.Int16:
{
ReturnType = MySqlDbType.Int16;
break;
}
case DbType.Int32:
{
ReturnType = MySqlDbType.Int32;
break;
}
case DbType.Int64:
{
ReturnType = MySqlDbType.Int64;
break;
}
case DbType.SByte:
{
ReturnType = MySqlDbType.Byte;
break;
}
case DbType.Single:
{
ReturnType = MySqlDbType.Float;
break;
}
case DbType.Time:
{
ReturnType = MySqlDbType.Time;
break;
}
case DbType.UInt16:
{
ReturnType = MySqlDbType.UInt16;
break;
}
case DbType.UInt32:
{
ReturnType = MySqlDbType.UInt32;
break;
}
case DbType.UInt64:
{
ReturnType = MySqlDbType.UInt64;
break;
}
case DbType.AnsiStringFixedLength:
case DbType.StringFixedLength:
{
ReturnType = MySqlDbType.String;
break;
}
default:
{
ReturnType = MySqlDbType.Blob;
break;
}
}
return ReturnType;
}
public string ToParameterName(string ParamName)
{
string sParamName = string.Empty;
if (ParamName != string.Empty)
{
sParamName = ParamName.Replace("@", "?");
}
return sParamName;
}
public string ToSql(string Sql)
{
string sSql = string.Empty;
if (!string.IsNullOrEmpty(Sql))
{
sSql = Sql.Replace("[", "").Replace("]", "").Replace("@","?");
}
return sSql;
}
#endregion
}
}DbHelper类：
using System;
using System.Data;
using System.Collections.Generic;
using System.Data.Common;
using System.Configuration;
using System.Web;
using System.Text.RegularExpressions;
namespace EXSystem.Data
{
public enum DataType
{
Access,
MySql,
SqlServer,
}
public class DbHelper
{
private DbConnection _Connection = null;
private string _ConnectionString = string.Empty;
private DbDataAdapter _DataAdapter = null;
//private DbCommand _Command;
private DataType _DataType = GetDataType();
private IDbProvider _IDbProvider = null;
private string _GetLastIdSql = string.Empty;
private static object lockHelper = new object();
private bool _Transaction = false;
private DbTransaction _Trans = null;
public DbHelper()
{
LoadSet();
}
public DbHelper(DataType SetDataType, string ConnectionString)
{
this._DataType = SetDataType;
this._ConnectionString = ConnectionString;
this._IDbProvider = Provider;
this._Connection = _IDbProvider.CreateConnection(GetConnectionString);
this._DataAdapter = _IDbProvider.CreateDataAdapter();
this._GetLastIdSql = _IDbProvider.GetLastIdSql();
}
private static DataType GetDataType()
{
DataType settype = DataType.Access;
try
{
settype = (DataType)Enum.Parse(typeof(DataType), ConfigurationManager.AppSettings["DataType"].ToString(), true);
return settype;
}
catch (ArgumentException Ex)
{
throw new ArgumentException("请检查Web.config中DataType节点Value值是否正确，例如：Access、MySql、SqlServer,Errorr：" + Ex.Message);
}
}
public DataType SetDataType
{
get { return this._DataType; }
set { this._DataType = value; }
}
public string GetConnectionString
{
get { return this._ConnectionString; }
set { this._ConnectionString = value; }
}
public bool Transaction
{
get { return this._Transaction; }
set { this._Transaction = value; }
}
/// <summary>
/// 开始一个事务
/// </summary>
private void BeginTrans()
{
this._Trans = this._Connection.BeginTransaction();
this._Transaction = true;
}
private void Commit()
{
if (_Trans != null)
{
_Trans.Commit();
_Transaction = false;
}
}
private void Rollback()
{
if (_Trans != null)
{
_Trans.Rollback();
_Transaction = false;
}
}
private void LoadSet()
{
this._IDbProvider = Provider;
this._Connection = _IDbProvider.CreateConnection(GetConnectionString);
this._DataAdapter = _IDbProvider.CreateDataAdapter();
this._GetLastIdSql = _IDbProvider.GetLastIdSql();
}
public void Close()
{
if (this._Connection.State == ConnectionState.Open)
{
this._Connection.Close();
}
}
public void ReSet()
{
this._Connection = null;
this._DataAdapter = null;
this._GetLastIdSql = string.Empty;
this._IDbProvider = null;
}
/// <summary>
/// IDbProvider接口
/// </summary>
private IDbProvider Provider
{
get
{
if (_IDbProvider == null)
{
lock (lockHelper)
{
if (_IDbProvider == null)
{
try
{
switch (_DataType)
{
case DataType.Access:
{
_IDbProvider = new Access();
break;
}
case DataType.MySql:
{
_IDbProvider = new MySql();
break;
}
case DataType.SqlServer:
{
_IDbProvider = new SqlServer();
break;
}
//default:
// {
// _IDbProvider = new Access();
// break;
// }
}
}
catch
{
throw new Exception("请检查Web.config中DataType节点Value值是否正确，例如：Access、MySql、SqlServer");
}
}
}
}
return _IDbProvider;
}
}
#region 私有方法
/// <summary>
/// 预处理用户提供的命令,数据库连接/事务/命令类型/参数
/// </summary>
/// <param name="command">要处理的DbCommand</param>
/// <param name="connection">已存在连接字符的数据库连接</param>
/// <param name="commandType">命令类型 (存储过程,命令文本, 其它.)</param>
/// <param name="commandText">存储过程名或都SQL命令文本</param>
/// <param name="commandParameters">和命令相关联的DbParameter参数数组,如果没有参数为'null'</param>
/// <param name="mustCloseConnection">如果连接是打开的,则为true,其它情况下为false.</param>
protected virtual void PrepareCommand(DbCommand command, DbConnection connection, CommandType commandType, string commandText, DbParameter[] commandParameters)
{
if (command == null)
{
throw new ArgumentNullException("command");
}
if ((commandText == null) || (commandText.Length == 0))
{
throw new ArgumentNullException("commandText");
}
if (connection.State != ConnectionState.Open)
{
connection.Open();
}
command.Connection = connection;
command.CommandText = commandText;
if (this._Transaction == true)
{
BeginTrans();
if (this._Trans.Connection == null)
{
throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
}
command.Transaction = _Trans;
}
command.CommandType = commandType;
if (commandParameters != null)
{
this.AddParameters(command, commandParameters);
}
}
/// <summary>
/// 将DbParameter参数数组(参数值)分配给DbCommand命令.
/// 这个方法将给任何一个参数分配DBNull.Value;
/// 该操作将阻止默认值的使用.
/// </summary>
/// <param name="command">命令名</param>
/// <param name="commandParameters">DbParameters数组</param>
protected virtual void AddParameters(DbCommand command, DbParameter[] commandParameters)
{
if (command == null)
{
throw new ArgumentNullException("command");
}
if (commandParameters != null)
{
foreach (DbParameter parameter in commandParameters)
{
if (parameter != null)
{
if (((parameter.Direction == ParameterDirection.Output) || (parameter.Direction == ParameterDirection.Input)) && (parameter.Value == null))
{
parameter.Value = DBNull.Value;
}
command.Parameters.Add(parameter);
}
}
}
}
public virtual DbParameter GetParameter(string name, DbType dbType, int size, object Value, string sourceColumn, ParameterDirection Direction)
{
DbParameter parameter = this._IDbProvider.GetParameter(name, dbType, size);
parameter.DbType = dbType;
parameter.ParameterName = this._IDbProvider.ToParameterName(name);
if (!string.IsNullOrEmpty(sourceColumn))
{
parameter.SourceColumn = sourceColumn;
}
if ((size > 0) && (parameter is DbParameter))
{
parameter.Size = size;
}
if (!(Direction == ParameterDirection.Output && Value == null))
parameter.Value = ConverValue.ToStrValue(dbType, Value);
return parameter;
}
void ClearCommand(DbCommand command)
{
bool flag = true;
foreach (DbParameter parameter in command.Parameters)
{
if (parameter.Direction != ParameterDirection.Output)
{
flag = false;
}
}
if (flag)
{
command.Parameters.Clear();
}
}
DbDataAdapter DataAdapter(DbConnection Connection, string commandText, CommandType commandType, DbParameter[] commandParameters)
{
if (Connection == null)
{
throw new ArgumentNullException("connection");
}
try
{
DbCommand Command = Connection.CreateCommand();
this.PrepareCommand(Command, Connection, commandType, this._IDbProvider.ToSql(this._IDbProvider.ToParameterName(commandText)), commandParameters);
DbDataAdapter Adpter = this._DataAdapter;
Adpter.MissingSchemaAction = MissingSchemaAction.AddWithKey;
Adpter.SelectCommand = Command;
//Command.Parameters.Clear();
Commit();
return Adpter;
}
catch (Exception ep)
{
Rollback();
throw new Exception(ep.Message);
}
finally
{
Connection.Close();
}
}
int ExecuteNonQuery(DbCommand command)
{
bool flag = false;
if (command.Connection.State != ConnectionState.Open)
{
command.Connection.Open();
flag = true;
}
if (command == null)
{
throw new ArgumentNullException("command");
}
int num = command.ExecuteNonQuery();
if (flag)
{
command.Connection.Close();
}
return num;
}
int ExecuteNonQuery(DbConnection Connection, string commandText, CommandType commandType, params DbParameter[] commandParameters)
{
if (Connection == null)
{
throw new ArgumentNullException("connection");
}
if (Connection.State == ConnectionState.Open)
{
Connection.Close();
}
try
{
DbCommand Command = Connection.CreateCommand();
if (Command.Connection.State == ConnectionState.Closed)
{
Command.Connection.Open();
}
this.PrepareCommand(Command, Connection, commandType, _IDbProvider.ToSql(_IDbProvider.ToParameterName(commandText)), commandParameters);
int num = this.ExecuteNonQuery(Command);
Commit();
// 清除参数,以便再次使用.
Command.Parameters.Clear();
Connection.Close();
return num;
}
catch (Exception ep)
{
Rollback();
throw new Exception(ep.Message);
}
finally
{
Connection.Close();
}
}
/// <summary>
/// 用于模湖字段添加或修改
/// </summary>
/// <param name="connection"></param>
/// <param name="TableName"></param>
/// <param name="SqlType"></param>
/// <param name="commandParameters"></param>
/// <param name="WherecommandParameters"></param>
/// <returns></returns>
public virtual int ExecuteNonQuery(DbConnection connection, string TableName, int SqlType, DbParameter[] commandParameters, params DbParameter[] WherecommandParameters)
{
int ReturnInt = 0;
if (SqlType < 0)
{
SqlType = 0;
WherecommandParameters = null;
}
if (SqlType > 1)
{
SqlType = 1;
}
if (connection == null)
{
throw new ArgumentNullException("connection");
}
else
{
if (connection.State == ConnectionState.Closed)
{
connection.Open();
}
try
{
DbCommand command = connection.CreateCommand();
string sql = string.Empty;
string FieldWhere = string.Empty;
string TempFields = string.Empty;
string TempFieldValue = string.Empty;
if (!string.IsNullOrEmpty(TableName))
{
if (commandParameters != null)
{
foreach (DbParameter parameter in commandParameters)
{
if (parameter != null)
{
if (CheckFieldName(connection, TableName, parameter.ParameterName.Trim().Replace("@", "").Replace("?", "")))
{
if (((parameter.Direction == ParameterDirection.Output) || (parameter.Direction == ParameterDirection.Input)) && (parameter.Value == null))
{
parameter.Value = DBNull.Value;
}
if (SqlType == 0)
{
if (CheckPrimaryKey(connection, TableName, parameter.ParameterName.Trim().Replace("@", "").Replace("?", "")))
{
if (CheckPrimaryKeyValue(connection, TableName, parameter.ParameterName.Trim().Replace("@", "").Replace("?", ""), parameter.Value))
{
parameter.Value = ConverValue.ObjectToInt32(parameter.Value) + 1;
}
}
TempFields = TempFields + "[" + parameter.ParameterName.Trim().Replace("@", "").Replace("?", "") + "]" + ",";
TempFieldValue = TempFields + "?" + parameter.ParameterName.Trim().Replace("@", "").Replace("?", "") + ",";
}
else if (SqlType == 1)
{
TempFields = TempFields + "[" + parameter.ParameterName.Trim().Replace("@", "").Replace("?", "") + "]=?" + parameter.ParameterName.Trim().Replace("@", "").Replace("?", "") + ",";
TempFieldValue = string.Empty;
}
command.Parameters.Add(parameter);
}
}
}
if (TempFields.Length > 0)
{
TempFields = TempFields.Substring(0, TempFields.Length - 1);
}
if (WherecommandParameters != null && SqlType == 1)
{
foreach (DbParameter parameter in WherecommandParameters)
{
if (parameter != null)
{
if (CheckFieldName(connection, TableName, parameter.ParameterName.Trim().Replace("@", "").Replace("?", "")))
{
if (((parameter.Direction == ParameterDirection.Output) || (parameter.Direction == ParameterDirection.Input)) && (parameter.Value == null))
{
parameter.Value = DBNull.Value;
}
command.Parameters.Add(parameter);
FieldWhere = FieldWhere + "[" + parameter.ParameterName.Trim().Replace("@", "").Replace("?", "") + "]=?" + parameter.ParameterName.Trim().Replace("@", "").Replace("?", "") + " AND ";
}
}
}
if (FieldWhere.Length > 4)
{
FieldWhere = FieldWhere.Substring(0, FieldWhere.Length - 4).Trim();
}
}
if (SqlType == 0 && !string.IsNullOrEmpty(TempFieldValue))
{
if (!string.IsNullOrEmpty(TempFields))
{
if (!string.IsNullOrEmpty(TempFields.Replace(",", "").Replace("?", "").Replace("@", "").Replace("[", "").Replace("]", "")))
{
sql = string.Format("INSERT INTO [" + TableName + "] (" + TempFields + ") VALUES (" + TempFieldValue + ")");
sql = sql.Replace(",)", ")").Replace("(,", "(");
}
}
}
else if (SqlType == 1)
{
if (!string.IsNullOrEmpty(FieldWhere))
{
if (!string.IsNullOrEmpty(FieldWhere.Replace(",", "").Replace("?", "").Replace("@", "").Replace("[", "").Replace("]", "")))
{
FieldWhere = string.Format("WHERE " + FieldWhere);
}
}
if (!string.IsNullOrEmpty(TempFields))
{
if (!string.IsNullOrEmpty(TempFields.Replace(",", "").Replace("?", "").Replace("@", "").Replace("[", "").Replace("]", "")))
{
sql = string.Format("UPDATE [" + TableName + "] SET " + TempFields + " " + FieldWhere);
}
}
}
if (!string.IsNullOrEmpty(sql))
{
command.Connection = connection;
command.CommandText = _IDbProvider.ToSql(_IDbProvider.ToParameterName(sql.Replace("@@", "@").Replace("??", "?")));
if (this._Transaction == true)
{
BeginTrans();
if (this._Trans.Connection == null)
{
throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
}
command.Transaction = _Trans;
}
command.CommandType = CommandType.Text;
ReturnInt = this.ExecuteNonQuery(command);
Commit();
// 清除参数,以便再次使用.
command.Parameters.Clear();
connection.Close();
}
}
}
}
catch (Exception ep)
{
Rollback();
throw new Exception(ep.Message);
}
finally
{
connection.Close();
}
}
return ReturnInt;
}
public virtual int ExecuteNonQuery(string TableName, int SqlType, DbParameter[] commandParameters, params DbParameter[] WherecommandParameters)
{
return ExecuteNonQuery(_Connection, TableName, SqlType, commandParameters, WherecommandParameters);
}
public virtual int ExecuteNonQuery(string TableName, DbParameter[] commandParameters)
{
return ExecuteNonQuery(_Connection, TableName, 0, commandParameters, null);
}
public virtual int ExecuteNonQuery(DbConnection connection, string TableName, DbParameter[] commandParameters)
{
return ExecuteNonQuery(connection, TableName, 0, commandParameters, null);
}
public virtual int ExecuteNonQuery(string TableName, DbParameter[] commandParameters, params DbParameter[] WherecommandParameters)
{
return ExecuteNonQuery(_Connection, TableName, 1, commandParameters, WherecommandParameters);
}
public virtual int ExecuteNonQuery(DbConnection connection, string TableName, DbParameter[] commandParameters, params DbParameter[] WherecommandParameters)
{
return ExecuteNonQuery(connection, TableName,1, commandParameters, WherecommandParameters);
}
/// <summary>
/// 用于模湖字段添加或修改
/// </summary>
/// <param name="connection"></param>
/// <param name="TableName"></param>
/// <param name="SqlType"></param>
/// <param name="ListParameter"></param>
/// <param name="WhereListParameter"></param>
/// <returns></returns>
public virtual int ExecuteNonQuery(DbConnection connection, string TableName, int SqlType, List<DbParameter> ListParameter, List<DbParameter> WhereListParameter)
{
int ReturnInt = 0;
string TempFields = string.Empty;
string TempFieldValue = string.Empty;
string WhereField = string.Empty;
string sql = string.Empty;
if (ListParameter != null)
{
if (ListParameter.Count > 0)
{
try
{
if (connection == null)
{
throw new ArgumentNullException("connection");
}
else
{
if (connection.State == ConnectionState.Closed)
{
connection.Open();
}
DbCommand command = connection.CreateCommand();
foreach (DbParameter parameter in ListParameter)
{
if (parameter != null && !string.IsNullOrEmpty(parameter.ParameterName.Trim()))
{
if (CheckFieldName(connection, TableName, parameter.ParameterName.Trim().Replace("@", "").Replace("?", "")))
{
if (((parameter.Direction == ParameterDirection.Output) || (parameter.Direction == ParameterDirection.Input)) && (parameter.Value == null))
{
parameter.Value = DBNull.Value;
}
////if (parameter.DbType == DbType.Int32 || parameter.DbType == DbType.Int16 || parameter.DbType == DbType.Byte || parameter.DbType == DbType.Binary || parameter.DbType == DbType.Int64 || parameter.DbType == DbType.SByte || parameter.DbType == DbType.UInt16)
////{
//// if (parameter.Value == DBNull.Value)
//// {
//// }
////}
if (SqlType == 0)
{
if (CheckPrimaryKey(connection,TableName,parameter.ParameterName.Trim().Replace("@", "").Replace("?", "")))
{
if (CheckPrimaryKeyValue(connection, TableName, parameter.ParameterName.Trim().Replace("@", "").Replace("?", ""),parameter.Value))
{
parameter.Value = ConverValue.ObjectToInt32(parameter.Value) + 1;
}
}
TempFields = TempFields + "[" + parameter.ParameterName.Trim().Replace("@", "").Replace("?", "") + "]" + ",";
TempFieldValue = TempFieldValue + parameter.ParameterName.Trim() + ",";
}
else if (SqlType == 1)
{
TempFields = TempFields + "[" + parameter.ParameterName.Trim().Replace("@", "").Replace("?", "") + "]=?" + parameter.ParameterName.Trim().Replace("@", "").Replace("?", "") + ",";
TempFieldValue = string.Empty;
}
command.Parameters.Add(parameter);
}
}
}
if (WhereListParameter != null)
{
if (WhereListParameter.Count > 0 && SqlType == 1)
{
foreach (DbParameter parameter in WhereListParameter)
{
if (CheckFieldName(connection, TableName, parameter.ParameterName.Trim().Replace("@", "").Replace("?", "")))
{
if (((parameter.Direction == ParameterDirection.Output) || (parameter.Direction == ParameterDirection.Input)) && (parameter.Value == null))
{
parameter.Value = DBNull.Value;
}
command.Parameters.Add(parameter);
WhereField = WhereField + "[" + parameter.ParameterName.Trim().Replace("@", "").Replace("?", "") + "]=?" + parameter.ParameterName.Trim().Replace("@", "").Replace("?", "") + " AND ";
}
}
}
}
if (SqlType == 0)
{
if (TempFields.Length > 0 && TempFieldValue.Length > 0)
{
TempFields = TempFields.Substring(0, TempFields.Length - 1);
TempFieldValue = TempFieldValue.Substring(0, TempFieldValue.Length - 1);
}
sql = "INSERT INTO [" + TableName + "] (" + TempFields + ") VALUES (" + TempFieldValue + ")";
sql = sql.Replace(",)", ")");
}
else if (SqlType == 1)
{
if (TempFields.Length > 0)
{
TempFields = TempFields.Substring(0, TempFields.Length - 1);
}
if (WhereField.Length > 4)
{
WhereField = WhereField.Substring(0, WhereField.Length - 4).Trim();
}
if (!string.IsNullOrEmpty(WhereField))
{
WhereField = "WHERE " + WhereField;
}
sql = "UPDATE [" + TableName + "] SET " + TempFields + " " + WhereField;
}
if (!string.IsNullOrEmpty(sql))
{
command.Connection = connection;
command.CommandText = _IDbProvider.ToSql(_IDbProvider.ToParameterName(sql.Replace("@@", "@").Replace("??", "?")));
if (this._Transaction == true)
{
BeginTrans();
if (this._Trans.Connection == null)
{
throw new ArgumentException("The transaction was rolled back or commited, please provide an open transaction.", "transaction");
}
command.Transaction = _Trans;
}
command.CommandType = CommandType.Text;
ReturnInt = this.ExecuteNonQuery(command);
Commit();
// 清除参数,以便再次使用.
command.Parameters.Clear();
connection.Close();
}
}
}
catch (Exception ep)
{
Rollback();
throw new Exception(ep.Message);
}
finally
{
connection.Close();
}
}
}
return ReturnInt;
}
public virtual int ExecuteNonQuery(DbConnection Connection, string TableName, List<DbParameter> FieldParameter)
{
return ExecuteNonQuery(Connection, TableName, 0, FieldParameter, null);
}
public virtual int ExecuteNonQuery(string TableName, List<DbParameter> FieldParameter)
{
return ExecuteNonQuery(_Connection, TableName, 0, FieldParameter, null);
}
public virtual int ExecuteNonQuery(DbConnection Connection, string TableName, List<DbParameter> FieldParameter, List<DbParameter> WhereFieldParameter)
{
return ExecuteNonQuery(_Connection, TableName, 1, FieldParameter, WhereFieldParameter);
}
public virtual int ExecuteNonQuery(string TableName, List<DbParameter> FieldParameter, List<DbParameter> WhereFieldParameter)
{
return ExecuteNonQuery(_Connection, TableName, 1, FieldParameter, WhereFieldParameter);
}
public virtual IDataReader ExecuteReader(DbConnection Connection, string commandText, CommandType commandType, DbParameter[] commandParameters)
{
IDataReader reader2;
if (Connection == null)
{
throw new ArgumentNullException("connection");
}
if (Connection.State == ConnectionState.Open)
{
Connection.Close();
}
DbCommand Command = Connection.CreateCommand();
if (Command.Connection.State == ConnectionState.Closed)
{
Command.Connection.Open();
}
try
{
this.PrepareCommand(Command, Connection, commandType, _IDbProvider.ToSql(_IDbProvider.ToParameterName(commandText)), commandParameters);
IDataReader reader = this.ExecuteReader(Command);
Commit();
this.ClearCommand(Command);
reader2 = reader;
}
catch (Exception ep)
{
Rollback();
throw new Exception(ep.Message);
}
return reader2;
}
protected virtual IDataReader ExecuteReader(DbCommand command)
{
IDataReader reader = null;
if (command.Connection.State != ConnectionState.Open)
{
command.Connection.Open();
}
else
{
try
{
reader = command.ExecuteReader(CommandBehavior.Default);
Commit();
}
catch (Exception ep)
{
Rollback();
throw new Exception(ep.Message);
}
}
this.ClearCommand(command);
return reader;
}
object ExecuteScalar(IDbCommand command)
{
bool flag = false;
if (command.Connection.State != ConnectionState.Open)
{
command.Connection.Open();
flag = true;
}
object obj2 = command.ExecuteScalar();
if (flag)
{
command.Connection.Close();
}
return obj2;
}
object ExecuteScalar(DbConnection Connection, string commandText, CommandType commandType, params DbParameter[] commandParameters)
{
if (Connection == null)
{
throw new ArgumentNullException("connection");
}
try
{
if (Connection.State == ConnectionState.Open)
{
Connection.Close();
}
DbCommand Command = Connection.CreateCommand();
if (Command.Connection.State == ConnectionState.Closed)
{
Command.Connection.Open();
}
this.PrepareCommand(Command, Connection, commandType, _IDbProvider.ToSql(_IDbProvider.ToParameterName(commandText)), commandParameters);
object obj2 = this.ExecuteScalar(Command);
// ClearCommand(Command);
Command.Parameters.Clear();
Commit();
Connection.Close();
if (obj2 == null) obj2 = null;
return obj2;
}
catch (Exception ep)
{
Rollback();
throw new Exception(ep.Message);
}
finally
{
if (Connection.State == ConnectionState.Open)
{
Connection.Close();
}
}
}
DataSet ExecuteDataSet(DbCommand command)
{
DataSet set2;
bool flag = false;
if (command.Connection.State != ConnectionState.Open)
{
command.Connection.Open();
flag = true;
}
using (DbDataAdapter dataAdapter = this._DataAdapter)
{
try
{
dataAdapter.SelectCommand = command;
DataSet set = new DataSet();
try
{
dataAdapter.Fill(set);
}
catch (Exception)
{
throw;
}
set2 = set;
}
finally
{
if (flag)
{
command.Connection.Close();
}
if (dataAdapter != null)
{
IDisposable disposable = dataAdapter as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
}
return set2;
}
DataSet ExecuteDataSet(DbConnection Connection, string commandText, CommandType commandType, params DbParameter[] commandParameters)
{
if (Connection == null)
{
throw new ArgumentNullException("connection");
}
try
{
DbCommand Command = Connection.CreateCommand();
this.PrepareCommand(Command, Connection, commandType, _IDbProvider.ToSql(_IDbProvider.ToParameterName(commandText)), commandParameters);
DataSet set = this.ExecuteDataSet(Command);
Commit();
if (set != null)
{
return set;
}
else
{
return null;
}
}
catch (Exception ep)
{
Rollback();
throw new Exception(ep.Message);
}
finally
{
Connection.Close();
}
}
#endregion
#region Parameter
public virtual DbParameter GetOutParameter(string name, DbType dbType, int size)
{
return GetParameter(name, dbType, size, null, string.Empty, ParameterDirection.Output);
}
public virtual DbParameter GetInParameter(string name, DbType dbType, int size, object value, string sourceColumn)
{
return GetParameter(name, dbType, size, value, sourceColumn, ParameterDirection.Input);
}
public virtual DbParameter GetInParameter(string name, DbType dbType, int size, object value)
{
return GetParameter(name, dbType, size, value, null, ParameterDirection.Input);
}
public virtual DbParameter GetInParameter(string name, DbType dbType, object value)
{
return GetParameter(name, dbType, 0, value, null, ParameterDirection.Input);
}
#endregion
#region DataAdapter
public virtual DbDataAdapter SelectDataAdapter(string commandText, CommandType commandType, params DbParameter[] commandParameters)
{
return DataAdapter(_Connection, commandText, commandType, commandParameters);
}
public virtual DbDataAdapter SelectDataAdapter(string commandText, CommandType commandType)
{
return DataAdapter(_Connection, commandText, commandType, null);
}
public virtual DbDataAdapter SelectDataAdapter(string commandText)
{
return DataAdapter(_Connection, commandText, CommandType.Text, null);
}
#endregion
#region ExecuteNonQuery
public virtual int ExecuteNonQuery(string commandText, CommandType commandType, params DbParameter[] commandParameters)
{
return ExecuteNonQuery(_Connection, commandText, commandType, commandParameters);
}
public virtual int ExecuteNonQuery(string commandText, CommandType commandType)
{
return ExecuteNonQuery(_Connection, commandText, commandType, null);
}
public virtual int ExecuteNonQuery(string commandText)
{
return ExecuteNonQuery(_Connection, commandText, CommandType.Text, null);
}
#endregion
#region Reader
public virtual IDataReader ExecuteReader(string commandText, CommandType commandType, DbParameter[] commandParameters)
{
return ExecuteReader(_Connection, commandText, commandType, commandParameters);
}
public virtual IDataReader ExecuteReader(string commandText, CommandType commandType)
{
return ExecuteReader(_Connection, commandText, commandType, null);
}
public virtual IDataReader ExecuteReader(string commandText)
{
return ExecuteReader(_Connection, commandText, CommandType.Text, null);
}
#endregion Reader结束
#region ExecuteScalar
public virtual object ExecuteScalar(string commandText, CommandType commandType, params DbParameter[] commandParameters)
{
return ExecuteScalar(_Connection, commandText, commandType, commandParameters);
}
public virtual object ExecuteScalar(string commandText, CommandType commandType)
{
return ExecuteScalar(_Connection, commandText, commandType, null);
}
public virtual object ExecuteScalar(string commandText)
{
return ExecuteScalar(_Connection, commandText, CommandType.Text, null);
}
#endregion ExecuteScalar结束
#region DataSet
public virtual DataSet ExecuteDataSet(string commandText, CommandType commandType, params DbParameter[] commandParameters)
{
return ExecuteDataSet(_Connection, commandText, commandType, commandParameters);
}
public virtual DataSet ExecuteDataSet(string commandText, CommandType commandType)
{
return ExecuteDataSet(_Connection, commandText, commandType, (DbParameter[])null);
}
public virtual DataSet ExecuteDataSet(string commandText)
{
return ExecuteDataSet(_Connection, commandText, CommandType.Text, (DbParameter[])null);
}
#endregion DataSet结束
#region DataTable
public virtual DataTable ExecuteDataTable(DbConnection Connection,string commandText, CommandType commandType, params DbParameter[] commandParameters)
{
DataTable ReturnTable = new DataTable();
DataSet getDataSet = ExecuteDataSet(Connection, commandText, commandType, commandParameters);
ReturnTable = getDataSet.Tables[0];
return ReturnTable;
}
public virtual DataTable ExecuteDataTable(string commandText, CommandType commandType, params DbParameter[] commandParameters)
{
DataTable ReturnTable = new DataTable();
DataSet getDataSet = ExecuteDataSet(_Connection, commandText, commandType, commandParameters);
ReturnTable = getDataSet.Tables[0];
return ReturnTable;
}
public virtual DataTable ExecuteDataTable(string commandText, CommandType commandType)
{
return ExecuteDataTable(commandText, commandType, (DbParameter[])null);
}
public virtual DataTable ExecuteDataTable(string commandText)
{
return ExecuteDataTable(commandText, CommandType.Text, (DbParameter[])null);
}
/// <summary>
/// 需要分页时使用
/// </summary>
/// <param name="SqlAllFields">查询字段，如果是多表查询，请将必要的表名或别名加上，如:a.id,a.name,b.score</param>
/// <param name="SqlTablesAndWhere">查询的表如果包含查询条件</param>
/// <param name="IndexField">用以分页的不能重复的索引字段名，最好是主表的自增长字段，如果是多表查询，请带上表名或别名，如:a.id</param>
/// <param name="CurrentPage">当前页</param>
/// <param name="MaxPerPage">每页记录数</param>
/// <param name="PageCount">输出参数，返回查询的总页数</param>
/// <param name="RecordCount">总记录数</param>
/// <param name="commandParameters">存储过程,根据SqlTablesAndWhere的Where字段条件</param>
/// <returns>获取到的DataTable</returns>
public virtual DataTable GetDataTable(string SqlAllFields, string SqlTablesAndWhere, string IndexField, string OrderFields, int CurrentPage, int MaxPerPage, out int RecordCount, out int PageCount, params DbParameter[] commandParameters)
{
RecordCount = 0;
PageCount = 0;
if (MaxPerPage <= 0)
{
MaxPerPage = 10;
}
string SqlCount = "SELECT COUNT(" + IndexField + ") FROM " + SqlTablesAndWhere;
RecordCount = (int)ExecuteScalar(SqlCount, CommandType.Text, commandParameters);
if (RecordCount % MaxPerPage == 0)
{
PageCount = RecordCount / MaxPerPage;
}
else
{
PageCount = RecordCount / MaxPerPage + 1;
}
if (CurrentPage > PageCount)
CurrentPage = PageCount;
if (CurrentPage < 1)
CurrentPage = 1;
string Sql = null;
if (CurrentPage == 1)
{
if (GetDataType() == DataType.MySql)
{
Sql = "SELECT " + SqlAllFields + " FROM " + SqlTablesAndWhere + " " + OrderFields + " LIMIT " + MaxPerPage;
}
else
{
Sql = "SELECT TOP " + MaxPerPage + " " + SqlAllFields + " FROM " + SqlTablesAndWhere + " " + OrderFields;
}
}
else
{
if (GetDataType() == DataType.MySql)
{
Sql = "SELECT " + SqlAllFields + " FROM ";
if (SqlTablesAndWhere.ToLower().IndexOf(" where ") > 0)
{
string _where = Regex.Replace(SqlTablesAndWhere, @"/ WHERE/ ", " WHERE (", RegexOptions.IgnoreCase | RegexOptions.Compiled);
Sql += _where + ") AND (";
}
else
{
Sql += SqlTablesAndWhere + " WHERE (";
}
Sql += IndexField + " NOT IN (SELECT " + IndexField + " FROM " + SqlTablesAndWhere + " " + OrderFields + " LIMIT " + (CurrentPage - 1) * MaxPerPage;
Sql += ")) " + OrderFields + " LIMIT " + MaxPerPage;
}
else
{
Sql = "SELECT TOP " + MaxPerPage + " " + SqlAllFields + " FROM ";
if (SqlTablesAndWhere.ToLower().IndexOf(" where ") > 0)
{
string _where = Regex.Replace(SqlTablesAndWhere, @"/ WHERE/ ", " WHERE (", RegexOptions.IgnoreCase | RegexOptions.Compiled);
Sql += _where + ") AND (";
}
else
{
Sql += SqlTablesAndWhere + " WHERE (";
}
Sql += IndexField + " NOT IN (SELECT TOP " + (CurrentPage - 1) * MaxPerPage + " " + IndexField + " FROM " + SqlTablesAndWhere + " " + OrderFields;
Sql += ")) " + OrderFields;
}
}
DataSet ds = new DataSet();
DataTable dt = new DataTable();
ds = ExecuteDataSet(Sql, CommandType.Text, commandParameters);
dt = ds.Tables[0];
return dt;
}
public virtual DataTable TableSearch(DataTable dt, string sSql,string Like, int RowNum, string order)
{
DataTable table = new DataTable();
table = dt.Clone();
DataRow[] rowArray = dt.Select(sSql);
int length = rowArray.Length;
if ((length > RowNum) && (RowNum != 0))
{
length = RowNum;
}
for (int i = 0; i < length; i++)
{
table.ImportRow(rowArray[i]);
}
if (!string.IsNullOrEmpty(Like))
{
table.DefaultView.RowFilter = Like;
}
table.DefaultView.Sort = order;
return table;
}
#endregion DataTable结束
public virtual int GetMaxId(string TableAndWhere, string fieldName, CommandType commandType, params DbParameter[] commandParameters)
{
string query = "SELECT MAX(" + fieldName + ") FROM " + TableAndWhere;
return ConverValue.ObjectToInt32(ExecuteScalar(query, commandType, commandParameters)) + 1;
}
int GetMaxId(DbConnection connection,string TableName, string fieldName)
{
string query = "SELECT MAX(" + fieldName + ") FROM " + TableName;
return ConverValue.ObjectToInt32(ExecuteScalar(connection,query, CommandType.Text,null)) + 1;
}
public virtual int GetMaxId(string TableAndWhere, string fieldName, CommandType commandType)
{
string query = "SELECT MAX(" + fieldName + ") FROM " + TableAndWhere;
return ConverValue.ObjectToInt32(ExecuteScalar(query, commandType, null)) + 1;
}
public virtual int GetMaxId(string TableAndWhere, string fieldName)
{
string query = "SELECT MAX(" + fieldName + ") FROM " + TableAndWhere;
return ConverValue.ObjectToInt32(ExecuteScalar(query, CommandType.Text, null)) + 1;
}
public virtual int GetCountId(string TableAndWhere, string fieldName, CommandType commandType, params DbParameter[] commandParameters)
{
string query = "SELECT COUNT(" + fieldName + ") FROM " + TableAndWhere;
return ConverValue.ObjectToInt32(ExecuteScalar(query, commandType, commandParameters));
}
public virtual int GetCountId(string TableAndWhere, string fieldName, CommandType commandType)
{
string query = "SELECT COUNT(" + fieldName + ") FROM " + TableAndWhere;
return ConverValue.ObjectToInt32(ExecuteScalar(query, commandType, null));
}
public virtual int GetCountId(string TableAndWhere, string fieldName)
{
string query = "SELECT COUNT(" + fieldName + ") FROM " + TableAndWhere;
return ConverValue.ObjectToInt32(ExecuteScalar(query, CommandType.Text, null));
}
public virtual bool CheckFieldName(DbConnection Connection,string TableName, string FieldName)
{
bool ok = false;
if (!string.IsNullOrEmpty(TableName.Trim()))
{
if (CheckTable(Connection, TableName))
{
DataTable dt = ExecuteDataTable(Connection, "SELECT * FROM " + TableName.Trim(), CommandType.Text, null);
if (dt != null)
{
ok = dt.Columns.Contains(FieldName.Trim());
}
}
}
return ok;
}
public virtual bool CheckPrimaryKey(DbConnection Connection, string TableName, string FieldName)
{
bool ok = false;
if (!string.IsNullOrEmpty(TableName.Trim()))
{
if (CheckFieldName(Connection, TableName, FieldName))
{
//DataTable dt = ExecuteDataTable(Connection, "SELECT * FROM " + TableName.Trim(), CommandType.Text, null);
//Adapter.Fill(dt);
//if (dt != null)
//{
// //for (int i = 0; i < dt.Columns.Count; i++)
// //{
// // if (dt.Columns[i].Unique)
// // {
// // ok = true;
// // break;
// // }
// //}
// foreach (DataColumn Column in dt.PrimaryKey)
// {
// if(string.Compare(Column.ColumnName, FieldName, true) == 0)
// {
// ok = true;
// break;
// }
// }
//}
if (ExecuteScalar(Connection, "select [" + FieldName + "] from " + TableName + " where COLUMNPROPERTY(id," + FieldName + ",'IsIdentity')=1", CommandType.Text, null) != null)
{
ok = true;
}
else
{
ok = false;
}
}
}
return ok;
}
public virtual bool CheckPrimaryKey(string TableName, string FieldName)
{
return CheckPrimaryKey(_Connection, TableName, FieldName);
}
public virtual bool CheckPrimaryKeyValue(DbConnection connection, string TableName, string fieldName, object CheckValue)
{
bool ok = false;
string query = "SELECT " + fieldName + " FROM " + TableName;
object val = ExecuteScalar(connection, query, CommandType.Text, null);
if (val != null)
{
if (object.Equals(val, CheckValue))
{
ok = true;
}
}
return ok;
}
/// <summary>
/// 检测某一数据库表中是否存某一字段
/// </summary>
/// <param name="TableName">表名</param>
/// <param name="FieldName">字段名</param>
/// <returns></returns>
public virtual bool CheckFieldName(string TableName, string FieldName)
{
return CheckFieldName(_Connection, TableName, FieldName);
}
/// <summary>
/// 检测某数据库是否存某数据表
/// </summary>
/// <param name="Connection">Connection对象</param>
/// <param name="tableName">表名</param>
/// <returns></returns>
public virtual bool CheckTable(DbConnection Connection, string tableName)
{
if (Connection == null)
{
throw new ArgumentNullException("connection");
}
else
{
if (Connection.State == ConnectionState.Closed)
{
Connection.Open();
}
}
DataTable dt = Connection.GetSchema("Tables");
DataRow[] drs = dt.Select(string.Format("TABLE_TYPE='TABLE' and TABLE_NAME='{0}'", tableName));
if (drs.Length > 0) return true;
else return false;
}
/// <summary>
/// 检测某数据库是否存某数据表
/// </summary>
/// <param name="tableName">表名</param>
/// <returns></returns>
public virtual bool CheckTable(string tableName)
{
return CheckTable(_Connection, tableName);
}
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- C#编写一个支持Mysql,Acces,SQL数据库类（支持存储过程） （转）
- 一个好用的c# + Mysql + （存储过程 带有返回值的）
- 发布NBearLite v1.0.0 beta - 全面支持SqlServer，Oracle，MySql，PostgreSql数据库存储过程调用代码生成（C#/VB.NET）
- 发布NBearLite v1.0.0 beta - 全面支持SqlServer，Oracle，MySql，PostgreSql数据库存储过程调用代码生成（C#/VB.NET）
- Oracle笔记（4）：一个存储过程编写及C#调用
- 发布NBearLite v1.0.0 beta - 全面支持SqlServer，Oracle，MySql，PostgreSql数据库存储过程调用代码生成（C#/VB.NET）
- 一个通用数据库操作组件DBUtil(c#)、支持SqlServer、Oracle、Mysql、Access、SQLITE
- mysql 主从不支持存储过程
- mysql 存储过程（proceduce）查询一个表的结果插入另外一个表
- 使用C#编写一个求解数独的小软件
- 一个验证IP范围内权限的C#方法,支持 ? * -
- c#+windows环境 编写mysql集群服务
- 重写代码生成器支持模板（多层架构，MVC），多语言c#,java；支持mysql和sqlserver，动态编译
- 写一个MySql存储过程实现房贷等额本息还款计算(另外附javascript代码)
- c#下各种数据库操作的封装！(支持ACCESS,SQLSERVER,DB2,ORACLE,MYSQL)
- 一个工作流程启动的支持事务的存储过程
- 一个使用JAVA编写的类似按键精灵的程序，支持脚本文件编写(含源代码)
- mysql支持在同一个事务中出错而回滚多个数据库的数据吗？
- 唯一一个2013年度免费网站空间无广告无流量要求支持PHP+MySQL+ASP+ACCESS
- C#编写一个简单记事本功能