前台页面
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62 |
<head><meta http-equiv="Content-Type"
content="text/html; charset=utf-8"/> <title>根据班级获取学员下拉框数据</title> <script type="text/javascript"
> //1.页面加载完毕后创建异步对象 请求班级数据 window.onload = function () { //1.1创建异步对象 var
xhr = new
XMLHttpRequest(); //1.2设置参数 xhr.open("get", "GetData.ashx?type=1", true); //1.3设置不使用浏览器缓存 xhr.setRequestHeader("If-Modified-Since", "0"); //1.4设置回调函数 xhr.onreadystatechange = function () { //当完全接收完响应报文后，并且 响应状态码为200的时候 if
(xhr.readyState == 4 && xhr.status == 200) { //[{‘id‘:‘1‘,‘name‘:‘1班‘}，{‘id‘:‘2‘,‘name‘:‘2班‘}，{‘id‘:‘3‘,‘name‘:‘3班‘}] var
res = xhr.responseText;//获取响应报文体内容 //===============将数据转成js数组============ //var resJson = eval(res);//第一种转换方法 //标准json格式[{"id":"1","name":"1班"}，{"id":"2","name":"2班"}] //将 接收到的 json字符串 转换成 json对象 //注意：json其实是一种 数据传输的 格式（json格式满足js字面量表示法语法） 浏览器和服务器端 实际 不存在 所谓的 json 对象 其实就是js对象 var
jsonArr = JSON.parse(res);//第二种转换方法 注意：用这种格式转换的时候属性名必须用双引号 loadSel("selClass", jsonArr, "id", "name"); //======================================== //alert(resJson2.length); //document.getElementById("selClass").innerHTML = res; } } //1.5发送异步请求 xhr.send(null); }; /* 生成下拉框选项 */ function loadSel(selId, dataArr, valueField, textField) { //根据id获取下拉框 var
selObj = document.getElementById(selId); //清空下拉框选项 selObj.options.length = 0; //遍历数据数组 for
(var
i = 0; i < dataArr.length; i++) { //取出数据元素 var
item = dataArr[i]; //item.id item.name方式来访问 或者item["id"] item["name"] 来访问 //创建 下拉框选项 对象 var
opt = new
Option(item[textField], item[valueField]); //添加到下拉框中 selObj.options.add(opt); } } </script></head><body> <div id="divCon"> 班级：<select
id="selClass"><option>哇哈哈哈</option></select> 学生：<select
id="selStu"></select> </div></body> |
一般处理程序GetData.ashx.cs：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36 |
public
void ProcessRequest(HttpContext context) { //1.获取参数 Type string
strType = context.Request.Params["type"]; //2.根据type调用不同的方法 switch
(strType) { case
"1"://加载班级列表数据 LoadClassData(context); break; } } #region 加载班级列表数据 -- void LoadClassData(HttpContext context) /// <summary> /// 加载班级列表数据 /// </summary> /// <param name="context"></param> void
LoadClassData(HttpContext context) { //读取班级数据 DataTable dt= DbHelperSQL.GetDataTable("select * from Class where CIsDel=0"); //注意[{},{},{}] 外面的【】是数组的字面量表示法 里面的{}是对象的字面量表示法 //[{‘id‘:‘1‘,‘name‘:‘1班‘}，{‘id‘:‘2‘,‘name‘:‘2班‘}，{‘id‘:‘3‘,‘name‘:‘3班‘}] //标准json格式 ： [{"id":"1","name":"1班"}，{"id":"2","name":"2班"}] //json格式最大的要求就是 所有的键必须要加双引号，值 ： 如果是字符串也必须要加双引号 System.Text.StringBuilder sbOpts = new
System.Text.StringBuilder("[",200); foreach
(DataRow dr in
dt.Rows) { //可以直接生成html 发给浏览器 但 缺点：传输量大 浏览器端不灵活（如果浏览器要显示班级表格呢？） //sbOpts.Append("<option value=‘" + dr["CId"] + "‘>" + dr["CName"] + "</option>"); sbOpts.Append("{\"id\":\""
+ dr["CId"] + "\",\"name\":\""
+ dr["CName"] + "\"},"); } context.Response.Write(sbOpts.Remove(sbOpts.Length-1,1).ToString()+"]");//最后多一个“，”所以要截取 } #endregion |
dbhelper文件：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405 |
using
System;using
System.Collections.Generic;using
System.Text;using
System.Data;using
System.Data.SqlClient;using
System.Reflection;//反射命名空间namespace
Ajax{ /// <summary> /// 数据层 - 数据库 操作类 /// </summary> internal
class DbHelperSQL { //获得配置文件的连接字符串 public
static string strConn = System.Configuration.ConfigurationManager.ConnectionStrings["connStr"].ConnectionString; #region 01.查询数据表 +static DataTable GetTabel(string strSql, params SqlParameter[] paras) /// <summary> /// 查询数据表 /// </summary> /// <param name="strSql">sql语句</param> /// <param name="paras">参数数组</param> /// <returns></returns> public
static DataTable GetDataTable(string
strSql, params
SqlParameter[] paras) { DataTable dt = null; using
(SqlConnection conn = new
SqlConnection(strConn)) { //创建 适配器对象（sql命令，连接通道） SqlDataAdapter da = new
SqlDataAdapter(strSql, conn); //添加参数 da.SelectCommand.Parameters.AddRange(paras); //创建数据表对象 dt = new
DataTable(); //适配器 读取数据库，并将查询的结果 装入程序的 dt里 da.Fill(dt); } return
dt; } #endregion #region 02.执行 增删改 (非查询语句) +int ExcuteNonQuery(string strSql, params SqlParameter[] paras) /// <summary> /// 执行 增删改 (非查询语句) /// </summary> /// <param name="strSql"></param> /// <param name="paras"></param> /// <returns></returns> public
static int ExcuteNonQuery(string
strSql, params
SqlParameter[] paras) { int
res = -1; //创建连接通道 using
(SqlConnection conn = new
SqlConnection(strConn)) { //创建命令对象（sql语句，连接通道） SqlCommand cmd = new
SqlCommand(strSql, conn); //添加参数 cmd.Parameters.AddRange(paras); conn.Open(); res = cmd.ExecuteNonQuery(); } return
res; } #endregion #region 02a.执行 多条增删改 (非查询语句) +int ExcuteNonQuery(string strSql, params SqlParameter[] paras) /// <summary> /// 执行 多条增删改 (非查询语句) /// </summary> /// <param name="strSql"></param> /// <param name="paras"></param> /// <returns></returns> public
static int ExcuteNonQuerys(string[] strSqls, SqlParameter[][] paras2Arr) { int
res = 0; //创建连接通道 using
(SqlConnection conn = new
SqlConnection(strConn)) { conn.Open(); //创建 事务 SqlTransaction tran = conn.BeginTransaction(); //创建命令对象 SqlCommand cmd = new
SqlCommand(); //为命令对象指定连接通道 cmd.Connection = conn; //为命令对象指定事务 cmd.Transaction = tran; try { //循环执行sql语句 for
(int
i = 0; i < strSqls.Length; i++) { //获得要执行的sql语句 string
strSql = strSqls[i]; //为命令对象指定 此次执行的 sql语句 cmd.CommandText = strSql; //添加参数 if
(paras2Arr.Length > i)//如果 参数2维数组的长度大于当前循环的下标 { cmd.Parameters.AddRange(paras2Arr[i]);//将 交错数组 的第一个元素（其实也是一个数组，添加到参数集合中） } res += cmd.ExecuteNonQuery(); cmd.Parameters.Clear(); } tran.Commit();//提交事务 } catch
(Exception ex) { res = 0; tran.Rollback();//回滚事务 throw
ex; } } return
res; } #endregion #region 02.执行 查询单个值 +int ExcuteScalar(string strSql, params SqlParameter[] paras) /// <summary> /// 执行 增删改 (非查询语句) /// </summary> /// <param name="strSql"></param> /// <param name="paras"></param> /// <returns></returns> public
static int ExcuteScalar(string
strSql, params
SqlParameter[] paras) { int
res = -1; //创建连接通道 using
(SqlConnection conn = new
SqlConnection(strConn)) { //创建命令对象（sql语句，连接通道） SqlCommand cmd = new
SqlCommand(strSql, conn); //添加参数 cmd.Parameters.AddRange(paras); conn.Open(); res = Convert.ToInt32(cmd.ExecuteScalar()); } return
res; } #endregion #region 04.执行 特殊的 分页存储过程 +DataTable GetPageListByProc(int pageIndex, int pageSize,out int pageCount,out int rowCount) /// <summary> ///04.执行 特殊的 分页存储过程 /// </summary> /// <param name="proName">存储过程名称</param> /// <param name="pageIndex">页码</param> /// <param name="pageSize">页容量</param> /// <param name="userId">用户id</param> /// <param name="pageCount">总页数--输出</param> /// <param name="rowCount">总行数--输出</param> /// <returns></returns> public
static DataTable GetPageListByProc(string
proName,int
pageIndex, int
pageSize, int
userId, out
int pageCount, out
int rowCount) { DataTable dt = new
DataTable(); //创建连接通道 using
(SqlConnection conn = new
SqlConnection(strConn)) { //创建适配器对象 SqlDataAdapter da = new
SqlDataAdapter(proName, conn); //设置 命令类型 为存储过程 da.SelectCommand.CommandType = CommandType.StoredProcedure; //设置 参数 da.SelectCommand.Parameters.AddWithValue("@pi", pageIndex);//当前页码 da.SelectCommand.Parameters.AddWithValue("@ps", pageSize);//页容量 //在存储过程中 输出参数 da.SelectCommand.Parameters.Add(new
SqlParameter("@pc", SqlDbType.Int)); da.SelectCommand.Parameters.Add(new
SqlParameter("@rc",SqlDbType.Int)); //将后面两个参数 设置为 输出类型 da.SelectCommand.Parameters[2].Direction = ParameterDirection.Output; da.SelectCommand.Parameters[3].Direction = ParameterDirection.Output; da.SelectCommand.Parameters.AddWithValue("@uid", userId); //执行 并将查询到的 结果 赋给 数据表对象 da.Fill(dt); //获得 存储过程 返回的 输出参数 rowCount = Convert.ToInt32(da.SelectCommand.Parameters[2].Value); pageCount= Convert.ToInt32(da.SelectCommand.Parameters[3].Value); } //返回数据表 return
dt; } #endregion #region 04.执行 特殊的 分页存储过程 +DataTable GetPageListByProc(int pageIndex, int pageSize,out int pageCount,out int rowCount) /// <summary> ///04.执行 特殊的 分页存储过程 /// </summary> /// <param name="proName">存储过程名称</param> /// <param name="pageIndex">页码</param> /// <param name="pageSize">页容量</param> /// <param name="userId">用户id</param> /// <param name="pageCount">总页数--输出</param> /// <param name="rowCount">总行数--输出</param> /// <returns></returns> public
static int ExcuteNonQueryWithProc(string
proName, params
SqlParameter[] paras) { DataTable dt = new
DataTable(); //创建连接通道 using
(SqlConnection conn = new
SqlConnection(strConn)) { SqlCommand cmd = new
SqlCommand(proName,conn); cmd.CommandType = CommandType.StoredProcedure; cmd.Parameters.AddRange(paras); conn.Open(); return
cmd.ExecuteNonQuery(); } } #endregion #region 01.3为 对象数据源控件 提供 分页数据 /// <summary> /// 01.3为 对象数据源控件 提供 分页数据 /// </summary> /// <param name="pageSize">页容量</param> /// <param name="startRowIndex">起始行下标</param> /// <returns></returns> public
static DataTable GetPagedListForObjectDataSource(int
pageSize, int
startRowIndex) { string
strSql = "select * from(select Row_Number() over(order by cid) as num, * from Classes)as temp where num>@startRowIndex and num<=@size"; SqlParameter[] paras = { new
SqlParameter("@startRowIndex",startRowIndex), new
SqlParameter("@size",pageSize+startRowIndex) }; return
GetDataTable(strSql, paras); } #endregion #region 3.执行查询多行语句 - 返回数据读取器 +static SqlDataReader ExcuteDataReader(string strSelectCmd, params SqlParameter[] paras) /// <summary> /// 执行查询多行语句 - 返回数据读取器 /// </summary> /// <param name="strSelectCmd"></param> /// <param name="paras"></param> /// <returns></returns> public
static SqlDataReader ExcuteDataReader(string
strSelectCmd, params
SqlParameter[] paras) { SqlConnection conn = null; try { //1.创建连接通道 conn = new
SqlConnection(strConn); //2.创建命令对象 SqlCommand cmd = new
SqlCommand(strSelectCmd, conn); //3.添加命令参数 cmd.Parameters.AddRange(paras); //4.打开连接 conn.Open(); //5.创建读取器（当关闭此读取器时，会自动关闭连接通道） SqlDataReader dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);//当关闭此读取器时，会自动关闭连接通道 //6.返回读取器 return
dr; } catch
(Exception ex) { conn.Dispose(); throw
ex; } } #endregion #region 2.0升级泛型版 ------ 执行查询多行语句 - 返回数据表 /// <summary> /// 2.0升级泛型版 ------ 执行查询多行语句 - 返回数据表 /// </summary> /// <typeparam name="T2">泛型类型</typeparam> /// <param name="strSelectCmd">查询sql语句</param> /// <param name="paras">查询参数</param> /// <returns>泛型集合</returns> public
static List<T2> ExcuteList<T2>(string
strSelectCmd, params
SqlParameter[] paras) { //1.创建连接通道 using
(SqlConnection conn = new
SqlConnection(strConn)) { //2.创建适配器 SqlDataAdapter da = new
SqlDataAdapter(strSelectCmd, conn); //2.1设置查询命令的参数 da.SelectCommand.Parameters.AddRange(paras); //3.数据表 DataTable dt = new
DataTable(); //4.将数据查询并填充到数据表中 da.Fill(dt); //5.将DataTable转成泛型集合List<T2> if
(dt.Rows.Count > 0) { //6.创建泛型集合对象 List<T2> list = new
List<T2>(); //7.遍历数据行，将行数据存入 实体对象中，并添加到 泛型集合中list foreach
(DataRow row in
dt.Rows) { //留言：等学完反射后再讲~~~~！ //7.1先获得泛型的类型(里面包含该类的所有信息---有什么属性啊，有什么方法啊，什么字段啊....................) Type t = typeof(T2); //7.2根据类型创建该类型的对象 T2 model = (T2)Activator.CreateInstance(t);// new MODEL.Classes() //7.3根据类型 获得 该类型的 所有属性定义 PropertyInfo[] properties = t.GetProperties(); //7.4遍历属性数组 foreach
(PropertyInfo p in
properties) { //7.4.1获得属性名，作为列名 string
colName = p.Name; //7.4.2根据列名 获得当前循环行对应列的值 object
colValue = row[colName]; //7.4.3将 列值 赋给 model对象的p属性 //model.ID=colValue; p.SetValue(model, colValue, null); } //7.5将装好 了行数据的 实体对象 添加到 泛型集合中 O了！！！ list.Add(model); } return
list; } } return
null; } #endregion #region 6.查询结果集里的第一个单元格的值（单个值）-- 泛型版本 + static T ExcuteScalar<T>(string strSelectCmd, params SqlParameter[] paras) /// <summary> /// 查询结果集里的第一个单元格的值（单个值）-- 泛型版本 /// </summary> /// <typeparam name="T">类型参数</typeparam> /// <param name="strSelectCmd"></param> /// <param name="paras"></param> /// <returns></returns> public
static T ExcuteScalar<T>(string
strSelectCmd, params
SqlParameter[] paras) { using
(SqlConnection conn = new
SqlConnection(strConn)) { SqlCommand cmd = new
SqlCommand(strSelectCmd, conn); cmd.Parameters.AddRange(paras); conn.Open(); object
o = cmd.ExecuteScalar(); return
(T)Convert.ChangeType(o, typeof(T)); } } #endregion #region 将数据表 转成对应 T2 类型的泛型集合对象 /// <summary> /// 将数据表 转成对应 T2 类型的泛型集合对象 /// </summary> /// <typeparam name="T2">泛型类型</typeparam> /// <returns>泛型集合</returns> public
static List<T2> Table2List<T2>(DataTable dt) { //5.将DataTable转成泛型集合List<T2> if
(dt.Rows.Count > 0) { //6.创建泛型集合对象 List<T2> list = new
List<T2>(); //7.遍历数据行，将行数据存入 实体对象中，并添加到 泛型集合中list foreach
(DataRow row in
dt.Rows) { //留言：等学完反射后再讲~~~~！ //7.1先获得泛型的类型(里面包含该类的所有信息---有什么属性啊，有什么方法啊，什么字段啊....................) Type t = typeof(T2); //7.2根据类型创建该类型的对象 T2 model = (T2)Activator.CreateInstance(t);// new MODEL.Classes() //7.3根据类型 获得 该类型的 所有属性定义 PropertyInfo[] properties = t.GetProperties(); //7.4遍历属性数组 foreach
(PropertyInfo p in
properties) { //7.4.1获得属性名，作为列名 string
colName = p.Name; //7.4.2根据列名 获得当前循环行对应列的值 object
colValue = row[colName]; //7.4.3将 列值 赋给 model对象的p属性 //model.ID=colValue; p.SetValue(model, colValue, null); } //7.5将装好 了行数据的 实体对象 添加到 泛型集合中 O了！！！ list.Add(model); } return
list; } return
null; } #endregion public
static void PrepareCommand(SqlCommand cmd, SqlConnection conn,SqlTransaction trans, CommandType type, string
cmdText, SqlParameter[] cmdParms) { if
(conn.State != ConnectionState.Open) conn.Open(); cmd.Connection = conn; cmd.CommandText = cmdText; cmd.CommandType = type; if
(trans != null) cmd.Transaction = trans; 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); } } } }} |
原文：http://www.cnblogs.com/mekor/p/3674296.html