1. /// <summary> 
2.    /// 数据库访问通用类 
3.    /// </summary> 
4.    public class SqlHelper 
5.    { 
6.        private string connectionString; 
7.  
8.        /// <summary> 
9.        /// 设定数据库访问字符串 
10.        /// </summary> 
11.        public string ConnectionString 
12.        { 
13.             
14.            set { connectionString = value; } 
15.        } 
16.  
17.        /// <summary> 
18.        /// 构造函数 
19.        /// </summary> 
20.        /// <param name="connectionString">数据库访问字符串</param> 
21.        public SqlHelper(string connectionString) 
22.        { 
23.            this.connectionString = connectionString; 
24.        } 
25.  
26.        /// <summary> 
27.        /// 执行一个查询，并返回查询结果 
28.        /// </summary> 
29.        /// <param name="sql">要执行的sql语句</param> 
30.        /// <param name="commandType">要执行的查询语句的类型，如存储过程或者sql文本命令</param> 
31.        /// <returns>返回查询结果集</returns> 
32.        public DataTable ExecuteDataTable(string sql,CommandType commandType) 
33.        { 
34.            return ExecuteDataTable(sql, commandType, null); 
35.        } 
36.  
37.        /// <summary> 
38.        /// 执行一个查询，并返回结果集 
39.        /// </summary> 
40.        /// <param name="sql">要执行的sql文本命令</param> 
41.        /// <returns>返回查询的结果集</returns> 
42.        public DataTable ExecuteDataTable(string sql) 
43.        { 
44.            return ExecuteDataTable(sql, CommandType.Text, null); 
45.        } 
46.  
47.  
48.        /// <summary> 
49.        /// 执行一个查询，并返回查询结果 
50.        /// </summary> 
51.        /// <param name="sql">要执行的sql语句</param> 
52.        /// <param name="commandtype">要执行查询语句的类型，如存储过程或者sql文本命令</param> 
53.        /// <param name="parameters">Transact-SQL语句或者存储过程参数数组</param> 
54.        /// <returns></returns> 
55.        public DataTable ExecuteDataTable(string sql, CommandType commandtype, SqlParameter[] parameters) 
56.        { 
57.            DataTable data = new DataTable(); //实例化datatable，用于装载查询结果集 
58.            using (SqlConnection con = new SqlConnection(connectionString)) 
59.            { 
60.                using (SqlCommand cmd = new SqlCommand(sql, con)) 
61.                { 
62.                    cmd.CommandType = commandtype;//设置command的commandType为指定的Commandtype 
63.                    //如果同时传入了参数，则添加这些参数 
64.                    if (parameters != null) 
65.                    { 
66.                        foreach (SqlParameter parameter in parameters) 
67.                        { 
68.                            cmd.Parameters.Add(parameter); 
69.                        } 
70.                    } 
71.  
72.                    //通过包含查询sql的sqlcommand实例来实例化sqldataadapter 
73.                    SqlDataAdapter adapter = new SqlDataAdapter(cmd); 
74.                    adapter.Fill(data);//填充datatable 
75.  
76.                } 
77.            } 
78.            return data; 
79.        } 
80.  
81.        /// <summary> 
82.        /// 返回一个SqlDataReader对象的实例 
83.        /// </summary> 
84.        /// <param name="sql">要执行的SQl查询命令</param> 
85.        /// <returns></returns> 
86.        public SqlDataReader ExecuteReader(string sql) 
87.        { 
88.            return ExecuteReader(sql, CommandType.Text, null); 
89.        } 
90.  
91.        /// <summary> 
92.        ///  
93.        /// </summary> 
94.        /// <param name="sql">要执行的sql语句</param> 
95.        /// <param name="commandType">要执行查询语句的类型，如存储过程或者SQl文本命令</param> 
96.        /// <returns></returns> 
97.        public SqlDataReader ExecuteReader(string sql,CommandType commandType) 
98.        { 
99.            return ExecuteReader(sql, commandType, null); 
100.        } 
101.  
102.        /// <summary> 
103.        /// 返回一个sqldatareader对象的实例 
104.        /// </summary> 
105.        /// <param name="sql"></param> 
106.        /// <param name="commandType"></param> 
107.        /// <param name="parameters"></param> 
108.        /// <returns></returns> 
109.        public SqlDataReader ExecuteReader(string sql, CommandType commandType, SqlParameter[] parameters) 
110.        { 
111.            SqlConnection con = new SqlConnection(connectionString); 
112.            SqlCommand cmd = new SqlCommand(sql, con); 
113.  
114.            if (parameters != null) 
115.            { 
116.                foreach (SqlParameter parameter in parameters) 
117.                { 
118.                    cmd.Parameters.Add(parameters); 
119.                } 
120.            } 
121.            con.Open(); 
122.            //CommandBehavior.CloseConnection参数指示关闭reader对象时关闭与其关联的Connection对象 
123.            return cmd.ExecuteReader(CommandBehavior.CloseConnection); 
124.        } 
125.  
126.        /// <summary> 
127.        /// 执行一个查询，返回结果集的首行首列。忽略其他行，其他列 
128.        /// </summary> 
129.        /// <param name="sql">要执行的SQl命令</param> 
130.        /// <returns></returns> 
131.        public Object ExecuteScalar(string sql) 
132.        { 
133.            return ExecuteScalar(sql, CommandType.Text, null); 
134.        } 
135.  
136.        /// <summary> 
137.        ///  
138.        /// </summary> 
139.        /// <param name="sql"></param> 
140.        /// <param name="commandType"></param> 
141.        /// <returns></returns> 
142.        public Object ExecuteScalar(string sql, CommandType commandType) 
143.        { 
144.            return ExecuteScalar(sql, commandType, null); 
145.        } 
146.  
147.  
148.        /// <summary> 
149.        ///  
150.        /// </summary> 
151.        /// <param name="sql"></param> 
152.        /// <param name="commandType">参数类型</param> 
153.        /// <param name="parameters"></param> 
154.        /// <returns></returns> 
155.        public Object ExecuteScalar(string sql,CommandType commandType, SqlParameter[] parameters) 
156.        { 
157.            Object result=null; 
158.            SqlConnection con=new SqlConnection(connectionString); 
159.            SqlCommand cmd=new SqlCommand(sql,con); 
160.            cmd.CommandType= commandType; 
161.            if(parameters!=null) 
162.            { 
163.                foreach (SqlParameter parapmeter in parameters) 
164.                { 
165.                    cmd.Parameters.Add(parapmeter); 
166.                } 
167.            } 
168.  
169.            con.Open(); 
170.            result=cmd.ExecuteScalar(); 
171.            con.Close(); 
172.            return result; 
173.        } 
174.  
175.        /// <summary> 
176.        /// 对数据库进行增删改的操作 
177.        /// </summary> 
178.        /// <param name="sql">要执行的sql命令</param> 
179.        /// <returns></returns> 
180.        public int ExecuteNonQuery(string sql) 
181.        { 
182.            return ExecuteNonQuery(sql, CommandType.Text, null); 
183.        } 
184.  
185.        /// <summary> 
186.        /// 数据库进行增删改的操作 
187.        /// </summary> 
188.        /// <param name="sql">对数据库进行操作的sql命令</param> 
189.        /// <param name="commandType">要执行查询语句的类型，如存储过程或者sql文本命令</param> 
190.        /// <returns></returns> 
191.        public int ExecuteNonQuery(string sql, CommandType commandType) 
192.        { 
193.            return ExecuteNonQuery(sql, commandType, null); 
194.        } 
195.  
196.        /// <summary> 
197.        /// 对数据库进行增删改的操作 
198.        /// </summary> 
199.        /// <param name="sql">要执行的sql语句</param> 
200.        /// <param name="commandType">要执行的查询语句类型，如存储过程或者sql文本命令</param> 
201.        /// <param name="parameters">Transact-SQL语句或者存储过程的参数数组</param> 
202.        /// <returns></returns> 
203.        public int ExecuteNonQuery(string sql, CommandType commandType, SqlParameter[] parameters) 
204.        { 
205.            int count = 0; 
206.            SqlConnection con = new SqlConnection(connectionString); 
207.            SqlCommand cmd = new SqlCommand(sql, con); 
208.            cmd.CommandType = commandType; 
209.            if (parameters != null) 
210.            { 
211.                foreach(SqlParameter parameter in parameters) 
212.                { 
213.                    cmd.Parameters.Add(parameter); 
214.                } 
215.            } 
216.  
217.            con.Open(); 
218.            count = cmd.ExecuteNonQuery(); 
219.            con.Close(); 
220.            return count; 
221.        } 
222.  
223.        /// <summary> 
224.        /// 返回当前连接的数据库中所有用户创建的数据库 
225.        /// </summary> 
226.        /// <returns></returns> 
227.        public DataTable GetTables() 
228.        { 
229.            DataTable table = null; 
230.            using (SqlConnection con = new SqlConnection(connectionString)) 
231.            { 
232.                con.Open(); 
233.                table = con.GetSchema("Tables"); 
234.  
235.            } 
236.            return table; 
237.        } 
238.    } 
239. 本文出自 “强子的专栏” 博客，请务必保留此出处http://yisuowushinian.blog.51cto.com/4241271/999324

【ASP.NET开发】ASP.NET对SQLServer的通用数据库访问类(转)