FoolWeb 各层代码实例

FoolWeb.DateEngine 数据库操作类库

这里现在只写了一个类用于操作mssql.将来支持别的数据库试直接扩展就行了.

下来带个代码段

/// <summary>通用数据库接口
/// </summary>
using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;

namespace FoolWeb.DateEngine {

    #region 事务属性
    public enum EffentNextType {
        /// <summary>
        /// 对其他语句无任何影响
        /// </summary>
        None,
        /// <summary>
        /// 当前语句必须为"SELECT COUNT(1) FROM .."格式，如果存在则继续执行，不存在回滚事务
        /// </summary>
        WhenHaveContine,
        /// <summary>
        /// 当前语句必须为"SELECT COUNT(1) FROM .."格式，如果不存在则继续执行，存在回滚事务
        /// </summary>
        WhenNoHaveContine,
        /// <summary>
        /// 当前语句影响到的行数必须大于0，否则回滚事务
        /// </summary>
        ExcuteEffectRows,
        /// <summary>
        /// 引发事件-当前语句必须为"SELECT COUNT(1) FROM .."格式，如果不存在则继续执行，存在回滚事务
        /// </summary>
        SolicitationEvent
    }

    #endregion
    #region command定义
    public class CommandInfo {
        public object ShareObject=null;
        public object OriginalData=null;
        event EventHandler _solicitationEvent;

        public event EventHandler SolicitationEvent {
            add {
                _solicitationEvent+=value;
            }
            remove {
                _solicitationEvent-=value;
            }
        }

        public void OnSolicitationEvent() {
            if( _solicitationEvent!=null ) {
                _solicitationEvent(this, new EventArgs());
            }
        }

        public string CommandText;
        public System.Data.Common.DbParameter[] Parameters;
        public EffentNextType EffentNextType=EffentNextType.None;

        public CommandInfo() {
        }

        public CommandInfo( string sqlText, SqlParameter[] para ) {
            this.CommandText=sqlText;
            this.Parameters=para;
        }

