存储过程操作类

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;
using  System.Data;
using  System.Data.SqlClient;
using  System.Xml;
using  System.Collections;

namespace  StoredProcedure
{
     public   class  StoredProcedure
    {
         #region  数据成员
         private  SqlConnection _SqlConnection  =   null ;
         private  String _Procedure  =  String.Empty;
         private  SqlCommand _SqlCmd  =   new  SqlCommand();
         private  Hashtable _InputTable  =   null ;  //  保存input参数和值
         private  String _LastError  =  String.Empty;
         #endregion

         #region  构造函数
         public  StoredProcedure()
        {
            _InputTable  =   new  Hashtable();
            _SqlCmd.CommandType  =  CommandType.StoredProcedure;
        }

         public  StoredProcedure( String DBConnStr):  this ()
        {
            SqlConnection SqlConnection  =   new  SqlConnection(DBConnStr);
             this .SqlConnection  =  SqlConnection;
        }

         public  StoredProcedure(String Procedure, String DBConnStr):  this ()
        {
            SqlConnection SqlConnection  =   new  SqlConnection(DBConnStr);
             this .SqlConnection  =  SqlConnection;
             this .Procedure  =  Procedure;
        }
         #endregion

         #region  属性
         public  String LastError
        {
             get
            {
                 return   this ._LastError;
            }
        }

         public  Object ReturnValue
        {
             get
            {
                 return  _SqlCmd.Parameters[ " RetVal " ].Value;
            }
        }

         public  SqlConnection SqlConnection
        {
             set
            {
                 this ._SqlConnection  =  value;
                _SqlCmd.Connection  =   this ._SqlConnection;
            }   
        }

         public  String Procedure
        {
             set
            {
                 this ._Procedure  =  value;
                _SqlCmd.CommandText  =   this ._Procedure;
            }

             get
            {
                 return   this ._Procedure;
            }
        }
         #endregion

         #region  公共方法
         ///   <summary>
         ///  执行存储过程，仅返回是否成功标志
         ///   </summary>
         ///   <param name="Procedure"> 存储过程名 </param>
         ///   <returns> 是否成功标志 </returns>
         public  Boolean ExecuteNonQuery(String Procedure)
        {
             this .Procedure  =  Procedure;
             return  ExecuteNonQuery();
        }

         ///   <summary>
         ///  执行存储过程，仅返回是否成功标志
         ///   </summary>
         ///   <returns> 是否成功标志 </returns>
         public  Boolean ExecuteNonQuery()
        {
            Boolean RetValue  =   true ;
             //  绑定参数
             if  (Bindings()  ==   true )
            {
                 try
                {
                     //  执行
                    _SqlCmd.ExecuteNonQuery();
                }
                 catch  (Exception ex)
                {
                    _LastError  =   " execute command error:  "   +  ex.Message;
                    RetValue  =   false ;
                }
            }
             else
            {
                RetValue  =   false ;
            }

            _InputTable.Clear();

             return  RetValue;
        }

         ///   <summary>
         ///  执行存储过程，返回SqlDataReader
         ///   </summary>
         ///   <param name="Procedure"> 存储过程名 </param>
         ///   <returns> 数据库读取行的只进流SqlDataReader </returns>
         public  SqlDataReader ExecuteReader(String Procedure)
        {
             this .Procedure  =  Procedure;
             return  ExecuteReader();
        }

         ///   <summary>
         ///  执行存储过程，返回SqlDataReader
         ///   </summary>
         ///   <returns> 数据库读取行的只进流SqlDataReader </returns>
         public  SqlDataReader ExecuteReader()
        {
            SqlDataReader sqlReader  =   null ;
             //  绑定参数
             if  (Bindings()  ==   true )
            {
                 try
                {
                     //  执行
                    sqlReader  =  _SqlCmd.ExecuteReader();
                }
                 catch  (Exception ex)
                {
                    _LastError  =   " execute command error:  "   +  ex.Message;
                }
            }

            _InputTable.Clear();
   
             return  sqlReader;
        }

         ///   <summary>
         ///  执行存储过程，返回DataSet
         ///   </summary>
         ///   <param name="Procedure"> 存储过程名 </param>
         ///   <returns> DataSet </returns>
         public  DataSet ExecuteDataSet(String Procedure)
        {
             this .Procedure  =  Procedure;
             return  ExecuteDataSet();
        }

