1 using System;
2 using System.Collections;
3 using System.Collections.Specialized;
4 using System.Data;
5 using System.Data.SqlClient;
6 using System.Configuration;
7
8 namespace LiTianPing.SQLServerDAL //可以修改成实际项目的命名空间名称
9 {
10 /**//// <summary>
11 /// Copyright (C) 2004-2008 LiTianPing
12 /// 数据访问基础类(基于SQLServer)
13 /// 用户可以修改满足自己项目的需要。
14 /// </summary>
15 public abstract class DbHelperSQL
16 {
17 //数据库连接字符串(web.config来配置)
18 //<add key="ConnectionString" value="server=127.0.0.1;database=DATABASE;uid=sa;pwd=" />
19 protected static string connectionString = ConfigurationSettings.AppSettings["ConnectionString"];
20 public DbHelperSQL()
21 {
22 }
23
24 公用方法#region 公用方法
25
26 public static int GetMaxID(string FieldName,string TableName)
27 {
28 string strsql = "select max(" + FieldName + ")+1 from " + TableName;
29 object obj = GetSingle(strsql);
30 if (obj == null)
31 {
32 return 1;
33 }
34 else
35 {
36 return int.Parse(obj.ToString());
37 }
38 }
39 public static bool Exists(string strSql, params SqlParameter[] cmdParms)
40 {
41 object obj = GetSingle(strSql, cmdParms);
42 int cmdresult;
43 if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
44 {
45 cmdresult = 0;
46 }
47 else
48 {
49 cmdresult = int.Parse(obj.ToString());
50 }
51 if (cmdresult == 0)
52 {
53 return false;
54 }
55 else
56 {
57 return true;
58 }
59 }
60 #endregion
61
62 执行简单SQL语句#region 执行简单SQL语句
63
64 /**//// <summary>
65 /// 执行SQL语句，返回影响的记录数
66 /// </summary>
67 /// <param name="SQLString">SQL语句</param>
68 /// <returns>影响的记录数</returns>
69 public static int ExecuteSql(string SQLString)
70 {
71 using (SqlConnection connection = new SqlConnection(connectionString))
72 {
73 using (SqlCommand cmd = new SqlCommand(SQLString,connection))
74 {
75 try
76 {
77 connection.Open();
78 int rows=cmd.ExecuteNonQuery();
79 return rows;
80 }
81 catch(System.Data.SqlClient.SqlException E)
82 {
83 connection.Close();
84 throw new Exception(E.Message);
85 }
86 }
87 }
88 }
89
90 /**//// <summary>
91 /// 执行多条SQL语句，实现数据库事务。
92 /// </summary>
93 /// <param name="SQLStringList">多条SQL语句</param>
94 public static void ExecuteSqlTran(ArrayList SQLStringList)
95 {
96 using (SqlConnection conn = new SqlConnection(connectionString))
97 {
98 conn.Open();
99 SqlCommand cmd = new SqlCommand();
100 cmd.Connection=conn;
101 SqlTransaction tx=conn.BeginTransaction();
102 cmd.Transaction=tx;
103 try
104 {
105 for(int n=0;n<SQLStringList.Count;n++)
106 {
107 string strsql=SQLStringList[n].ToString();
108 if (strsql.Trim().Length>1)
109 {
110 cmd.CommandText=strsql;
111 cmd.ExecuteNonQuery();
112 }
113 }
114 tx.Commit();
115 }
116 catch(System.Data.SqlClient.SqlException E)
117 {
118 tx.Rollback();
119 throw new Exception(E.Message);
120 }
121 }
122 }
123 /**//// <summary>
124 /// 执行带一个存储过程参数的的SQL语句。
125 /// </summary>
126 /// <param name="SQLString">SQL语句</param>
127 /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
128 /// <returns>影响的记录数</returns>
129 public static int ExecuteSql(string SQLString,string content)
130 {
131 using (SqlConnection connection = new SqlConnection(connectionString))
132 {
133 SqlCommand cmd = new SqlCommand(SQLString,connection);
134 System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter ( "@content", SqlDbType.NText);
135 myParameter.Value = content ;
136 cmd.Parameters.Add(myParameter);
137 try
138 {
139 connection.Open();
140 int rows=cmd.ExecuteNonQuery();
141 return rows;
142 }
143 catch(System.Data.SqlClient.SqlException E)
144 {
145 throw new Exception(E.Message);
146 }
147 finally
148 {
149 cmd.Dispose();
150 connection.Close();
151 }
152 }
153 }
154 /**//// <summary>
155 /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
156 /// </summary>
157 /// <param name="strSQL">SQL语句</param>
158 /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
159 /// <returns>影响的记录数</returns>
160 public static int ExecuteSqlInsertImg(string strSQL,byte[] fs)
161 {
162 using (SqlConnection connection = new SqlConnection(connectionString))
163 {
164 SqlCommand cmd = new SqlCommand(strSQL,connection);
165 System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter ( "@fs", SqlDbType.Image);
166 myParameter.Value = fs ;
167 cmd.Parameters.Add(myParameter);
168 try
169 {
170 connection.Open();
171 int rows=cmd.ExecuteNonQuery();
172 return rows;
173 }
174 catch(System.Data.SqlClient.SqlException E)
175 {
176 throw new Exception(E.Message);
177 }
178 finally
179 {
180 cmd.Dispose();
181 connection.Close();
182 }
183 }
184 }
185
186 /**//// <summary>
187 /// 执行一条计算查询结果语句，返回查询结果（object）。
188 /// </summary>
189 /// <param name="SQLString">计算查询结果语句</param>
190 /// <returns>查询结果（object）</returns>
191 public static object GetSingle(string SQLString)
192 {
193 using (SqlConnection connection = new SqlConnection(connectionString))
194 {
195 using(SqlCommand cmd = new SqlCommand(SQLString,connection))
196 {
197 try
198 {
199 connection.Open();
200 object obj = cmd.ExecuteScalar();
201 if((Object.Equals(obj,null))||(Object.Equals(obj,System.DBNull.Value)))
202 {
203 return null;
204 }
205 else
206 {
207 return obj;
208 }
209 }
210 catch(System.Data.SqlClient.SqlException e)
211 {
212 connection.Close();
213 throw new Exception(e.Message);
214 }
215 }
216 }
217 }
218 /**//// <summary>
219 /// 执行查询语句，返回SqlDataReader
220 /// </summary>
221 /// <param name="strSQL">查询语句</param>
222 /// <returns>SqlDataReader</returns>
223 public static SqlDataReader ExecuteReader(string strSQL)
224 {
225 SqlConnection connection = new SqlConnection(connectionString);
226 SqlCommand cmd = new SqlCommand(strSQL,connection);
227 try
228 {
229 connection.Open();
230 SqlDataReader myReader = cmd.ExecuteReader();
231 return myReader;
232 }
233 catch(System.Data.SqlClient.SqlException e)
234 {
235 throw new Exception(e.Message);
236 }
237
238 }
239 /**//// <summary>
240 /// 执行查询语句，返回DataSet
241 /// </summary>
242 /// <param name="SQLString">查询语句</param>
243 /// <returns>DataSet</returns>
244 public static DataSet Query(string SQLString)
245 {
246 using (SqlConnection connection = new SqlConnection(connectionString))
247 {
248 DataSet ds = new DataSet();
249 try
250 {
251 connection.Open();
252 SqlDataAdapter command = new SqlDataAdapter(SQLString,connection);
253 command.Fill(ds,"ds");
254 }
255 catch(System.Data.SqlClient.SqlException ex)
256 {
257 throw new Exception(ex.Message);
258 }
259 return ds;
260 }
261 }
262
263
264 #endregion
265
266 执行带参数的SQL语句#region 执行带参数的SQL语句
267
268 /**//// <summary>
269 /// 执行SQL语句，返回影响的记录数
270 /// </summary>
271 /// <param name="SQLString">SQL语句</param>
272 /// <returns>影响的记录数</returns>
273 public static int ExecuteSql(string SQLString,params SqlParameter[] cmdParms)
274 {
275 using (SqlConnection connection = new SqlConnection(connectionString))
276 {
277 using (SqlCommand cmd = new SqlCommand())
278 {
279 try
280 {
281 PrepareCommand(cmd, connection, null,SQLString, cmdParms);
282 int rows=cmd.ExecuteNonQuery();
283 cmd.Parameters.Clear();
284 return rows;
285 }
286 catch(System.Data.SqlClient.SqlException E)
287 {
288 throw new Exception(E.Message);
289 }
290 }
291 }
292 }
293
294
295 /**//// <summary>
296 /// 执行多条SQL语句，实现数据库事务。
297 /// </summary>
298 /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
299 public static void ExecuteSqlTran(Hashtable SQLStringList)
300 {
301 using (SqlConnection conn = new SqlConnection(connectionString))
302 {
303 conn.Open();
304 using (SqlTransaction trans = conn.BeginTransaction())
305 {
306 SqlCommand cmd = new SqlCommand();
307 try
308 {
309 //循环
310 foreach (DictionaryEntry myDE in SQLStringList)
311 {
312 string cmdText=myDE.Key.ToString();
313 SqlParameter[] cmdParms=(SqlParameter[])myDE.Value;
314 PrepareCommand(cmd,conn,trans,cmdText, cmdParms);
315 int val = cmd.ExecuteNonQuery();
316 cmd.Parameters.Clear();
317
318 trans.Commit();
319 }
320 }
321 catch
322 {
323 trans.Rollback();
324 throw;
325 }
326 }
327 }
328 }
329
330
331 /**//// <summary>
332 /// 执行一条计算查询结果语句，返回查询结果（object）。
333 /// </summary>
334 /// <param name="SQLString">计算查询结果语句</param>
335 /// <returns>查询结果（object）</returns>
336 public static object GetSingle(string SQLString,params SqlParameter[] cmdParms)
337 {
338 using (SqlConnection connection = new SqlConnection(connectionString))
339 {
340 using (SqlCommand cmd = new SqlCommand())
341 {
342 try
343 {
344 PrepareCommand(cmd, connection, null,SQLString, cmdParms);
345 object obj = cmd.ExecuteScalar();
346 cmd.Parameters.Clear();
347 if((Object.Equals(obj,null))||(Object.Equals(obj,System.DBNull.Value)))
348 {
349 return null;
350 }
351 else
352 {
353 return obj;
354 }
355 }
356 catch(System.Data.SqlClient.SqlException e)
357 {
358 throw new Exception(e.Message);
359 }
360 }
361 }
362 }
363
364 /**//// <summary>
365 /// 执行查询语句，返回SqlDataReader
366 /// </summary>
367 /// <param name="strSQL">查询语句</param>
368 /// <returns>SqlDataReader</returns>
369 public static SqlDataReader ExecuteReader(string SQLString,params SqlParameter[] cmdParms)
370 {
371 SqlConnection connection = new SqlConnection(connectionString);
372 SqlCommand cmd = new SqlCommand();
373 try
374 {
375 PrepareCommand(cmd, connection, null,SQLString, cmdParms);
376 SqlDataReader myReader = cmd.ExecuteReader();
377 cmd.Parameters.Clear();
378 return myReader;
379 }
380 catch(System.Data.SqlClient.SqlException e)
381 {
382 throw new Exception(e.Message);
383 }
384
385 }
386
387 /**//// <summary>
388 /// 执行查询语句，返回DataSet
389 /// </summary>
390 /// <param name="SQLString">查询语句</param>
391 /// <returns>DataSet</returns>
392 public static DataSet Query(string SQLString,params SqlParameter[] cmdParms)
393 {
394 using (SqlConnection connection = new SqlConnection(connectionString))
395 {
396 SqlCommand cmd = new SqlCommand();
397 PrepareCommand(cmd, connection, null,SQLString, cmdParms);
398 using( SqlDataAdapter da = new SqlDataAdapter(cmd) )
399 {
400 DataSet ds = new DataSet();
401 try
402 {
403 da.Fill(ds,"ds");
404 cmd.Parameters.Clear();
405 }
406 catch(System.Data.SqlClient.SqlException ex)
407 {
408 throw new Exception(ex.Message);
409 }
410 return ds;
411 }
412 }
413 }
414
415
416 private static void PrepareCommand(SqlCommand cmd,SqlConnection conn,SqlTransaction trans, string cmdText, SqlParameter[] cmdParms)
417 {
418 if (conn.State != ConnectionState.Open)
419 conn.Open();
420 cmd.Connection = conn;
421 cmd.CommandText = cmdText;
422 if (trans != null)
423 cmd.Transaction = trans;
424 cmd.CommandType = CommandType.Text;//cmdType;
425 if (cmdParms != null)
426 {
427 foreach (SqlParameter parm in cmdParms)
428 cmd.Parameters.Add(parm);
429 }
430 }
431
432 #endregion
433
434 存储过程操作#region 存储过程操作
435
436 /**//// <summary>
437 /// 执行存储过程
438 /// </summary>
439 /// <param name="storedProcName">存储过程名</param>
440 /// <param name="parameters">存储过程参数</param>
441 /// <returns>SqlDataReader</returns>
442 public static SqlDataReader RunProcedure(string storedProcName, IDataParameter[] parameters )
443 {
444 SqlConnection connection = new SqlConnection(connectionString);
445 SqlDataReader returnReader;
446 connection.Open();
447 SqlCommand command = BuildQueryCommand( connection,storedProcName, parameters );
448 command.CommandType = CommandType.StoredProcedure;
449 returnReader = command.ExecuteReader();
450 return returnReader;
451 }
452
453
454 /**//// <summary>
455 /// 执行存储过程
456 /// </summary>
457 /// <param name="storedProcName">存储过程名</param>
458 /// <param name="parameters">存储过程参数</param>
459 /// <param name="tableName">DataSet结果中的表名</param>
460 /// <returns>DataSet</returns>
461 public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName )
462 {
463 using (SqlConnection connection = new SqlConnection(connectionString))
464 {
465 DataSet dataSet = new DataSet();
466 connection.Open();
467 SqlDataAdapter sqlDA = new SqlDataAdapter();
468 sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters );
469 sqlDA.Fill( dataSet, tableName );
470 connection.Close();
471 return dataSet;
472 }
473 }
474
475
476 /**//// <summary>
477 /// 构建 SqlCommand 对象(用来返回一个结果集，而不是一个整数值)
478 /// </summary>
479 /// <param name="connection">数据库连接</param>
480 /// <param name="storedProcName">存储过程名</param>
481 /// <param name="parameters">存储过程参数</param>
482 /// <returns>SqlCommand</returns>
483 private static SqlCommand BuildQueryCommand(SqlConnection connection,string storedProcName, IDataParameter[] parameters)
484 {
485 SqlCommand command = new SqlCommand( storedProcName, connection );
486 command.CommandType = CommandType.StoredProcedure;
487 foreach (SqlParameter parameter in parameters)
488 {
489 command.Parameters.Add( parameter );
490 }
491 return command;
492 }
493
494 /**//// <summary>
495 /// 执行存储过程，返回影响的行数
496 /// </summary>
497 /// <param name="storedProcName">存储过程名</param>
498 /// <param name="parameters">存储过程参数</param>
499 /// <param name="rowsAffected">影响的行数</param>
500 /// <returns></returns>
501 public static int RunProcedure(string storedProcName, IDataParameter[] parameters, out int rowsAffected )
502 {
503 using (SqlConnection connection = new SqlConnection(connectionString))
504 {
505 int result;
506 connection.Open();
507 SqlCommand command = BuildIntCommand(connection,storedProcName, parameters );
508 rowsAffected = command.ExecuteNonQuery();
509 result = (int)command.Parameters["ReturnValue"].Value;
510 //Connection.Close();
511 return result;
512 }
513 }
514
515 /**//// <summary>
516 /// 创建 SqlCommand 对象实例(用来返回一个整数值)
517 /// </summary>
518 /// <param name="storedProcName">存储过程名</param>
519 /// <param name="parameters">存储过程参数</param>
520 /// <returns>SqlCommand 对象实例</returns>
521 private static SqlCommand BuildIntCommand(SqlConnection connection,string storedProcName, IDataParameter[] parameters)
522 {
523 SqlCommand command = BuildQueryCommand(connection,storedProcName, parameters );
524 command.Parameters.Add( new SqlParameter ( "ReturnValue",
525 SqlDbType.Int,4,ParameterDirection.ReturnValue,
526 false,0,0,string.Empty,DataRowVersion.Default,null ));
527 return command;
528 }
529 #endregion
530
531 }
532 }
533
534
1 using System;
2 using System.Data;
3 using System.Configuration;
4 using System.Web;
5 using System.Web.Security;
6 using System.Web.UI;
7 using System.Web.UI.WebControls;
8 using System.Web.UI.WebControls.WebParts;
9 using System.Web.UI.HtmlControls;
10 using System.Data.SqlClient;
11 using System.Text;
12 namespace ChinaSite.classes
13 {
14 public class DbAccess
15 {
16 SqlConnection conn = null;
17 SqlCommand cmd = null;
18 public DbAccess()
19 {
20 //
21 // TODO: 在此处添加构造函数逻辑
22 //
23 conn = new SqlConnection();
24 //conn.ConnectionString = "initial catalog=pubs;data source=.;user id=sa;password=";
25 //conn.ConnectionString = Convert.ToString(System.Configuration.ConfigurationSettings.AppSettings["datasource"]);
26 conn.ConnectionString = Convert.ToString(System.Configuration.ConfigurationManager.AppSettings["datasource"]);
27 cmd = new SqlCommand();
28 cmd.Connection = conn;
29 }
30 /// <summary>
31 /// 获取数据根据sql语句
32 /// </summary>
33 /// <param name="sql"></param>
34 /// <returns></returns>
35 public DataTable GetTable(string sql)
36 {
37 DataSet ds = new DataSet();
38
39 try
40 {
41 cmd.CommandText = sql;
42 SqlDataAdapter da = new SqlDataAdapter();
43 da.SelectCommand = cmd;
44
45 da.Fill(ds);
46 }
47 catch (Exception ex)
48 {
49
50 this.ShowError(ex.Message);
51 return null;
52
53 }
54 return ds.Tables[0] ?? new DataTable();
55 }
56
57 /// <summary>
58 /// 获取数据根据sql语句 带参数 的
59 /// </summary>
60 /// <param name="sql"></param>
61 /// <param name="pas"></param>
62 /// <returns></returns>
63 public DataTable GetTable(string sql, params SqlParameter[] pas)
64 {
65 DataSet ds = new DataSet();
66 try
67 {
68 cmd.CommandText = sql;
69 SqlDataAdapter da = new SqlDataAdapter();
70 da.SelectCommand = cmd;
71 cmd.Parameters.Clear();
72
73 foreach (SqlParameter temppa in pas)
74 {
75 cmd.Parameters.Add(temppa);
76 }
77
78
79 da.Fill(ds);
80 }
81 catch (Exception ex)
82 {
83
84 this.ShowError(ex.Message);
85 return null;
86 }
87 return ds.Tables[0] ?? new DataTable();
88 }
89 /// <summary>
90 /// 根据sql语句返回跟新状态
91 /// </summary>
92 /// <param name="sql"></param>
93 /// <returns></returns>
94 public bool GetState(string sql)
95 {
96 bool succ = false;
97 try
98 {
99 cmd.CommandText = sql;
100 conn.Open();
101 succ = cmd.ExecuteNonQuery() > 0 ? (true) : (false);
102 conn.Close();
103 }
104 catch (Exception ex)
105 {
106
107 this.ShowError(ex.Message);
108 return false;
109 }
110 return succ;
111
112 }
113 /// <summary>
114 /// 根据sql语句返回跟新状态带参数的
115 /// </summary>
116 /// <param name="sql">sql语句</param>
117 /// <param name="pas">参数的集合</param>
118 /// <returns></returns>
119 public bool GetState(string sql, params SqlParameter[] pas)
120 {
121 bool succ = false;
122 try
123 {
124 cmd.CommandText = sql;
125 cmd.Parameters.Clear();
126
127 foreach (SqlParameter temppa in pas)
128 {
129 cmd.Parameters.Add(temppa);
130 }
131 conn.Open();
132 succ = cmd.ExecuteNonQuery() > 0 ? (true) : (false);
133 conn.Close();
134 }
135 catch (Exception ex)
136 {
137
138 this.ShowError(ex.Message);
139 return false;
140 }
141 return succ;
142
143 }
144 /// <summary>
145 /// 根据sql语句返回第一个单元格的数据
146 /// </summary>
147 /// <param name="sql"></param>
148 /// <returns></returns>
149 public string GetOne(string sql)
150 {
151 string res = "";
152 try
153 {
154 cmd.CommandText = sql;
155 conn.Open();
156 res = cmd.ExecuteScalar() == null ? ("") : (Convert.ToString(cmd.ExecuteScalar()));
157 conn.Close();
158 }
159 catch (Exception ex)
160 {
161
162 this.ShowError(ex.Message);
163 return null;
164 }
165 return res;
166 }
167 /// <summary>
168 /// 根据sql语句返回第一个单元格的数据带参数的
169 /// </summary>
170 /// <param name="sql"></param>
171 /// <param name="pas"></param>
172 /// <returns></returns>
173 public string GetOne(string sql, params SqlParameter[] pas)
174 {
175 string res = "";
176 try
177 {
178 cmd.CommandText = sql;
179 cmd.Parameters.Clear();
180
181 foreach (SqlParameter temppa in pas)
182 {
183 cmd.Parameters.Add(temppa);
184 }
185 conn.Open();
186 res = cmd.ExecuteScalar() == null ? ("") : (Convert.ToString(cmd.ExecuteScalar()));
187 conn.Close();
188 }
189 catch (Exception ex)
190 {
191
192 this.ShowError(ex.Message);
193 return null;
194 }
195 return res;
196 }
197 /// <summary>
198 /// 返回数据的DataReader
199 /// </summary>
200 /// <param name="sql"></param>
201 /// <returns></returns>
202 public SqlDataReader GetDataReader(string sql)
203 {
204 SqlDataReader dr = null;
205 try
206 {
207 conn.Open();
208 cmd.CommandText = sql;
209 dr = cmd.ExecuteReader();
210 }
211 catch (Exception ex)
212 {
213
214 this.ShowError(ex.Message);
215 return null;
216 }
217 return dr;
218 }
219 /// <summary>
220 /// 返回数据的DataReader带参数的
221 /// </summary>
222 /// <param name="sql"></param>
223 /// <param name="pas"></param>
224 /// <returns></returns>
225 public SqlDataReader GetDataReader(string sql, params SqlParameter[] pas)
226 {
227 SqlDataReader dr = null;
228 try
229 {
230 conn.Open();
231 cmd.Parameters.Clear();
232
233 foreach (SqlParameter temppa in pas)
234 {
235 cmd.Parameters.Add(temppa);
236 }
237
238 cmd.CommandText = sql;
239 dr = cmd.ExecuteReader();
240 }
241 catch (Exception ex)
242 {
243
244 this.ShowError(ex.Message);
245 return null;
246 }
247 return dr;
248 }
249 /// <summary>
250 /// 打开连接
251 /// </summary>
252 public void OpenConn()
253 {
254 if (conn.State != ConnectionState.Open)
255 {
256 try
257 {
258 conn.Open();
259 }
260 catch (Exception ex)
261 {
262
263 this.ShowError(ex.Message);
264 return;
265 }
266 }
267 }
268 /// <summary>
269 /// 关闭连接
270 /// </summary>
271 public void CloseConn()
272 {
273 if (conn.State != ConnectionState.Closed)
274 {
275 try
276 {
277 conn.Close();
278 cmd = null;
279 conn = null;
280 }
281 catch (Exception ex)
282 {
283
284 this.ShowError(ex.Message);
285 return;
286 }
287 }
288 }
289 /// <summary>
290 /// 弹出错误的信息
291 /// </summary>
292 /// <param name="err"></param>
293 public void ShowError(string err)
294 {
295 System.Web.HttpContext.Current.Response.Write(Script(err, ""));
296 }
297 /// <summary>
298 /// 显示信息
299 /// </summary>
300 /// <param name="err"></param>
301 public void ShowMessage(string mes, string loc)
302 {
303 System.Web.HttpContext.Current.Response.Write(Script(mes, loc));
304 }
305 /// <summary>
306 /// javascript脚本
307 /// </summary>
308 /// <param name="mess"></param>
309 /// <param name="loc"></param>
310 /// <returns></returns>
311 public string Script(string mess, string loc)
312 {
313 StringBuilder sb = new StringBuilder();
314 sb.Append("<script language='javascript'>");
315 sb.Append("alter('");
316 sb.Append(mess);
317 sb.Append("');");
318 sb.Append(loc);
319 sb.Append("</script>");
320 return sb.ToString();
321
322 }
323
324 }
325 }