        public CommandInfo( string sqlText, SqlParameter[] para, EffentNextType type ) {
            this.CommandText=sqlText;
            this.Parameters=para;
            this.EffentNextType=type;
        }
    }
    #endregion
    /// <summary>
    /// 数据访问抽象基础类
    /// </summary>
    public abstract class MsSQLHelper {
        #region 属性定义
        //数据库连接字符串(web.config来配置)，可以动态更改connectionString支持多数据库.
        public static string connectionString="";
        //构造函数默认数据库
        public MsSQLHelper() {
            connectionString=ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;
        }
        //构造函数指定数据库
        public MsSQLHelper( string _connstr ) {
            connectionString=ConfigurationManager.ConnectionStrings[_connstr].ConnectionString;
        }
        #endregion
        #region 公用方法
        /// <summary>
        /// 判断是否存在某表的某个字段
        /// </summary>
        /// <param name="tableName">表名称</param>
        /// <param name="columnName">列名称</param>
        /// <returns>是否存在</returns>
        public static bool ColumnExists( string tableName, string columnName ) {
            string sql="select count(1) from syscolumns where [id]=object_id(\""+tableName+"\") and [name]=\""+columnName+"\"";
            object res=GetSingle(sql);
            if( res==null ) {
                return false;
            }
            return Convert.ToInt32(res)>0;
        }
        /// <summary>
        /// 获取表中数字字段的最大值
        /// </summary>
        /// <param name="FieldName">字段名</param>
        /// <param name="TableName">表名</param>
        /// <returns>返回字段最大值max(空的话返回0)</returns>
        public static int GetMaxID( string FieldName, string TableName ) {
            string strsql="select max("+FieldName+") from "+TableName;
            object obj=MsSQLHelper.GetSingle(strsql);
            if( obj==null ) {
                return 0;
            } else {
                return int.Parse(obj.ToString());
            }
        }
        /// <summary>
        /// 判断知否存在值
        /// </summary>
        /// <param name="strSql">sql语句</param>
        /// <returns>存在true不存在false</returns>
        public static bool Exists( string strSql ) {
            object obj=MsSQLHelper.GetSingle(strSql);
            int cmdresult;
            if( ( Object.Equals(obj, null) )||( Object.Equals(obj, System.DBNull.Value) ) ) {
                cmdresult=0;
            } else {
                cmdresult=int.Parse(obj.ToString());
            }
            if( cmdresult==0 ) {
                return false;
            } else {
                return true;
            }
        }
        /// <summary>
        /// 表是否存在
        /// </summary>
        /// <param name="TableName">表名</param>
        /// <returns>存在true不存在false</returns>
        public static bool TabExists( string TableName ) {
            string strsql="select count(*) from sysobjects where id = object_id(N\"["+TableName+"]\") and OBJECTPROPERTY(id, N\"IsUserTable\") = 1";
            object obj=MsSQLHelper.GetSingle(strsql);
            int cmdresult;
            if( ( Object.Equals(obj, null) )||( Object.Equals(obj, System.DBNull.Value) ) ) {
                cmdresult=0;
            } else {
                cmdresult=int.Parse(obj.ToString());
            }
            if( cmdresult==0 ) {
                return false;
            } else {
                return true;
            }
        }
        public static bool Exists( string strSql, params SqlParameter[] cmdParms ) {
            object obj=MsSQLHelper.GetSingle(strSql, cmdParms);
            int cmdresult;
            if( ( Object.Equals(obj, null) )||( Object.Equals(obj, System.DBNull.Value) ) ) {
                cmdresult=0;
            } else {
                cmdresult=int.Parse(obj.ToString());
            }
            if( cmdresult==0 ) {
                return false;
            } else {
                return true;
            }
        }
        #endregion
        #region 执行简单SQL语句
        /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql( string SQLString ) {
            using( SqlConnection connection=new SqlConnection(connectionString) ) {
                using( SqlCommand cmd=new SqlCommand(SQLString, connection) ) {
                    try {
                        connection.Open();
                        int rows=cmd.ExecuteNonQuery();
                        return rows;
                    } catch( System.Data.SqlClient.SqlException e ) {
                        connection.Close();
                        throw e;
                    }
                }
            }
        }
        /// <summary>
        /// 执行SQL语句，返回影响的记录数(延迟执行)
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <param name="Times">延迟时间</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSqlByTime( string SQLString, int Times ) {
            using( SqlConnection connection=new SqlConnection(connectionString) ) {
                using( SqlCommand cmd=new SqlCommand(SQLString, connection) ) {
                    try {
                        connection.Open();
                        cmd.CommandTimeout=Times;
                        int rows=cmd.ExecuteNonQuery();
                        return rows;
                    } catch( System.Data.SqlClient.SqlException e ) {
                        connection.Close();
                        throw e;
                    }
                }
            }
        }

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">多条SQL语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSqlTran( List<String> SQLStringList ) {
            using( SqlConnection conn=new SqlConnection(connectionString) ) {
                conn.Open();
                SqlCommand cmd=new SqlCommand();
                cmd.Connection=conn;
                SqlTransaction tx=conn.BeginTransaction();
                cmd.Transaction=tx;
                try {
                    int count=0;
                    for( int n=0 ; n<SQLStringList.Count ; n++ ) {
                        string strsql=SQLStringList[n];
                        if( strsql.Trim().Length>1 ) {
                            cmd.CommandText=strsql;
                            count+=cmd.ExecuteNonQuery();
                        }
                    }
                    tx.Commit();
                    return count;
                } catch {
                    tx.Rollback();
                    return 0;
                }
            }
        }
        /// <summary>
        /// 执行带一个存储过程参数的的SQL语句。
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql( string SQLString, string content ) {
            using( SqlConnection connection=new SqlConnection(connectionString) ) {
                SqlCommand cmd=new SqlCommand(SQLString, connection);
                System.Data.SqlClient.SqlParameter myParameter=new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);
                myParameter.Value=content;
                cmd.Parameters.Add(myParameter);
                try {
                    connection.Open();
                    int rows=cmd.ExecuteNonQuery();
                    return rows;
                } catch( System.Data.SqlClient.SqlException e ) {
                    throw e;
                } finally {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }
        /// <summary>
        /// 执行带一个存储过程参数的的SQL语句。
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
        /// <returns>返回查询结果第一列</returns>
        public static object ExecuteSqlGet( string SQLString, string content ) {
            using( SqlConnection connection=new SqlConnection(connectionString) ) {
                SqlCommand cmd=new SqlCommand(SQLString, connection);
                System.Data.SqlClient.SqlParameter myParameter=new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);
                myParameter.Value=content;
                cmd.Parameters.Add(myParameter);
                try {
                    connection.Open();
                    object obj=cmd.ExecuteScalar();
                    if( ( Object.Equals(obj, null) )||( Object.Equals(obj, System.DBNull.Value) ) ) {
                        return null;
                    } else {
                        return obj;
                    }
                } catch( System.Data.SqlClient.SqlException e ) {
                    throw e;
                } finally {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }
        /// <summary>
        /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
        /// </summary>
        /// <param name="strSQL">SQL语句</param>
        /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSqlInsertImg( string strSQL, byte[] fs ) {
            using( SqlConnection connection=new SqlConnection(connectionString) ) {
                SqlCommand cmd=new SqlCommand(strSQL, connection);
                System.Data.SqlClient.SqlParameter myParameter=new System.Data.SqlClient.SqlParameter("@fs", SqlDbType.Image);
                myParameter.Value=fs;
                cmd.Parameters.Add(myParameter);
                try {
                    connection.Open();
                    int rows=cmd.ExecuteNonQuery();
                    return rows;
                } catch( System.Data.SqlClient.SqlException e ) {
                    throw e;
                } finally {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }
        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="SQLString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public static object GetSingle( string SQLString ) {
            using( SqlConnection connection=new SqlConnection(connectionString) ) {
                using( SqlCommand cmd=new SqlCommand(SQLString, connection) ) {
                    try {
                        connection.Open();
                        object obj=cmd.ExecuteScalar();
                        if( ( Object.Equals(obj, null) )||( Object.Equals(obj, System.DBNull.Value) ) ) {
                            return null;
                        } else {
                            return obj;
                        }
                    } catch( System.Data.SqlClient.SqlException e ) {
                        connection.Close();
                        throw e;
                    }
                }
            }
        }
        public static object GetSingle( string SQLString, int Times ) {
            using( SqlConnection connection=new SqlConnection(connectionString) ) {
                using( SqlCommand cmd=new SqlCommand(SQLString, connection) ) {
                    try {
                        connection.Open();
                        cmd.CommandTimeout=Times;
                        object obj=cmd.ExecuteScalar();
                        if( ( Object.Equals(obj, null) )||( Object.Equals(obj, System.DBNull.Value) ) ) {
                            return null;
                        } else {
                            return obj;
                        }
                    } catch( System.Data.SqlClient.SqlException e ) {
                        connection.Close();
                        throw e;
                    }
                }
            }
        }
        /// <summary>
        /// 执行查询语句，返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
        /// </summary>
        /// <param name="strSQL">查询语句</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader ExecuteReader( string strSQL ) {
            SqlConnection connection=new SqlConnection(connectionString);
            SqlCommand cmd=new SqlCommand(strSQL, connection);
            try {
                connection.Open();
                SqlDataReader myReader=cmd.ExecuteReader(CommandBehavior.CloseConnection);
                return myReader;
            } catch( System.Data.SqlClient.SqlException e ) {
                throw e;
            }
        }
        /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="SQLString">查询语句</param>
        /// <returns>DataSet</returns>
        public static DataSet Query( string SQLString ) {
            using( SqlConnection connection=new SqlConnection(connectionString) ) {
                DataSet ds=new DataSet();
                try {
                    connection.Open();
                    SqlDataAdapter command=new SqlDataAdapter(SQLString, connection);
                    command.Fill(ds, "ds");
                } catch( System.Data.SqlClient.SqlException ex ) {
                    throw new Exception(ex.Message);
                }
                return ds;
            }
        }
        /// <summary>
        /// 查询并得到数据集DataSet
        /// </summary>
        /// <param name="SQLString">查询语句</param>
        /// <param name="Times"></param>
        /// <returns></returns>
        public static DataSet Query( string SQLString, int Times ) {
            using( SqlConnection connection=new SqlConnection(connectionString) ) {
                DataSet ds=new DataSet();
                try {
                    connection.Open();
                    SqlDataAdapter command=new SqlDataAdapter(SQLString, connection);
                    command.SelectCommand.CommandTimeout=Times;
                    command.Fill(ds, "ds");
                } catch( System.Data.SqlClient.SqlException ex ) {
                    throw new Exception(ex.Message);
                }
                return ds;
            }
        }
        #endregion
        #region 执行带参数的SQL语句
        /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql( string SQLString, params SqlParameter[] cmdParms ) {
            using( SqlConnection connection=new SqlConnection(connectionString) ) {
                using( SqlCommand cmd=new SqlCommand() ) {
                    try {
                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                        int rows=cmd.ExecuteNonQuery();
                        cmd.Parameters.Clear();
                        return rows;
                    } catch( System.Data.SqlClient.SqlException e ) {
                        throw e;
                    }
                }
            }
        }
        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
        public static void ExecuteSqlTran( Hashtable SQLStringList ) {
            using( SqlConnection conn=new SqlConnection(connectionString) ) {
                conn.Open();
                using( SqlTransaction trans=conn.BeginTransaction() ) {
                    SqlCommand cmd=new SqlCommand();
                    try {
                        //循环
                        foreach( DictionaryEntry myDE in SQLStringList ) {
                            string cmdText=myDE.Key.ToString();
                            SqlParameter[] cmdParms=(SqlParameter[])myDE.Value;
                            PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
                            int val=cmd.ExecuteNonQuery();
                            cmd.Parameters.Clear();
                        }
                        trans.Commit();
                    } catch {
                        trans.Rollback();
                        throw;
                    }
                }
            }
        }
        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
        public static int ExecuteSqlTran( System.Collections.Generic.List<CommandInfo> cmdList ) {
            using( SqlConnection conn=new SqlConnection(connectionString) ) {
                conn.Open();
                using( SqlTransaction trans=conn.BeginTransaction() ) {
                    SqlCommand cmd=new SqlCommand();
                    try {
                        int count=0;
                        //循环
                        foreach( CommandInfo myDE in cmdList ) {
                            string cmdText=myDE.CommandText;
                            SqlParameter[] cmdParms=(SqlParameter[])myDE.Parameters;
                            PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
                            if( myDE.EffentNextType==EffentNextType.WhenHaveContine||myDE.EffentNextType==EffentNextType.WhenNoHaveContine ) {
                                if( myDE.CommandText.ToLower().IndexOf("count(")==-1 ) {
                                    trans.Rollback();
                                    return 0;
                                }
                                object obj=cmd.ExecuteScalar();
                                bool isHave=false;
                                if( obj==null&&obj==DBNull.Value ) {
                                    isHave=false;
                                }
                                isHave=Convert.ToInt32(obj)>0;
                                if( myDE.EffentNextType==EffentNextType.WhenHaveContine&&!isHave ) {
                                    trans.Rollback();
                                    return 0;
                                }
                                if( myDE.EffentNextType==EffentNextType.WhenNoHaveContine&&isHave ) {
                                    trans.Rollback();
                                    return 0;
                                }
                                continue;
                            }
                            int val=cmd.ExecuteNonQuery();
                            count+=val;
                            if( myDE.EffentNextType==EffentNextType.ExcuteEffectRows&&val==0 ) {
                                trans.Rollback();
                                return 0;
                            }
                            cmd.Parameters.Clear();
                        }
                        trans.Commit();
                        return count;
                    } catch {
                        trans.Rollback();
                        throw;
                    }
                }
            }
        }
        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
        public static void ExecuteSqlTranWithIndentity( System.Collections.Generic.List<CommandInfo> SQLStringList ) {
            using( SqlConnection conn=new SqlConnection(connectionString) ) {
                conn.Open();
                using( SqlTransaction trans=conn.BeginTransaction() ) {
                    SqlCommand cmd=new SqlCommand();
                    try {
                        int indentity=0;
                        //循环
                        foreach( CommandInfo myDE in SQLStringList ) {
                            string cmdText=myDE.CommandText;
                            SqlParameter[] cmdParms=(SqlParameter[])myDE.Parameters;
                            foreach( SqlParameter q in cmdParms ) {
                                if( q.Direction==ParameterDirection.InputOutput ) {
                                    q.Value=indentity;
                                }
                            }
                            PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
                            int val=cmd.ExecuteNonQuery();
                            foreach( SqlParameter q in cmdParms ) {
                                if( q.Direction==ParameterDirection.Output ) {
                                    indentity=Convert.ToInt32(q.Value);
                                }
                            }
                            cmd.Parameters.Clear();
                        }
                        trans.Commit();
                    } catch {
                        trans.Rollback();
                        throw;
                    }
                }
            }
        }
        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
        public static void ExecuteSqlTranWithIndentity( Hashtable SQLStringList ) {
            using( SqlConnection conn=new SqlConnection(connectionString) ) {
                conn.Open();
                using( SqlTransaction trans=conn.BeginTransaction() ) {
                    SqlCommand cmd=new SqlCommand();
                    try {
                        int indentity=0;
                        //循环
                        foreach( DictionaryEntry myDE in SQLStringList ) {
                            string cmdText=myDE.Key.ToString();
                            SqlParameter[] cmdParms=(SqlParameter[])myDE.Value;
                            foreach( SqlParameter q in cmdParms ) {
                                if( q.Direction==ParameterDirection.InputOutput ) {
                                    q.Value=indentity;
                                }
                            }
                            PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
                            int val=cmd.ExecuteNonQuery();
                            foreach( SqlParameter q in cmdParms ) {
                                if( q.Direction==ParameterDirection.Output ) {
                                    indentity=Convert.ToInt32(q.Value);
                                }
                            }
                            cmd.Parameters.Clear();
                        }
                        trans.Commit();
                    } catch {
                        trans.Rollback();
                        throw;
                    }
                }
            }
        }
        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="SQLString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public static object GetSingle( string SQLString, params SqlParameter[] cmdParms ) {
            using( SqlConnection connection=new SqlConnection(connectionString) ) {
                using( SqlCommand cmd=new SqlCommand() ) {
                    try {
                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                        object obj=cmd.ExecuteScalar();
                        cmd.Parameters.Clear();
                        if( ( Object.Equals(obj, null) )||( Object.Equals(obj, System.DBNull.Value) ) ) {
                            return null;
                        } else {
                            return obj;
                        }
                    } catch( System.Data.SqlClient.SqlException e ) {
                        throw e;
                    }
                }
            }
        }
        /// <summary>
        /// 执行查询语句，返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
        /// </summary>
        /// <param name="strSQL">查询语句</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader ExecuteReader( string SQLString, params SqlParameter[] cmdParms ) {
            SqlConnection connection=new SqlConnection(connectionString);
            SqlCommand cmd=new SqlCommand();
            try {
                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                SqlDataReader myReader=cmd.ExecuteReader(CommandBehavior.CloseConnection);
                cmd.Parameters.Clear();
                return myReader;
            } catch( System.Data.SqlClient.SqlException e ) {
                throw e;
            }
        }
        /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="SQLString">查询语句</param>
        /// <returns>DataSet</returns>
        public static DataSet Query( string SQLString, params SqlParameter[] cmdParms ) {
            using( SqlConnection connection=new SqlConnection(connectionString) ) {
                SqlCommand cmd=new SqlCommand();
                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                using( SqlDataAdapter da=new SqlDataAdapter(cmd) ) {
                    DataSet ds=new DataSet();
                    try {
                        da.Fill(ds, "ds");
                        cmd.Parameters.Clear();
                    } catch( System.Data.SqlClient.SqlException ex ) {
                        throw new Exception(ex.Message);
                    }
                    return ds;
                }
            }
        }
        private static void PrepareCommand( SqlCommand cmd, SqlConnection conn, SqlTransaction trans, string cmdText, SqlParameter[] cmdParms ) {
            if( conn.State!=ConnectionState.Open )
                conn.Open();
            cmd.Connection=conn;
            cmd.CommandText=cmdText;
            if( trans!=null )
                cmd.Transaction=trans;
            cmd.CommandType=CommandType.Text;//cmdType;
            if( cmdParms!=null ) {
                foreach( SqlParameter parameter in cmdParms ) {
                    if( ( parameter.Direction==ParameterDirection.InputOutput||parameter.Direction==ParameterDirection.Input )&&
                    ( parameter.Value==null ) ) {
                        parameter.Value=DBNull.Value;
                    }
                    cmd.Parameters.Add(parameter);
                }
            }
        }
        #endregion
        #region 存储过程操作
        /// <summary>
        /// 执行存储过程，返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
        /// </summary>
        /// <param name="storedProcName">存储过程名</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader RunProcedure( string storedProcName ) {
            SqlConnection connection=new SqlConnection(connectionString);
            SqlDataReader returnReader;
            connection.Open();
            SqlCommand command=new SqlCommand(storedProcName, connection);
            command.CommandType=CommandType.StoredProcedure;
            returnReader=command.ExecuteReader(CommandBehavior.CloseConnection);
            return returnReader;
        }

        /// <summary>
        /// 执行存储过程，返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
        /// </summary>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader RunProcedure( string storedProcName, IDataParameter[] parameters ) {
            SqlConnection connection=new SqlConnection(connectionString);
            SqlDataReader returnReader;
            connection.Open();
            SqlCommand command=BuildQueryCommand(connection, storedProcName, parameters);
            command.CommandType=CommandType.StoredProcedure;
            returnReader=command.ExecuteReader(CommandBehavior.CloseConnection);
            return returnReader;
        }
        /// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <param name="tableName">DataSet结果中的表名</param>
        /// <returns>DataSet</returns>
        public static DataSet RunProcedure( string storedProcName, string tableName ) {
            using( SqlConnection connection=new SqlConnection(connectionString) ) {
                DataSet dataSet=new DataSet();
                connection.Open();
                SqlDataAdapter sqlDA=new SqlDataAdapter();
                sqlDA.SelectCommand=new SqlCommand(storedProcName, connection);
                sqlDA.Fill(dataSet, tableName);
                connection.Close();
                return dataSet;
            }
        }
        /// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <param name="tableName">DataSet结果中的表名</param>
        /// <returns>DataSet</returns>
        public static DataSet RunProcedure( string storedProcName, IDataParameter[] parameters, string tableName ) {
            using( SqlConnection connection=new SqlConnection(connectionString) ) {
                DataSet dataSet=new DataSet();
                connection.Open();
                SqlDataAdapter sqlDA=new SqlDataAdapter();
                sqlDA.SelectCommand=BuildQueryCommand(connection, storedProcName, parameters);
                sqlDA.Fill(dataSet, tableName);
                connection.Close();
                return dataSet;
            }
        }
        public static DataSet RunProcedure( string storedProcName, IDataParameter[] parameters, string tableName, int Times ) {
            using( SqlConnection connection=new SqlConnection(connectionString) ) {
                DataSet dataSet=new DataSet();
                connection.Open();
                SqlDataAdapter sqlDA=new SqlDataAdapter();
                sqlDA.SelectCommand=BuildQueryCommand(connection, storedProcName, parameters);
                sqlDA.SelectCommand.CommandTimeout=Times;
                sqlDA.Fill(dataSet, tableName);
                connection.Close();
                return dataSet;
            }
        }
        /// <summary>
        /// 构建 SqlCommand 对象(用来返回一个结果集，而不是一个整数值)
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <returns>SqlCommand</returns>
        private static SqlCommand BuildQueryCommand( SqlConnection connection, string storedProcName, IDataParameter[] parameters ) {
            SqlCommand command=new SqlCommand(storedProcName, connection);
            command.CommandType=CommandType.StoredProcedure;
            foreach( SqlParameter parameter in parameters ) {
                if( parameter!=null ) {
                    // 检查未分配值的输出参数,将其分配以DBNull.Value.
                    if( ( parameter.Direction==ParameterDirection.InputOutput||parameter.Direction==ParameterDirection.Input )&&
                    ( parameter.Value==null ) ) {
                        parameter.Value=DBNull.Value;
                    }
                    command.Parameters.Add(parameter);
                }
            }
            return command;
        }
        /// <summary>
        /// 执行存储过程，返回影响的行数
        /// </summary>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <param name="rowsAffected">影响的行数</param>
        /// <returns></returns>
        public static int RunProcedure( string storedProcName, out int rowsAffected ) {
            using( SqlConnection connection=new SqlConnection(connectionString) ) {
                int result;
                connection.Open();
                SqlCommand command=new SqlCommand(storedProcName, connection);
                rowsAffected=command.ExecuteNonQuery();
                result=(int)command.Parameters["ReturnValue"].Value;
                //Connection.Close();
                return result;
            }
        }
        /// <summary>
        /// 执行存储过程，返回影响的行数
        /// </summary>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <param name="rowsAffected">影响的行数</param>
        /// <returns></returns>
        public static int RunProcedure( string storedProcName, IDataParameter[] parameters, out int rowsAffected ) {
            using( SqlConnection connection=new SqlConnection(connectionString) ) {
                int result;
                connection.Open();
                SqlCommand command=BuildIntCommand(connection, storedProcName, parameters);
                rowsAffected=command.ExecuteNonQuery();
                result=(int)command.Parameters["ReturnValue"].Value;
                //Connection.Close();
                return result;
            }
        }
        /// <summary>
        /// 创建 SqlCommand 对象实例(用来返回一个整数值)
        /// </summary>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <returns>SqlCommand 对象实例</returns>
        private static SqlCommand BuildIntCommand( SqlConnection connection, string storedProcName, IDataParameter[] parameters ) {
            SqlCommand command=BuildQueryCommand(connection, storedProcName, parameters);
            command.Parameters.Add(new SqlParameter("ReturnValue",
            SqlDbType.Int, 4, ParameterDirection.ReturnValue,
            false, 0, 0, string.Empty, DataRowVersion.Default, null));
            return command;
        }
        #endregion
    }
}