登陆
01.//首先判断用户名和密码都不能为空
02.if (userNameTxt.Text.Trim() == "" || passwordTxt.Text.Trim() == "")
03.{
04. errlabel.Text = "用户名和密码不能为空!";
05. return;
06.}
07.
08.SqlHelper sh = new SqlHelper();//用Sql帮助类来实现查询，封装了常用的SQL操作
09.string sql = string.Empty;
10.//判断用户类型
11.if (userType == 1)
12.{
13. sql = "select * from jcsjk_users where username='" + userNameTxt.Text + "'" +
14. " and password='" + passwordTxt.Text + "' and type='1'";
15.}
16.else if (userType == 2)
17.{
18. sql = "select * from jcsjk_users where username='" + userNameTxt.Text + "'" +
19. " and password='" + passwordTxt.Text + "' and type='2'";
20.}
21.
22.if (sh.GetRecordCount(sql) > 0)
23.{
24. LogHelp.writeLog(userNameTxt.Text, "用户登录", "用户成功登陆");
25. if (userType == 2)
26. {
27. FrmMain.metaIsLgoin = true;
28. FrmMain.metaUsername = userNameTxt.Text;
29. }
30. errlabel.Text = "系统正在初始化，请稍等...";
31. this.Update();
32. errlabel.Update();
33. while (!FrmMain.isInitFinish)
34. {
35. ;
36. }
37. this.Close();
38.}
39.else
40.{
41. LogHelp.writeLog(userNameTxt.Text, "用户登录", "用户登陆失败");
42. errlabel.Text = "用户名或密码错误";
43.}
//首先判断用户名和密码都不能为空
if (userNameTxt.Text.Trim() == "" || passwordTxt.Text.Trim() == "")
{
errlabel.Text = "用户名和密码不能为空!";
return;
}
SqlHelper sh = new SqlHelper();//用Sql帮助类来实现查询，封装了常用的SQL操作
string sql = string.Empty;
//判断用户类型
if (userType == 1)
{
sql = "select * from jcsjk_users where username='" + userNameTxt.Text + "'" +
" and password='" + passwordTxt.Text + "' and type='1'";
}
else if (userType == 2)
{
sql = "select * from jcsjk_users where username='" + userNameTxt.Text + "'" +
" and password='" + passwordTxt.Text + "' and type='2'";
}
if (sh.GetRecordCount(sql) > 0)
{
LogHelp.writeLog(userNameTxt.Text, "用户登录", "用户成功登陆");
if (userType == 2)
{
FrmMain.metaIsLgoin = true;
FrmMain.metaUsername = userNameTxt.Text;
}
errlabel.Text = "系统正在初始化，请稍等...";
this.Update();
errlabel.Update();
while (!FrmMain.isInitFinish)
{
;
}
this.Close();
}
else
{
LogHelp.writeLog(userNameTxt.Text, "用户登录", "用户登陆失败");
errlabel.Text = "用户名或密码错误";
}
上面这段代码根据用户输入的用户名和密码来判断是否正确的，以及是属于哪种权限的用户。上面的代码用到了SQL的一个帮助类，主要封装了一些常用的SQL操作，这个类定义如下（以后还会经常用到这个类，基本上所有的SQL操作都由这个类完成，除了一些特殊操作，例如事务、必须考参数插入很长字符串等）：
view plaincopy to clipboardprint?
01.public class SqlHelper
02.{
03. protected OracleConnection Connection;
04. private string connectionString;
05.
06. public SqlHelper()
07. {
08. //connectionString = "Data Source=JCSJK;User Id=dzyj_jcsjk;Password=dzyj_jcsjk";
09. //connectionString = "Data Source=BRUCEWOO;User Id=sde;Password=wan861620";
10. connectionString = ConfigurationSettings.AppSettings["ConnectionString"];
11. Connection = new OracleConnection(connectionString);
12. }
13.
14. ///
15. /// 带参数的构造函数
16. ///
17. /// 数据库联接字符串
18. public SqlHelper(string ConnString)
19. {
20. string connStr;
21. connStr = System.Configuration.ConfigurationSettings.AppSettings[ConnString].ToString();
22. Connection = new OracleConnection(connStr);
23. }
24.
25. ///
26. /// 打开数据库
27. ///
28. public void OpenConn()
29. {
30. if (this.Connection.State != ConnectionState.Open)
31. {
32. this.Connection.Open();
33. }
34. }
35.
36. ///
37. /// 关闭数据库联接
38. ///
39. public void CloseConn()
40. {
41. if (Connection.State == ConnectionState.Open)
42. {
43. Connection.Close();
44. }
45. }
46.
47. #region 执行SQL语句，返回数据到DataSet中
48. ///
49. /// 执行SQL语句，返回数据到DataSet中
50. ///
51. /// sql语句
52. ///
53. public DataSet ReturnDataSet(string sql, string tableName)
54. {
55. DataSet dataSet = new DataSet();
56. OpenConn();
57. OracleDataAdapter OraDA = new OracleDataAdapter(sql, Connection);
58. OraDA.Fill(dataSet, tableName);
59. return dataSet;
60. }
61. #endregion
62.
63. #region 执行Sql语句,返回带分页功能的dataset
64. ///
65. /// 执行Sql语句,返回带分页功能的dataset
66. ///
67. /// Sql语句
68. /// 每页显示记录数
69. /// <当前页/param>
70. /// 返回dataset表名
71. ///
72. public DataSet ReturnDataSet(string sql,int PageSize,int CurrPageIndex,string DataSetName)
73. {
74. DataSet dataSet = new DataSet();
75. OpenConn();
76. OracleDataAdapter OraDA = new OracleDataAdapter(sql, Connection);
77. OraDA.Fill(dataSet, PageSize * (CurrPageIndex - 1), PageSize,DataSetName);
78. return dataSet;
79. }
80. #endregion
81.
82. #region 执行SQL语句，返回 DataReader,用之前一定要先.read()打开,然后才能读到数据
83. ///
84. /// 执行SQL语句，返回 DataReader,用之前一定要先.read()打开,然后才能读到数据
85. ///
86. /// sql语句
87. ///
88. public OracleDataReader ReturnDataReader(String sql)
89. {
90. OpenConn();
91. OracleCommand command = new OracleCommand(sql,Connection);
92. return command.ExecuteReader(https://www.wendangku.net/doc/cf4048138.html,mandBehavior.CloseConnection);
93. }
94. #endregion
95.
96. #region 执行SQL语句，返回记录总数数
97. ///
98. /// 执行SQL语句，返回记录总数数
99. ///
100. /// sql语句
101. ///
102. public int GetRecordCount(string sql)
103. {
104. int recordCount = 0;
105. OpenConn();
106. OracleCommand command = new OracleCommand(sql,Connection);
107. OracleDataReader dataReader = command.ExecuteReader();
108. while(dataReader.Read())
109. {
110. recordCount++;
111. }
112. dataReader.Close();
113.
114. return recordCount;
115. }
116. #endregion
117.
118. #region 取当前序列,条件为seq.nextval或seq.currval
119. ///
120. /// 取当前序列
121. ///
122. ///
123. ///
124. public decimal GetSeq(string seqstr)
125. {
126. decimal seqnum = 0;
127. string sql = "select " + seqstr + " from dual";
128. OpenConn();
129. OracleCommand command = new OracleCommand(sql,Connection);
130. OracleDataReader dataReader = command.ExecuteReader();
131. if(dataReader.Read())
132. {
133. seqnum = decimal.Parse(dataReader[0].ToString());
134. }
135. dataReader.Close();
136. // CloseConn();
137. return seqnum;
138. }
139. #endregion
140.
141. #region 执行SQL语句,返回所影响的行数
142. ///
143. /// 执行SQL语句,返回所影响的行数
144. ///
145. ///
146. ///
147. public int ExecuteSQL(string sql)
148. {
149. int Cmd = 0;
150. OpenConn();
151. OracleCommand command = new OracleCommand(sql, Connection);
152. try
153. {
154. Cmd = command.ExecuteNonQuery();
155. }
156. catch (OracleException e)
157. {
158. CloseConn();
159. throw e;
160. }
161.
162. return Cmd;
163. }
164. #endregion
165.
166. // ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
167. // ＝＝用hashTable对数据库进行insert,update,del操作,注意此时只能用默认的数据库连接"connstr"＝＝
168. // ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
169.
170. #region 根据表名及哈稀表自动插入数据库 用法：Insert("test",ht)
171.
172. ///
173. /// 用hashTable对数据库进行insert操作,注意此时只能用默认的数据库连接"connstr"＝＝
174. ///
175. /// 表名
176. /// 键值对的HashTable(字段名，值)
177. ///
178. public int Insert(string TableName, Hashtable ht)
179. {
180. OracleParameter[] Parms = new OracleParameter[ht.Count];
181. IDictionaryEnumerator et = ht.GetEnumerator();
182. DataTable dt = GetTabType(TableName);
183. System.Data.OracleClient.OracleType otype;
184. int size = 0;
185. int i = 0;
186. // 作哈希表循环
187. while (et.MoveNext())
188. {
189. GetoType(et.Key.ToString().ToUpper(), dt, out otype, out size);
190. OracleParameter op = MakeParam(":"+et.Key.ToString(),otype,size,et.Value.ToString());
191. // 添加SqlParameter对象
192. Parms[i] = op;
193. i = i+1;
194. }
195. string str_Sql = GetInsertSqlbyHt(TableName, ht); // 获得插入sql语句
196. int val = ExecuteNonQuery(str_Sql, Parms);
197. return val;
198. }
199. #endregion
200.
201. #region 根据相关条件对数据库进行更新操作 用法：Update("test","Id=:Id",ht);
202.
203. public int Update(string TableName, string ht_Where, Hashtable ht)
204. {
205. OracleParameter[] Parms = new OracleParameter[ht.Count];
206. IDictionaryEnumerator et = ht.GetEnumerator();
207.
DataTable dt = GetTabType(TableName);
208. OracleType otype;
209. int size = 0;
210. int i = 0;
211. // 作哈希表循环
212. while ( et.MoveNext() )
213. {
214. GetoType(et.Key.ToString().ToUpper(),dt,out otype,out size);
215. System.Data.OracleClient.OracleParameter op=MakeParam(":"+et.Key.ToString(),otype,size,et.Value.ToString());
216. Parms[i] = op; // 添加SqlParameter对象
217. i = i + 1;
218. }
219. string str_Sql = GetUpdateSqlbyHt(TableName, ht_Where, ht); // 获得插入sql语句
220. int val = ExecuteNonQuery(str_Sql, Parms);
221. return val;
222. }
223. #endregion
224.
225. #region del操作,注意此处条件个数与hash里参数个数应该一致 用法：Del("test","Id=:Id",ht)
226.
227. ///
228. /// 删除一条记录
229. ///
230. /// 表名
231. ///
232. ///
233. ///
234. public int Del(string TableName, string ht_Where, Hashtable ht)
235. {
236. OracleParameter[] Parms = new OracleParameter[ht.Count];
237. IDictionaryEnumerator et = ht.GetEnumerator();
238. DataTable dt = GetTabType(TableName);
239. OracleType otype;
240. int i = 0;
241. int size = 0;
242. // 作哈希表循环
243. while (et.MoveNext())
244. {
245. GetoType(et.Key.ToString().ToUpper(), dt, out otype, out size);
246. OracleParameter op = MakeParam(":"+et.Key.ToString(),et.Value.ToString());
247. // 添加SqlParameter对象
248. Parms[i] = op;
249. i = i + 1;
250. }
251. // 获得删除sql语句
252. string str_Sql = GetDelSqlbyHt(TableName, ht_Where, ht);
253. int val = ExecuteNonQuery(str_Sql,null);
254. return val;
255. }
256. #endregion
257.
258. // ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
259. // ＝＝＝＝＝＝＝＝上面三个操作的内部调用函数＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
260. // ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
261.
262. #region 根据哈稀表及表名自动生成相应insert语句(参数类型的)
263. ///
264. /// 根据哈稀表及表名自动生成相应insert语句
265. ///
266. /// 要插入的表名
267. /// 哈稀表
268. ///
269. public static string GetInsertSqlbyHt(string TableName, Hashtable ht)
270. {
271. string str_Sql = "";
272. int i = 0;
273. int ht_Count = ht.Count; // 哈希表个数
274. IDictionaryEnumerator myEnumerator = ht.GetEnumerator();
275. string before = "";
276. string behide = "";
277. while ( myEnumerator.MoveNext() )
278. {
279. if (i==0)
280. {
281. before = "(" + myEnumerator.Key;
282. }
283. else if ( i+1 == ht_Count)
284. {
285. before = before+","+myEnumerator.Key+")";
286. }
287. else
288. {
289. before=before+","+myEnumerator.Key;
290. }
291. i = i+1;
292. }
293. behide = " Values"+before.Replace(",",",:").Replace("(","(:");
294. str_Sql = "Insert into " + TableName + before + behide;
295. return str_Sql;
296. }
297. #endregion
298.
299. #region 根据表名，where条件，哈稀表自动生成更新语句(参数类型的)
300.
301. public static string GetUpdateSqlbyHt(string Table,string ht_Where,Hashtable ht)
302. {
303. string str_Sql = "";
304. int i = 0;
305. int ht_Count = ht.Count; // 哈希表个数
306. IDictionaryEnumerator myEnumerator = ht.GetEnumerator();
307. while ( myEnumerator.MoveNext() )
308. {
309. if (i==0)
310. {
311. if (ht_Where.ToString().ToLower().IndexOf((myEnumerator.Key+"=:"+myEnumerator.Key).ToLower())==-1)
312. {
313. str_Sql=myEnumerator.Key+"=:"+myEnumerator.Key;
314. }
315. }
316. else
317. {
318. if (ht_Where.ToString().ToLower().IndexOf((":"+myEnumerator.Key+" ").ToLower())==-1)
319. {
320. str_Sql=str_Sql+","+myEnumerator.Key+"=:"+myEnumerator.Key;
321. }
322. }
323. i=i+1;
324. }
325. if (ht_Where==null || ht_Where.Replace(" ","") == "") // 更新时候没有条件
326. {
327. str_Sql = "update "+Table+" set "+str_Sql;
328. }
329. else
330. {
331. str_Sql = "update "+ Table +" set " + str_Sql + " where " + ht_Where;
332. }
333. str_Sql = str_Sql.Replace("set ,","set ").Replace("update ,","update ");
334. return str_Sql;
335. }
336. #endregion
337.
338. #region 根据表名，where条件，哈稀表自动生成del语句(参数类型的)
339.
340. public static string GetDelSqlbyHt(string Table, string ht_Where, Hashtable ht)
341. {
342. string str_Sql
= "";
343. int i = 0;
344.
345. int ht_Count = ht.Count; // 哈希表个数
346. IDictionaryEnumerator myEnumerator = ht.GetEnumerator();
347. while ( myEnumerator.MoveNext() )
348. {
349. if (i==0)
350. {
351. if (ht_Where.ToString().ToLower().IndexOf((myEnumerator.Key+"=:"+myEnumerator.Key).ToLower())==-1)
352. {
353. str_Sql = myEnumerator.Key+"=:"+myEnumerator.Key;
354. }
355. }
356. else
357. {
358. if (ht_Where.ToString().ToLower().IndexOf((":"+myEnumerator.Key+" ").ToLower())==-1)
359. {
360. str_Sql = str_Sql+","+myEnumerator.Key+"=:"+myEnumerator.Key;
361. }
362. }
363. i = i + 1;
364. }
365. if (ht_Where == null || ht_Where.Replace(" ","") == "") // 更新时候没有条件
366. {
367. str_Sql = "Delete "+Table;
368. }
369. else
370. {
371. str_Sql = "Delete "+Table+" where "+ht_Where;
372. }
373. return str_Sql;
374. }
375. #endregion
376.
377. #region 生成oracle参数
378. ///
379. /// 生成oracle参数
380. ///
381. /// 字段名
382. /// 数据类型
383. /// 数据大小
384. /// 值
385. ///
386. public static OracleParameter MakeParam(string ParamName,System.Data.OracleClient.OracleType otype,int size,Object Value)
387. {
388. OracleParameter para = new OracleParameter(ParamName,Value);
389. para.OracleType = otype;
390. para.Size = size;
391. return para;
392. }
393. #endregion
394.
395. #region 生成oracle参数
396.
397. public static OracleParameter MakeParam(string ParamName, string Value)
398. {
399. return new OracleParameter(ParamName, Value);
400. }
401. #endregion
402.
403. #region 根据表结构字段的类型和长度拼装oracle sql语句参数
404.
405. public static void GetoType(string key, DataTable dt, out OracleType otype, out int size)
406. {
407. DataView dv = dt.DefaultView;
408. dv.RowFilter = "column_name='" + key + "'";
409.
410. string fType = dv[0]["data_type"].ToString().ToUpper();
411. switch (fType)
412. {
413. case "DATE":
414. otype = OracleType.DateTime;
415. size = int.Parse(dv[0]["data_length"].ToString());
416. break;
417. case "CHAR":
418.
otype= OracleType.Char;
419. size=int.Parse(dv[0]["data_length"].ToString());
420. break;
421. case "LONG":
422. otype= OracleType.Double;
423.
424. size=int.Parse(dv[0]["data_length"].ToString());
425. break;
426. case "NVARCHAR2":
427. otype= OracleType.NVarChar;
428. size=int.Parse(dv[0]["data_length"].ToString());
429. break;
430. case "VARCHAR2":
431. otype= OracleType.NVarChar;
432. size=int.Parse(dv[0]["data_length"].ToString());
433. break;
434. default:
435. otype= OracleType.NVarChar;
436. size=100;
437. break;
438. }
439. }
440.
441. #endregion
442.
443. #region 动态取表里字段的类型和长度,此处没有动态用到connstr,是默认的！by/文少
444.
445. public System.Data.DataTable GetTabType(string tabname)
446. {
447. string sql = "select column_name,data_type,data_length from all_tab_columns where table_name='"
448. + tabname.ToUpper() + "'";
449. OpenConn();
450. return (ReturnDataSet(sql, "dv")).Tables[0];
451. }
452. #endregion
453.
454. #region 执行sql语句
455.
456. public int ExecuteNonQuery(string cmdText, params OracleParameter[] cmdParms)
457. {
458. OracleCommand cmd = new OracleCommand();
459. OpenConn();
460. cmd.Connection = Connection;
461. https://www.wendangku.net/doc/cf4048138.html,mandText = cmdText;
462. if (cmdParms != null)
463. {
464. foreach (OracleParameter parm in cmdParms)
465. {
466. cmd.Parameters.Add(parm);
467. }
468. }
469. int val = cmd.ExecuteNonQuery();
470. cmd.Parameters.Clear();
471.
472. return val;
473. }
474. #endregion
475.
476. ///
477. /// 根据表名得到所属用户
478. ///
479. /// 表名
480. ///
481. public string GetTableOwner(string strTableName)
482. {
483. string strTableOwner = string.Empty;
484. OpenConn();
485. string sql = "select owner from dba_tables where table_name='" + strTableName.ToUpper() + "'";
486. OracleCommand cmd = new OracleCommand(sql, Connection);
487. OracleDataReader odr = cmd.ExecuteReader();
488. if (odr.Read())
489. {
490. strTableOwner = odr[0].ToString();
491. }
492. odr.Close();
493. return strTableOwner;
494. }
495.}
第四步实现其他一些功能，如退出系统，代码如下：
view plaincopy to clipboardprint?
01.Ap
plication.Exit();
Application.Exit();
为了以后其他模块能够知道登录的用户信息，实现了一个返回用户名的函数，也是一句代码实现，如下：
view plaincopy to clipboardprint?
01.return userNameTxt.Text;
return userNameTxt.Text;
整个登录过程就全部实现，登录成功以后就开始初始化系统，初始化完成以后进入主界面。