.net 连接sqlserver类库

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Web;
 using System.Data.SqlClient;
 using System.Data;
 using System.Configuration;

 public class SqlHelper
 {
     public static readonly string conString = ConfigurationManager.ConnectionStrings["sqlCon"].ConnectionString;
     //增删改
     public static bool ExeNonQuery(string sql, CommandType type, params SqlParameter[] lists)
     {
         bool bFlag = false;
         using (SqlConnection con = new SqlConnection(conString))
         {
             SqlCommand cmd = new SqlCommand();
             cmd.Connection = con;
             cmd.CommandText = sql;
             cmd.CommandType = type;
             if (lists != null)
             {
                 foreach (SqlParameter p in lists)
                 {
                     cmd.Parameters.Add(p);
                 }
             }
             try
             {
                 if (con.State == ConnectionState.Closed)
                 {
                     con.Open();
                 }
                 int result = cmd.ExecuteNonQuery();
                 if (result > )
                 {
                     bFlag = true;
                 }

             }
             catch { ;}
         }
         return bFlag;
     }

     //查．读
     public static SqlDataReader ExeDataReader(string sql, CommandType type, params SqlParameter[] lists)
     {
         SqlConnection con = new SqlConnection(conString);
         SqlCommand cmd = new SqlCommand();
         cmd.Connection = con;
         cmd.CommandText = sql;
         cmd.CommandType = type;

         if (con.State == ConnectionState.Closed)
         {
             con.Open();
         }

         if (lists != null)
         {
             foreach (SqlParameter p in lists)
             {
                 cmd.Parameters.Add(p);
             }
         }

         SqlDataReader reader = cmd.ExecuteReader();

         return reader;
     }

     //返回单个值
     public static object GetScalar(string sql, CommandType type, params SqlParameter[] lists)
     {
         object returnValue = null;
         using (SqlConnection con = new SqlConnection(conString))
         {
             SqlCommand cmd = new SqlCommand();
             cmd.Connection = con;
             cmd.CommandText = sql;
             cmd.CommandType = type;
             if (lists != null)
             {
                 foreach (SqlParameter p in lists)
                 {
                     cmd.Parameters.Add(p);
                 }
             }
             try
             {
                 if (con.State == ConnectionState.Closed)
                 {
                     con.Open();
                 }
                 returnValue = cmd.ExecuteScalar();

             }
             catch { ; }
         }
         return returnValue;
     }

     //事务
     public static bool ExeNonQueryTran(List<SqlCommand> list)
     {
         bool flag = true;
         SqlTransaction tran = null;
         using (SqlConnection con = new SqlConnection(conString))
         {
             try
             {
                 if (con.State == ConnectionState.Closed)
                 {
                     con.Open();
                     tran = con.BeginTransaction();
                     foreach (SqlCommand com in list)
                     {
                         com.Connection = con;
                         com.Transaction = tran;
                         com.ExecuteNonQuery();
                     }
                     tran.Commit();
                 }
             }
             catch (Exception ex)
             {
                 Console.Write(ex.Message);
                 tran.Rollback();
                 flag = false;
             }
         }
         return flag;
     }
     //返回DataTable
     public static DataTable GetTable(string sql)
     {
         SqlConnection conn = new SqlConnection(conString);
         SqlDataAdapter da = new SqlDataAdapter(sql, conn);
         DataTable table = new DataTable();
         da.Fill(table);
         return table;
     }
     /// <summary>
     /// 调用带参数的存储过程，返回dataTable
     /// </summary>
     /// <param name="proc">存储过程的名称</param>
     /// <param name="rows">一页几行</param>
     /// <param name="page">当前页</param>
     /// <param name="tabName">表名</param>
     /// <returns>dataTable</returns>
     public static DataTable Proc_Table(string proc, int rows, int page, string tabName)
     {
         SqlConnection conn = new SqlConnection(conString);
         SqlCommand cmd = new SqlCommand(proc, conn);
         //指定调用存储过程
         cmd.CommandType = CommandType.StoredProcedure;
         cmd.Parameters.Add("@rows", rows);
         cmd.Parameters.Add("@page", page);
         cmd.Parameters.Add("@tabName", tabName);
         SqlDataAdapter apt = new SqlDataAdapter(cmd);
         DataTable dt = new DataTable();
         apt.Fill(dt);
         return dt;
     }

    //调用带参数的存储过程返回datatable
     public static DataTable GetTablebyproc(string proc, int pageRow, int pagSize, string tabName)
     {
         SqlConnection conn = new SqlConnection(conString);
         SqlCommand cmd = new SqlCommand(proc,conn);
         cmd.CommandType = CommandType.StoredProcedure;
         cmd.Parameters.Add("@rows", pageRow);
         cmd.Parameters.Add("@pagesize", pagSize);
         cmd.Parameters.Add("@tablename", tabName);
         SqlDataAdapter apt = new SqlDataAdapter(cmd);
         DataTable table = new DataTable();
         apt.Fill(table);
         return table;

     }
     public static DataTable GetDataByPager(string tbname, string fieldkey, int pagecurrent, int pagesize, string fieldshow, string fieldorder, string wherestring, ref int pagecount)
     {
         SqlParameter[] parameters = {
                 new SqlParameter("@tbname",   SqlDbType.VarChar, ),
                 new SqlParameter("@FieldKey", SqlDbType.VarChar, ),
                 new SqlParameter("@PageCurrent", SqlDbType.Int),
                 new SqlParameter("@PageSize", SqlDbType.Int),
                 new SqlParameter("@FieldShow", SqlDbType.VarChar, ),
                 new SqlParameter("@FieldOrder", SqlDbType.VarChar, ),
                 new SqlParameter("@WhereString", SqlDbType.VarChar, ),
                 new SqlParameter("@RecordCount", SqlDbType.Int),
             };
         parameters[].Value = tbname;
         parameters[].Value = fieldkey;
         parameters[].Value = pagecurrent;
         parameters[].Value = pagesize;
         parameters[].Value = fieldshow;
         parameters[].Value = fieldorder;
         parameters[].Value = wherestring;
         parameters[].Direction = ParameterDirection.Output;
         DataTable dt = ExecuteQuery("sp_get_data", parameters).Tables[];
         pagecount = Convert.ToInt32(parameters[].Value);
         return dt;
     }
     /// <summary>
     /// 执行有参数的查询类存储过程
     /// </summary>
     /// <param name="pstrStoreProcedure">存储过程名</param>
     /// <param name="pParms">存储过程的参数数组</param>
     /// <returns>查询得到的结果集</returns>
     public static DataSet ExecuteQuery(string pstrStoreProcedure, SqlParameter[] pParms)
     {

         DataSet dsResult = new DataSet();
         SqlDataAdapter sda = new SqlDataAdapter();
         SqlConnection con = new SqlConnection(conString);
         SqlCommand cmd;
         int intCounter;
         try
         {
             if (con.State != ConnectionState.Open)
                 con.Open();
             cmd = new SqlCommand();
             cmd.Connection = con;
             cmd.CommandType = CommandType.StoredProcedure;
             cmd.CommandText = pstrStoreProcedure;
             if (pParms != null)
             {
                 for (intCounter = ; intCounter < pParms.GetLength(); intCounter++)
                 {
                     cmd.Parameters.Add(pParms[intCounter]);
                 }
             }
             sda.SelectCommand = cmd;
             sda.Fill(dsResult);

         }
         catch (SqlException ex)
         {
             throw new Exception(ex.Message);
         }
         finally
         {
             //清空关闭操作
             sda.Dispose();
             con.Close();
             con.Dispose();

         }
         return dsResult;
     }
     /// <summary>
     /// 此分页存储过程直没修改 大家可以用自己的
     /// </summary>
     /// <param name="tableName">表名</param>
     /// <param name="getFields">需要返回的列</param>
     /// <param name="orderName">排序的字段名</param>
     /// <param name="pageSize">页尺寸</param>
     /// <param name="pageIndex">页码</param>
     /// <param name="isGetCount">返回记录总数,非 0 值则返回</param>
     /// <param name="orderType">设置排序类型,0表示升序非0降序</param>
     /// <param name="strWhere"></param>
     /// <returns></returns>
     //public static DataSet GetList(string tableName, string getFields, string orderName, int pageSize, int pageIndex, bool isGetCount, bool orderType, string strWhere)
     //{
     //    SqlParameter[] parameters = {
     //            new SqlParameter("@tblName", SqlDbType.VarChar, 255),
     //            new SqlParameter("@strGetFields", SqlDbType.VarChar, 1000),
     //            new SqlParameter("@fldName", SqlDbType.VarChar, 255),
     //          new SqlParameter("@PageSize", SqlDbType.Int),
     //       new SqlParameter("@PageIndex", SqlDbType.Int),
     //        new SqlParameter("@doCount", SqlDbType.Bit),
     //            new SqlParameter("@OrderType", SqlDbType.Bit),
     //            new SqlParameter("@strWhere", SqlDbType.VarChar, 1500)
     //                             };
     //    parameters[0].Value = tableName;
     //    parameters[1].Value = getFields;
     //    parameters[2].Value = orderName;
     //    parameters[3].Value = pageSize;
     //    parameters[4].Value = pageIndex;
     //    parameters[5].Value = isGetCount ? 1 : 0;
     //    parameters[6].Value = orderType ? 1 : 0;
     //    parameters[7].Value = strWhere;
     //    return SqlHelper.RunProcedure("pro_pageList", parameters, "ds");
     //}
     //public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName)
     //{
     //    using (SqlConnection connection = new SqlConnection(conString))
     //    {
     //        DataSet dataSet = new DataSet();
     //        connection.Open();
     //        new SqlDataAdapter { SelectCommand = BuildQueryCommand(connection, storedProcName, parameters) }.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)
         {
             CommandType = CommandType.StoredProcedure
         };
         foreach (SqlParameter parameter in parameters)
         {
             if (parameter != null)
             {
                 if (((parameter.Direction == ParameterDirection.InputOutput) || (parameter.Direction == ParameterDirection.Input)) && (parameter.Value == null))
                 {
                     parameter.Value = DBNull.Value;
                 }
                 command.Parameters.Add(parameter);
             }
         }
         return command;
     }
     //根据表名和主键id来进行删除
     public static int DelData(string tabName, string ID)
     {
         if (ID != string.Empty && ID != "")
         {
             string sql = string.Format("delete from {0}  WHERE (ID IN ({1}))", tabName, ID);
             int delNum = ExecuteSql(sql);
             return delNum;
         }
         return ;
     }
     //增删改返回执行条数
     public static int ExecuteSql(string SQLString)
     {
         int num2;
         using (SqlConnection connection = new SqlConnection(conString))
         {
             SqlCommand command = new SqlCommand(SQLString, connection);
             try
             {
                 connection.Open();
                 num2 = command.ExecuteNonQuery();
             }
             catch (SqlException exception)
             {
                 connection.Close();
                 throw exception;
             }
             finally
             {
                 if (command != null)
                 {
                     command.Dispose();
                 }
             }
         }
         return num2;
     }
 }