1. /// <summary>  
  2.        /// 数据库连接  
  3.        /// </summary>  
  4.        public static SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString);  
  5.  
  6.        /// <summary>  
  7.        /// 获取执行查询获取DataReader的方法  
  8.        /// </summary>  
  9.        /// <param name="cmdText">sql字符串或存储过程名称</param>  
  10.        /// <param name="cmdParms">sql字符串中的参数</param>  
  11.        /// <returns>SqlDataReader</returns>  
  12.        public static SqlDataReader getDataReader(string cmdText, params SqlParameter[] cmdParms)  
  13.        {  
  14.            SqlCommand cmd = new SqlCommand();  
  15.            try 
  16.            {  
  17.                PrepareCommand(conn, cmd, cmdText, cmdParms);  
  18.                SqlDataReader sdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);  
  19.                cmd.Parameters.Clear();  
  20.                return sdr;  
  21.            }  
  22.            catch 
  23.            {  
  24.                conn.Close();  
  25.                throw;  
  26.            }  
  27.        }  
  28.  
  29.        /// <summary>  
  30.        /// 获取执行查询获取DataReader的方法  
  31.        /// </summary>  
  32.        /// <param name="cmdText">sql字符串或存储过程名称</param>  
  33.        /// <returns>SqlDataReader</returns>  
  34.        public static SqlDataReader getDataReader(string cmdText)  
  35.        {  
  36.            try 
  37.            {  
  38.                conn.Open();  
  39.                SqlCommand cmd = new SqlCommand(cmdText, conn);  
  40.                SqlDataReader sdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);  
  41.                return sdr;  
  42.            }  
  43.            catch 
  44.            {  
  45.                conn.Close();  
  46.                throw;  
  47.            }  
  48.        }  
  49.  
  50.        /// <summary>  
  51.        /// 执行sql语句的方法  
  52.        /// </summary>  
  53.        /// <param name="cmdText">sql字符串</param>  
  54.        /// <param name="cmdParms">sql字符串中的参数</param>  
  55.        public static int executeSql(string cmdText, params SqlParameter[] cmdParms)  
  56.        {  
  57.            SqlCommand cmd = new SqlCommand();  
  58.            PrepareCommand(conn, cmd, cmdText, cmdParms);  
  59.            int temp = cmd.ExecuteNonQuery();  
  60.            conn.Close();  
  61.            cmd.Parameters.Clear();  
  62.            return temp;  
  63.        }  
  64.  
  65.        /// <summary>  
  66.        /// 执行sql语句的方法  
  67.        /// </summary>  
  68.        /// <param name="cmdText">sql字符串或存储过程名称</param>  
  69.        public static int executeSql(string cmdText)  
  70.        {  
  71.            SqlCommand cmd = new SqlCommand();  
  72.            if (conn.State != ConnectionState.Open)  
  73.            {  
  74.                conn.Open();  
  75.            }  
  76.            int temp = cmd.ExecuteNonQuery();  
  77.            conn.Close();  
  78.            return temp;  
  79.        }  
  80.  
  81.  
  82.        /// <summary>  
  83.        /// 执行存储过程  
  84.        /// </summary>  
  85.        /// <param name="cmdText">存储过程名称</param>  
  86.        /// <param name="cmdParms">存储过程中的参数</param>  
  87.        public static int executePro(string cmdText, params SqlParameter[] cmdParms)  
  88.        {  
  89.            SqlCommand cmd = new SqlCommand();  
  90.            PrepareCommandPro(conn, cmd, cmdText, cmdParms);  
  91.            int temp = cmd.ExecuteNonQuery();  
  92.            conn.Close();  
  93.            cmd.Parameters.Clear();  
  94.            return temp;  
  95.        }  
  96.  
  97.        /// <summary>  
  98.        /// 执行sql语句获得第一行第一列的字符串  
  99.        /// </summary>  
  100.        /// <param name="cmdText">sql字符串或存储过程名称</param>  
  101.        /// <returns>查询的结果</returns>  
  102.        public static string executeScalarStr(string cmdText)  
  103.        {  
  104.            SqlCommand cmd = new SqlCommand(cmdText, conn);  
  105.            if (conn.State != ConnectionState.Open)  
  106.            {  
  107.                conn.Open();  
  108.            }  
  109.            string temp = Convert.ToString(cmd.ExecuteScalar());  
  110.            conn.Close();  
  111.            return temp;  
  112.        }  
  113.  
  114.        /// <summary>  
  115.        /// 执行sql语句获得第一行第一列的字符串  
  116.        /// </summary>  
  117.        /// <param name="cmdText">sql字符串或存储过程名称</param>  
  118.        /// <param name="cmdParms">sql字符串中的参数</param>  
  119.        /// <returns>查询的结果</returns>  
  120.        public static string executeScalarStr(string cmdText, params SqlParameter[] cmdParms)  
  121.        {  
  122.            SqlCommand cmd = new SqlCommand();  
  123.            PrepareCommand(conn, cmd, cmdText, cmdParms);  
  124.            string result = Convert.ToString(cmd.ExecuteScalar());  
  125.            conn.Close();  
  126.            cmd.Parameters.Clear();  
  127.            return result;  
  128.        }  
  129.  
  130.        /// <summary>  
  131.        /// 执行sql语句获得第一行第一列的数字,用来获得count()结果  
  132.        /// </summary>  
  133.        /// <param name="cmdText">sql字符串或存储过程名称</param>  
  134.        /// <param name="cmdParms">sql字符串中的参数</param>  
  135.        /// <returns>查询的结果数字</returns>  
  136.        public static int executeScalar(string cmdText, params SqlParameter[] cmdParms)  
  137.        {  
  138.            SqlCommand cmd = new SqlCommand();  
  139.            PrepareCommand(conn, cmd, cmdText, cmdParms);  
  140.            int result = Convert.ToInt32(cmd.ExecuteScalar());  
  141.            conn.Close();  
  142.            cmd.Parameters.Clear();  
  143.            return result;  
  144.        }  
  145.  
  146.        /// <summary>  
  147.        /// 执行sql语句获得第一行第一列的数字,用来获得count()结果  
  148.        /// </summary>  
  149.        /// <param name="cmdText">sql字符串或存储过程名称</param>  
  150.        /// <returns>查询的结果数字</returns>  
  151.        public static int executeScalar(string cmdText)  
  152.        {  
  153.            SqlCommand cmd = new SqlCommand(cmdText, conn);  
  154.            if (conn.State != ConnectionState.Open)  
  155.            {  
  156.                conn.Open();  
  157.            }  
  158.            int temp = Convert.ToInt32(cmd.ExecuteScalar());  
  159.            conn.Close();  
  160.            return temp;  
  161.        }  
  162.  
  163.        /// <summary>  
  164.        /// 处理数据库连接以及参数的方法  
  165.        /// </summary>  
  166.        /// <param name="conn">数据库连接</param>  
  167.        /// <param name="cmd">根据数据库连接和sql语句创建的SqlCommand对象</param>  
  168.        /// <param name="cmdText">sql语句名称</param>  
  169.        /// <param name="cmdParms">sql语句中的参数</param>  
  170.        private static void PrepareCommand(SqlConnection conn, SqlCommand cmd, string cmdText, SqlParameter[] cmdParms)  
  171.        {  
  172.            //判断连接的状态。如果是关闭状态，则打开  
  173.            if (conn.State != ConnectionState.Open)  
  174.            {  
  175.                conn.Open();  
  176.            }  
  177.  
  178.            //cmd属性赋值  
  179.            cmd.Connection = conn;  
  180.            cmd.CommandText = cmdText;  
  181.            cmd.CommandType = CommandType.Text;  
  182.  
  183.            //添加cmd需要的参数  
  184.            if (cmdParms != null)  
  185.            {  
  186.                foreach (SqlParameter parm in cmdParms)  
  187.                {  
  188.                    cmd.Parameters.Add(parm);  
  189.                }  
  190.            }  
  191.        }  
  192.        /// <summary>  
  193.        /// 处理数据库连接以及参数的方法  
  194.        /// </summary>  
  195.        /// <param name="conn">数据库连接</param>  
  196.        /// <param name="cmd">根据数据库连接和存储过程创建的SqlCommand对象</param>  
  197.        /// <param name="cmdText">存储过程名称</param>  
  198.        /// <param name="cmdParms">存储过程中的参数</param>  
  199.        private static void PrepareCommandPro(SqlConnection conn, SqlCommand cmd, string cmdText, SqlParameter[] cmdParms)  
  200.        {  
  201.            //判断连接的状态。如果是关闭状态，则打开  
  202.            if (conn.State != ConnectionState.Open)  
  203.            {  
  204.                conn.Open();  
  205.            }  
  206.  
  207.            //cmd属性赋值  
  208.            cmd.Connection = conn;  
  209.            cmd.CommandText = cmdText;  
  210.            cmd.CommandType = CommandType.StoredProcedure;  
  211.  
  212.            //添加cmd需要的存储过程参数  
  213.            if (cmdParms != null)  
  214.            {  
  215.                foreach (SqlParameter parm in cmdParms)  
  216.                {  
  217.                    cmd.Parameters.Add(parm);  
  218.                }  
  219.            }  
  220.        }  
  221.        /// <summary>  
  222.        /// 无参数的存储过程的处理方法。  
  223.        /// </summary>  
  224.        /// <param name="conn">数据库连接</param>  
  225.        /// <param name="cmd">根据数据库连接和存储过程创建的SqlCommand对象</param>  
  226.        /// <param name="cmdText">存储过程名称</param>  
  227.        private static void PrepareCommandPro(SqlConnection conn, SqlCommand cmd, string cmdText)  
  228.        {  
  229.            //判断连接的状态。如果是关闭状态，则打开  
  230.            if (conn.State != ConnectionState.Open)  
  231.            {  
  232.                conn.Open();  
  233.            }  
  234.  
  235.            //cmd属性赋值  
  236.            cmd.Connection = conn;  
  237.            cmd.CommandText = cmdText;  
  238.            cmd.CommandType = CommandType.StoredProcedure;  
  239.        }  
  240.  
  241.        /// <summary>  
  242.        /// 返回一个数据集  
  243.        /// </summary>  
  244.        /// <param name="cmdStr">sql语句</param>  
  245.        /// <returns></returns>  
  246.        public static DataSet getDataSet(string cmdStr)  
  247.        {  
  248.            try 
  249.            {  
  250.                conn.Open();  
  251.                SqlDataAdapter sda = new SqlDataAdapter(cmdStr,conn);  
  252.                DataSet ds = new DataSet();  
  253.                sda.Fill(ds, "table");  
  254.                return ds;  
  255.            }  
  256.            catch 
  257.            {  
  258.                throw;  
  259.            }  
  260.            finally 
  261.            {  
  262.                conn.Close();  
  263.            }  
  264.        }  
  265.        /// <summary>  
  266.        /// 返回一个数据集  
  267.        /// </summary>  
  268.        /// <param name="cmdStr">sql语句</param>  
  269.        /// <param name="cmdParms">sql语句中的参数</param>  
  270.        /// <returns></returns>  
  271.        public static DataSet getDataSet(string cmdStr, params SqlParameter[] cmdParms)  
  272.        {  
  273.            try 
  274.            {  
  275.                conn.Open();  
  276.                SqlCommand cmd = new SqlCommand();  
  277.                PrepareCommand(conn, cmd, cmdStr, cmdParms);  
  278.                SqlDataAdapter sda = new SqlDataAdapter(cmd);  
  279.                DataSet ds = new DataSet();  
  280.                sda.Fill(ds, "table");  
  281.                cmd.Parameters.Clear();  
  282.                return ds;  
  283.            }  
  284.            catch 
  285.            {  
  286.                throw;  
  287.            }  
  288.            finally 
  289.            {  
  290.                conn.Close();  
  291.            }  
  292.        }  
  293.  
  294.        /// <summary>  
  295.        /// 无参数的存储过程的执行  
  296.        /// </summary>  
  297.        /// <param name="cmdStr">存储过程</param>  
  298.        /// <returns>一个数据集</returns>  
  299.        public static DataSet getDataSetPro(string cmdStr)  
  300.        {  
  301.            try 
  302.            {  
  303.                conn.Open();  
  304.                SqlCommand cmd = new SqlCommand();  
  305.                PrepareCommandPro(conn, cmd, cmdStr);  
  306.                SqlDataAdapter sda = new SqlDataAdapter(cmd);  
  307.                DataSet ds = new DataSet();  
  308.                sda.Fill(ds, "table");  
  309.                cmd.Parameters.Clear();  
  310.                return ds;  
  311.            }  
  312.            catch 
  313.            {  
  314.                throw;  
  315.            }  
  316.            finally 
  317.            {  
  318.                conn.Close();  
  319.            }  
  320.        }  
  321.        /// <summary>  
  322.        /// 返回一个数据集  
  323.        /// </summary>  
  324.        /// <param name="cmdStr">存储过程</param>  
  325.        /// <param name="cmdParms">存储过程中的参数</param>  
  326.        /// <returns></returns>  
  327.        public static DataSet getDataSetPro(string cmdStr, params SqlParameter[] cmdParms)  
  328.        {  
  329.            try 
  330.            {  
  331.                conn.Open();  
  332.                SqlCommand cmd = new SqlCommand();  
  333.                PrepareCommandPro(conn, cmd, cmdStr, cmdParms);  
  334.                SqlDataAdapter sda = new SqlDataAdapter(cmd);  
  335.                DataSet ds = new DataSet();  
  336.                sda.Fill(ds, "table");  
  337.                cmd.Parameters.Clear();  
  338.                return ds;  
  339.            }  
  340.            catch 
  341.            {  
  342.                throw;  
  343.            }  
  344.            finally 
  345.            {  
  346.                conn.Close();  
  347.            }  
  348.        }  
  349.  
  350.  
  351.        /// <summary>  
  352.        /// 获取执行查询获取DataReader的方法  
  353.        /// </summary>  
  354.        /// <param name="cmd">SqlCommand</param>  
  355.        /// <returns></returns>  
  356.        public static SqlDataReader getDataReader(SqlCommand cmd)  
  357.        {  
  358.            cmd.Connection= conn;  
  359.            conn.Open();  
  360.            SqlDataReader sda;  
  361.            sda = cmd.ExecuteReader(CommandBehavior.CloseConnection);  
  362.            conn.Close();  
  363.            return sda;  
  364.        }