         ///   <summary>
         ///  执行存储过程，返回DataSet
         ///   </summary>
         ///   <returns> DataSet </returns>
         public  DataSet ExecuteDataSet()
        {
            DataSet ds  =   new  DataSet();
            SqlDataAdapter sqlAdapter  =   null ;

             //  绑定参数
             if  (Bindings()  ==   true )
            {
                 try
                {
                     //  执行
                    sqlAdapter  =   new  SqlDataAdapter(_SqlCmd);
                }
                 catch  (Exception ex)
                {
                    _LastError  =   " execute command error:  "   +  ex.Message;
                }
            }

            _InputTable.Clear();
            sqlAdapter.Fill(ds,  " table " );
             return  ds;
        }

         ///   <summary>
         ///  执行存储过程，返回SqlDataAdapter
         ///   </summary>
         ///   <param name="Procedure"> 存储过程名 </param>
         ///   <returns> SqlDataAdapter </returns>
         public  SqlDataAdapter ExecuteAdapter(String Procedure)
        {
             this .Procedure  =  Procedure;
             return  ExecuteAdapter();
        }

         ///   <summary>
         ///  执行存储过程，返回SqlDataAdapter
         ///   </summary>
         ///   <returns> SqlDataAdapter </returns>
         public  SqlDataAdapter ExecuteAdapter()
        {
            SqlDataAdapter sqlAdapter  =   null ;

             //  绑定参数
             if  (Bindings()  ==   true )
            {
                 try
                {
                     //  执行
                    sqlAdapter  =   new  SqlDataAdapter(_SqlCmd);
                }
                 catch  (Exception ex)
                {
                    _LastError  =   " execute command error:  "   +  ex.Message;
                }
            }

            _InputTable.Clear();

             return  sqlAdapter;
        }

         ///   <summary>
         ///  获取output的键值
         ///   </summary>
         ///   <param name="Output"> output键名称 </param>
         ///   <returns> output键值 </returns>
         public  Object GetOutputValue(String Output)
        {
             // _SqlCmd.Parameters[Output].Direction = ParameterDirection.Output; 
             return  _SqlCmd.Parameters[Output].Value;
        }

         ///   <summary>
         ///  设置Input参数值
         ///   </summary>
         ///   <param name="Key"> 参数名 </param>
         ///   <param name="Value"> 参数值 </param>
         public   void  SetInputValue(String Key, Object Value)
        {
             if  (Key  ==   null )
            {
                 return ;
            }
             if  ( ! Key.StartsWith( " @ " ))
            {
                Key  =   " @ "   +  Key;
            }

             if  (_InputTable.ContainsKey(Key))
            {
                _InputTable[Key]  =  Value;
            }
             else
            {
                _InputTable.Add(Key, Value);
            }
        }

         ///   <summary>
         ///  获取已设置的Input参数值
         ///  注：存储过程被成功执行后, Input参数被清空
         ///   </summary>
         ///   <param name="Key"> 参数名 </param>
         ///   <returns> 参数值 </returns>
         public  Object GetInputValue(String Key)
        {
             if  (Key  ==   null )
            {
                 return   null ;
            }
             if  ( ! Key.StartsWith( " @ " ))
            {
                Key  =   " @ "   +  Key;
            }

             if  (_InputTable.ContainsKey(Key))
            {
                 return  _InputTable[Key];
            }
             else
            {
                 return   null ;
            }
        }
         #endregion

         #region  私有方法
         ///   <summary>
         ///  给SqlCommand对象绑定参数
         ///   </summary>
         ///   <returns> 是否成功标志 </returns>
         private  Boolean Bindings()
        {
            _SqlCmd.Parameters.Clear();
            XmlReader sqlXmlReader  =  GetParameters();
             try
            {
                 while  (sqlXmlReader.Read())
                {
                     try
                    {
                         if  (Byte.Parse(sqlXmlReader[ " isoutparam " ])  ==   1 )
                        {
                             //  绑定output参数
                            _SqlCmd.Parameters.Add(sqlXmlReader[ " name " ],
                            GetSqlDbType(sqlXmlReader[ " type " ]),
                            Int32.Parse(sqlXmlReader[ " length " ])).Direction  =  ParameterDirection.Output;
                        }
                         else
                        {
                             //  绑定input参数，并赋值
                            _SqlCmd.Parameters.Add(sqlXmlReader[ " name " ],
                            GetSqlDbType(sqlXmlReader[ " type " ]),
                            Int32.Parse(sqlXmlReader[ " length " ])).Value  =   this .GetInputValue(sqlXmlReader[ " name " ]);
                            /*
                            * 不必担心赋值的ParametersValue类型问题，SqlParameter.Value是object类型，自动转换
                             */
                        }
                    }
                     catch  (Exception ex)
                    {
                        _LastError  =  sqlXmlReader[ " name " ]  +   "  parameter error:  "   +  ex.Message;
                         return   false ;
                    }
                }

                 //  绑定返回值
                _SqlCmd.Parameters.Add( " RetVal " , SqlDbType.Variant).Direction  =  ParameterDirection.ReturnValue;
            }
             catch  (Exception ex)
            {
                _LastError  =   " binding parameter error:  "   +  ex.Message;
                 return   false ;
            }

             return   true ;
        }

         ///   <summary>
         ///  由存储过程名, 取包含参数的XmlReader
         ///   </summary>
         ///   <param name="Procedure"> 存储过程名 </param>
         ///   <returns> 包含参数的XmlReader </returns>
         private  XmlReader GetParameters()
        {
            String sqlStr  =   " SELECT B.[name], C.[name] AS [type], B.length, B.isoutparam, B.isnullable " ;
            sqlStr  +=   "  FROM sysobjects AS A INNER JOIN " ;
            sqlStr  +=   "  syscolumns AS B ON A.id = B.id AND A.xtype = 'P' AND A.name = ' "   +  _Procedure  +   " ' INNER JOIN " ;
            sqlStr  +=   "  systypes C ON B.xtype = C.xtype AND C.[name] <> 'sysname' " ;
            sqlStr  +=   "  ORDER BY ROW_NUMBER() OVER (ORDER BY B.id), B.isoutparam " ;
            sqlStr  +=   "  FOR XML RAW " ;
            SqlCommand sqlCmd  =   new  SqlCommand(sqlStr, _SqlConnection);
             //  <row name="Action" type="varchar" length="50" isoutparam="0" isnullable="1" />
            XmlReader sqlXmlReader  =   null ;
             try
            {
                sqlXmlReader  =  sqlCmd.ExecuteXmlReader();
            }
             catch  (Exception ex)
            {
                 if  (sqlXmlReader  !=   null ) sqlXmlReader.Close();
                sqlXmlReader  =   null ;
                _LastError  =   " get parameters error:  "   +  ex.Message;
            }
             finally
            {
                sqlCmd.Dispose();
                sqlCmd  =   null ;
            }
             return  sqlXmlReader;
        }

         protected   internal   static  SqlDbType GetSqlDbType(String TypeName)
        {
             switch  (TypeName)
            {
                 case   " image " :
                  return  SqlDbType.Image;
                 case   " text " :
                  return  SqlDbType.Text;
                 case   " uniqueidentifier " :
                  return  SqlDbType.UniqueIdentifier;
                 case   " tinyint " :
                  return  SqlDbType.TinyInt;
                 case   " smallint " :
                  return  SqlDbType.SmallInt;
                 case   " int " :
                  return  SqlDbType.Int;
                 case   " smalldatetime " :
                  return  SqlDbType.SmallDateTime;
                 case   " real " :
                  return  SqlDbType.Real;
                 case   " money " :
                  return  SqlDbType.Money;
                 case   " datetime " :
                  return  SqlDbType.DateTime;
                 case   " float " :
                  return  SqlDbType.Float;
                 case   " sql_variant " :
                  return  SqlDbType.Variant;
                 case   " ntext " :
                  return  SqlDbType.NText;
                 case   " bit " :
                  return  SqlDbType.Bit;
                 case   " decimal " :
                  return  SqlDbType.Decimal;
                 case   " numeric " :
                  return  SqlDbType.Decimal;
                 case   " smallmoney " :
                  return  SqlDbType.SmallMoney;
                 case   " bigint " :
                  return  SqlDbType.BigInt;
                 case   " varbinary " :
                  return  SqlDbType.VarBinary;
                 case   " varchar " :
                  return  SqlDbType.VarChar;
                 case   " binary " :
                  return  SqlDbType.Binary;
                 case   " char " :
                  return  SqlDbType.Char;
                 case   " timestamp " :
                  return  SqlDbType.Timestamp;
                 case   " nvarchar " :
                  return  SqlDbType.NVarChar;
                 case   " nchar " :
                  return  SqlDbType.NChar;
                 case   " xml " :
                  return  SqlDbType.Xml;
                 default :
                  return  SqlDbType.Variant;
            }
        }
         #endregion   
 
    }
}