C#

c#2.0泛型学习

2008-10-21T05:14:00.002-07:00

根据微软的视频教程"跟我一起学Visual Studio 2005C#语法篇"来学,因为里面有比较多的代码示例,学起来比较容易好理解

1.未使用泛型的Stack类

1using System;
2
3public class Stack
4{
5 readonly int m_Size;
6 int m_StackPointer = 0;
7 object[] m_Items;
8 public Stack(): this(100)
9 { }
10 public Stack(int size)
11 {
12 m_Size = size;
13 m_Items = new object[m_Size];
14 }
15 public void Push(object item)
16 {
17 if (m_StackPointer >= m_Size)
18 throw new StackOverflowException();
19
20 m_Items[m_StackPointer] = item;
21 m_StackPointer++;
22 }
23 public object Pop()
24 {
25 m_StackPointer--;
26 if (m_StackPointer >= 0)
27 {
28 return m_Items[m_StackPointer];
29 }
30 else
31 {
32 m_StackPointer = 0;
33 throw new InvalidOperationException("Cannot pop an empty stack");
34 }
35 }
36}
37
2.使用泛型的类

1using System;
2
3public class Stack
4{
5 readonly int m_Size;
6 int m_StackPointer = 0;
7 T[] m_Items;
8 public Stack()
9 : this(100)
10 {
11 }
12 public Stack(int size)
13 {
14 m_Size = size;
15 m_Items = new T[m_Size];
16 }
17 public void Push(T item)
18 {
19 if (m_StackPointer >= m_Size)
20 throw new StackOverflowException();
21
22 m_Items[m_StackPointer] = item;
23 m_StackPointer++;
24 }
25 public T Pop()
26 {
27 m_StackPointer--;
28 if (m_StackPointer >= 0)
29 {
30 return m_Items[m_StackPointer];
31 }
32 else
33 {
34 m_StackPointer = 0;
35 //throw new InvalidOperationException("Cannot pop an empty stack");
36 return default(T);
37 }
38 }
39}
40
41public class Stack1 : Stack
42{
43
44}
45
下为PDF文档,我感觉挺好的,很简单,我听的懂就是好的
/Clingingboy/one.pdf

多个泛型
1class Node
2{
3 public K Key;
4 public T Item;
5 public Node NextNode;
6 public Node()
7 {
8 Key = default(K);
9 Item = default(T);
10 NextNode = null;
11 }
12 public Node(K key, T item, Node nextNode)
13 {
14 Key = key;
15 Item = item;
16 NextNode = nextNode;
17 }
18}
泛型别名

1using list = LinkedList;
泛型约束

1public class LinkedList where K : IComparable
2{
3 Node m_Head;
4 public LinkedList()
5 {
6 m_Head = new Node();
7 }
8 public void AddHead(K key, T item)
9 {
10 Node newNode = new Node(key, item, m_Head.NextNode);
11 m_Head.NextNode = newNode;
12 }
13
14 T Find(K key)
15 {
16 Node current = m_Head;
17 while (current.NextNode != null)
18 {
19 if (current.Key.CompareTo(key) == 0)
20 break;
21 else
22 current = current.NextNode;
23 }
24 return current.Item;
25 }
26
27}
28

1using System;
2using System.Collections.Generic;
3using System.Text;
4
5namespace VS2005Demo1
6{
7 public class MyBaseClassGeneric // sealed,static
8 {
9 }
10
11 interface IMyBaseInterface
12 {
13 void A();
14 }
15
16 internal class GenericClass where T : MyBaseClassGeneric,IMyBaseInterface
17 {
18
19 }
20
21 class GClass where K : MyBaseClassGeneric,IMyBaseInterface,new() where T : K
22 {
23
24 }
25
26 class GUClass where T : K where K : MyBaseClassGeneric,IMyBaseInterface, new()
27 {
28 GClass obj = new GClass();
29 }
30
31
32 不能将引用/值类型约束与基类约束一起使用，因为基类约束涉及到类#region 不能将引用/值类型约束与基类约束一起使用，因为基类约束涉及到类
33
34 //class A where T : struct,class
35 //{}
36
37 #endregion
38
39 不能使用结构和默认构造函数约束，因为默认构造函数约束也涉及到类#region 不能使用结构和默认构造函数约束，因为默认构造函数约束也涉及到类
40
41 //class A where T : struct,new()
42 //{}
43
44 #endregion
45
46 虽然您可以使用类和默认构造函数约束，但这样做没有任何价值#region 虽然您可以使用类和默认构造函数约束，但这样做没有任何价值
47
48 class A where T : new()
49 {
50 T obj = new T();
51 }
52
53 class TypeA
54 {
55 public TypeA() { }
56 }
57
58 class TestA
59 {
60 A obj = new A();
61 }
62
63 #endregion
64
65 可以将引用/值类型约束与接口约束组合起来，前提是引用/值类型约束出现在约束列表的开头#region 可以将引用/值类型约束与接口约束组合起来，前提是引用/值类型约束出现在约束列表的开头
66
67 class SClass where K : struct, IMyBaseInterface
68 { }
69
70 class CClass where K : class, IMyBaseInterface
71 { }
72
73 #endregion
74}
75

资料引用:http://www.knowsky.com/339311.html

C#编程--基础知识点

2008-10-21T05:14:00.001-07:00

.NetFramework简介
.netframework运行于操作系统之上，提供良好的跨语言特性。
.netframework包含两个内容：公共语言运行时（CLR）和类库集（FCL）
MSIL微软中间语言。当编译.net支持的语言编写的代码的时候，输出的代码为MSIL
CLR又包含：通用语言规范(CLS:保证语言互操作性的一组规则)和公共类型系统(CTS:包含了.net支持的各语言间兼容的数据类型和功能)

--------------------------------------------------------------------------------

C#中的变量和常量
C#中的基本数据类型：
值类型和引用类型
值类型：简单类型、结构类型和枚举类型。
简单类型：整数类型、浮点类型、小数类型（decimal）和布尔类型等
sbyte是有符号的，相当java的byte型，范围-128~127
C#中byte是无符号的，范围0~255

--------------------------------------------------------------------------------

变量命名方法：
帕斯卡命名法和骆驼命名法
帕斯卡命名法：如果有多个单词组成，每个单词首字母大写
骆驼命名法：如果有多个单词组成，第一个单词全部小写，后面的单词大写

--------------------------------------------------------------------------------

C#中的常量：const与readonly两种
const声明的常量：叫静态常量，必须声明时就初始化，且只能用常数值初始化
readonly声明的常量：叫动态常量，可以在声明时不初始化，只能在构造函数中初始化，但必须每个构造函数中都要初始化；而且可以使用变量值初始化

class Test
{
const float PI = 3.1416f; //常量命名：全部大写
readonly float G;
public Test()
{
G = 9.80F;
}
public Test(float g) //每个构造函数中都要初始化；而且可以使用变量值初始化
{
G = g;
}
}

--------------------------------------------------------------------------------

C#中的装箱和拆箱
装箱：值类型转换成有引用类型
拆箱：引用类型转换成值类型
值类型：存在栈中
引用类型：在堆中存放对象的地址（即引用），对象本身存放在栈中
拆装箱允许值类型和引用类型相互处理

--------------------------------------------------------------------------------

C#语法

Switch()括号中可以是int ,char和string ,switch语句中的case语句冒号后什么都不写，可以不写break,其他情况一定要写break，否则报错

数组：五种声明方式
int []array;
array = new int[2];

//第二种声明方式
int []array1 = new int[2];

//第三种声明方式
int []array2 = {1,2,3};

//第四种声明方式
int []array3 = new int[]{1,2,3};

//第五种声明方式
int []array4 = new int[3]{1,2,3};

//数组大小也可以是变量
int count = 3;
int []arr = new int[count];
--------------------------------------------------------------------------------

枚举：用有意义的字符去访问数据
public enum Contry:long //指定枚举类型，必须是整型,不写为int型
{
Pacific, //第一个未付值，默认为零
China=1860,
Japan,
US=1901,
Canada

}

--------------------------------------------------------------------------------

C#中的面向对象
析构函数：函数名与构造函数名一样，~函数名（），不接受参数，由垃圾回收器自动调用（GC.Collect()调用垃圾回收器）

virtual关键字：C#中，子类要重写父类的方法，必须把父类的方法标识为virtual(虚拟的)，同时重写方法用override修饰
new 关键字：new关键字：在子类中定义的一个和父类方法签名一样，但是个全新的方法。并非重写父类的方法。
base关键字：用base关键字调用父类的方法

访问修饰符：
public 公有的，
internal 在一个项目中的，
protected有父子关系的类，
private仅所属类的成员

注意：如果有一个类既继承类又实现接口，类名要写在接口名前面。

--------------------------------------------------------------------------------

属性，索引器，委托，事件

属性：访问修饰一般为public，首字母大写。属性内有get和set访问器，get内必须要有return，set内有value关键字，代表从外部接受的值。
索引器：索引器的作用：像处理数组一样去处理类的对象。
public class Student
{
private string []obj=new string[10];

//this关键字在这里代表每一个类的对象，[]中整数是指通过下标访问
public string this[int index] //此是可以通过索引号去访问每一个类的成员
{
get
{
return obj[index];
}
set
{
if(value!=null)
obj[index]=value;
}
}
static void Main(string []args)
{
Student stucollection=new Student();
stucollection[0]="柯南";
stucollection[1]="小五郎";
stucollection[5]="怪盗基德";
}
}

委托：相当于函数指针，可使程序在运行是再指定具体要运行的方法。
(1) 定义委托：Public delegate int Call()
(2) 实例化委托：objcall=new Call(方法名)
(3) 调用委托：objcall();

事件：事件实际上是一种特殊的委托，委托每次只能指向一个方法，而事件可以指向多个方法
（1）定义一个委托public delegate void delegateMe();
（2）定义一个事件 private event delegate eventMe;
（3）订阅事件 eventMe+=new delegateMe(方法名1（）);
eventMe+=new delegateMe(方法名2（）);
（4）引发事件 if(condition) then eventMe();

--------------------------------------------------------------------------------
多线程

创建线程实例：
Thread obj=new Thread(new ThreadStart(方法名称))
开始：Start();
休眠：Sleep();
终止：Abort();
挂起：Suspend();
恢复：Resume();
当前线程：Thread.CurrentThread
ThreadPriority枚举值用来指定调度线程的优先级（共5级）

lock关键字
C#中通过lock关键字提供同步
线程同步：确保不同的线程对共享资源进行访问时，每次只有一个线程访问资源。
Lock(this)
{
For(int i=0;i<10;i++)
{
//语句;
}
}

--------------------------------------------------------------------------------

数组集合对象

Array: Array和数组很相似,还可以相互转化和拷贝,很多方法都是是通用，可以用Array的静态方法对数组实现反转，排序，这是数组本身无法做到的

using system.Array;
Array ar=Array.CreateInstance(typeof(int),5); //创建一个Array的实例
ar.SetValue(12,0); //赋值

Array.Reverse(ar); // 反转
Array.Sort(ar); // 排序

ArrayList:最常用的集合之一.集合的好处是在不知道数据大小时，可以实现容量自动增长，而数组做不到.
Add()添加元素
Remove(位置)移除元素

ArrayList al=new ArrayList();
//如果要遍历集合元素，
//方法一：
//将集合中的数拷贝到数组中
object []temp=al.ToArray();
foreach(object t in temp)
{
Console.WriteLine(t);
}

//方法二，使用迭代器
IEnumerator ie=al.GetEnumerator();
while(ie.MoveNext())
{
Console.WriteLine(ie.Current);
}

HashTable:以键值对的形式保存值

Hashtable hash=new Hashtable(4);
hash.Add("中国",1860);
hash.Add("德国",1940);

Console.WriteLine(hash["中国"].ToString());通过key获得value

SortedList :是 Hashtable 和 Array 的混合
能存放键值对，类似Hashtable
能通过自身提供的方法通过索引直接遍历，类似于Array
objsortlist.GetKey(i) 方法获得键
objsortlist.GetByIndex(i)方法获得值

.NET 2.0下读取数据库中的全部表以及表内的字段名

2008-10-21T05:13:00.001-07:00

TDBOperator db = null;

try

{

db = TDBOperatorFactory.GetDBOperator(comFunction.getDBLink());

//打开数据库连接

db.Open();

System.Data.Common.DbConnection dc = db.getDbConnection();

string[] res = new string[4];

res[1] = "dbo";

//取得全部表名

DataTable dt = dc.GetSchema("Tables");

this.Text = dt.Rows.Count.ToString();

dt.WriteXml("table.xml");

foreach (System.Data.DataRow row in dt.Rows)

{

//取出数据库中系统表外的所有表名

if (row[3].ToString() == "TABLE")

{

listBox1.Items.Add(row[2].ToString());

listBox1.Items.Add("============================");

for (int i = 0; i < 4; i++) res[i] = null;

res[2] = row[2].ToString();

//取得相应表的所有字段

DataTable dtColumns = dc.GetSchema("Columns", res);

foreach (System.Data.DataRow rowColumns in dtColumns.Rows)

{

listBox1.Items.Add(rowColumns[3].ToString());

}

dtColumns.WriteXml(row[2].ToString() + "b.xml");

listBox1.Items.Add("============================");

}

}

}

catch (Exception ex)

{

comMsgBox.showError(ex.Message);

}

finally

{

db.Close();

}

C#通过ADO.NET建表点实现方法

2008-10-21T05:12:00.002-07:00

新建表：
create table [表名]
(
[自动编号字段] int IDENTITY (1,1) PRIMARY KEY ,
[字段1] nVarChar(50) default '默认值' null ,
[字段2] ntext null ,
[字段3] datetime,
[字段4] money null ,
[字段5] int default 0,
[字段6] Decimal (12,4) default 0,
[字段7] image null ,
)

删除表：
Drop table [表名]

插入数据：
INSERT INTO [表名] (字段1,字段2) VALUES (100,'abc.NET')

删除数据：
DELETE FROM [表名] WHERE [字段名]>100

更新数据：
UPDATE [表名] SET [字段1] = 200,[字段2] = 'abc.NET' WHERE [字段三] = 'HAIWA'

新增字段：
ALTER TABLE [表名] ADD [字段名] NVARCHAR (50) NULL

删除字段：
ALTER TABLE [表名] DROP COLUMN [字段名]

修改字段：
ALTER TABLE [表名] ALTER COLUMN [字段名] NVARCHAR (50) NULL

重命名表：(Access 重命名表，请参考文章：在Access数据库中重命名表)
sp_rename '表名', '新表名', 'OBJECT'

新建约束：
ALTER TABLE [表名] ADD CONSTRAINT 约束名 CHECK ([约束字段] <= '2000-1-1')

删除约束：
ALTER TABLE [表名] DROP CONSTRAINT 约束名

新建默认值
ALTER TABLE [表名] ADD CONSTRAINT 默认值名 DEFAULT 'abc.NET' FOR [字段名]

删除默认值
ALTER TABLE [表名] DROP CONSTRAINT 默认值名

汉字转换为拼音的函数收藏

2008-10-21T05:12:00.001-07:00

using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;

namespace SplitWord
{
/**//**//**//// 用C#实现汉字转化为拼音
/// 实现的原理就是先将汉字转化成为内码，然后通过内码和拼音的对照来查找。
public class chs2py
{
/**//**//**//**/
/**//**//**//**/
/**//**//**//**/
/**//**//**////

///将汉字转换成为拼音
///作者：
///完成于：
///

static Regex MyRegex = new Regex("^[一-龥]$"); //汉字的正则表达式.eg: if(MyRegex.IsMatch(chrstr.ToString()))
private static int[] pyvalue = new int[]{-20319,-20317,-20304,-20295,-20292,-20283,-20265,-20257,-20242,-20230,-20051,-20036,-20032,-20026,
-20002,-19990,-19986,-19982,-19976,-19805,-19784,-19775,-19774,-19763,-19756,-19751,-19746,-19741,-19739,-19728,
-19725,-19715,-19540,-19531,-19525,-19515,-19500,-19484,-19479,-19467,-19289,-19288,-19281,-19275,-19270,-19263,
-19261,-19249,-19243,-19242,-19238,-19235,-19227,-19224,-19218,-19212,-19038,-19023,-19018,-19006,-19003,-18996,
-18977,-18961,-18952,-18783,-18774,-18773,-18763,-18756,-18741,-18735,-18731,-18722,-18710,-18697,-18696,-18526,
-18518,-18501,-18490,-18478,-18463,-18448,-18447,-18446,-18239,-18237,-18231,-18220,-18211,-18201,-18184,-18183,
-18181,-18012,-17997,-17988,-17970,-17964,-17961,-17950,-17947,-17931,-17928,-17922,-17759,-17752,-17733,-17730,
-17721,-17703,-17701,-17697,-17692,-17683,-17676,-17496,-17487,-17482,-17468,-17454,-17433,-17427,-17417,-17202,
-17185,-16983,-16970,-16942,-16915,-16733,-16708,-16706,-16689,-16664,-16657,-16647,-16474,-16470,-16465,-16459,
-16452,-16448,-16433,-16429,-16427,-16423,-16419,-16412,-16407,-16403,-16401,-16393,-16220,-16216,-16212,-16205,
-16202,-16187,-16180,-16171,-16169,-16158,-16155,-15959,-15958,-15944,-15933,-15920,-15915,-15903,-15889,-15878,
-15707,-15701,-15681,-15667,-15661,-15659,-15652,-15640,-15631,-15625,-15454,-15448,-15436,-15435,-15419,-15416,
-15408,-15394,-15385,-15377,-15375,-15369,-15363,-15362,-15183,-15180,-15165,-15158,-15153,-15150,-15149,-15144,
-15143,-15141,-15140,-15139,-15128,-15121,-15119,-15117,-15110,-15109,-14941,-14937,-14933,-14930,-14929,-14928,
-14926,-14922,-14921,-14914,-14908,-14902,-14894,-14889,-14882,-14873,-14871,-14857,-14678,-14674,-14670,-14668,
-14663,-14654,-14645,-14630,-14594,-14429,-14407,-14399,-14384,-14379,-14368,-14355,-14353,-14345,-14170,-14159,
-14151,-14149,-14145,-14140,-14137,-14135,-14125,-14123,-14122,-14112,-14109,-14099,-14097,-14094,-14092,-14090,
-14087,-14083,-13917,-13914,-13910,-13907,-13906,-13905,-13896,-13894,-13878,-13870,-13859,-13847,-13831,-13658,
-13611,-13601,-13406,-13404,-13400,-13398,-13395,-13391,-13387,-13383,-13367,-13359,-13356,-13343,-13340,-13329,
-13326,-13318,-13147,-13138,-13120,-13107,-13096,-13095,-13091,-13076,-13068,-13063,-13060,-12888,-12875,-12871,
-12860,-12858,-12852,-12849,-12838,-12831,-12829,-12812,-12802,-12607,-12597,-12594,-12585,-12556,-12359,-12346,
-12320,-12300,-12120,-12099,-12089,-12074,-12067,-12058,-12039,-11867,-11861,-11847,-11831,-11798,-11781,-11604,
-11589,-11536,-11358,-11340,-11339,-11324,-11303,-11097,-11077,-11067,-11055,-11052,-11045,-11041,-11038,-11024,
-11020,-11019,-11018,-11014,-10838,-10832,-10815,-10800,-10790,-10780,-10764,-10587,-10544,-10533,-10519,-10331,
-10329,-10328,-10322,-10315,-10309,-10307,-10296,-10281,-10274,-10270,-10262,-10260,-10256,-10254};
private static string[] pystr = new string[]{"a","ai","an","ang","ao","ba","bai","ban","bang","bao","bei","ben","beng","bi","bian","biao",
"bie","bin","bing","bo","bu","ca","cai","can","cang","cao","ce","ceng","cha","chai","chan","chang","chao","che","chen",
"cheng","chi","chong","chou","chu","chuai","chuan","chuang","chui","chun","chuo","ci","cong","cou","cu","cuan","cui",
"cun","cuo","da","dai","dan","dang","dao","de","deng","di","dian","diao","die","ding","diu","dong","dou","du","duan",
"dui","dun","duo","e","en","er","fa","fan","fang","fei","fen","feng","fo","fou","fu","ga","gai","gan","gang","gao",
"ge","gei","gen","geng","gong","gou","gu","gua","guai","guan","guang","gui","gun","guo","ha","hai","han","hang",
"hao","he","hei","hen","heng","hong","hou","hu","hua","huai","huan","huang","hui","hun","huo","ji","jia","jian",
"jiang","jiao","jie","jin","jing","jiong","jiu","ju","juan","jue","jun","ka","kai","kan","kang","kao","ke","ken",
"keng","kong","kou","ku","kua","kuai","kuan","kuang","kui","kun","kuo","la","lai","lan","lang","lao","le","lei",
"leng","li","lia","lian","liang","liao","lie","lin","ling","liu","long","lou","lu","lv","luan","lue","lun","luo",
"ma","mai","man","mang","mao","me","mei","men","meng","mi","mian","miao","mie","min","ming","miu","mo","mou","mu",
"na","nai","nan","nang","nao","ne","nei","nen","neng","ni","nian","niang","niao","nie","nin","ning","niu","nong",
"nu","nv","nuan","nue","nuo","o","ou","pa","pai","pan","pang","pao","pei","pen","peng","pi","pian","piao","pie",
"pin","ping","po","pu","qi","qia","qian","qiang","qiao","qie","qin","qing","qiong","qiu","qu","quan","que","qun",
"ran","rang","rao","re","ren","reng","ri","rong","rou","ru","ruan","rui","run","ruo","sa","sai","san","sang",
"sao","se","sen","seng","sha","shai","shan","shang","shao","she","shen","sheng","shi","shou","shu","shua",
"shuai","shuan","shuang","shui","shun","shuo","si","song","sou","su","suan","sui","sun","suo","ta","tai",
"tan","tang","tao","te","teng","ti","tian","tiao","tie","ting","tong","tou","tu","tuan","tui","tun","tuo",
"wa","wai","wan","wang","wei","wen","weng","wo","wu","xi","xia","xian","xiang","xiao","xie","xin","xing",
"xiong","xiu","xu","xuan","xue","xun","ya","yan","yang","yao","ye","yi","yin","ying","yo","yong","you",
"yu","yuan","yue","yun","za","zai","zan","zang","zao","ze","zei","zen","zeng","zha","zhai","zhan","zhang",
"zhao","zhe","zhen","zheng","zhi","zhong","zhou","zhu","zhua","zhuai","zhuan","zhuang","zhui","zhun","zhuo",
"zi","zong","zou","zu","zuan","zui","zun","zuo"};
/**//**//**////

/// 转化汉字的全部拼音
///

///
///
public static string Convert(string chrstr)
{
Regex MyRegex = new Regex("^[一-龥]$");
byte[] array = new byte[2];
string returnstr = "";
int chrasc = 0;
int i1 = 0;
int i2 = 0;
char[] nowchar = chrstr.ToCharArray();
for (int j = 0; j < nowchar.Length; j++)
{
if (MyRegex.IsMatch(nowchar[j].ToString()))
{
array = System.Text.Encoding.Default.GetBytes(nowchar[j].ToString());
i1 = (short)(array[0]);
i2 = (short)(array[1]);
chrasc = i1 * 256 + i2 - 65536;
if (chrasc > 0 && chrasc < 160)
{
returnstr += nowchar[j];
}
else
{
for (int i = (pyvalue.Length - 1); i >= 0; i--)
{
if (pyvalue[i] <= chrasc)
{
returnstr += pystr[i];
break;
}
}
}
}
else
{
returnstr += nowchar[j].ToString();
}
}
return returnstr;
}
//ChineseToPY
/**//**//**////

/// 只转换汉字首字母
///

///
///
public static string GetChineseSpell(string strText)
{
int len = strText.Length;
string myStr = "";
for (int i = 0; i < len; i++)
{
myStr += getSpell(strText.Substring(i, 1));
}
return myStr;
}

public static string getSpell(string cnChar)
{
byte[] arrCN = Encoding.Default.GetBytes(cnChar);
if (arrCN.Length > 1)
{
int area = (short)arrCN[0];
int pos = (short)arrCN[1];
int code = (area << 8) + pos;
int[] areacode ={ 45217, 45253, 45761, 46318, 46826, 47010, 47297, 47614, 48119, 48119, 49062, 49324, 49896, 50371, 50614, 50622, 50906, 51387, 51446, 52218, 52698, 52698, 52698, 52980, 53689, 54481 };
for (int i = 0; i < 26; i++)
{
int max = 55290;
if (i != 25) max = areacode[i + 1];
if (areacode[i] <= code && code < max)
{
return Encoding.Default.GetString(new byte[]{ (byte)(65 + i) });
}
}
return "*";
}
else return cnChar;
}
}
}

关于.NET使用自定义XML做参数配置文件

2008-10-21T05:11:00.002-07:00

WEB开发,尤其是大型项目的开发,其中不乏大名鼎鼎的CMS,XXMS,呵呵.
他们都有个共同的特点,那就是网站配置参数N多.
怎么设置好众多的参数配置,是在项目初期需要规划的一个重点.
总结这几年做WEB开发的一点点积累.个人认为以下方案是比较合理化的,对于以后参数的增加修改带来的一些问题可以得到一定的控制.同样适合WINFORM哈.

运行环境: .NET 2.0
在项目设计过程中,采用模块化设计,所以参数也得独立开,每个模块的参数配置单独存放与一个单独的XML文件中.
原理:利用XML的序列化与反序列化配合实体读取和保存参数设置到XML文件中.
先看XML结构
SystemInfo.xml

网站标题
SiteTitle
设置网站的标题
Text
博客园
^.*$
False

网站地址
SiteUrl
设置网站的地址
Text
http://www.cnblogs.com
^.*$
False

配置文件子节点结构
/**/'''

''' 配置文件结构
'''

'''

_
Public Class ItemClass Item

Private _ColsDisplay As UInt16
Private _isRequired As Boolean
Private _name As String
Private _title As String
Private _explain As String
Private _mode As String
Private _value As String
Private _pattern As String
Private _range As String
Private _rangeHint As String

/**/'''

''' 节点名称
'''

Public Property Name()Property Name() As String
Get
Return Me._name
End Get
Set(ByVal value As String)
Me._name = value
End Set
End Property

/**/'''

''' 节点标题
'''

Public Property Title()Property Title() As String
Get
Return Me._title
End Get
Set(ByVal value As String)
Me._title = value
End Set
End Property

/**/'''

''' 节点说明
'''

Public Property Explain()Property Explain() As String
Get
Return Me._explain
End Get
Set(ByVal value As String)
Me._explain = value
End Set
End Property

/**/'''

''' 节点值类型
'''

Public Property Mode()Property Mode() As String
Get
Return Me._mode
End Get
Set(ByVal value As String)
Me._mode = value
End Set
End Property

/**/'''

''' 节点值
'''

Public Property Value()Property Value() As String
Get
Return Me._value
End Get
Set(ByVal value As String)
Me._value = value
End Set
End Property

/**/'''

''' 限制格式
'''

Public Property Pattern()Property Pattern() As String
Get
Return Me._pattern
End Get
Set(ByVal value As String)
Me._pattern = value
End Set
End Property

/**/'''

''' 选择范围
'''

Public Property Range()Property Range() As String
Get
Return Me._range
End Get
Set(ByVal value As String)
Me._range = value
End Set
End Property

/**/'''

''' 选择范围标题
'''

Public Property RangeHint()Property RangeHint() As String
Get
Return Me._rangeHint
End Get
Set(ByVal value As String)
Me._rangeHint = value
End Set
End Property

/**/'''

''' 是否必需
'''

Public Property IsRequired()Property IsRequired() As Boolean
Get
Return Me._isRequired
End Get
Set(ByVal value As Boolean)
Me._isRequired = value
End Set
End Property

/**/'''

''' 列显示
'''

Public Property ColsDisplay()Property ColsDisplay() As UInt16
Get
Return Me._ColsDisplay
End Get
Set(ByVal value As UInt16)
Me._ColsDisplay = value
End Set
End Property

End Class
自定义配置文件实体
/**/'''

''' 自定义配置文件实体
'''

'''

_
Public Class ConfigsClass Configs

Private _SiteTitle As Item
Private _SiteUrl As Item

/**/'''

''' 网站标题
'''

Public Property SiteTitle()Property SiteTitle() As Item
Get
Return Me._SiteTitle
End Get
Set(ByVal value As Item)
Me._SiteTitle = value
End Set
End Property

/**/'''

''' 网站地址
'''

Public Property SiteUrl()Property SiteUrl() As Item
Get
Return Me._SiteUrl
End Get
Set(ByVal value As Item)
Me._SiteUrl = value
End Set
End Property

End Class
以下需引用
Imports System.Xml
Imports System.Xml.Serialization

序列化XML文件的读取
/**/'''

''' 读取序列化XML配置文件内容
'''

''' 类型
''' 配置文件地址,绝对地址
'''
'''
Public Shared Function Deserialize()Function Deserialize(ByVal Types As Type, ByVal FilePath As String) As Object
Dim Fs As FileStream = Nothing
Dim Xmls As Object = String.Empty
Fs = New FileStream(FilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)
Dim Xms As XmlSerializer = New XmlSerializer(Types)
Xmls = Xms.Deserialize(Fs)
Fs.Flush()
Fs.Close()
Return Xmls
End Function
XML文件保存
/**/'''

''' 保存序列化XML配置文件内容
'''

''' 类型
''' 实体
''' 配置文件地址,绝对地址
'''
Public Shared Sub SaveConfig()Sub SaveConfig(ByVal Types As Type, ByVal Info As Configs, ByVal FilePath As String)
Dim Fs As Stream = New FileStream(FilePath, FileMode.Create, FileAccess.Write, FileShare.ReadWrite)
Dim Xms As XmlSerializer = New XmlSerializer(Types)
Xms.Serialize(Fs, Info)
Fs.Flush()
Fs.Close()
End Sub
调用参数

Dim Info As Configs = New Configs
Info = Deserialize(GetType (Configs), "SystemInfo.Xml")
Response.write(Info.SiteTitle.Title)
Response.write(Info.SiteTitle.Value)

以上为全部代码

下面做简单说明
以前自己做项目的时候.只是运用到简单的序列化与反序列化,同样也是在CNBLOG先辈们的手迹中得到的解释.
在运用一段时间后发现很繁琐. 因为我只用到了一层结构.

博客园

虽然这样很简单明了.可是在实际开发中,不免存在一些问题,比如:
1、输入值的类型判断
2、输入值是否允许空
3、输入值是否符合指定类型
4、在做UI的时候还需要找到对应的控件，再写相关的说明文字。
等等。。很繁琐。

而新的代码。解决了这些问题，在使用中，只需要调用相应节点的值就OK了。在对于内容解释及类型控制上尤其方便。再也不需要因为更改一个参数的控制，而去在N个HTML代码中定位你的配置参数控件，然后再XXXXX。直接使用XML文件编辑器修改XML文件就OK啦。

小弟第一次发表，欢迎大家批评指正！

一种简便实效的配置文件读写方法

2008-10-21T05:11:00.001-07:00

主要做法：

第一步，将配置信息做一个简单的类。

要点：因为要用到序列化，而且是用XmlSerializer来序列化，所以要存到文件的变量信息都要声明为Public,要序列化的类用修饰。

示例：一个连接数据库的配置信息

'配置信息

Public Class Item

'初始默认值

Public ID As Integer = 0

Public Server As String = "(Local)"

Public Database As String = "NorthWind"

Public Tusted As Boolean = True

Public User As String = ""

Public Password As String = ""

End Class

第二步：配置处理的类。

说明：这个类是通用的。用到别的配置，你只需修改上面的配置信息类就可以了。它实现了存档和读取的功能，并转化为配置信息对象，操作起来较为方便。你可以添加内容加密的处理。

Public Class Config

'默认ConnectionInfo的ID

Public ID As Integer

'必须是Public,XmlSerializer只对Pulbic变量作用

Public Items As Item()

Private m_Count As Integer = 0

'添加配置信息

Public Sub Add(ByVal ConnectionInfo As Item)

If ConnectionInfo Is Nothing Then Exit Sub

If m_Count > 0 Then

If Not Me.ConnectionInfo(ConnectionInfo.ID) Is Nothing Then

MsgBox(ID.ToString & "已存在")

Exit Sub

End If

End If

ReDim Preserve Me.Items(m_Count)

Me.Items(m_Count) = ConnectionInfo

m_Count += 1

End Sub

'取指定ID的配置信息

Public ReadOnly Property ConnectionInfo(ByVal ID As Integer) As Item

Get

Dim mItem As Item

Dim i As Integer

For i = 0 To m_Count - 1

If Me.Items(i).ID = ID Then

mItem = Me.Items(ID)

Exit For

End If

Next

Return mItem

End Get

End Property

'序列化并保存到指定文件

Public Sub SaveXmlFile(ByVal FileName As String)

If Me Is Nothing Then Exit Sub

Dim XmlWriter As New System.IO.StreamWriter(FileName, False)

XmlWriter.Write(SerializeClass.GetXML(Me))

XmlWriter.Close()

End Sub

'从指定文件读取反序列化转为对象

Public Function LoadXmlFile(ByVal FileName As String) As Config

Dim XmlReader As New System.IO.StreamReader(FileName, System.Text.Encoding.Default)

Dim mConfig As Config

mConfig = CType(SerializeClass.LoadXML(GetType(Config), XmlReader.ReadToEnd), Config)

XmlReader.Close()

mConfig.m_Count = mConfig.Items.Length

Return mConfig

End Function

End Class

就以上两步就可以了，下面这个类是用来序列化用的。

'这是用XmlSerializer序列化对象的类

Public Class SerializeClass

Public Shared Function GetXML(ByVal mObject As Object) As String

Dim oSerializer As New System.Xml.Serialization.XmlSerializer(mObject.GetType)

Dim oStringWriter As New System.IO.StringWriter

oSerializer.Serialize(oStringWriter, mObject)

Return oStringWriter.ToString

End Function

Public Shared Function LoadXML(ByVal mClass As Type, ByVal XML As String) As Object

Dim oSerializer As New System.Xml.Serialization.XmlSerializer(mClass)

Dim oStringReader As New System.IO.StringReader(XML)

Return oSerializer.Deserialize(oStringReader)

End Function

End Class

以下是使用方法示例：

'测试存配置文件

Private Sub TestSaveConfig()

Dim mConfig As Config = New Config

Dim mItem As Item

mItem = New Item

mConfig.Add(mItem)

mItem = New Item

With mItem

.ID = 1

.User = "Master"

.Password = "123456"

.Tusted = False

End With

mConfig.Add(mItem)

mConfig.SaveXmlFile(Application.StartupPath & "\Config.xml")

End Sub

'测试读配置文件

Private Sub TestLoadConfig()

Dim mConfig As Config = New Config

mConfig = mConfig.LoadXmlFile(Application.StartupPath & "\Config.xml")

'读取默认值的用户名

MsgBox(mConfig.Items(mConfig.ID).User)

'不妨修改一下配置

mConfig.ID = 1

mConfig.ConnectionInfo(0).Server = "Server"

mConfig.ConnectionInfo(1).Database = "Master"

'再存盘

mConfig.SaveXmlFile(Application.StartupPath & "\Config.xml")

End Sub

MS SQL数据类型及长度限制

2008-10-21T05:10:00.002-07:00

可以定义用户定义的数据类型，其是系统提供的数据类型的别名。有关用户定义的数据类型的更多信息，请参见 sp_addtype 和创建用户定义的数据类型。
　　当两个具有不同数据类型、排序规则、精度、小数位数或长度的表达式通过运算符进行组合时：
通过将数据类型的优先顺序规则应用到输入表达式的数据类型来确定所得值的数据类型。有关更多信息，请参见数据类型的优先顺序。

　　如果结果数据类型为 char、varchar、text、nchar、nvarchar 或 ntext，则结果值的排序规则由排序规则的优先顺序规则决定。有关更多信息，请参见排序规则的优先顺序。

　　结果的精度、小数位数及长度取决于输入表达式的精度、小数位数及长度。有关更多信息，请参见精度、小数位数和长度。
　　SQL Server 为 SQL-92 兼容性提供了数据类型同义词。有关更多信息，请参见数据类型同义词。

精确数字

整数

bigint 从 -2^63 (-9223372036854775808) 到 2^63-1 (9223372036854775807) 的整型数据（所有数字）。

int 从 -2^31 (-2,147,483,648) 到 2^31 - 1 (2,147,483,647) 的整型数据（所有数字）。

smallint 从 -2^15 (-32,768) 到 2^15 - 1 (32,767) 的整数数据。

tinyint 从 0 到 255 的整数数据。

bit

bit 1 或 0 的整数数据。

decimal 和 numeric

decimal 从 -10^38 +1 到 10^38 –1 的固定精度和小数位的数字数据。

numeric 功能上等同于 decimal。

money 和 smallmoney

money 货币数据值介于 -2^63 (-922,337,203,685,477.5808) 与 2^63 -1 (+922,337,203,685,477.5807) 之间，精确到货币单位的千分之十。

smallmoney 货币数据值介于 -214,748.3648 与 +214,748.3647 之间，精确到货币单位的千分之十。

近似数字

float 从 -1.79E + 308 到 1.79E + 308 的浮点精度数字。

real 从 -3.40E + 38 到 3.40E + 38 的浮点精度数字。

datetime 和 smalldatetime

datetime 从 1753 年 1 月 1 日到 9999 年 12 月 31 日的日期和时间数据，精确到百分之三秒（或 3.33 毫秒）。

smalldatetime 从 1900 年 1 月 1 日到 2079 年 6 月 6 日的日期和时间数据，精确到分钟。

字符串

char 固定长度的非 Unicode 字符数据，最大长度为 8,000 个字符。

varchar 可变长度的非 Unicode 数据，最长为 8,000 个字符。

text 可变长度的非 Unicode 数据，最大长度为 2^31 - 1 (2,147,483,647) 个字符。

Unicode 字符串

nchar 固定长度的 Unicode 数据，最大长度为 4,000 个字符。

nvarchar 可变长度 Unicode 数据，其最大长度为 4,000 字符。sysname 是系统提供用户定义的数据类型，在功能上等同于 nvarchar(128)，用于引用数据库对象名。

ntext 可变长度 Unicode 数据，其最大长度为 2^30 - 1 (1,073,741,823) 个字符。

二进制字符串

binary 固定长度的二进制数据，其最大长度为 8,000 个字节。
varbinary 可变长度的二进制数据，其最大长度为 8,000 个字节。
image 可变长度的二进制数据，其最大长度为 2^31 - 1 (2,147,483,647) 个字节。

其它数据类型

cursor 游标的引用。

sql_variant
一种存储 SQL Server 支持的各种数据类型（text、ntext、timestamp 和 sql_variant 除外）值的数据类型。

table
一种特殊的数据类型，存储供以后处理的结果集。

timestamp
数据库范围的唯一数字，每次更新行时也进行更新。

uniqueidentifier
全局唯一标识符 (GUID)。

C#实现USB接口的程序代码

2008-10-21T05:10:00.001-07:00

namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
USB usb;
usb = new UDisk();//插入U盘
usb.OutputFile();//从U盘读出文件
usb.InputFile();//往U盘写入文件
usb.Dispose();//拔出U盘
Console.WriteLine("");
usb = new MDisk();//插入移动硬盘
usb.OutputFile();//从移动硬盘读出文件
usb.InputFile();//往移动硬盘写入文件
usb.Dispose();//拔出移动硬盘
Console.WriteLine("");
usb = new MP4();//插入MP4
usb.OutputFile();//从MP4读出文件
usb.InputFile();//往MP4写入文件
usb.Dispose();//拔出MP4
Console.ReadKey();
}

//USB接口
public interface USB : IDisposable
{
void OutputFile();//读出文件
void InputFile();//写入文件
}

//U盘
public class UDisk : USB
{
public UDisk()
{
Console.WriteLine("U盘准备就绪...");
}
public void OutputFile()
{
Console.WriteLine("从U盘读出文件");
}
public void InputFile()
{
Console.WriteLine("往U盘写入文件");
}
public void Dispose()
{
Console.WriteLine("U盘已被拔出");
}
}

//移动硬盘
public class MDisk : USB
{
public MDisk()
{
Console.WriteLine("移动硬盘准备就绪...");
}
public void OutputFile()
{
Console.WriteLine("从移动硬盘读出文件");
}
public void InputFile()
{
Console.WriteLine("往移动硬盘写入文件");
}
public void Dispose()
{
Console.WriteLine("移动硬盘已被拔出");
}
}

//MP4
public class MP4 : USB
{
public MP4()
{
Console.WriteLine("MP4准备就绪...");
}
public void OutputFile()
{
Console.WriteLine("从MP4读出文件");
}
public void InputFile()
{
Console.WriteLine("往MP4写入文件");
}
public void Dispose()
{
Console.WriteLine("MP4已被拔出");
}
}
}
}

C#编程忘记密码功能的实现方法

2008-10-21T05:09:00.000-07:00

int result = user.GetBackPassword(LoginName.Text.Trim(), Question.Text.Trim(),
Answer.Text.Trim(), Email.Text);

if (result == 1)
{
Message.Text = "您的密码已发送，请到邮箱查收";
//user.ChangePassword(
}
else
{
Message.Text = "您的输入信息有误！";
}

public int GetBackPassword(string userName, string question, string answer, string email)
{
object m_DBNull = Convert.DBNull;
//获得新的随机密码
string newPassword = MakePassword(6);
//定义存储过程参数
SqlParameter[] para = {
new SqlParameter("@userName", userName),
new SqlParameter("@question", question),
new SqlParameter("@answer", answer),
new SqlParameter("@newPassword", newPassword),
new SqlParameter("@result", SqlDbType.Int, 8, ParameterDirection.Output,
true, 0, 0, "", DataRowVersion.Default, m_DBNull)
};

//执行存储过程
try
{
DAL.SQLHelper.ExecuteNonQuery(DAL.SQLHelper.CONN_STRING, CommandType.StoredProcedure,
"GetBackPwd", para);
}
catch
{
throw new Exception("邮件无法发送！");
}
//获得输出参数的值
int result = Convert.ToInt32(para[4].Value);
//如果密码保护资料填写正确
if (result == 1)
{
//从Web.config获取发信人地址、邮件标题、邮件用户名和密码以及SmtpServer
string sender = System.Configuration.ConfigurationSettings.AppSettings["mainSender"];
string title = System.Configuration.ConfigurationSettings.AppSettings["mailTitle"];
string mailUser = System.Configuration.ConfigurationSettings.AppSettings["mailUser"];
string mailPwd = System.Configuration.ConfigurationSettings.AppSettings["mailPwd"];
string smtpServer = System.Configuration.ConfigurationSettings.AppSettings["mailSmtpServer"];
//发信
try
{
Mail.CDOsendmail(sender, email, title, "您在eshop的密码已找回,新密码为"+newPassword
, mailUser, mailPwd, smtpServer);
}
catch(Exception ex)
{
throw new Exception(ex.Message);
}
}

return result;
}

//随机生成密码
private static string MakePassword(int pwdLength)
{
//声明要返回的字符串
string tmpstr = "";
//密码中包含的字符数组
string pwdchars="abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
//数组索引随机数
int iRandNum;
//随机数生成器
Random rnd = new Random();
for(int i=0;i {
//Random类的Next方法生成一个指定范围的随机数
iRandNum = rnd.Next(pwdchars.Length);
//tmpstr随机添加一个字符
tmpstr += pwdchars[iRandNum];
}
return tmpstr;
}

ALTER PROCEDURE GetBackPwd
@question nvarchar(50),
@answer nvarchar(50),
@userName nvarchar(50),
@newPassword nvarchar(50),
@result int output
AS
if exists (SELECT * FROM USERINFO WHERE USERNAME=@USERNAME AND QUESTION=@QUESTION
AND ANSWER=@ANSWER)
BEGIN
SET @RESULT = 1
UPDATE USERINFO
SET USERPWD = @newPassword
WHERE userName = @userName
END
ELSE
BEGIN
SET @RESULT = -1
END
GO
SET QUOTED_IDENTIFIER OFF
GO
SET ANSI_NULLS ON
GO

用Visual C#制作新闻阅读器

2008-10-21T05:08:00.000-07:00

一、弄清结构再动手

　　要想轻松的抽取RSS信息，自然先要了解它的结构，所谓“知己知彼，百战不殆”嘛。

　　1、RSS的结构

　　我们先打开百度新闻一个RSS链接，如果你再多打开几个别的网站的RSS链接，会发现他们都有大致相同的结构。而我们在揭秘RSS（上）中为大家讲解的其实就是编成实现这样的一个XML文件。

　　为了能够方便地对这样的XML文档进行处理，在本文里，我们使用C#作为开发的语言。

　　分析整个RSS链接后，我们知道RSS大致的结构入图1。

　　2、抽取的原理

　　知道了结构，我们还要知道结构中各部分的含义。在图1中RSS节点表示当前是一个RSS文件，它由一个CHANNEL节点及其子节点组成，其中一些子节点提供关于频道本身的信息，比如title表示频道的名称（“百度互联网新闻”）。

　　CHANNEL节点又包含多个ITEM子节点，而ITEM节点就是程序需要处理的部分，因为它对应着每条实际的新闻项信息, 每个ITEM节点又通过其子节点提供关于这条新闻的详细信息，比如title表示新闻的标题（“微软IM称王”），link对应新闻实际的链接。

　　RSS具体规范可查看http://blogs.law.harvard.edu/tech/rss

　　知道了这些后，要编程就不困难啦。我们只需提取并显示出CHANNEL和ITEM下的各条信息就可以了。现在来看看具体的实现方法吧。

　　二．做个程序读新闻

　　对RSS有一定了解后，我们开始编写程序。先还是需要一个最简单的界面。新建一个Win Form 工程，在Form上放置一个Label，一个文本框txtURL用来输入RSS链接（就是各网站RSS链接中包含的地址），一个按钮bnRead用来执行读取新闻, 一个TreeView树形控件treeRSS显示读出的新闻项。

　　1、定义装载结构

　　根据上面分析的RSS结构，我们首先来建立一个rss类，用它来装载RSS链接中CHANNEL和ITEM的各条信息。代码如下：

public class rss
{
　public struct Channel
　{
　　public string Title;
　　public Hashtable Items;
　}

　public struct Item
　{
　　public string Title;
　　public string Description;
　　public string Link;
　}
}

　　Channel结构将存储CHANNEL节点包含的所有子节点信息，其中Items成员字段是一个Hashtable集合，程序会将Item结构作为对象加入集合，用来存储Channel下的所有Item节点。这里我只读取了有限的几个节点，读者可以根据实际需要扩展整个结构定义。

　　2、从RSS链接中获取新闻信息

　　现在我们就可以开始编写读取函数，将抽取出的RSS信息放入上面设计好的结构中。

　　C#提供了专门的类来访问XML, 使我们能够轻松地读出RSS的内容。代码如下：

XmlTextReader Reader = new XmlTextReader(URL);
XmlValidatingReader Valid = new XmlValidatingReader(Reader);
Valid.ValidationType = ValidationType.None;
XmlDocument xmlDoc= new XmlDocument();
xmlDoc.Load(Reader);

　　使用XmlDocument类将txtURL中输入的RSS链接加载后，首先通过FoundChildNode函数，找到Channel节点。

private XmlNode FoundChildNode(XmlNode Node,string Name)
{
　XmlNode childlNode = null;
　for (int i=0;i < Node.ChildNodes.Count;i++)
　{
　　if ( Node.ChildNodes[i].Name == Name && Node.ChildNodes[i].ChildNodes.Count > 0 )
　　{
　　　childlNode = Node.ChildNodes[i];
　　　return childlNode;
　　}
　}
　return childlNode;
}
XmlNode rssNode = FoundChildNode(xmlDoc,"rss");
XmlNode channelNode = FoundChildNode(rssNode,"channel");

　　然后我们就可以遍历它的子节点，根据子节点的Name属性，读取我们需要的信息。

rss.Channel channel=new rss.Channel();
channel.Items=new Hashtable();
{
　switch ( channelNode.ChildNodes[i].Name )
　{
　　case "title":
　　　{
　　　　channel.Title = channelNode.ChildNodes[i].InnerText;
　　　　break;
　　　}
　　case "item":
　　　{
　　　　rss.Item item=this.getRssItem(channelNode.ChildNodes[i]);
　　　　channel.Items.Add(channel.Items.Count,item );
　　　　break;
　　　}
　}
}

　　如果发现是item子节点，就调用getRssItem函数，同样通过遍历子节点的方法，将其子节点内容填入Item结构中，然后再添加到Channel结构的Items集合中。因为本程序并不关心添加到集合的键值，只需要它是不重复的值，所以我传入了Count属性。

　　3.将读出的信息显示在程序中

　　将RSS内容读出后，就需要把信息展示给用户了。我们这里用的是基本的TreeView方法，通过遍历Channel结构的Items集合，将其标题添加到TreeView中。

private void ViewRss(rss.Channel channel)
{
　treeRss.BeginUpdate();
　treeRss.Nodes.Clear();
　TreeNode channelNode=treeRss.Nodes.Add(channel.Title );
　channelNode.Tag="";
　for (int i=0;i 　{
　　rss.Item item=(rss.Item)channel.Items[i];
　　TreeNode itemNode=channelNode.Nodes.Add(item.Title );
　　itemNode.Tag=item.Link;
　}
　treeRss.ExpandAll();
　treeRss.EndUpdate();
}

　　同时我们还可以设置TreeView的每个子节点的Tag属性为它对应的链接。以便当选中子节点时就可以通过读取Tag属性访问具体的信息。

private void treeRss_AfterSelect(object sender, System.Windows.Forms.TreeViewEventArgs e)
{
　TreeNode itemNode=e.Node ;
　string URL=itemNode.Tag.ToString();
　if (URL.Length!=0)
　　System.Diagnostics.Process.Start( URL);
}

　　程序运行效果如图2。

　　三．小结

　　怎么样，一个简单的RSS新闻阅读器就按前面所说轻松完成了，容易吧。虽然它还有很多不足，但如果大家通过这个例子学会了抽取RSS链接信息的基本方法，那就足够了！

使用c#捕获windows的关机事件

2008-10-21T05:07:00.004-07:00

在公司上班，下班时需要签退，而我呢隔三差五就会忘那么一次。怎么办呢，于是就想能不能捕获Windows的关机事件，做一个程序让它在关机的时候提醒我一下呢。

　　非常幸运很容易就找到了Microsoft.Win32命名空间下面的SystemEvents类，他有一个静态的事件SessionEnding在系统注销或者关机时发生，此事件只有在winform的程序下有效，而在控制台程序下面无效，不能激发事件;还有一点我们必须在程序推出时将加上的事件移除掉，否则就容易造成内存溢出。

　　关键代码如下：

以下是引用片段：
　　using System;
　　using System.Collections.Generic;
　　using System.Windows.Forms;
　　using Microsoft.Win32;
　　namespace Shutdown
　　{
　　static class Program
　　{
　　/**////
　　/// 应用程序的主入口点。
　　///
　　[STAThread]
　　static void Main()
　　{
　　Application.EnableVisualStyles();
　　Application.SetCompatibleTextRenderingDefault(false);
　　FormShutdown formShutdown = new FormShutdown();
　　SystemEvents.SessionEnding += new SessionEndingEventHandler(formShutdown.SystemEvents_SessionEnding);
　　Application.Run(formShutdown);
　　}
　　}
　　}Form 的代码：
　　using System;
　　using System.Collections.Generic;
　　using System.ComponentModel;
　　using System.Data;
　　using System.Drawing;
　　using System.Text;
　　using System.Windows.Forms;
　　using Microsoft.Win32;
　　namespace Shutdown
　　{
　　public partial class FormShutdown : Form
　　{
　　const string MESSAGE_TXT = "您签退了吗?";
　　const string MESSAGE_TITLE = "提示";
　　public FormShutdown()
　　{
　　InitializeComponent();
　　}
　　internal void SystemEvents_SessionEnding(object sender, SessionEndingEventArgs e)
　　{
　　DialogResult result = MessageBox.Show(MESSAGE_TXT, MESSAGE_TITLE, MessageBoxButtons.YesNo);
　　e.Cancel = (result == DialogResult.No);
　　}
　　private void FormShutdown_Load(object sender, EventArgs e)
　　{
　　this.Location = new Point(Screen.PrimaryScreen.WorkingArea.Width - 200, 0);
　　}
　　protected override void OnClosed(EventArgs e)
　　{
　　SystemEvents.SessionEnding -= new SessionEndingEventHandler(this.SystemEvents_SessionEnding);
　　base.OnClosed(e);
　　}
　　}
　　}

　　此程序在使用C#2.0在Windows2003下测试通过。大家在使用SystemEvents.SessionEnding事件时切记要在程序退出时移除事件。

　　不过有两点遗憾之处：

　　1. 使用这种方式不能捕获休眠时的事件

　　2. 这个程序占用的内存太多了，只有这么一个小功能居然占了12M的内存，这都是.net Framework惹的货;实在是不可思议。

　　大家有没有什么好主意可以克服这两个缺点呢?

一个用C#过滤HTML代码的函数

2008-10-21T05:07:00.003-07:00

public string checkStr(string html)
{
System.Text.RegularExpressions.Regex regex1 = new System.Text.RegularExpressions.Regex(@"", System.Text.RegularExpressions.RegexOptions.IgnoreCase);
System.Text.RegularExpressions.Regex regex2 = new System.Text.RegularExpressions.Regex(@" href *= *[\s\S]*script *:", System.Text.RegularExpressions.RegexOptions.IgnoreCase);
System.Text.RegularExpressions.Regex regex3 = new System.Text.RegularExpressions.Regex(@" no[\s\S]*=", System.Text.RegularExpressions.RegexOptions.IgnoreCase);
System.Text.RegularExpressions.Regex regex4 = new System.Text.RegularExpressions.Regex(@"", System.Text.RegularExpressions.RegexOptions.IgnoreCase);
System.Text.RegularExpressions.Regex regex5 = new System.Text.RegularExpressions.Regex(@"", System.Text.RegularExpressions.RegexOptions.IgnoreCase);
System.Text.RegularExpressions.Regex regex6 = new System.Text.RegularExpressions.Regex(@"\]+\>", System.Text.RegularExpressions.RegexOptions.IgnoreCase);
System.Text.RegularExpressions.Regex regex7 = new System.Text.RegularExpressions.Regex(@"

", System.Text.RegularExpressions.RegexOptions.IgnoreCase);
System.Text.RegularExpressions.Regex regex8 = new System.Text.RegularExpressions.Regex(@"

", System.Text.RegularExpressions.RegexOptions.IgnoreCase);
System.Text.RegularExpressions.Regex regex9 = new System.Text.RegularExpressions.Regex(@"<[^>]*>", System.Text.RegularExpressions.RegexOptions.IgnoreCase);
html = regex1.Replace(html, ""); //过滤标记
html = regex2.Replace(html, ""); //过滤href=JavaScript: () 属性
html = regex3.Replace(html, " _disibledevent="); //过滤其它控件的on...事件
html = regex4.Replace(html, ""); //过滤iframe
html = regex5.Replace(html, ""); //过滤frameset
html = regex6.Replace(html, ""); //过滤frameset
html = regex7.Replace(html, ""); //过滤frameset
html = regex8.Replace(html, ""); //过滤frameset
html = regex9.Replace(html, "");
html = html.Replace(" ", "");
html = html.Replace("", "");
html = html.Replace("", "");
return html;
}

关于C#在lucene.net下的中文切词

2008-10-21T05:07:00.001-07:00
经过一天的研究，终于完成了C#在lucene.net下可以使用的中文切词方法。感到有些复杂，不过我还是拿下了。颇有点成就感的，发上来跟大家分享一下!

　　在实现了中文切词的基础方法上，我将其封装在继承lucene的Analyzer类下

　　chineseAnalzer的方法就不用多说了。

以下是引用片段：
　　using System;
　　using System.Collections.Generic;
　　using System.Text;
　　
　　using Lucene.Net.Analysis;
　　using Lucene.Net.Analysis.Standard;
　　
　　namespace Lucene.Fanswo
　　{
　　 /**////
　　 ///
　　 ///
　　 public class ChineseAnalyzer:Analyzer
　　 {
　　 //private System.Collections.Hashtable stopSet;
　　 public static readonly System.String[] CHINESE_ENGLISH_STOP_WORDS = new System.String[] { "a", "an", "and", "are", "as", "at", "be", "but", "by", "for", "if", "in", "into", "is", "it", "no", "not", "of", "on", "or", "s", "such", "t", "that", "the", "their", "then", "there", "these", "they", "this", "to", "was", "will", "with", "我", "我们" };
　　
　　
　　 /**//// Constructs a {@link StandardTokenizer} filtered by a {@link
　　 /// StandardFilter}, a {@link LowerCaseFilter} and a {@link StopFilter}.
　　 ///
　　 public override TokenStream TokenStream(System.String fieldName, System.IO.TextReader reader)
　　 {
　　 TokenStream result = new ChineseTokenizer(reader);
　　 result = new StandardFilter(result);
　　 result = new LowerCaseFilter(result);
　　 result = new StopFilter(result, CHINESE_ENGLISH_STOP_WORDS);
　　 return result;
　　 }
　　
　　 }
　　}
　　

　　ChineseTokenizer类的实现：

　　这里通过词典来正向匹配字符，返回lucene下定义的token流

以下是引用片段：
　　using System;
　　using System.Collections.Generic;
　　using System.Text;
　　using Lucene.Net.Analysis;
　　using System.Collections;
　　using System.Text.RegularExpressions;
　　using System.IO;
　　
　　namespace Lucene.Fanswo
　　{
　　 class ChineseTokenizer : Tokenizer
　　 {
　　
　　 private int offset = 0, bufferIndex = 0, dataLen = 0;//偏移量，当前字符的位置，字符长度
　　
　　 private int start;//开始位置
　　 /**////
　　 /// 存在字符内容
　　 ///
　　 private string text;
　　
　　 /**////
　　 /// 切词所花费的时间
　　 ///
　　 public double TextSeg_Span = 0;
　　
　　 /**//// Constructs a tokenizer for this Reader.
　　 public ChineseTokenizer(System.IO.TextReader reader)
　　 {
　　 this.input = reader;
　　 text = input.ReadToEnd();
　　 dataLen = text.Length;
　　 }
　　
　　 /**//// 进行切词，返回数据流中下一个token或者数据流为空时返回null
　　 ///
　　 ///
　　 public override Token Next()
　　 {
　　 Token token = null;
　　 WordTree tree = new WordTree();
　　 //读取词库
　　 tree.LoadDict();
　　 //初始化词库，为树形
　　 Hashtable t_chartable = WordTree.chartable;
　　 string ReWord = "";
　　 string char_s;
　　 start = offset;
　　 bufferIndex = start;
　　
　　 while (true)
　　 {
　　 //开始位置超过字符长度退出循环
　　 if (start >= dataLen)
　　 {
　　 break;
　　 }
　　 //获取一个词
　　 char_s = text.Substring(start, 1);
　　 if (string.IsNullOrEmpty(char_s.Trim()))
　　 {
　　 start++;
　　 continue;
　　 }
　　 //字符不在字典中
　　 if (!t_chartable.Contains(char_s))
　　 {
　　 if (ReWord == "")
　　 {
　　 int j = start + 1;
　　 switch (tree.GetCharType(char_s))
　　 {
　　 case 0://中文单词
　　 ReWord += char_s;
　　 break;
　　 case 1://英文单词
　　 j = start + 1;
　　 while (j < dataLen)
　　 {
　　 if (tree.GetCharType(text.Substring(j, 1)) != 1)
　　 break;
　　
　　 j++;
　　 }
　　 ReWord += text.Substring(start, j - offset);
　　
　　 break;
　　 case 2://数字
　　 j = start + 1;
　　 while (j < dataLen)
　　 {
　　 if (tree.GetCharType(text.Substring(j, 1)) != 2)
　　 break;
　　
　　 j++;
　　 }
　　 ReWord += text.Substring(start, j - offset);
　　
　　 break;
　　
　　 default:
　　 ReWord += char_s;//其他字符单词
　　 break;
　　 }
　　
　　 offset = j;//设置取下一个词的开始位置
　　 }
　　 else
　　 {
　　 offset = start;//设置取下一个词的开始位置
　　 }
　　
　　 //返回token对象
　　 return new Token(ReWord, bufferIndex, bufferIndex + ReWord.Length - 1);
　　 }
　　 //字符在字典中
　　 ReWord += char_s;
　　 //取得属于当前字符的词典树
　　 t_chartable = (Hashtable)t_chartable[char_s];
　　 //设置下一循环取下一个词的开始位置
　　 start++;
　　 if (start == dataLen)
　　 {
　　 offset = dataLen;
　　 return new Token(ReWord, bufferIndex, bufferIndex + ReWord.Length - 1);
　　 }
　　 }
　　 return token;
　　 }
　　
　　 }
　　}

　　测试的代码：

以下是引用片段：
　　using System;
　　using System.Collections.Generic;
　　using System.Text;
　　
　　using Analyzer = Lucene.net.Analysis.Analyzer;
　　using SimpleAnalyzer = Lucene.Net.Analysis.SimpleAnalyzer;
　　using StandardAnalyzer = Lucene.Net.Analysis.Standard.StandardAnalyzer;
　　using Token = Lucene.Net.Analysis.Token;
　　using TokenStream = Lucene.Net.Analysis.TokenStream;
　　
　　namespace MyLuceneTest
　　{
　　 class Program
　　 {
　　 [STAThread]
　　 public static void Main(System.String[] args)
　　 {
　　 try
　　 {
　　 Test("中华人民共和国在1949年建立，从此开始了新中国的伟大篇章。长春市长春节致词", true);
　　 }
　　 catch (System.Exception e)
　　 {
　　 System.Console.Out.WriteLine(" caught a " + e.GetType() + "\n with message: " + e.Message + e.ToString());
　　 }
　　 }
　　
　　 internal static void Test(System.String text, bool verbose)
　　 {
　　 System.Console.Out.WriteLine(" Tokenizing string: " + text);
　　 Test(new System.IO.StringReader(text), verbose, text.Length);
　　 }
　　
　　 internal static void Test(System.IO.TextReader reader, bool verbose, long bytes)
　　 {
　　 //Analyzer analyzer = new StandardAnalyzer();
　　 Analyzer analyzer = new Lucene.Fanswo.ChineseAnalyzer();
　　 TokenStream stream = analyzer.TokenStream(null, reader);
　　
　　 System.DateTime start = System.DateTime.Now;
　　
　　 int count = 0;
　　 for (Token t = stream.Next(); t != null; t = stream.Next())
　　 {
　　 if (verbose)
　　 {
　　 System.Console.Out.WriteLine("Token=" + t.ToString());
　　 }
　　 count++;
　　 }
　　
　　 System.DateTime end = System.DateTime.Now;
　　
　　 long time = end.Ticks - start.Ticks;
　　 System.Console.Out.WriteLine(time + " milliseconds to extract " + count + " tokens");
　　 System.Console.Out.WriteLine((time * 1000.0) / count + " microseconds/token");
　　 System.Console.Out.WriteLine((bytes * 1000.0 * 60.0 * 60.0) / (time * 1000000.0) + " megabytes/hour");
　　 }
　　 }
　　}
　　

　　测试结果：

　　

　　完毕!

　　分词的郊率上还有待在算法上提高。还有中文的标点符号没有处理，我将进一步完善。

　　

详解Visual C＃数据库编程

2008-10-21T05:06:00.002-07:00
本文就来着重探讨一下Visual C#数据库基本编程，即：如何浏览记录、修改记录、删除记录和插入记录。针对数据库编程始终是程序设计语言的一个重要方面的内容，也是一个难点。数据库编程的内容十分丰富，但最为基本编程的也就是那么几点，譬如：连接数据库、得到需要的数据和针对数据记录的浏览、删除、修改、插入等操作。其中又以后面针对数据记录的数据操作为重点。

　　一.程序设计和运行的环境设置：

　　(1).视窗2000服务器版

　　(2).Microsoft Data Acess Component 2.6 以上版本 ( MDAC 2.6 )

　　(3)..net Framework SDK Beta 2

　　为了更清楚的说明问题，在数据库的选用上，采用了当前比较典型的数据库，一个是本地数据库Access 2000，另外一个是远程数据库SQL Server 2000。其中本地数据库名称为"db.mdb"，在其中定义了一张数据表"person"，"person"表的数据结构如下表：

　　字段名称字段类型字段意思

　　id 数字序号

　　xm 文本姓名

　　xb 文本性别

　　nl 文本年龄

　　zip 文本邮政编码

　　远程数据库Sql Server 2000的数据库服务器名称为"Server1",数据库名称为"Data1"，登陆的ID为"sa"，口令为空，在数据库也定义了一张"person"表，数据结构如上表。

　　二.如何浏览数据：

　　在《Visual C#的数据绑定》中，已经了解了如何把数据集中的某些字段绑定到WinForm组件的某个属性上，这样程序员就可以根据以WinForm组件的来定制数据显示的形式，并且此时的WinForm组件显示内容就可以随着记录指针的变化而改变。至此可见，浏览数据记录的关键就是如何改变记录指针。要实现这种操作，就要使用到BindingManagerBase类，此类的主要作用是管理对于那些实现了对同一个数据源进行绑定的对象。说的具体些，就是能够使得Windows窗体上的已经对同一数据源进行数据绑定的组件保持同步。在BindingManagerBase类中定义了一个属性"Position"，通过这个属性就可以改变BindingManagerBase对象中的数据指针。创建BindingManagerBase对象必须要使用到BindingContext类，其实每一个由Control类中继承而得到的对象，都有单一的BindingContext对象，在大多数创建窗体中实现数据绑定组件的BindingManagerBase对象是使用Form类的BindingContext来得到。下列代码是以Access 2000数据库为模型，创建的一个名称为"myBind"的BindingManagerBase对象。

以下是引用片段：
　　//创建一个 OleDbConnection
　　string strCon = " Provider = Microsoft.Jet.OLEDB.4.0 ; Data Source = db.mdb" ;
　　OleDbConnection myConn = new OleDbConnection ( strCon ) ;
　　string strCom = " SELECT * FROM person " ;
　　file://创建一个 DataSet
　　myDataSet = new DataSet ( ) ;
　　myConn.Open ( ) ;
　　file://用 OleDbDataAdapter 得到一个数据集
　　OleDbDataAdapter myCommand = new OleDbDataAdapter ( strCom , myConn ) ;
　　file://把Dataset绑定books数据表
　　myCommand.Fill ( myDataSet , "person" ) ;
　　file://关闭此OleDbConnection
　　myConn.Close ( ) ;
　　myBind = this.BindingContext [ myDataSet , "person" ] ;

　　下列代码是以Sql Server 2000数据库为模型，创建一个名称为"myBind"的BindingManagerBase对象。

以下是引用片段：
　　// 设定数据连接字符串，此字符串的意思是打开Sql server数据库，服务器名称为server1,数据库为data1
　　string strCon = "Provider = SQLOLEDB.1 ; Persist Security Info = False ; User ID = sa ; Initial Catalog = data1 ; Data Source = server1 " ;
　　OleDbConnection myConn = new OleDbConnection ( strCon ) ;
　　myConn.Open ( ) ;
　　string strCom = " SELECT * FROM person " ;
　　file://创建一个 DataSet
　　myDataSet = new DataSet ( ) ;
　　file://用 OleDbDataAdapter 得到一个数据集
　　OleDbDataAdapter myCommand = new OleDbDataAdapter ( strCom , myConn ) ;
　　file://把Dataset绑定person数据表
　　myCommand.Fill ( myDataSet , " person " ) ;
　　file://关闭此OleDbConnection
　　myConn.Close ( ) ;
　　myBind = this.BindingContext [ myDataSet , "person" ] ;

　　得到了是同一数据源的BindingManagerBase对象，通过改变此对象的"Position"属性值，这样绑定数据的组件显示的数据就随之变化，从而实现导航数据记录。

　　< I > .导航按钮"上一条"实现方法：

以下是引用片段：
　　protected void GoPrevious ( object sender , System.EventArgs e )
　　{
　　if ( myBind.Position == 0 )
　　MessageBox.Show ( "已经到了第一条记录!" , "信息提示!" , MessageBoxButtons.OK , MessageBoxIcon.Information ) ;
　　else
　　myBind.Position -= 1 ;
　　}

　　< II > . 导航按钮"下一条"实现方法：

以下是引用片段：
　　protected void GoNext ( object sender , System.EventArgs e )
　　{
　　if ( myBind.Position == myBind.Count -1 )
　　MessageBox.Show ( "已经到了最后一条记录!", "信息提示!" , MessageBoxButtons.OK , MessageBoxIcon.Information ) ;
　　else
　　myBind.Position += 1 ;
　　}

　　< III > . 导航按钮"至尾"实现方法：

以下是引用片段：
　　protected void GoLast ( object sender , System.EventArgs e )
　　{
　　myBind.Position = myBind.Count - 1 ;
　　}

　　< IV > . 导航按钮"至首"实现方法：

以下是引用片段：
　　protected void GoFirst ( object sender , System.EventArgs e )
　　{
　　myBind.Position = 0 ;
　　}

　　注释："Count"是BindingManagerBase对象的另外一个重要的属性，是数据集记录的总数。

　　三.实现删除记录：

　　在对数据记录进行操作的时候，有二点必须十分清晰：

　　其一：在对数据记录进行操作的时候，我想有一些程序员一定有这样一个疑惑，当对数据库服务器请求数据集的时候，就会产生"DataSet"对象，用以管理数据集，这样如果这些对数据库服务器的请求非常多，同样也就会产生很多的"DataSet"对象，达到一定时候必然会使得数据库服务器崩溃。这种想法是自然的，但和实际并不相符，因为"DataSet"对象并不是在服务器端产生的，而是在客户端产生的。所以面对众多的数据请求的时候对数据库服务器的影响并不十分太大。

　　其二：记得在用Delphi编写三层数据模型的时候的，每一次对数据库的修改其实只是对第二层产生的数据集的修改，要真正修改数据库，还必须调用一个另外的方法。在用ADO.NET处理数据库的时候，虽然处理的直接对象是数据库，但此时"DataSet"对象中的内容并没有随之改变，而绑定的数据组件显示的数据又来源于"DataSet"对象，这样就会产生一个错觉，就是修改了的记录并没有修改掉，删除的记录并没有删除掉。所以对数据记录进行操作的时候，在修改数据库后，还要对"DataSet"对象进行必要的修改，这样才能保证"DataSet"对象和数据库内容一致、同步。下面代码是删除当前绑定组件显示的记录的程序代码，此代码是以Access 2000数据库为模板的：

以下是引用片段：
　　protected void Delete_record ( object sender , System.EventArgs e )
　　{
　　DialogResult r = MessageBox.Show ( "是否删除当前记录!" , "删除当前记录!" , MessageBoxButtons.YesNo , MessageBoxIcon.Question ) ;
　　int ss = ( int ) r ;
　　if ( ss == 6 ) // 按动"确定"按钮
　　{
　　try{
　　file://连接到一个数据库
　　string strCon = " Provider = Microsoft.Jet.OLEDB.4.0 ; Data Source = db.mdb " ;
　　OleDbConnection myConn = new OleDbConnection ( strCon ) ;
　　myConn.Open ( ) ;
　　string strDele = "DELETE FROM person WHERE id= " + t_id.Text ;
　　OleDbCommand myCommand = new OleDbCommand ( strDele , myConn ) ;
　　file://从数据库中删除指定记录
　　myCommand.ExecuteNonQuery ( ) ;
　　file://从DataSet中删除指定记录
　　myDataSet.Tables [ "person" ] . Rows [ myBind.Position ] . Delete ( ) ;
　　myDataSet.Tables [ "person" ] . AcceptChanges ( ) ;
　　myConn.Close ( ) ;
　　}
　　catch ( Exception ed )
　　{
　　MessageBox.Show ( "删除记录错误信息： " + ed.ToString ( ) , "错误!" ) ;
　　}
　　}
　　}

使用C#编写查询IP段功能的程序

2008-10-21T05:06:00.001-07:00
本文将通过一个实例来向大家讲解如何使用C#来编写一个具备查询IP段功能的小程序。

　　主要功能：查询一个IP所有的IP段.

　　关键:从Byte数组到ulong的转换出来的数字和 IPAddress.Address 返回值的是不一样的.

以下是引用片段：
　　using System;
　　using System.Collections.Generic;
　　using System.Text;
　　using System.net;
　　namespace IPUtility
　　{
　　class Program
　　{
　　static void Main(string[] args)
　　{
　　IPRangeManage irm = new IPRangeManage();
　　irm.Add(new IPRange("石家庄", "219.148.24.0", "219.148.63.255"));
　　irm.Add(new IPRange("石家庄", "222.222.0.0", "222.222.63.255"));
　　irm.Add(new IPRange("唐山", "219.148.64.0", "219.148.79.255"));
　　irm.Add(new IPRange("保定", "219.148.20.0", "219.148.23.255"));
　　Console.WriteLine(irm.Search("219.148.56.3").Name);
　　Console.ReadLine();
　　}
　　}
　　public class IPRange
　　{
　　private string _Name = string.Empty;
　　private ulong _BeginIP = 0;
　　private ulong _EndIP = Int32.MaxValue;
　　/**////
　　/// IP段名称
　　///
　　public string Name
　　{
　　get { return _Name; }
　　set { _Name = value; }
　　}
　　/**////
　　/// ?始IP
　　///
　　public ulong BeginIP
　　{
　　get { return _BeginIP; }
　　set { _BeginIP = value; }
　　}
　　/**////
　　/// ?束IP
　　///
　　public ulong EndIP
　　{
　　get { return _EndIP; }
　　set { _EndIP = value; }
　　}
　　/**////
　　/// 此IP段的范?
　　///
　　public ulong Range
　　{
　　get
　　{
　　return EndIP - BeginIP;
　　}
　　}
　　public IPRange(string name, string iPBegin, string ipEnd)
　　{
　　this.Name = name;
　　this.BeginIP = IP2A(ipBegin);
　　this.EndIP = IP2A(ipEnd);
　　}
　　public static ulong IP2A(string ip)
　　{
　　byte[] bytes = IPAddress.Parse(ip).GetAddressBytes();
　　ulong ret = 0;
　　foreach (byte b in bytes)
　　{
　　ret <<= 8;
　　ret |= b;
　　}
　　return ret;
　　}
　　public static int Compare(IPRange x, IPRange y)
　　{
　　if(x.Range == y.Range)
　　return 0;
　　else if(x.Range > y.Range)
　　return 1;
　　else return -1;
　　}
　　}
　　public class IPRangeManage
　　{
　　public IPRangeManage()
　　{ }
　　private List< IPRange> _IPRangeList = new List< IPRange>();
　　private bool _NeedSort = true;
　　public void Add(IPRange ipRange)
　　{
　　_IPRangeList.Add(ipRange);
　　_NeedSort = true;
　　}
　　private void Sort()
　　{
　　if (_NeedSort)
　　{
　　_IPRangeList.Sort(new Comparison(IPRange.Compare));
　　}
　　}
　　public IPRange Search(string ipString)
　　{
　　ulong ip = IPRange.IP2A(ipString);
　　this.Sort();
　　foreach (IPRange ir in _IPRangeList)
　　{
　　if (ir.BeginIP <= ip && ir.EndIP >= ip)
　　{
　　return ir;
　　}
　　}
　　return null;
　　}
　　}
　　}

　　完毕。

C# 中的常用正则表达式总结

2008-10-21T05:05:00.004-07:00
这是我发了不少时间整理的C#的正则表达式，新手朋友注意一定要手册一下哦，这样可以节省很多写代码的时间，中国自学编程网为新手朋友整理发布。

　　只能输入数字："^[0-9]*$"。

　　只能输入n位的数字："^\d{n}$"。

　　只能输入至少n位的数字："^\d{n,}$"。

　　只能输入m~n位的数字：。"^\d{m,n}$"

　　只能输入零和非零开头的数字："^(0|[1-9][0-9]*)$"。

　　只能输入有两位小数的正实数："^[0-9]+(.[0-9]{2})?$"。

　　只能输入有1~3位小数的正实数："^[0-9]+(.[0-9]{1,3})?$"。

　　只能输入非零的正整数："^\+?[1-9][0-9]*$"。

　　只能输入非零的负整数："^\-[1-9][]0-9"*$。

　　只能输入长度为3的字符："^.{3}$"。

　　只能输入由26个英文字母组成的字符串："^[A-Za-z]+$"。

　　只能输入由26个大写英文字母组成的字符串："^[A-Z]+$"。

　　只能输入由26个小写英文字母组成的字符串："^[a-z]+$"。

　　只能输入由数字和26个英文字母组成的字符串："^[A-Za-z0-9]+$"。

　　只能输入由数字、26个英文字母或者下划线组成的字符串："^\w+$"。

　　验证用户密码："^[a-zA-Z]\w{5,17}$"正确格式为：以字母开头，长度在6~18之间，只能包含字符、数字和下划线。

　　验证是否含有^%&’,;=?$\"等字符："[^%&’,;=?$\x22]+"。

　　只能输入汉字："^[\u4e00-\u9fa5]{0,}$"

　　验证Email地址："^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$"。

　　验证InternetURL："^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$"。

　　验证电话号码："^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$"正确格式为："XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX"。

　　验证身份证号(15位或18位数字)："^\d{15}|\d{18}$"。

　　验证一年的12个月："^(0?[1-9]|1[0-2])$"正确格式为："01"～"09"和"1"～"12"。

　　验证一个月的31天："^((0?[1-9])|((1|2)[0-9])|30|31)$"正确格式为;"01"～"09"和"1"～"31"。

　　利用正则表达式限制网页表单里的文本框输入内容：

　　用正则表达式限制只能输入中文：onkeyup="value=value.replace(/[^\u4E00-\u9FA5]/g,’’)" onbeforepaste="cliPBoardData.setData(’text’,clipboardData.getData(’text’).replace(/[^\u4E00-\u9FA5]/g,’’))"

　　用正则表达式限制只能输入全角字符： onkeyup="value=value.replace(/[^\uFF00-\uFFFF]/g,’’)" onbeforepaste="clipboardData.setData(’text’,clipboardData.getData(’text’).replace(/[^\uFF00-\uFFFF]/g,’’))"

　　用正则表达式限制只能输入数字：onkeyup="value=value.replace(/[^\d]/g,’’) "onbeforepaste="clipboardData.setData(’text’,clipboardData.getData(’text’).replace(/[^\d]/g,’’))"

　　用正则表达式限制只能输入数字和英文：onkeyup="value=value.replace(/[\W]/g,’’) "onbeforepaste="clipboardData.setData(’text’,clipboardData.getData(’text’).replace(/[^\d]/g,’’))"

　　得用正则表达式从URL地址中提取文件名的JavaScript程序，如下结果为page1

以下是引用片段：
　　s="http://www.9499.net/page1.htm"
　　s=s.replace(/(.*\/){0,}([^\.]+).*/ig,"$2")
　　alert(s)

　　匹配双字节字符(包括汉字在内)：[^\x00-\xff]

　　应用：计算字符串的长度(一个双字节字符长度计2，ASCII字符计1)

以下是引用片段：
　　String.prototype.len=function(){return this.replace([^\x00-\xff]/g,"aa").length;}

　　匹配空行的正则表达式：\n[\s| ]*\r

　　匹配HTML标记的正则表达式：/<(.*)>.*<\/\1>|<(.*) \/>/

　　匹配首尾空格的正则表达式：(^\s*)|(\s*$)

以下是引用片段：
　　String.prototype.trim = function()
　　{
　　return this.replace(/(^\s*)|(\s*$)/g, "");
　　}

　　利用正则表达式分解和转换IP地址：

　　下面是利用正则表达式匹配IP地址，并将IP地址转换成对应数值的Javascript程序：

以下是引用片段：
　　function IP2V(ip)
　　{
　　re=/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //匹配IP地址的正则表达式
　　if(re.test(ip))
　　{
　　return RegExp.$1*Math.pow(255,3))+RegExp.$2*Math.pow(255,2))+RegExp.$3*255+RegExp.$4*1
　　}
　　else
　　{
　　throw new Error("Not a valid IP address!")
　　}
　　}

不过上面的程序如果不用正则表达式，而直接用split函数来分解可能更简单，程序如下：

以下是引用片段：
　　var ip="10.100.20.168"
　　ip=ip.split(".")
　　alert("IP值是："+(ip[0]*255*255*255+ip[1]*255*255+ip[2]*255+ip[3]*1))

　　符号解释：

　　\

　　将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如，’n’ 匹配字符 "n"。’\n’ 匹配一个换行符。序列 ’\\’ 匹配 "\" 而 "\(" 则匹配 "("。

　　^

　　匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 ’\n’ 或 ’\r’ 之后的位置。

　　$

　　匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 ’\n’ 或 ’\r’ 之前的位置。

　　*

　　匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。

　　+

　　匹配前面的子表达式一次或多次。例如，’zo+’ 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。

　　?

　　匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 中的"do" 。? 等价于 {0,1}。

　　{n}

　　n 是一个非负整数。匹配确定的 n 次。例如，’o{2}’ 不能匹配 "Bob" 中的 ’o’，但是能匹配 "food" 中的两个 o。

　　{n,}

　　n 是一个非负整数。至少匹配n 次。例如，’o{2,}’ 不能匹配 "Bob" 中的 ’o’，但能匹配 "foooood" 中的所有 o。’o{1,}’ 等价于 ’o+’。’o{0,}’ 则等价于 ’o*’。

　　{n,m}

　　m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。’o{0,1}’ 等价于 ’o?’。请注意在逗号和两个数之间不能有空格。

　　?

　　当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 "oooo"，’o+?’ 将匹配单个 "o"，而 ’o+’ 将匹配所有 ’o’。

　　.

　　匹配除 "\n" 之外的任何单个字符。要匹配包括 ’\n’ 在内的任何字符，请使用象 ’[.\n]’ 的模式。

　　(pattern)

　　匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 ’$’ 或 ’$’。

　　(?:pattern)

　　匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 "或" 字符 (|) 来组合一个模式的各个部分是很有用。例如， ’industr(?:y|ies) 就是一个比 ’industry|industries’ 更简略的表达式。

　　(?=pattern)

　　正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，’Windows (?=95|98|NT|2000)’ 能匹配 "Windows 2000" 中的 "Windows" ，但不能匹配 "Windows 3.1" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。

　　(?!pattern)

　　负向预查，在任何不匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如’Windows (?!95|98|NT|2000)’ 能匹配 "Windows 3.1" 中的 "Windows"，但不能匹配 "Windows 2000" 中的 "Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始

　　x|y

　　匹配 x 或 y。例如，’z|food’ 能匹配 "z" 或 "food"。’(z|f)ood’ 则匹配 "zood" 或 "food"。

　　[xyz]

　　字符集合。匹配所包含的任意一个字符。例如， ’[abc]’ 可以匹配 "plain" 中的 ’a’。

　　[^xyz]

　　负值字符集合。匹配未包含的任意字符。例如， ’[^abc]’ 可以匹配 "plain" 中的’p’。

　　[a-z]

　　字符范围。匹配指定范围内的任意字符。例如，’[a-z]’ 可以匹配 ’a’ 到 ’z’ 范围内的任意小写字母字符。

　　[^a-z]

　　负值字符范围。匹配任何不在指定范围内的任意字符。例如，’[^a-z]’ 可以匹配任何不在 ’a’ 到 ’z’ 范围内的任意字符。

　　\b

　　匹配一个单词边界，也就是指单词和空格间的位置。例如， ’er\b’ 可以匹配"never" 中的 ’er’，但不能匹配 "verb" 中的 ’er’。

　　\B

　　匹配非单词边界。’er\B’ 能匹配 "verb" 中的 ’er’，但不能匹配 "never" 中的 ’er’。

\cx

　　匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 ’c’ 字符。

　　\d

　　匹配一个数字字符。等价于 [0-9]。

　　\D

　　匹配一个非数字字符。等价于 [^0-9]。

　　\f

　　匹配一个换页符。等价于 \x0c 和 \cL。

　　\n

　　匹配一个换行符。等价于 \x0a 和 \cJ。

　　\r

　　匹配一个回车符。等价于 \x0d 和 \cM。

　　\s

　　匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。

　　\S

　　匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。

　　\t

　　匹配一个制表符。等价于 \x09 和 \cI。

　　\v

　　匹配一个垂直制表符。等价于 \x0b 和 \cK。

　　\w

　　匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]’。

　　\W

　　匹配任何非单词字符。等价于 ’[^A-Za-z0-9_]’。

　　\xn

　　匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，’\x41’ 匹配 "A"。’\x041’ 则等价于 ’\x04’ & "1"。正则表达式中可以使用 ASCII 编码。.

　　\num

　　匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，’(.)\1’ 匹配两个连续的相同字符。

　　\n

　　标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。

　　\nm

　　标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。

　　\nml

　　如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。

　　\un

　　匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)。

C#也能动态生成Word文档并填充数据

2008-10-21T05:05:00.003-07:00
要使用C#操作word，首先要添加引用：
1、添加引用->COM->Microsoft Word 11.0 Object Library

2、在.cs文件中添加

using Word;
下面的例子中包括C#对Word文档的创建、插入表格、设置样式等操作：

（例子中代码有些涉及数据信息部分被省略，重要是介绍一些C#操作word文档的方法）

public string CreateWordFile(string CheckedInfo)
...{
string message = "";
try
...{
Object Nothing = System.Reflection.Missing.Value;
Directory.CreateDirectory("C:/CNSI"); //创建文件所在目录
string name = "CNSI_" + DateTime.Now.ToShortString()+".doc";
object filename = "C://CNSI//" + name; //文件保存路径
//创建Word文档
Word.Application WordApp = new Word.ApplicationClass();
Word.Document WordDoc = WordApp.Documents.Add(ref Nothing, ref Nothing, ref Nothing, ref Nothing);

//添加页眉
WordApp.ActiveWindow.View.Type = WdViewType.wdOutlineView;
WordApp.ActiveWindow.View.SeekView = WdSeekView.wdSeekPrimaryHeader;
WordApp.ActiveWindow.ActivePane.Selection.InsertAfter("[页眉内容]");
WordApp.Selection.ParagraphFormat.Alignment = Word.WdParagraphAlignment.wdAlignParagraphRight;//设置右对齐
WordApp.ActiveWindow.View.SeekView = WdSeekView.wdSeekMainDocument;//跳出页眉设置

WordApp.Selection.ParagraphFormat.LineSpacing = 15f;//设置文档的行间距

//移动焦点并换行
object count = 14;
object WdLine = Word.WdUnits.wdLine;//换一行;
WordApp.Selection.MoveDown(ref WdLine, ref count, ref Nothing);//移动焦点
WordApp.Selection.TypeParagraph();//插入段落

//文档中创建表格
Word.Table newTable = WordDoc.Tables.Add(WordApp.Selection.Range, 12, 3, ref Nothing, ref Nothing);
//设置表格样式
newTable.Borders.OutsideLineStyle = Word.WdLineStyle.wdLineStyleThickThinLargeGap;
newTable.Borders.InsideLineStyle = Word.WdLineStyle.wdLineStyleSingle;
newTable.Columns[1].Width = 100f;
newTable.Columns[2].Width = 220f;
newTable.Columns[3].Width = 105f;

//填充表格内容
newTable.Cell(1, 1).Range.Text = "产品详细信息表";
newTable.Cell(1, 1).Range.Bold = 2;//设置单元格中字体为粗体
//合并单元格
newTable.Cell(1, 1).Merge(newTable.Cell(1, 3));
WordApp.Selection.Cells.VerticalAlignment = Word.WdCellVerticalAlignment.wdCellAlignVerticalCenter;//垂直居中
WordApp.Selection.ParagraphFormat.Alignment = Word.WdParagraphAlignment.wdAlignParagraphCenter;//水平居中

//填充表格内容
newTable.Cell(2, 1).Range.Text = "产品基本信息";
newTable.Cell(2, 1).Range.Font.Color = Word.WdColor.wdColorDarkBlue;//设置单元格内字体颜色
//合并单元格
newTable.Cell(2, 1).Merge(newTable.Cell(2, 3));
WordApp.Selection.Cells.VerticalAlignment = Word.WdCellVerticalAlignment.wdCellAlignVerticalCenter;

//填充表格内容
newTable.Cell(3, 1).Range.Text = "品牌名称：";
newTable.Cell(3, 2).Range.Text = BrandName;
//纵向合并单元格
newTable.Cell(3, 3).Select();//选中一行
object moveUnit = Word.WdUnits.wdLine;
object moveCount = 5;
object moveExtend = Word.WdMovementType.wdExtend;
WordApp.Selection.MoveDown(ref moveUnit, ref moveCount, ref moveExtend);
WordApp.Selection.Cells.Merge();
//插入图片
string FileName = Picture;//图片所在路径
object LinkToFile = false;
object SaveWithDocument = true;
object Anchor = WordDoc.Application.Selection.Range;
WordDoc.Application.ActiveDocument.InlineShapes.AddPicture(FileName, ref LinkToFile, ref SaveWithDocument, ref Anchor);
WordDoc.Application.ActiveDocument.InlineShapes[1].Width = 100f;//图片宽度
WordDoc.Application.ActiveDocument.InlineShapes[1].Height = 100f;//图片高度
//将图片设置为四周环绕型
Word.Shape s = WordDoc.Application.ActiveDocument.InlineShapes[1].ConvertToShape();
s.WrapFormat.Type = Word.WdWrapType.wdWrapSquare;

newTable.Cell(12, 1).Range.Text = "产品特殊属性";
newTable.Cell(12, 1).Merge(newTable.Cell(12, 3));
//在表格中增加行
WordDoc.Content.Tables[1].Rows.Add(ref Nothing);

WordDoc.Paragraphs.Last.Range.Text = "文档创建时间：" + DateTime.Now.ToString();//“落款”
WordDoc.Paragraphs.Last.Alignment = Word.WdParagraphAlignment.wdAlignParagraphRight;

//文件保存
WordDoc.SaveAs(ref filename, ref Nothing, ref Nothing, ref Nothing, ref Nothing, ref Nothing, ref Nothing, ref Nothing, ref Nothing, ref Nothing, ref Nothing, ref Nothing, ref Nothing, ref Nothing, ref Nothing, ref Nothing);
WordDoc.Close(ref Nothing, ref Nothing, ref Nothing);
WordApp.Quit(ref Nothing, ref Nothing, ref Nothing);
message=name+"文档生成成功，以保存到C:CNSI下";
}
catch
...{
message = "文件导出异常！";
}
return message;
}

　　查阅关于C#的全部文档

C#和ASP.NET开发的一些小技巧及注意事项

2008-10-21T05:05:00.001-07:00
1、构造函数不能带返回值类型，因为构造函数返回就是对象本身。

　　2、将字符串转换成日期类型，用DateTime.Parese()或DateTime.ParseExact()函数。

　　3、if(!Page.IsPostback){}

　　使用该函数，使网页仅在第一次加载时运行函数体的内容，在Page_Load()事件中，通常可用于初始化。如果不使用该函数，则可能会在一些控件回传时再次运行if（）函数体内的内容，导致相关控件修改后的值没有正确应用。

　　4、GridView的字段（BoundField）有一个属性HtmlEncode。这个属性用于将HTML进行包装，如果为true(默认值)，则原样显示字段内的内容。如果为false，则将字段内相应的HTML标签进行渲染。因此，要使字段内的图片链接显示出来，应设置HtmlEncode=“true”。

　　5、网页中获取日期后进行格式化的方法：Eval("wtDate", "{0:yyyy-MM-dd}")但在DateTime.Now.Date.ToString("yyyy-MM-dd") 中的字符串格式化却有所不同。

　　6、NVarChar数据类型，在SQL SERVER 2005中具有NVarChar(max)类型来代表最大为2^32 的数字，但是在.net2.0中并不支持这个类型，NVarChar最大能表示的数仍为4000字节。

　　7、将字符串类型转换为Guid类型，可将字符串作为Guid构造函数的参数进行传递。

如： Guid gd = New Guid(string);
Guid类型的空值为Guid.Empty ,而非null。

　　8、最好对各字段都存储值，即便不使用，也就进行初始设置，以避免为空值时，出现数据类型不匹配现象，如DateTime，uniqueIdentifier字段，取出空值进行处理时会带来麻烦。

　　9、对记录数进行统计,使用类似下面的语句:

int cout =(int)cmd.ExecuteScalar();

　　10、存储过程中，通配符与参数结合使用，要采用字符串加法，而不能直接放在参数两侧，如下：

WHERE RTRIM(f.ftTitle) LIKE '%'+RTRIM(@searchkey)+'%'

　　11、要获取list对象中某个项的值，可采用如下方法：

　　如List CurrentFault = new List();//创建一个对象

　　假设ftInfo类中定义了ftIsResovled属性，那么，要获取CurrentFault的第0项的ftIsResolved值，可通过语名： CurrentFault[0].ftIsResolved 来获得。

　　12、Input控件中包含有标签的内容（如）时，可能会有如下因为安全问题引起的错误：说明: 请求验证过程检测到有潜在危险的客户端输入值，对请求的处理已经中止。该值可能指示危及应用程序安全的尝试，如跨站点的脚本攻击。通过在 Page 指令或配置节中设置 validateRequest=false 可以禁用请求验证。但是，在这种情况下，强烈建议应用程序显式检查所有输入。

　　13、显示带有HTML标记的字段内容，如果需要渲染HTML标签，可以设置htmlencode属性为true。设置为false时，字段内的HTML标签将按普通字符显示。也可以使用HtmlEncode()方法来渲染字段内容的HTML标签。

　　14、LoginStatus控件可以方便地显示登录状态，并且提供登录和注销的快捷链接。但有时并不方便，特别是注销的同时要退出框架网页时，使用该控件就显得力不从心。可以直接使用LinkButton控件，在点击事件中，添加如下两句，就可以实现注销的同时跳转到框架网页的父窗口：

FormsAuthentication.SignOut();
Response.Write("");

　　15、C#中关闭窗口：

Response.Write("");

如何才能学好C＃

2008-10-21T05:04:00.004-07:00
1.微软支持
　　在你学习VS.NET的过程中，有疑问首先要向MicroSoft求助。如果你不懂得利用MicroSoft提供的庞大的学习资源，我要告诉你，你很不幸，你舍近求远了。
　　（1）首先，你要安装MSDN,他比所有VS.NET书籍详细。我为了装MSDN，可是牺牺了我的98和XP双启动，改成WindowsXP单系统。装了MSDN后，你要学习正则表达式，VS.NET 2003中点击“帮助”，再点击“搜索”，然后输入“正则”，一回车，哇，找到470个主题，这下你慢慢研究吧。实在研究不透，也不用急，还有Google和CSDN呢。　　　
　　（2）在线Microsoft .NET 框架 SDK 快速入门教程（http://chs.gotdotnet.com/QuickStart），可配合MSDN使用。分三块内容， ASP.NET | Windows 窗体 | 如何...?常见任务。 “常见任务快速入门”旨在帮助您快速找到常见编程问题的答案。
　　（3）微软中国社区（http://www.mscommunity.com/Profile/）。在社区注册，有问题就到社区去提问吧。
　（4）在线中文MSDN（http://www.microsoft.com/china/MSDN/default.asp）；在线英文MSDN（http://msdn.microsoft.com/）,考考你的E文，不过有金山词霸在，我都不怕，你还用怕什么呢！
　　（5）.NET主页（http://www.microsoft.com/china/net）
　（6）Visual Studio .NET主页（http://www.microsoft.com/china/msdn/vstudio/prodinfo/overview.asp)。
　　为什么选择VS.NET，为什么看好VS.NET,看看MicroSoft的Help文档有多详尽就知道了。如果你不去利用MicroSoft提供的庞大的Help资源，是不是有点对不起盖茨呢！　　
　　2.CSDN　http://www.csdn.net/
　　CSDN号称最大的开发者网络，确实不假。我最常去的是CSDN的
　　文档（http://www.csdn.net/develop/）
　　论坛（http://expert.csdn.net/expert/forum.asp)
　　只要你善于利用搜索功能，你在开发中遇到的多数问题可在文档和论坛中找到答案。如果你在开发过程中遇到疑难，而你又认为 BillGates帮不上你的忙，那么，你就上CSDN吧，一定会让你满意的。
　　教你两个绝招，第一招，是“搜索大法”。遇到问题，首先是在CSDN的文档和论坛进行搜索，看有无类似答案。如不行，再下一招。
　　第二招，“提问大法”，只要有礼貌有诚意地在论坛提问，一定有许多人乐于回答你的问题。
　　3.其他相关网站
　　有不少网站开辟VS.NET专栏，常去看看，必有收获。
　　pconline跟我学NET专栏（http://www.pconline.com.cn/pcedu/empolder/net/）
　 yesky的Visual Studio.NET专栏（http://www.yesky.com/SoftChannel/72342380467978240/index.shtml）
　 ccidnet的NET专区（http://tech.ccidnet.com/pub/column/c340.html）
　　4.资料下载
　　如果不是包月上网，那么下载大量资源，再断线慢慢研究就很有必要了。
　　91asp提供电子书下载（http://www.91asp.cn/）
　网友提供的大量VS.NET资源下载（ftp://qydn.vicp.net）　
北京希望电子出版社图书素材资料下载(http://www.b-xr.com/bbs.htm)
　
　　清华大学出版社VS.NET源码下载(http://www.wenyuan.com.cn/xiazai.htm)
　　5.国外资源
　　如果你的E文不错，不妨上E文网站去取经。
　　http://www.codestudy.com
　　http://www.codeproject.com
　　http://www.only4gurus.com/v2
　　http://www.gotdotnet.com
　　http://www.aspnetpro.com
　　6.其他特色网站、专栏
　　CSDN上Latitude的VS.NET专栏（http://www.csdn.net/develop/author/netauthor/Latitude/）
　【孟宪会之精彩世界】（http://xml.sz.luohuedu.net/xml/）　
　　DotNet中华网（http://www.aspxcn.com/）
　　 ASP酷（http://www.aspcool.com/）
　　http://www.chinaaspx.com
　　当然，还有一个地球人都知道的，全球最大的知识仓库，我不说，你也早就应该知道的，那不是http://www.google.com又是什么！

　　个人体会：掌握并利用大量网络资源来辅助VS.NET的学习，你将事半功倍。

C#语言基础常见问题汇总

2008-10-21T05:04:00.003-07:00
概述

1、什么是C#?

C#是Microsoft公司设计的一种编程语言。它松散地基于C/C++，并且有很多方面和Java类似。

Microsoft是这样描述C#的：“C#是从C和C++派生来的一种简单、现代、面向对象和类型安全的编程语言。C#(读做‘Csharp’)主要是从C/C++编程语言家族移植过来的，C和C++的程序员会马上熟悉它。C#试图结合Visual Basic的快速开发能力和C++的强大灵活的能力。”

2、如何开发C#应用程序?

.NET SDK包括了C#命令行编译器(csc.exe)，下一个版本的Visual Studio (Visual Studio 7 or Visual Studio.NET)会包含对C#开发的完整支持。

3、C#可以取代Java?

C#非常像Java语言——这两种语言的核心和C++相比都有相似的优缺点。例如，两个语言都有垃圾回收，但是两个语言都没有模板（template）。Microsoft已经中止了Visual J++产品，因此很难不认为Microsoft在使用C#来替代Java。

4、C#可以取代C++?

显然是不，但是我们又很难说C++是新的.NET平台上编写代码的最佳选择。为了使.NET的运行层能完全发挥作用，它要求编程语言遵循某些特定的规则——其中之一就是所有的语言类型必须遵守通用类型系统(Common Type System，CTS）。不幸的是，许多C++特性不能被CTS支持。例如，模板和类的多重继承。

Microsoft对这个问题的答案是给C++提供可管理的扩展（Managed Extensions，ME），这可以使C++遵守CTS。通过添加新的关键字来标记C++类有CTS的属性(例如.-gc表示垃圾回收)。但是在创建新的工程时很难讲为什么ME C++会比C#更合适。就特征（feature）而言它们很相似，但与C++不同的是C#从一开始就以.NET为环境设计的。ME C++存在的理由好像是将C++代码移植（port）为.NET环境下的代码。

因此，这个问题的答案，很可能是C++作为一个.NET环境之外的语言将依然保留它的重要性；而通过ME将现存的C++代码移植为适合.NET环境；但是很可能C#将是C++开发者开发新的.NET应用程序的最好选择。

8、C#是面向对象的吗?

是的，C#像Java和C++一样，是一个面向对象的语言。

9、C#有自己的类库吗?

不，就像所有的.NET语言（VB.Net，JScript .Net...）一样，C#访问.NET类库，C#没有自己的类库。

基本类型

1、C#提供什么标准类型?

C# 支持的基本类型和C++很相似，包括int, long, float, double, char, string, arrays, structs 和 classes。然而，不要假设太多，名字可能很形似，但是一些细节不相同。例如C#中的long是64位的，而C++的long取决于平台，32位的平台上是32位的，64位的平台上是64位的。class和struct在C++中几乎完全一样，但在C#中并不是这样的。

2、是否所有的C#类型都派生于一个公共的基类?

是，也不是，所有的对象都可以看作从Object (System.Object)派生而来。但是为了把像int，float这样的值类型实例看作是从Object对象派生的，这个实例必须通过一个装箱的操作(boxing)转化为引用类型。理论上，开发者可以忽略这些底层的转化，但是认识到这点对于系统性能影响很重要。

3、是否可以这样认为，可以将一个值类型的实例作为参数传给以对象为参数的方法？

是的，例如：

class CApplication {
public static void Main() {
int x = 25;
string s = “fred”;
DisplayMe( x );
DisplayMe( s ); }
static void DisplayMe( object o ) {
System.Console.WriteLine( “You are {0}”， o ); }}

将显示：

You are 25
You are fred

4、值类型和引用类型的最基本的区别是什么？

C#将类型分为两类，一类是值类型，另一类是引用类型。大部分固有的基本类型（如int, char）是值类型，structs 也是值类型。引用类型包括类、接口、数组和字符串。基本的概念非常简单，那就是一个值类型的实例代表了实际的数据（存在栈中），而一个引用类型的实例代表指向数据的指针或者引用（存在堆中）。

C++开发者最容易混淆的地方是：C#已经自己预定义了一些类型作为值类型，一些作为引用类型，而一个C++的开发者希望能够自己控制。

例如，在C++中，我们可以这样做：

int x1 = 3; // x1 是堆栈上的值
int *x2 = new int(3) // x2 是堆的一个值的引用

但是在C#中没有这样的控制：

int x1 = 3; // x1是堆栈上的值
int x2 = new int();
x2 = 3; // x2还是堆栈上的值!

5、既然 int是值类型，而 class是引用类型，那么int是怎样从Object派生的呢？

是这样的，当int用作int时候，这是一个值类型（在栈上），然而，当它用作是Object时，这是一个引用堆上的整数值的引用类型。换而言之，当你将int看作对象时，运行层将它自动转化为对象引用，这个转化过程称作装箱(boxing)。这个转换包括将栈里的值拷贝到了堆里，并且新建了一个对象的实例来引用该值。拆箱操作（unboxing）是个反过程——将对象转化为基于栈的值类型。

int x = 3;
// 堆栈上新的int类型，值为3
object objx = x;
// 堆上新的int, 设定值为3，x=3仍然在堆栈上
int y = (int)objx;
//新的int类型的值3在堆栈上，x=3在堆栈上，objx＝3在堆上

6、C#使用引用替代指针，那么C#的引用和C++的引用一样吗?

不完全，基本的思想是一样的，但是一个重要的区别是C#的引用可以是null。因此你不能确认C#的引用一定会是一个有效的对象。如果试图使用一个值为null的引用，一个NullReferenceException 异常将被抛出。

例如，看一看以下的方法：

void displayStringLength( string s ) {
Console.WriteLine( “String is length {0}”， s.Length ); }

如果这样调用它，这种方法将产生一个NullReferenceException 异常：

string s = null;
displayStringLength( s );

当然有些情况你认为产生这样一个异常是完全可以接受的结果，但是在这个例子里最好按下面的代码改写一下：

void displayStringLength( string s ) {
if( s == null )
Console.WriteLine(“String is null”);
else
Console.WriteLine(“String is length {0}”， s.Length );
}

class和struct

1、struct在C++中是多余的，为什么C#还要使用它们呢?

在C++中，一个结构和一个类几乎就是一个同样的东西。唯一的区别是缺省的成员的访问级别不一样(struct的缺省级别是public，class的缺省级别是private)。然而，在C#中struct和class完全不一样。在C#中，struct 是值类型，而class是引用类型。另外struct不能从其他struct或者class继承，尽管struct可以实现接口。struct没有析构器。

2、C#支持多重继承吗?

C#支持接口的多重继承，但是不支持类的多重继承。

3、C#接口和C++抽象类一样吗?

不，不完全。C++的抽象类不能被实例化。但是它可以(而且经常是)包含执行代码和数据成员。一个C#接口不能包含任何执行代码或数据成员，它只是一组方法名称和签名（signature）。一个C#的接口更像是一个COM接口而不是抽象类。

另一个主要的不同点是：C#类只能从一个类(不管是否抽象)继承，但可以实现多重接口。

4、C#构造器和C++ 构造器是否相同?

非常相似，但是它们绝对不同。第一，C#析构器不保证在某个特定的时间被调用。实际上它根本不保证被调用。真实的情况是，C#析构器只是一个伪装了的Finalize方法。具体点讲，它是一个插入调用基类Finalize方法的Finalize方法。因此，这段代码：

class CTest {
～CTest() {
System.Console.WriteLine(“Bye bye” );
}
}

实际上就是：

class CTest {
protected override void Finalize() {
System.Console.WriteLine(“Bye bye” );
base.Finalize();
}
}

如果你不相信，可以将一个 Finalize方法和一个析构器加入C#类中，然后就可以知道是如何编译的了。

5、什么是静态构造器?

它是整个类的一个构造器，而不是类的一个实例的构造器，它在类装载的时候被调用。

6、C#中所有的方法都是虚方法吗?

不，像C++一样，缺省的时候，方法不是虚拟的，但都可以改为虚拟的。

7、怎样在C#中声明一个纯虚函数？

在方法前使用abstract修饰符，类也可以标记为abstract(这是自然的)。注意，abstract方法不能有执行代码(不同于C++中纯虚方法)。

和C++处理的不同

1. 我“new”了一个对象，但是我怎样删除它？

你不能，不允许你显式地调用析构器，也没有delete操作符。但是不必担心，垃圾回收（garbage collection）会释放你的对象，最终会的(也许会的)。

2. 我试图在栈上建立一个对象，但是C#编译器不通过，这是怎么回事？

和C++不同，你不能在栈上建立一个对象的实例。类的实例总是被建立在堆上并且接受垃圾回收器(garbage collection)的管理。

3. 我定义了一个析构器，但是它从来不能被调用，为什么?

一个C#析构器实际上是Finalize方法的实现，但是运行环境不保证调用Finalize方法。你可以考虑通过调用GC.RequestFinalizeOnShutdown()方法试一下。

4. 大多数的C#基本类型和C++的基本类型有相同的名字，它们一样吗?

不，C#中char和C++中的wchar是相同的。C#中所有的字符包括字符串都是Unicode的，C#中整型值是固定大小的，而在C++中其大小取决于处理器。例如，一个C#的int是32位的，而C++ 中int在32-bit处理器上是32位的，在64-bit处理器上是64位的，一个C#的long是64位的。

C#的四个基本技巧

2008-10-21T05:04:00.001-07:00
1．如果可能尽量使用接口来编程

.NET框架包括类和接口，在编写程序的时候，你可能知道正在用.NET的哪个类。然而，在这种情况下如果你用.NET支持的接口而不是它的类来编程时，代码会变得更加稳定、可用性会更高。请分析下面的代码：

private void LoadList (object [] items, ListBox l)
{
　for (int i = 0; i < items.Length;i++)
l.Items.Add (items[i].ToString ());
}

这个函数从一个可为任何对象的数组中加载ListBox，这段代码被限定为只能使用数组。假想过些时候你发现那些对象存在数据库中，或别的集合中。那么你需要修改程序来使用不同的集合类型。如果你用ICollection接口来写那段程序，你就不用修改那段程序了，对于任何实现ICollection接口的类型它都能很好的工作:

private void LoadList (ICollection items,ListBox l)
{
foreach (object o in items)
l.Items.Add (o.ToString ());
}

ICollection被数组和所有System.Collection中的集合实现。此外，多维数组也支持ICollection接口。如果那还不够的话，数据库.NET类同样支持ICollection接口。用接口写的这个函数不用需改就可以才许多中情况下使用。

2. 使用属性代替原始数据

因为属性已经成为语言本身的元素，所以声明数据元素时它的作用域等级没有必要大于private。因为代码本身会把属性看成数据元素，你并没有失去使用简单数据类型的便利性。相反它会使你的代码更加灵活功能更加强大。属性使你的数据元素封装性更好。属性可以让你使用lazy evaluation来返回数据。lazy evaluation的意思是当用户请求时才计算它的值，而不是一直保留着它。

最后，属性可以是virtual也可以是abstract。你也可以在接口中定义属性。

这里还有维护方面的因素应当注意：尽管操作两者的方法是一样的，但是你把一个数据元素变成属性，那么原先客户端的程序便不能访问服务端的新版本程序了。实际上对于在Web service中你想实现序列化的值你可以把它们变成属性来使用：

private int TheMonth = 0;

[XmlAttribute ("Month")]
public int Month
{
　get {
return TheMonth;
　}
　set {
TheMonth = value;
　}
}

简单通过属性就可以使你的所有数据元素私有化。

3. 在Producer/Consumer 的Idiom中使用Delegate

当你生成一个实现producer idiom类的时候，使用deletate来通知consumer。这种方法相对于用接口更加灵活。Delegate是多点传送的，所以不用加额外的代码你就何以支持多用户。相对于用接口这样做可使类之间的耦合性降低。

下面的类处理键盘输入并把它传给所有的registered listeners：

public class KeyboardProcessor
{
private OnGetLine theFunc = null;

public OnGetLine OnGetLineCallback {
　get {
return theFunc;
　}
　set {
theFunc = value;
　}
}

public void Run (){
// Read input.
// If there is any listeners, publish:
string s;
do {
　s = Console.ReadLine ();
　if (s.Length == 0)
break;
　if (theFunc != null){
System.Delegate [] funcs =theFunc.GetInvocationList();
foreach (OnGetLine f in funcs) {
　try {
f (s);
　} catch (Exception e) {
Console.WriteLine
("Caught Exception: {0}", e.Message);
　}
}
　}
} while (true);
}

任何数目的listeners都可注册到producer，它们所要做的只是提供一个特定的函数：deletate。

4. 注意初始化顺序

C＃中对于一些变量声明加入了initializer的概念。它们在构造函数之前被执行，实际上变量在基类的构造函数执行前之前被初始化。

所以，在初始化变量的时候不要用基类中的数据，因为它们还没有被构造。

提高C#编程水平的50个要诀

2008-10-21T05:03:00.002-07:00
1.总是用属性 (Property) 来代替可访问的数据成员

2.在 readonly 和 const 之间，优先使用 readonly

3.在 as 和强制类型转换之间，优先使用 as 操作符

4.使用条件属性 (Conditional Attributes) 来代替条件编译语句 #if

5.总是为自定义类重载 ToString 方法

6.区别值类型和引用类型

7.使用不可变的值类型(Immutable Atomic Value Types)

8.在值类型中，确保0是一个合法的数据

9.理解 ReferenceEquals, static Equals, instance Equals 和比较运算符(==)之间的关系

10.理解 GetHashCode方法的缺陷

11.在编写循环时，优先使用 foreach.

12.在定义变量的时候就将其初始化

13.使用静态构造函数来初始化静态成员变量

14.用多个构造函数时，利用构造函数链

15.使用using和try/finally来处理资源的释放

16.尽量避免产生资源垃圾

17.尽量避免使用装箱(boxing)和拆箱(unboxing)

18.实现类的 Dispose 方法

19.在接口和继承(Inheritance)之间，优先使用接口(interface)

20.区分接口和重载(overrides)

21.用委托(delegate)来实现回调(callback)

22.用事件(event)来定义外部接口

23.避免返回类内部成员的引用

24.使用元数据来控制程序

25.优先使用可序列化(serilizable)类型

26.对需要排序的对象实现IComparable和IComparer接口

27.避免使用 ICloneable接口

28.避免使用类型转换操作符

29.只有当基类加入了与派生类中现有的函数名称相同的函数时，才需要使用 new 操作符

30.尽量使用 CLS-Compliant

31.尽量编写短少，简单的函数

32.尽量编写比较小的程序集(assembly)

33.限定类型的可见性(visibility)

34.编写大粒度的 web API

35.在使用事件时，优先继承基类事件，而不是重新创建一个事件

36.多使用 framework 的运行时调试 (DEBUG, TRACE, EVENTLOG等)

37.使用.net标准的配置机制

38.使用并且在类中支持.net的数据绑定功能 (Data Binding)

39.使用.net的验证机制 (Validation)

40.根据你的需求选择正确的集合类(Collection)

41.在自定义结构中使用 DataSet

42.利用属性(Attributes)

43.不要过度使用反射(Reflection)

44.创建完整的，应用程序特定的异常

45.尽可能多的考虑程序可能出现的异常，并作出处理

46.尽可能少的使用 Interop

47.尽量使用安全代码 (safe code)

48.多多学习、使用外部工具和资源

49.准备使用 C# 2.0

50.学习 ECMA 标准

C#合并多个结构一样的Excel

2008-10-21T05:03:00.001-07:00
合并代码如下：

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using Excel = Microsoft.Office.Interop.Excel;
namespace ConsoleApplication20
{
//添加引用-COM-MicroSoft Excel 11.0 Object Libery
class Program
{
static void Main(string[] args)
{
//M为表格宽度标志（Excel中的第M列为最后一列），3为表头高度
MergeExcel.DoMerge(new string[]
{
@"E:\excel\类型A\公司A.xls",
@"E:\excel\类型A\公司B.xls"
},
@"E:\excel\类型A\合并测试.xls", "M", 3);
MergeExcel.DoMerge(new string[]
{
@"E:\excel\类型B\统计表A.xls",
@"E:\excel\类型B\统计表B.xls"
},
@"E:\excel\类型B\合并测试.xls", "I", 4);
}

}
public class MergeExcel
{

Excel.Application app = new Microsoft.Office.Interop.Excel.ApplicationClass();
//保存目标的对象
Excel.Workbook bookDest = null;
Excel.Worksheet sheetDest = null;
//读取数据的对象
Excel.Workbook bookSource = null;
Excel.Worksheet sheetSource = null;

string[] _sourceFiles = null;
string _destFile = string.Empty;
string _columnEnd = string.Empty;
int _headerRowCount = 1;
int _currentRowCount = 0;

public MergeExcel(string[] sourceFiles,string destFile,string columnEnd,int headerRowCount)
{

bookDest = (Excel.WorkbookClass)app.Workbooks.Add(Missing.Value);
sheetDest = bookDest.Worksheets.Add(Missing.Value, Missing.Value, Missing.Value, Missing.Value) as Excel.Worksheet;
sheetDest.Name = "Data";

_sourceFiles = sourceFiles;
_destFile = destFile;
_columnEnd = columnEnd;
_headerRowCount = headerRowCount;

}
///

/// 打开工作表
///

///
void OpenBook(string fileName)
{
bookSource = app.Workbooks._Open(fileName, Missing.Value, Missing.Value, Missing.Value, Missing.Value
, Missing.Value, Missing.Value, Missing.Value, Missing.Value
, Missing.Value, Missing.Value, Missing.Value, Missing.Value);
sheetSource = bookSource.Worksheets[1] as Excel.Worksheet;
}
///

/// 关闭工作表
///

void CloseBook()
{
bookSource.Close(false, Missing.Value, Missing.Value);
}
///

/// 复制表头
///

void CopyHeader()
{
Excel.Range range = sheetSource.get_Range("A1", _columnEnd + _headerRowCount.ToString());
range.Copy(sheetDest.get_Range("A1",Missing.Value));
_currentRowCount += _headerRowCount;
}
///

/// 复制数据
///

void CopyData()
{
int sheetRowCount = sheetSource.UsedRange.Rows.Count;
Excel.Range range = sheetSource.get_Range(string.Format("A{0}", _headerRowCount + 1), _columnEnd + sheetRowCount.ToString());
range.Copy(sheetDest.get_Range(string.Format("A{0}", _currentRowCount + 1), Missing.Value));
_currentRowCount += range.Rows.Count;
}
///

/// 保存结果
///

void Save()
{
bookDest.Saved = true;
bookDest.SaveCopyAs(_destFile);
}
///

/// 退出进程
///

void Quit()
{
app.Quit();
}
///

/// 合并
///

void DoMerge()
{
bool b = false;
foreach (string strFile in _sourceFiles)
{
OpenBook(strFile);
if (b == false)
{
CopyHeader();
b = true;
}
CopyData();
CloseBook();
}
Save();
Quit();
}
///

/// 合并表格
///

/// 源文件
/// 目标文件
/// 最后一列标志
/// 表头行数
public static void DoMerge(string[] sourceFiles, string destFile, string columnEnd, int headerRowCount)
{
new MergeExcel(sourceFiles, destFile, columnEnd, headerRowCount).DoMerge();
}
}

}

资料引用:http://www.knowsky.com/440441.html

使用C#创建SQL Server的存储过程

2008-10-21T05:02:00.004-07:00
通常，开发人员使用的是T-SQL来创建SQL Server的存储过程、函数和触发器。而现在的SQL Server 2005已经完全支持.NET通用语言运行时（CLR）了。这就意味着，你可以使用.NET的语言，如C#、VB.NET之类的来开发SQL Server的存储过程、函数和触发器。 SQL Server 和 CLR 的集成给我们带来了n多好处，如实时编译、类型安全、增强的安全性以及增强的编程模型等。本文中，我将向大家演示如何使用C#创建SQL Server的存储过程。

背景
我们在使用SQL Server存储过程时，最常做的工作就是从数据库中读取或保存数据。其常用应用如下：
·执行一些简单的逻辑，没有任何返回值。也没有输出参数。
·执行一些逻辑，并通过一个或更多的输出参数返回结果。
·执行一些逻辑，并返回从表中读取的一条或多条记录。
·执行一些逻辑，并返回一行或多行记录。这些记录不是从表中读取的，而是你自定义的一些数据行。

为了演示如何用C#开发出这几种应用的SQL Server存储过程，我将一个一个地举出示例。

启用CLR集成
在你开始用C#写存储过程之前，必须要启用你的SQL Server的CLR集成特性。默认情况它是不启用的。打开你的SQL Server Management Studio并执行如下脚本。
sp_configure 'clr enabled', 1
GO
RECONFIGURE
GO
这里，我们执行了系统存储过程“sp_configure”，为其提供的两个参数分别为：“clr enabled”和“1”。如果要停用CLR集成的话也是执行这个存储过程，只不过第二个参数要变为“0”而已。另外，为了使新的设置产生效果，不要忘记调用“RECONFIGURE”。

SQL Server项目
现在打开Visual Studio，并从文件菜单中选择“新建项目”。在“新建项目”对话框中选择“Visual C#”下的“Database”。然后选择“SQL Server项目”模板。

起好项目名称后就单击“确定”按钮。

很快，你所创建的项目就要求你选择一个SQL Server数据库。

按照提示一步一步地做就好了，就算你选择了取消，也可以在“项目”–“属性”对话框中再一次选择数据库。举个例子，假如你的电脑上有一个Northwind数据库，那么就在“新建数据库引用”对话框中选中它，然后单击“确定”按钮。之后，SQL Server项目在部署的时候就会将我们开发的存储过程写入这个数据库（继续往后看你就清楚是怎么回事了）。

接下来，右键单击你新建的这个项目，选择“添加”-“存储过程”。然后将会出现如下图所示的对话框：

选择“存储过程”模板，并起一个合适的名字，然后单击“添加”按钮。

添加完后你就会发现，实际上这是创建了一个已经导入了需要用到的命名空间的类。
using System;
using System.Data;
using System.Data.SqlClient;
using System.Data.SqlTypes;
using Microsoft.SqlServer.Server;
注意一下加粗显示的命名空间（译者注：后两个using）。 System.Data.SqlTypes命名空间包含了很多不同的类型，它们可以用来代替SQL Server的数据类型。 Microsoft.SqlServer.Server命名空间下的类负责SQL Server的CLR集成。

没有返回值的存储过程
在这一节中，我们将会看到如何写一个执行了一些逻辑，但是却没有任何返回值和输出参数的存储过程。在这个例子里，我们将创建一个名为“ChangeCompanyName”的存储过程，它用来修改Customers表中CompanyName字段的值。这个存储过程需要两个参数 – CustomerID（需要更改公司名称的客户的ID）和CompanyName（新的公司名称）。 “ChangeCompanyName”存储过程完成后的代码如下：
[SqlProcedure]
public static void ChangeCompanyName
(SqlString CustomerID, SqlString CompanyName)
{
SqlConnection cnn = new SqlConnection
("context connection=true");
cnn.Open();
SqlCommand cmd = new SqlCommand();
cmd.Connection = cnn;
cmd.CommandText = "update customers set
companyname=@p1 where customerid=@p2";
SqlParameter p1 = new SqlParameter("@p1", CompanyName);
SqlParameter p2 = new SqlParameter("@p2", CustomerID);
cmd.Parameters.Add(p1);
cmd.Parameters.Add(p2);
int i=cmd.ExecuteNonQuery();
cnn.Close();
SqlContext.Pipe.Send(i.ToString());
}
仔细看一下这个ChangeCompanyName()方法。它是一个静态方法并且没有返回值（void）。它需要两个名为CustomerID和CompanyName的参数。请注意这两个参数的数据类型都是SqlString。 SqlString可以用来代替SQL Server中的nvarchar数据类型。这个方法用了一个[SqlProcedure]属性来修饰。该属性用于标记ChangeCompanyName()方法是一个SQL Server存储过程。

在方法内我们创建了一个SqlConnection对象，并设置其连接字符串为“context connection = true”。 “上下文连接”可以让你使用当前登录到数据库的用户作为你的登录数据库的验证信息。本例中，ChangeCompanyName()方法将会转换为存储过程，然后保存到Northwind数据库里。所以在这里的“上下文连接”指的就是Northwind数据库。这样你就不需要再写任何关于登录数据库的验证信息了。

接下来是打开数据库连接。然后通过设置SqlCommand对象的Connection和CommandText属性，让其执行更新操作。同时，我们还需要设置两个参数。这样通过调用ExecuteNonQuery()方法就可以执行更新操作了。再接下来就是关闭连接。

最后，将ExecuteNonQuery()方法的返回值发送到客户端。当然你也可以不做这一步。现在我们来了解一下SqlContext类的使用。 SqlContext类用于在服务端和客户端之间传递处理结果。本例使用了Send()方法发送一个字符串返回给调用者。

返回从表中读取的一条或多条记录的存储过程
我们在使用存储过程时，经常会SELECT一条或多条记录。你可以采用两种方法来创建这样的存储过程。

首先我们创建一个名为GetAllCustomers()的方法，代码如下：
[SqlProcedure]
public static void GetAllCustomers()
{
SqlConnection cnn = new SqlConnection
("context connection=true");
cnn.Open();
SqlCommand cmd = new SqlCommand();
cmd.Connection = cnn;
cmd.CommandText = "select * from customers";
SqlDataReader reader = cmd.ExecuteReader();
SqlContext.Pipe.Send(reader);
reader.Close();
cnn.Close();
}
这个GetAllCustomers()方法用了一个[SqlProcedure]属性来修饰。在方法内创建一个SqlConnection和一个SqlCommand对象。然后使用ExecuteReader()方法来执行SELECT语句。接下来用Send()方法将取得的SqlDataReader数据发送到客户端。最后就是关闭SqlDataReader和SqlConnection。在这种方法中，是我们自己创建的SqlDataReader。其实，我们也可以把这个任务交给SqlContext类去完成，代码如下：
[SqlProcedure]
public static void GetCustomerByID
(SqlString CustomerID)
{
SqlConnection cnn = new SqlConnection
("context connection=true");
cnn.Open();
SqlCommand cmd = new SqlCommand();
cmd.Connection = cnn;
cmd.CommandText = "select * from customers
where customerid=@p1";
SqlParameter p1 = new SqlParameter("@p1", CustomerID);
cmd.Parameters.Add(p1);
SqlContext.Pipe.ExecuteAndSend(cmd);
cnn.Close();
}
GetCustomerByID()方法需要一个参数 – CustomerID，它将从Customers表中返回某个customer的记录。这个方法内的代码，除了ExecuteAndSend()方法外，你应该都已经比较熟悉了。 ExecuteAndSend()方法接收一个SqlCommand对象作为参数，执行它就会返回数据集给客户端。

有输出参数的存储过程
我们在使用存储过程时，经常会通过输出参数返回一个经过计算的值。所以，现在让我们来看一看如何创建具有一个或多个输出参数的存储过程。
[SqlProcedure]
public static void GetCompanyName
(SqlString CustomerID,out SqlString CompanyName)
{
SqlConnection cnn = new SqlConnection
("context connection=true");
cnn.Open();
SqlCommand cmd = new SqlCommand();
cmd.Connection = cnn;
cmd.CommandText = "select companyname from
customers where customerid=@p1";
SqlParameter p1 = new SqlParameter
("@p1", CustomerID);
cmd.Parameters.Add(p1);
object obj = cmd.ExecuteScalar();
cnn.Close();
CompanyName = obj.ToString();
}
这是一个名为GetCompanyName()的方法，它需要两个参数。第一个参数是CustomerID，它是一个输入参数；第二个参数是CompanyName，它是一个输出参数（用关键字out来指明）。这两个参数都是SqlString类型的。 GetCompanyName()方法会接收一个CustomerID参数，然后返回CompanyName（作为输出参数）。

该方法内的代码首先设置了SqlConnection和SqlCommand对象。然后，使用ExecuteScalar()方法来执行SELECT语句。 ExecuteScalar()方法返回的值是一个object类型，它其实就是公司名称。最后将输出参数CompanyName设置为这个值。

返回一行或多行自定义数据的存储过程
我们在使用存储过程时，更多的还是从某些表中读取数据。但是，某些情况下我们需要的数据可能不在任何表里。例如，你可能会基于某些计算来生成一个数据表格。因为它的数据不是从表中获得的，所以上面的方法就不在适用了。幸运的是，SQL Server的CLR集成特性给我们提供了一个解决这个问题的方法。请看如下代码：
[SqlProcedure]
public static void GetCustomRow()
{
SqlMetaData[] metadata = new SqlMetaData[2];
metadata[0] = new SqlMetaData
("CustomerID", SqlDbType.NVarChar,50);
metadata[1] = new SqlMetaData
("CompanyName", SqlDbType.NVarChar,50);
SqlDataRecord record = new SqlDataRecord(metadata);
record.SetString(0, "ALFKI");
record.SetString(1, "Alfreds Futterkiste");
SqlContext.Pipe.Send(record);
}
GetCustomRow()方法会返回一条记录并发送给客户端。这个方法首先声明了一个SqlMetaData对象。当你要用到自定义列的时候，就可以使用这个SqlMetaData类。在我们的示例中，创建了两个类型为NVarChar，长度为50的列。然后创建了一个SqlDataRecord对象。 SqlDataRecord类可以用来表示一个自定义行。它的构造函数需要一个SqlMetaData数组作为参数。 SqlDataRecord对象的SetString()方法用来设置列的值。另外，还有许多不同的类似SetString()这样的方法，可以用来处理不同的数据类型。最后，调用Send()方法将SqlDataRecord对象发送到客户端。

在上面的示例中，我们只返回了一行数据给调用者。那么，如果要返回多行呢？请看下面的代码：
[SqlProcedure]
public static void GetMultipleCustomRows()
{
SqlMetaData[] metadata = new SqlMetaData[2];
metadata[0] = new SqlMetaData
("CustomerID", SqlDbType.NVarChar, 50);
metadata[1] = new SqlMetaData
("CompanyName", SqlDbType.NVarChar, 50);
SqlDataRecord record = new SqlDataRecord(metadata);
SqlContext.Pipe.SendResultsStart(record);
record.SetString(0, "ALFKI");
record.SetString(1, "Alfreds Futterkiste");
SqlContext.Pipe.SendResultsRow(record);
record.SetString(0, "ANATR");
record.SetString(1, "Ana Trujillo Emparedados y helados");
SqlContext.Pipe.SendResultsRow(record);
SqlContext.Pipe.SendResultsEnd();
}
GetMultipleCustomRows()方法将会返回多个SqlDataRecord对象到客户端。接下来创建自定义列和设置列的值都和之前的例子一样。但是，我们使用的是SendResutlsStart()方法来传输数据。 SendResultsRow()方法也是发送一个SqlDataRecord对象到客户端，但是我们可以多次调用它，从而做到发送多条记录。最后，调用SendResultsEnd()方法用来标记已经完成数据传输操作。

我们已经开发完了存储过程。现在就可以将这个项目编译为一个程序集（.DLL）。但是我们的工作并没有到此结束。我们还需要部署这个程序集和存储过程到SQL Server数据库。有两种方法可以完成这个工作 – 手动和自动。手动方法是使用T-SQL语句注册你的程序集，并将存储过程部署到SQL Server数据库中。在本例中，我将使用自动的方法来部署存储过程到SQL Server数据库。

右键单击你的项目，然后在菜单中选择“部署”选项。

如此就会自动地完成注册程序集和部署存储过程的工作。注意，只有在你创建项目时添加了数据库引用的时候，才会出现“部署”选项。如果因为某些原因你没能添加数据库引用，那么你可以通过项目属性对话框来设置它。

如果你在SQL Server Management Studio查看Northwind数据库的话，那么就应该可以看到和下图相似的结果。

注意，在存储过程节点下出现了我们创建的所有方法（有“锁”图标的），并且在程序集节点下出现了我们的程序集。

就是这些东西，很简单吧。现在你就可以在你的程序中调用这些存储过程了。你也可以在SQL Server Management Studio中来测试它们。

c#数据库操作的3种典型用法

2008-10-21T05:02:00.003-07:00
由于最近和数据库打交道,需要用C#和SQL Server 2005进行操作,就把近段时间内的最常用的操作做个总结.本人也是第一次用C#操作数据库,所以这三种典型用法对初学者还是挺有帮助的.
以下是我在visual studio 2005上写的一个类(连的是SQL Server 2005),已经过测试通过.里面有3个方法比较典型,在此把源码贴出:
using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;

namespace DatabaseOperate
{
class SqlOperateInfo
{
//Suppose your ServerName is "aa",DatabaseName is "bb",UserName is "cc", Password is "dd"
private string sqlConnectionCommand = "Data Source=aa;Initial Catalog=bb;User ID=cc;Pwd=dd";
//This table contains two columns:KeywordID int not null,KeywordName varchar(100) not null
private string dataTableName = "Basic_Keyword_Test";

private string storedProcedureName = "Sp_InertToBasic_Keyword_Test";
private string sqlSelectCommand = "Select KeywordID, KeywordName From Basic_Keyword_Test";
//sqlUpdateCommand could contain "insert" , "delete" , "update" operate
private string sqlUpdateCommand = "Delete From Basic_Keyword_Test Where KeywordID = 1";

public void UseSqlReader()
{
SqlConnection sqlConnection = new SqlConnection(sqlConnectionCommand);
SqlCommand sqlCommand = new SqlCommand();
sqlCommand.CommandType = System.Data.CommandType.Text;
sqlCommand.Connection = sqlConnection;
sqlCommand.CommandText = sqlSelectCommand;

sqlConnection.Open();
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
while(sqlDataReader.Read())
{
//Get KeywordID and KeywordName , You can do anything you like. Here I just output them.
int keywordid = (int)sqlDataReader[0];
//the same as: int keywordid = (int)sqlDataReader["KeywordID"]
string keywordName = (string)sqlDataReader[1];
//the same as: string keywordName = (int)sqlDataReader["KeywordName"]
Console.WriteLine("KeywordID = " + keywordid + " , KeywordName = " + keywordName);
}

sqlDataReader.Close();
sqlCommand.Dispose();
sqlConnection.Close();
}
public void UseSqlStoredProcedure()
{
SqlConnection sqlConnection = new SqlConnection(sqlConnectionCommand);
SqlCommand sqlCommand = new SqlCommand();
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Connection = sqlConnection;
sqlCommand.CommandText = storedProcedureName;

sqlConnection.Open();
sqlCommand.ExecuteNonQuery();
//you can use reader here,too.as long as you modify the sp and let it like select * from ....

sqlCommand.Dispose();
sqlConnection.Close();
}
public void UseSqlDataSet()
{
SqlConnection sqlConnection = new SqlConnection(sqlConnectionCommand);
SqlCommand sqlCommand = new SqlCommand();
sqlCommand.CommandType = System.Data.CommandType.Text;
sqlCommand.Connection = sqlConnection;
sqlCommand.CommandText = sqlSelectCommand;

sqlConnection.Open();
SqlDataAdapter sqlDataAdapter = new SqlDataAdapter();
sqlDataAdapter.SelectCommand = sqlCommand;
DataSet dataSet = new DataSet();
//sqlCommandBuilder is for update the dataset to database
SqlCommandBuilder sqlCommandBuilder = new SqlCommandBuilder(sqlDataAdapter);
sqlDataAdapter.Fill(dataSet, dataTableName);

//Do something to dataset then you can update it to Database.Here I just add a row
DataRow row = dataSet.Tables[0].NewRow();
row[0] = 10000;
row[1] = "new row";
dataSet.Tables[0].Rows.Add(row);

sqlDataAdapter.Update(dataSet, dataTableName);

sqlCommand.Dispose();
sqlDataAdapter.Dispose();
sqlConnection.Close();
}
}
}

以上的程序概括了最典型的用法,也是最基本的用法.更多的用法我将会陆续给出,大家有什么疑问或建议,欢迎来信(jiangbiao0827@163.com)或留言.关于SQL Server的使用和心得,我也会在近期在DataBase区给出.

利用C#远程存取Access数据库

2008-10-21T05:02:00.001-07:00
目前，基于数据库服务器的桌面管理程序和Web程序已经有太多的应用了，尤其是网络的大量普及，孤立地数据库管理系统无法胜任分布式管理应用，但是面对基于Access数据库的现有的桌面应用我们也无法完全的摒弃。我们利用.Net 远程处理功能将连接和存取Access的行为封装为一个远程对象，供网络中其它客户端通过调用该远程对象来存取实际的Access数据库。我们以 C# 2005 为开发语言来实现上述功能。

　　一、技术要点

　　我们都知道Windows应用程序在运行时会启动一个进程，其总包括若干线程，不同的进程之间通信是开发分布式应用程序所必需的，传统上，这不仅需要深入了解通信流两端上进程的对象，而且还要深入了解低级别协议的宿主、应用程序编程接口以及配置工具等。总之，它是一项需要大量专业知识和经验的复杂任务。

　　幸好.Net为我们提供了远程处理功能，它所提供的通信方法可以快速而方便地完成上述建立通信的任务。因此，无论是需要快速开发 Web 应用程序，还是要花费更多时间生成关键的企业范围的应用程序，.NET Framework 都会提供支持。通过 .NET 远程处理，客户端应用程序可以使用同一台计算机或其网络中其他任何可用的计算机上的其他进程中的对象。

　　要使用 .NET 远程处理创建可以让两个对象跨越应用程序直接通信的应用程序，只需生成以下对象即可：

　　1、可远程处理的对象。

　　2、侦听对该远程对象的请求的应用程序即服务器程序。

　　3、对该远程对象发出请求的客户端应用程序。

　　.Net下不同应用程序中的对象的通信方式有两种：一种是跨应用程序域边界传输对象副本，一种是使用代理交换消息。MarshalByRefObject 是通过使用代理交换消息来进行通信的对象的基类。当跨应用程序使用远程对象时，对象的基类必须是从 MarshalByRefObject 继承。

　　二、程序实现

　　（1）我们先在VS的IDE中创建名为“TestRemoteAccess”的新的解决方案来容纳前述用来实现远程处理的三个项目，首先向解决方案中添加名为“RemoteObject”的类库，然后将默认创建的类名更改为“CRemoteAccess”，并且继承于“MarshalByRefObject”，代码如下：

using System;
using System.Collections.Generic;
using System.Text;
namespace RemoteObject
{
　public class CRemoteAccess : MarshalByRefObject
　{}
}

　　我们需要在该对象内创建用于连接和存取本地Access数据库的所有函数，供服务端客户端程序同时调用。用于连接和存取Access数据库的方法这里不再详述，参看附件源码。

　　首先所有需要向客户端公开的函数其可见性都必须设为 public。变量m_ConnString需要设置为public static，目的是当客户端调用了SetRemoteAccessConnString后将数据库连接字符串保存下来以备在本次连接期间始终能够访问，代码如下：

……
public static string m_ConnString;
……
public void SetRemoteAccessConnString(string Connstr)
{
　m_ConnString = Connstr;
}
……

　　成功连接了Access数据库后我们需要返回数据集给请求的客户端进行显示和编辑，在远程对象中我们声明了几个相关函数：

private void LoadData(string SqlStr, string TableName)
public void SaveData(DataTable ClientDataTable)
public DataTable GetUserTable(string SqlStr, string TableName)

　　客户端可以传递SQL查询脚本通过调用 GetUserTable来获取相关数据库表的数据，并返回一个DataTable，然后可以将该DataTable附值给DataGridView以便将数据显示出来。GetUserTable通过调用私有的LoadData 函数来完成对数据的获取。SaveData函数用于将编辑过的数据集保存回本地Access数据库文件，代码如下：

……
m_connection.Open();
m_adapter.Update(ClientDataTable);
……
　　（2）远程对象创建完成，我们需要创建用于侦听该远程对象请求的服务端应用程序。在“TestRemoteAccess”解决方案中新建一个Windows窗体项目名为：“TestServer”，从工具箱中拖拽下几个组件，界面如下所示：

　　服务器程序TestServer除了具备远程访问对象的能力外，它最主要的作用就是获取实际的Access数据库文件路径，并且设置远程对象的数据库连接字符串。我们必须添加远程对象以及远程处理和网络通讯协议等的类库的引用。在服务器程序启动初始，需要创建远程对象的实例以及注册通信端口，然后调用RemotingConfiguration.RegisterWellKnownServiceType 方法，MSDN中关于该方法的描述是这样的：通过使用给定的参数初始化 WellKnownServiceTypeEntry 的新实例，将服务端上的对象 Type 注册为已知类型，所有知道已注册已知对象的 URI 的客户都可以获取该对象的代理。所谓URI即统一资源标识符 (Uniform Resource Identifier)。代码如下：

……
remotableObject = new RemoteObject.CRemoteAccess();
TcpChannel channel = new TcpChannel(8080);
ChannelServices.RegisterChannel(channel);
RemotingConfiguration.RegisterWellKnownServiceType(typeof(RemoteObject.CRemoteAccess), "RithiaTestAccessServer", WellKnownObjectMode.Singleton);
……

　　当选择了要进行存取的Access数据库文件后，我们需要调用远程对象的SetRemoteAccessConnString方法，该方法将保存在本次与服务器程序连接期间连接该Access数据库文件的连接字符串，代码如下：

……
ProviderStr = ProviderStrPart + txtAccessMdbFileName.Text + ";Jet OLEDB:Database Password=" + txtAccessPassword.Text;
……
remotableObject.SetRemoteAccessConnString(ProviderStr);
……

　　（3）最后我们创建用于连接和请求服务的客户端程序，它会通过调用服务器程序TestServer已经注册的远程对象来获取相关数据集，并将编辑过的数据保存回实际的数据库文件。在“TestRemoteAccess”解决方案中新建一个Windows窗体项目名为：“TestClient”，从工具箱中拖拽下几个组件，界面如下所示：

　　客户端程序需要知道服务器程序所运行在的计算机名称或IP地址以及侦听的端口号，然后创建远程对象的实例，并且创建DataTable以便接收返回的数据，代码如下：

……
string RemoteURL;
Host = txtHost.Text;
Port = txtPort.Text;
RemoteURL = "tcp://" + Host + ":" + Port + "/RithiaTestAccessServer";
try
{
　TcpChannel chan = new TcpChannel();
　ChannelServices.RegisterChannel(chan);
　remoteObject = (RemoteObject.CRemoteAccess)Activator.GetObject(typeof(RemoteObject.CRemoteAccess), RemoteURL);
　RemoteDataTable = new DataTable();
　button3.Enabled = false;
}
catch (Exception E)
{
　MessageBox.Show(E.Message.ToString());
}
finally
{
}
……

　　客户端程序根据服务程序所侦听的信道是TCP还是HTTP来注册相应的信道和端口号，并且组合成远程对象的Url，即Url= 信道://主机名:端口号/对象的Uri，然后创建远程对象的实例，就像使用本地对象一样可以对其进行存取，我们可以调用远程对象的GetUserTable方法获取指定查询脚本的结果集，代码如下：

……
RemoteDataTable = remoteObject.GetUserTable(txtSQL.Text, "Test");
dataGridView1.DataSource = RemoteDataTable;
……

　　保存结果集时仅需简单调用SaveData方法即可，代码如下：

……
remoteObject.SaveData(RemoteDataTable);
……

　　三、结果

　　该程序成功地在Visual Studio .Net 2005及Windows XP SP2下调试运行通过。

c#一种简单快速改变窗体风格和肤色的方法源码及其控件

2008-10-21T05:01:00.004-07:00
原文地址：http://bbs.bccn.net/thread-73964-1-1.html

学生成绩管理系统源码下载地址

NetBeans5.5编写
Struts1.2.8 + Hibernate3.1 + MYSQL5.0

数据库结构为：
DROP DATABASE IF EXISTS ENOVA;
CREATE DATABASE ENOVA;
USE ENOVA;

CREATE TABLE STUDENT (
ID int(11) NOT NULL auto_increment,
NUMBER char(15) NOT NULL UNIQUE,
NAME varchar(4) NOT NULL ,
SEX varchar(1) default NULL,
NATION varchar(10) default NULL,
ENROLL_YEAR YEAR(4) NOT NULL ,
BIRTHDAY date default NULL,
BIRTH_PLACE varchar(50) default NULL,
PASSWORD char(15) NOT NULL ,
CLASS_ID int(11) NOT NULL ,
PRIMARY KEY (ID))ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE TEACHER(
ID int(11) NOT NULL auto_increment,
NAME varchar(4) default NULL ,
SEX varchar(1) default NULL,
USERNAME char(15) NOT NULL UNIQUE ,
PASSWORD char(15) NOT NULL ,
PRIMARY KEY (ID))ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE DEPARTMENT(
ID int(11) NOT NULL auto_increment,
NAME varchar(20) NOT NULL,
PRIMARY KEY (ID))ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE SPECIAL(
ID int(11) NOT NULL auto_increment,
NAME varchar(20) NOT NULL,
DEPARTMENT_ID int(11) NOT NULL ,
PRIMARY KEY (ID))ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE CLASS(
ID int(11) NOT NULL auto_increment,
NAME varchar(20) NOT NULL,
TEACHER_ID int(11) NOT NULL ,
SPECIAL_ID int(11) NOT NULL ,
YEAR year(4) NOT NULL ,
PRIMARY KEY (ID))ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE COURSE(
ID int(11) NOT NULL auto_increment,
NAME varchar(20) NOT NULL,
TEACHER_ID int(11) NOT NULL ,
HOUR int(4) default NULL,
CREDIT float(2,1) NOT NULL ,
YEAR year(4) default NULL,
TERM varchar(1) default NULL,
EXAM_MODE varchar(2) default NULL,
EXAM_TYPE varchar(2) default NULL,
TYPE varchar(2) default NULL,
PRIMARY KEY (ID))ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE SCORE(
COURSE_ID int(11) NOT NULL ,
STUDENT_ID int(11) NOT NULL ,
VALUE int(4) default NULL ,
DATE date NOT NULL ,
PRIMARY KEY (STUDENT_ID,COURSE_ID))ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE ROOT(
ID int(11) NOT NULL auto_increment,
USERNAME char(15) NOT NULL UNIQUE ,
PASSWORD char(15) NOT NULL ,
PRIMARY KEY (ID))ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE CLASS_COURSE(
CLASS_ID int(11) NOT NULL ,
COURSE_ID int(11) NOT NULL ,
PRIMARY KEY (CLASS_ID,COURSE_ID))ENGINE=InnoDB DEFAULT CHARSET=utf8;

alter table STUDENT add constraint FK_STUDENT_CLASS
foreign key(CLASS_ID) references CLASS(ID) on delete cascade;

alter table SPECIAL add constraint FK_SPECIAL_DEPARTMENT
foreign key(DEPARTMENT_ID) references DEPARTMENT(ID) on delete cascade;

alter table CLASS add constraint FK_CLASS_TEACHER
foreign key(TEACHER_ID) references TEACHER(ID) on delete cascade;

alter table CLASS add constraint FK_CLASS_SPECIAL
foreign key(SPECIAL_ID) references SPECIAL(ID) on delete cascade;

alter table SCORE add constraint FK_SCORE_COURSE
foreign key(COURSE_ID) references COURSE(ID) on delete cascade;

alter table SCORE add constraint FK_SCORE_SUTDENT
foreign key(STUDENT_ID) references STUDENT(ID) on delete cascade;

alter table CLASS_COURSE add constraint FK_CC_CLASS
foreign key(CLASS_ID) references CLASS(ID) on delete cascade;

alter table CLASS_COURSE add constraint FK_CC_COURSE
foreign key(COURSE_ID) references COURSE(ID) on delete cascade;

alter table COURSE add constraint FK_COURSE_TEACHER
foreign key(TEACHER_ID) references TEACHER(ID) on delete cascade;

insert into ROOT(USERNAME,PASSWORD) values('vlinux','lovefs');

create trigger CLASS_COURSE_DELETE BEFORE DELETE ON CLASS_COURSE
FOR EACH ROW DELETE FROM SCORE WHERE COURSE_ID=old.COURSE_ID
and STUDENT_ID in (SELECT ID FROM STUDENT WHERE CLASS_ID=old.CLASS_ID);

grant all on ENOVA.* to enova@localhost identified by "enova" with grant option;

数据结构文件可以从/enova/src/enova/ENOVA_DB.SQL中找到

管理员初始帐号／密码为：vlinux/lovefs

PS：管理员的学生成绩管理模块还没时间做，如果那个人有能力的就帮忙做了吧，不过估计在这个注释缺乏的程序中想快速理解好像有点难度。考试完我会适当加上注释的。毕竟我目前的目标就是为BCCN写一个自己的论坛。
大家可以把这个程序当成一本书，有什么对Struts、Hibernate不理解的地方可以参考一下。呵呵，一起努力吧。

用 C# 编程实现读写Binary

2008-10-21T05:01:00.003-07:00
本文给出一个用 C# 编程实现读写 Binary 的实例代码，对于初学者来说是个不可多得的参考性文章……

以下是引用片段：
　　//返回blob数据
　　public MemoryStream getBlob(string SQL)
　　...{
　　try
　　...{
　　Db_Conn();
　　cmd = new OleDbCommand(SQL, Conn);
　　cmd.CommandType = CommandType.Text;//是sql
　　OleDbDataReader Rs = cmd.ExecuteReader();
　　if (Rs.Read()) //循环到下一条记录
　　...{
　　if (!(Rs.GetValue(0) is System.DBNull))
　　...{
　　byte[] image_bytes = (byte[])Rs.GetValue(0);
　　MemoryStream ms = new MemoryStream(image_bytes);
　　return ms;
　　}
　　else
　　return null;
　　}
　　else
　　return null;
　　}
　　finally
　　...{
　　this.close();
　　}
　　}
　　//设置blob
　　public bool SetBlob(string SQL, MemoryStream Ms)
　　...{
　　try
　　...{
　　Db_Conn();
　　cmd = new OleDbCommand(SQL, Conn);
　　cmd.CommandType = CommandType.Text;//是sql
　　int n=Convert.ToInt32(Ms.Length.ToString());
　　Ms.Position = 0;
　　byte[] pReadByte = new Byte[n];
　　Ms.Read(pReadByte, 0, n);
　　cmd.Parameters.Add("BLOB", OleDbType.Binary).Value = pReadByte;
　　cmd.ExecuteNonQuery();
　　return true;
　　}
　　catch (Exception ex)
　　...{
　　MessageBox.Show("错误:因" + ex.Message + ",无法执行:" + SQL);
　　return false;
　　}
　　finally
　　...{
　　this.close();
　　}
　　}

　　调用 getBlob

以下是引用片段：
　　String sqlStr = "select content from dp where id=" + ID;//content为dp中的BLOB字段,ID为主键
　　MemoryStream ms = DBClass.getBlob(sqlStr);
　　if (ms == null)
　　richTextBox.Clear();
　　else
　　...{
　　if (ms.Length > 0)
　　...{
　　ms.Position = 0;
　　try
　　...{
　　richTextBox.LoadFile(ms, RichTextBoxStreamType.RichText);
　　}catch...{
　　richTextBox.LoadFile(ms, RichTextBoxStreamType.PlainText);
　　}
　　}else
　　richTextBox.Clear();
　　}

　　调用setBlob

以下是引用片段：
　　String sqlStr = "update dp set content=:BLOB where id=" + ID;
　　MemoryStream ms = new MemoryStream();
　　richTextBox.SaveFile(ms, RichTextBoxStreamType.RichText);
　　if (!DBClass.SetBlob(sqlStr, ms))
　　...{
　　MessageBox.Show("保存失败");
　　}

C#操作ACCESS数据库（创建,压缩,备份,恢复）

2008-10-21T05:01:00.001-07:00
用C#压缩和修复Access数据库(这部分是劳动人民翻译的)
介绍
下面这段C# 代码可以用来压缩和修复Access数据库,不管它是一个简单的".mdb"ACCESS数据库还是一个".mdw"网络共享数据库,这个过程和你在用MS Access应用程序中使用的"工具-数据库实用工具-压缩和修复"时执行的操作完全一样.实例代码使用了"迟绑定"(运行中在内存中建立COM对象),这样就不需要在工程中加入COM引用了,也不需要在PC上安装MS Access应用程序.只需要一个Jet引擎(Jet引擎包含在MDAC安装包中,在Windows NT4以后的版本中,系统已经自带了这个引擎).

C#操作ACCESS数据库的背景
不知你是否也厌烦了在工程中加入复杂的COM库引用,但我相信这个纯.NET代码将省去额外的交互操作, RCWs和COM引用.基本上,由于系统中安装的Microsoft类库的不同(例如:MS Office Object Library 9,10,11等等),我们也不知道用户PC中安装的Office版本,所以我们要通过ProgID来访问COM对象,而不能用CLSID.例如,当调用"Excel.Application",时,得到的是Excel,而不管系统中安装MS Office的版本,当在代码中加入"MS Excel 10 Object library"引用时,其实只是给应用程序加入了一个非常受限制的功能.所以我们使用System.Reflection和迟绑定.
1. 实例代码
只需调用CompactAccessDB函数即可压缩和修复目标数据库.

2. 参数:
connectionString – 用来连接到Access数据库.
Mdwfilename –要压缩的MDB文件的全名(路径+文件名).
由于Jet引擎的限制,执行此方法压缩Access数据库会把结果生成为一个新文件,所以我们要还需要把这个新的Access文件拷贝到目的位置覆盖原来未压缩文件.

当调用此方法时请确认被压缩数据库无打开的连接.

C#操作ACCESS数据库代码如下:

/// MBD compact method © 2004 Alexander Youmashev
/// !!IMPORTANT!!
/// !make sure there's no open connections
/// to your db before calling this method!
/// !!IMPORTANT!!
///
///
connection string to your db
///
FULL name
/// of an MDB file you want to compress.
Public static void CompactAccessDB(string connectionString, string mdwfilename)
{
object[] oParams;

//create an inctance of a Jet Replication Object
object objJRO =
Activator.CreateInstance(Type.GetTypeFromProgID(\"JRO.JetEngine\"));

//filling Parameters array
//cnahge \"Jet OLEDB:Engine Type=5\" to an appropriate value
// or leave it as is if you db is JET4X format (access 2000,2002)
//(yes, jetengine5 is for JET4X, no misprint here)

oParams = new object[] {
connectionString,
\"Provider=Microsoft.Jet.OLEDB.4.0;Data\" +
\" Source=C:tempdb.mdb;Jet OLEDB:Engine Type=5\"};

//invoke a CompactDatabase method of a JRO object
//pass Parameters array

objJRO.GetType().InvokeMember(\"CompactDatabase\",
System.Reflection.BindingFlags.InvokeMethod,
null,
objJRO,
oParams);

//database is compacted now
//to a new file C:tempdb.mdw
//let's copy it over an old one and delete it

System.IO.File.Delete(mdwfilename);
System.IO.File.Move(\"C:tempdb.mdb\", mdwfilename);
//clean up (just in case)
System.Runtime.InteropServices.Marshal.ReleaseComObject(objJRO);
objJRO=null;
}

教你一种更绝的：如何在没有Microsoft Access用.NET操作ACCESS数据库？(创建,压缩,备份,恢复组件) （这部分可不是翻译的）

手头没有Microsoft Access，C#如何操作ACCESS数据库？
写一个小型程序,手头没有Microsoft Access,如何建立数据库,一切依然简单.
首先引用C:Program FilesCommon FilesSystemadomsadox.dll,该DLL包含ADOX命名空间;
接着引用C:Program FilesCommon FilesSystemadomsjro.dll,该DLL包含JRO命名空间
注意:如，导入dll不成功，手动把com组件导入为 .net组件，在用vs.net工具导入

using System;
using System.IO;
using ADOX; //该命名空间包含创建ACCESS的类(方法)--解决方案 ==> 引用 ==> 添加引用 ==> 游览找到.dll
using JRO; //该命名空间包含压缩ACCESS的类(方法)

public class Access
{
///根据指定的文件名称创建ACCESS数据库
///mdbPath:要创件的ACCESS绝对路径
public void Create( string mdbPath )
{
if( File.Exists(mdbPath) ) //检查数据库是否已存在
{
throw new Exception(\"目标数据库已存在,无法创建\");
}
// 可以加上密码,这样创建后的数据库必须输入密码后才能打开
mdbPath = \"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=\" + mdbPath;
// 创建一个CatalogClass对象的实例,
ADOX.CatalogClass cat = new ADOX.CatalogClass();
// 使用CatalogClass对象的Create方法创建ACCESS数据库
cat.Create(mdbPath);
}

///压缩修复ACCESS数据库,mdbPath为数据库绝对路径
public void Compact( string mdbPath )
{
if( !File.Exists(mdbPath) ) //检查数据库是否已存在
{
throw new Exception(\"目标数据库不存在,无法压缩\");
}
//声明临时数据库的名称
string temp = DateTime.Now.Year.ToString();
temp += DateTime.Now.Month.ToString();
temp += DateTime.Now.Day.ToString();
temp += DateTime.Now.Hour.ToString();
temp += DateTime.Now.Minute.ToString();
temp += DateTime.Now.Second.ToString() + \".bak\";
temp = mdbPath.Substring(0, mdbPath.LastIndexOf(\"\")+1) + temp;
//定义临时数据库的连接字符串
temp2 = \"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=\" + temp;
//定义目标数据库的连接字符串
mdbPath2 = \"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=\" + mdbPath;
//创建一个JetEngineClass对象的实例
JRO.JetEngineClass jt = new JRO.JetEngineClass();
//使用JetEngineClass对象的CompactDatabase方法压缩修复数据库
jt.CompactDatabase( mdbPath2, temp2 );
//拷贝临时数据库到目标数据库(覆盖)
File.Copy( temp, mdbPath, true );
//最后删除临时数据库
File.Delete( temp );
}

/// 备份数据库,mdb1,源数据库绝对路径; mdb2: 目标数据库绝对路径
public void Backup( string mdb1, string mdb2 )
{
if( !File.Exists(mdb1) )
{
throw new Exception(\"源数据库不存在\");
}
try
{
File.Copy( mdb1, mdb2, true );
}
catch( IOException ixp )
{
throw new Exception(ixp.ToString());
}
}

///恢复数据库,mdb1为备份数据库绝对路径,mdb2为当前数据库绝对路径
public void Recover( string mdb1, string mdb2 )
{
if( !File.Exists(mdb1) )
{
throw new Exception(\"备份数据库不存在\");
}
try
{
File.Copy( mdb1, mdb2, true );
}
catch( IOException ixp )
{
throw new Exception(ixp.ToString());
}
}
}

C#接口的作用

2008-10-21T05:00:00.004-07:00
1、C#接口的作用：

C#接口是一个让很多初学C#者容易迷糊的东西，用起来好像很简单，定义接口，里面包含方法，但没有方法具体实现的代码，然后在继承该接口的类里面要实现接口的所有方法的代码，但没有真正认识到接口的作用的时候就觉得用接口是多此一举，当然你这样想那是绝对绝对错误的，比尔盖茨的微软请的员工都是比盖茨还聪明的人，他们的C#能添这样的多足吗？！关于接口的作用，网上有一位就真的深入浅出给我们做了很好理解的分析。我们定义一个接口
public interface IBark
{
void Bark();
}
再定义一个类,继承于IBark,并且必需实现其中的Bark()方法
public class Dog:IBark
{
public Dog()
{}
public void Bark()
{
Consol.write("汪汪");
}
}
然后,声明Dog的一个实例,并调用Bark()方法
Dog 旺财=new Dog();
旺财.Bark();
试想一样,若是想调用Bark()方法,只需要在Dog()中声明这样的一个方法不就行了吗,干什么还要用接口呢.因为接口中并没有Bark()具体实现.真的实现还是要在Dog()中.那么使用接口不是多此一举吗?
还有人是这样说的:从接口的定义方面来说,接口其实就是类和类之间的一种协定,一种约束.还拿上面的例子来说.所有继承了IBark接口的类中必需实现Bark()方法.那么从用户(使用类的用户)的角度来说,如果他知道了某个类是继承于IBark接口,那么他就可以放心大胆的调用Bark()方法,而不用管Bark()方法具体是如何实现的.比如,我们另外写了一个类.
public class Cat:IBark
{
public Cat()
{}
public void Bark()
{
Consol.write("喵喵");
}
}
当用户用到Cat类或是Dog类的时候,知道他们继承于IBark,那么不用管类里的具体实现,而就可以直接调用Bark()方法,因为这两个类中肯定有关于Bark()方法的具体实现.

如果我们从设计的角度来看.一个项目中用若干个类需要去编写,由于这些类比较复杂,工作量比较大,这样每个类就需要占用一个工作人员进行编写.比如A程序员去定Dog类,B程序员去写Cat类.这两个类本来没什么联系的,可是由于用户需要他们都实现一个关于"叫"的方法.这就要对他们进行一种约束.让他们都继承于IBark接口,目的是方便统一管理.另一个是方便调用.当然了,不使用接口一样可以达到目的.只不过这样的话,这种约束就不那么明显,如果这样类还有Duck类等等,比较多的时候难免有人会漏掉这样方法.所以说还是通过接口更可靠一些,约束力更强一些.

2、C#中接口的深入浅出:
通过学习对C#中接口的作用有了更进一步的理解，拿出来跟大家分享一下，有说的不对的地方请大家指教。
我在上一篇帖子（http://www.programfan.com/club/showbbs.asp?id=150228）中只是简单的谈了一下接口的作用，有兴趣的朋友可以去看一下。
言归正传：
假设我们公司有两种程序员：VB程序员，指的是用VB写程序的程序员，用clsVBProgramer这个类表示；Delphi程序员指的是用Delphi写程序的程序员，用clsDelphiProgramer这个类来表示。每个类都有一个WriteCode()方法。定义如下：
class clsVBProgramer()
{
....
WriteCode()
{
//用VB语言写代码；
}
....
}

class clsDelphiProgramer()
{
....
WriteCode()
{
//用Delphi语言写代码；
}
....
}

现在公司来了一个项目，要求派某个程序员写一个程序。
class clsProject()
{
....
WritePrograme(clsVBProgramer programer)//用VB写代码
{
programer.WriteCode();
}
WritePrograme(clsDelphiProgramer programer)//重载方法，用Delphi写代码
{
programer.WriteCode();
}
......
}
在主程序中我们可以这样写：
main()
{
clsProject proj=new clsProject;
//如果需要用VB写代码
clsVBProgramer programer1=new clsVBProgramer;
proj.WritePrograme(programer1);
//如果需要用Delphi写代码
clsDelphiProgramer programer2=new clsDelphiProgramer;
proj.WritePrograme(programer2);
}

但是如果这时公司又来了一个C#程序员，我们怎么改这段程序，使它能够实现用C#写程序的功能呢？我们需要增加一个新类clsCSharpProgramer,同时在此clsProject这个类中要再次重载WritePrograme（clsCSharpProgramer programer）方法。这下麻烦多了。如果还有C程序员，C++程序员，JAVA程序员呢。麻烦大了！

但是如果改用接口，就完全不一样了：
首先声明一个程序员接口：
interface IProgramer()
{
WriteCode();
}
然后声明两个类，并实现IProgramer接口：
class clsVBProgramer():IProgramer
{
....
WriteCode()
{
//用VB语言写代码；
}
....
}

class clsDelphiProgramer():IProgramer
{
....
WriteCode()
{
//用Delphi语言写代码；
}
....
}
对clsProject这个类进行一下修改：
class clsProject()
{
....
WritePrograme(IProgramer programer)
{
programer.WriteCode();//写代码
}
......
}

main()
{
clsProject proj=new clsProject;
IProgramer programer;
//如果需要用VB写代码
programer=new clsVBProgramer;
proj.WritePrograme(programer);
//如果需要用Delphi写代码
programer=new clsDelphiProgramer;
proj.WritePrograme(programer);
}
如果再有C#，C，C++，JAVA这样的程序员添加进来的话，我们只需把它们相关的类加进来，然后在main()中稍做修改就OK了。扩充性特别好！

另外我们如果把clsProject这个类封成一个组件，那么当我们的用户需要要扩充功能的时候，我们只需要在外部做很小的修改就能实现，可以说根本就用不着改动我们已经封好组件！是不是很方便，很强大！

运用C#完成分布式数据库查询

2008-10-21T05:00:00.003-07:00
随着传统的数据库、计算机网络和数字通信技术的飞速发展，以数据分布存储和分布处理为主要特征的分布式数据库系统的研究和开发越来越受到人们的关注。但由于其开发较为复杂，在一定程度上制约了它的发展。基于此，本文提出了在.Net环境下使用一种新的开发语言C#结合ADO.Net数据访问模型来开发分布式数据库系统，大大简化了开发过程。

　　1 分布式数据库系统

　　就其本质而言，分布式数据库系统的数据在逻辑上是统一的，而在物理上却是分散的。与集中式数据库相比它有如下主要优点：

　　· 解决组织机构分散而数据需要相互联系的问题。

　　· 均衡负载。负载在各处理机间分担，可避免临界瓶颈。

　　· 可靠性高。数据分布在不同场地，且存有多个副本，即使个别场地发生故障，不致引起整个系统的瘫痪。

　　· 可扩充性好。当需要增加新的相对自主的组织单位时，可在对当前机构影响最小的情况下进行扩充。

　　分布式数据库系统虽然有诸多优点，但它同时也带来了许多新问题。如：数据一致性问题、数据远程传递的实现、通信开销的降低等，这使得分布式数据库系统的开发变得较为复杂。幸运的是，微软的.Net开发环境为我们提供了C#开发语言和ADO.Net数据访问模型，结合两者来开发分布式数据库系统能够大大简化开发工作。

　　2 远程处理框架和ADO.Net

　　开发分布式数据库系统需要解决的两个重要问题是：各场地间的数据通信以及对数据库的操作及管理。使用C#结合ADO.Net能够高效、可靠地解决这两方面的问题。具体表现为，在C#中通过使用.Net远程处理框架能够方便地解决数据、命令远程传递问题；C#通过ADO.Net对数据库进行操作，使分布式数据库系统中对数据库的各种操作变得高效、可靠，同时易于解决数据一致性问题。

　　2.1 .Net远程处理框架

　　实现数据和命令的远程传递有三种方式。第一种是使用报文或消息的方式，把要传送的数据转化为流格式，再通过套接字编程用报文的形式发送到远程主机。此种方法麻烦，不易实现。第二种是使用Web Service，即各远程主机提供一个数据库查询服务的Web Service。这种方式只能对单个场地进行查询，无法实现多场地的联合查询。第三种是使用.Net远程处理框架（.Net Remoting Framework）技术，它将远程调用的技术细节隐藏起来，服务程序只需通过简单的设置就可以把本地对象变成为远程提供服务的远程对象，客户端可以像访问本地对象一样透明地访问远程对象，所有的消息、报文等都交给.Net Remoting对象处理，大大简化了开发。远程处理的一般过程如图1所示：

图1 远程处理过程

　　首先，服务器端创建一个服务器类的实例，远程处理系统创建一个表示该类的代理对象，并向客户端对象返回一个对该代理的引用。当客户端调用方法时，远程处理基础结构连接检查类型信息，并通过信道将该调用发送到服务器进程。侦听信道获得该请求并将其转发给服务器远程处理系统，服务器远程处理系统查找（或在必要时创建）并调用被请求的对象。然后，此过程将反向进行，服务器远程处理系统将响应捆绑成消息并由服务器信道发送到客户端信道。最后，客户端远程处理系统通过代理将调用的结果返回给客户端对象。

　　2.2 ADO.Net

　　ADO.Net以XML为核心，是.Net数据库应用程序的解决方案。它使用离线数据结构，数据源中的数据被缓存到数据集（DataSet）对象中，用户无须锁定数据源，数据以XML格式保存。

　　2.2.1 ADO.Net管理数据一致性

　　在分布式数据库系统中，很可能出现多个用户同时访问和修改数据的情况，因此，对于分布式数据库系统，数据一致性是不可或缺的。ADO.Net通过使用乐观一致性方案来控制数据一致性（实际上DataSet对象被设计成支持使用乐观一致性控制机制），即数据行只有在数据库中真正被更新时才会被锁定，而在悲观一致性方案中，数据行在从被提取出来到在数据库中更新这段时间内一直被锁定。因此，使用ADO.Net能够在更少的时间内响应数量巨大的用户。

　　另外，在分布式数据库系统中，还会经常遇到当用户修改自从提取出来以来已经被修改的行时，违反一致性原则。对此问题ADO.Net也作了很好地解决，即使用DataSet对象为每一条修改过的记录维护两个版本：原始版本和更新版本，在更新的记录被写回数据库之前，先要把数据集中记录的原始版本与数据库中的当前版本进行比较，如果两个版本匹配，就在数据库中更新记录；否则，就会出现违反一致性原则的错误。

　　3 实例开发

　　一个家用电器连锁店设有一个总部和许多分店，总部和分店以及各分店之间经常需要进行各种信息的查询（如：商品当日价目表、各店销售状况和库存信息等），对此组织机构建立分布式数据库查询系统，可实现总部和各店信息的共享，便于统一管理。

　　3.1 系统设计

　　3.1.1系统结构图

　　系统结构如图2所示：

图2 系统结构图

　　总部和各分店都配置了一台具有固定IP的服务器，其它电脑通过集线器与服务器相连，总部和各分店的服务器通过通信网络联接起来。

　　3.1.2 系统实现步骤

　　系统实现分为三个主要步骤。首先，为总部和各分店设计数据库。由于数据量较大，故采用SQL Server为每个分店创建销售和库存数据库，同时为总部创建员工数据库、整个连锁店的存货数据库、信用卡客户数据库以及供应商信息数据库等。其次，需要建立一个提供数据库服务（DbServer）的动态链接库（dll），将查询时所要用到的一些服务（如：远程对象的发布和获取等）和函数（如：本地异地数据表的查询、数据表的远程创建和删除、表间的连接和合并等）置入该dll中，各分店都需要使用这个dll，以便查询时对一些服务和函数进行调用。最后，根据实际需要开发客户端查询界面。

　　3.2系统实现的关键技术

　　3.2.1 远程对象的发布与获取

　　系统运行后所要做的第一个工作是发布本地的远程对象并获取其它各店所发布的远程对象。发布远程对象时，首先要设置一个网络端口号，然后创建并注册一个通道，最后发布该服务器端的激活对象。其它场地的服务器根据IP地址和网络端口号即可方便地获取所发布的远程对象。实现远程对象发布和获取的关键代码如下：

　　远程对象的发布：

//创建一个通道实例,port为指定的网络端口号
TcpChannel MyChannel= new TcpChannel (Int32.Parse(port));
//注册通道
ChannelServices.RegisterChannel(MyChannel);
//发布该服务器端激活对象
RemotingConfiguration.RegisterWellKnownServiceType( typeof ( DbServer ), "STORE", WellKnownObjectMode.Singleton);
远程对象的获取：
//根据IP地址和端口号获取相应的远程对象
try
{myDbServer=(DbServer)Activator.GetObject(typeof(DbServer),"tcp://"+ip+":"+p+"/STORE"); }
//捕捉异常
catch( NullReferenceException nullExp )
{MessageBox.Show( "指定的url地址不可到达 " + nullExp.Message );}
catch( RemotingException remExp )
{MessageBox.Show( "指定获得的对象定义不对" + remExp.Message );}

　　3.2.2数据库的访问

　　通过ADO.Net访问数据库，可以方便地连接数据库，将数据源中的数据导入DataSet对象中，在DataSet对象中可对数据表进行各种操作，而且DataSet对象本身也可远程传递。这为开发分布式数据库系统带来极大方便。实现数据库访问的关键代码如下所示：

//建立数据库的连接
string SqlConn = "Initial Catalog=Store;Data Source=Localhost;Userid=sa;Password=;";
SqlConnection Conn= new SqlConnection
(SqlConn);
Conn.Open();//打开数据库
//将数据源中的数据导入到数据集对象
try{
DataSet ds = new DataSet();
DataTable dt=new DataTable("Result");
SqlDataAdapter adapter=new SqlDataAdapter();
SqlCommand mySqlDataSetCmd =new SqlCommand
(CmdString,Conn);//CmdString为要执行的命令
adapter.SelectCommand= mySqlDataSetCmd;
adapter.Fill(dt);
ds.Tables.Add(dt); }
finally
{ Conn.Close();//关闭数据库的连接}

　　3.2.3 查询

　　分布式数据库系统中的查询一般分为三类：本地查询、远程查询和联合查询。本地查询和集中式数据库的查询没什么区别；对于远程查询，只要获取远程对象后，调用查询函数，即可方便地实现；最复杂的是联合查询，涉及到多场地之间数据的查询、表的远程创建、传递、连接、合并等技术。下面以实例介绍联合查询的实现。

　　第二连锁店要查询离其较近的第三、第四连锁店中所有北京的供应商所供应的空调的库存信息以便调货，可通过以下步骤实现。首先，获取总部以及第三、第四连锁店所发布的远程对象。接着，通过远程对象在总部创建一临时数据表t1，将查询到的所有北京的供应商信息存放在t1表中（各分店只有供应商名，并不知其所在地，只有总部才有供应商的详细信息），再将t1表保存到第三和第四连锁店。然后让t1表分别与两店的库存表作连接，找出所有北京供应商所供应的空调库存信息（如空调名称、型号、个数、价格等信息），并将连接结果t2和t3数据表返回到第二连锁店。最后对t2和t3两表进行合并，并使用DataGrid控件显示出来。上述实现中，包含了不同场地之间数据表的复制、传递、连接等，所用到的一些函数（如：远程创建数据表、表与表间的远程连接、合并等）都放在dll中，可以方便地调用。

　　4 结束语

　　利用C#的.Net Remoting技术能够方便地解决各场地间数据的通信问题。另外，C#通过ADO.Net访问数据库，使得对数据库的操作及管理变得更加高效、可靠。这两种技术的使用，有效地解决了开发分布式数据库系统的主要问题，大大减轻了系统开发工作量，并且提高了系统的可靠性和安全性。

利用c#来获取汉字首字母

2008-10-21T05:00:00.001-07:00
public static string CVT(string str)
{
if (str.CompareTo("吖") < 0)
{
string s=str.Substring(0,1).ToUpper();
if (char.IsNumber(s, 0))
{
return "0";
}
else
{
return s;
}

}
else if (str.CompareTo("八") < 0)
{
return "A";
}
else if (str.CompareTo("嚓") < 0)
{
return "B";
}
else if (str.CompareTo("咑") < 0)
{
return "C";
}
else if (str.CompareTo("妸") < 0)
{
return "D";
}
else if (str.CompareTo("发") < 0)
{
return "E";
}
else if (str.CompareTo("旮") < 0)
{
return "F";
}
else if (str.CompareTo("铪") < 0)
{
return "G";
}
else if (str.CompareTo("讥") < 0)
{
return "H";
}
else if (str.CompareTo("咔") < 0)
{
return "J";
}
else if (str.CompareTo("垃") < 0)
{
return "K";
}
else if (str.CompareTo("嘸") < 0)
{
return "L";
}
else if (str.CompareTo("拏") < 0)
{
return "M";
}
else if (str.CompareTo("噢") < 0)
{
return "N";
}
else if (str.CompareTo("妑") < 0)
{
return "O";
}
else if (str.CompareTo("七") < 0)
{
return "P";
}
else if (str.CompareTo("亽") < 0)
{
return "Q";
}
else if (str.CompareTo("仨") < 0)
{
return "R";
}
else if (str.CompareTo("他") < 0)
{
return "S";
}
else if (str.CompareTo("哇") < 0)
{
return "T";
}
else if (str.CompareTo("夕") < 0)
{
return "W";
}
else if (str.CompareTo("丫") < 0)
{
return "X";
}
else if (str.CompareTo("帀") < 0)
{
return "Y";
}
else if (str.CompareTo("咗") < 0)
{
return "Z";
}
else
{
return "0";
}

}
}

C#加密方法汇总

2008-10-21T04:59:00.003-07:00
方法一：

//须添加对System.Web的引用
using System.Web.Security;

///

/// SHA1加密字符串
///

/// 源字符串
/// 加密后的字符串
public string SHA1(string source)
{
return FormsAuthentication.HashPasswordForStoringInConfigFile(source, "SHA1");
}
///

/// MD5加密字符串
///

/// 源字符串
/// 加密后的字符串
public string MD5(string source)
{
return FormsAuthentication.HashPasswordForStoringInConfigFile(source, "MD5");;
}
//须添加对System.Web的引用
using System.Web.Security;

///

/// SHA1加密字符串
///

/// 源字符串
/// 加密后的字符串
public string SHA1(string source)
{
return FormsAuthentication.HashPasswordForStoringInConfigFile(source, "SHA1");
}
///

/// MD5加密字符串
///

/// 源字符串
/// 加密后的字符串
public string MD5(string source)
{
return FormsAuthentication.HashPasswordForStoringInConfigFile(source, "MD5");;
}
方法二(可逆加密解密)：

using System.Security.Cryptography;

public string Encode(string data)
{
byte[] byKey = System.Text.ASCIIEncoding.ASCII.GetBytes(KEY_64);
byte[] byIV = System.Text.ASCIIEncoding.ASCII.GetBytes(IV_64);

DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();
int i = cryptoProvider.KeySize;
MemoryStream ms = new MemoryStream();
CryptoStream cst = new CryptoStream(ms, cryptoProvider.CreateEncryptor(byKey, byIV), CryptoStreamMode.Write);

StreamWriter sw = new StreamWriter(cst);
sw.Write(data);
sw.Flush();
cst.FlushFinalBlock();
sw.Flush();
return Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length);

}

public string Decode(string data)
{
byte[] byKey = System.Text.ASCIIEncoding.ASCII.GetBytes(KEY_64);
byte[] byIV = System.Text.ASCIIEncoding.ASCII.GetBytes(IV_64);

byte[] byEnc;
try
{
byEnc = Convert.FromBase64String(data);
}
catch
{
return null;
}

DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();
MemoryStream ms = new MemoryStream(byEnc);
CryptoStream cst = new CryptoStream(ms, cryptoProvider.CreateDecryptor(byKey, byIV), CryptoStreamMode.Read);
StreamReader sr = new StreamReader(cst);
return sr.ReadToEnd();
}
using System.Security.Cryptography;

public string Encode(string data)
{
byte[] byKey = System.Text.ASCIIEncoding.ASCII.GetBytes(KEY_64);
byte[] byIV = System.Text.ASCIIEncoding.ASCII.GetBytes(IV_64);

DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();
int i = cryptoProvider.KeySize;
MemoryStream ms = new MemoryStream();
CryptoStream cst = new CryptoStream(ms, cryptoProvider.CreateEncryptor(byKey, byIV), CryptoStreamMode.Write);

StreamWriter sw = new StreamWriter(cst);
sw.Write(data);
sw.Flush();
cst.FlushFinalBlock();
sw.Flush();
return Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length);

}

public string Decode(string data)
{
byte[] byKey = System.Text.ASCIIEncoding.ASCII.GetBytes(KEY_64);
byte[] byIV = System.Text.ASCIIEncoding.ASCII.GetBytes(IV_64);

byte[] byEnc;
try
{
byEnc = Convert.FromBase64String(data);
}
catch
{
return null;
}

DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();
MemoryStream ms = new MemoryStream(byEnc);
CryptoStream cst = new CryptoStream(ms, cryptoProvider.CreateDecryptor(byKey, byIV), CryptoStreamMode.Read);
StreamReader sr = new StreamReader(cst);
return sr.ReadToEnd();
}
方法三(MD5不可逆)：

using System.Security.Cryptography;

//MD5不可逆加密

//32位加密

public string GetMD5_32(string s, string _input_charset)
{
MD5 md5 = new MD5CryptoServiceProvider();
byte[] t = md5.ComputeHash(Encoding.GetEncoding(_input_charset).GetBytes(s));
StringBuilder sb = new StringBuilder(32);
for (int i = 0; i < t.Length; i++)
{
sb.Append(t[i].ToString("x").PadLeft(2, '0'));
}
return sb.ToString();
}

//16位加密
public static string GetMd5_16(string ConvertString)
{
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
string t2 = BitConverter.ToString(md5.ComputeHash(UTF8Encoding.Default.GetBytes(ConvertString)), 4, 8);
t2 = t2.Replace("-", "");
return t2;
}
using System.Security.Cryptography;

//MD5不可逆加密

//32位加密

public string GetMD5_32(string s, string _input_charset)
{
MD5 md5 = new MD5CryptoServiceProvider();
byte[] t = md5.ComputeHash(Encoding.GetEncoding(_input_charset).GetBytes(s));
StringBuilder sb = new StringBuilder(32);
for (int i = 0; i < t.Length; i++)
{
sb.Append(t[i].ToString("x").PadLeft(2, '0'));
}
return sb.ToString();
}

//16位加密
public static string GetMd5_16(string ConvertString)
{
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
string t2 = BitConverter.ToString(md5.ComputeHash(UTF8Encoding.Default.GetBytes(ConvertString)), 4, 8);
t2 = t2.Replace("-", "");
return t2;
}
方法四(对称加密)：

using System.IO;
using System.Security.Cryptography;

private SymmetricAlgorithm mobjCryptoService;
private string Key;
///

/// 对称加密类的构造函数
///

public SymmetricMethod()
{
mobjCryptoService = new RijndaelManaged();
Key = "Guz(%&hj7x89H$yuBI0456FtmaT5&fvHUFCy76*h%(HilJ$lhj!y6&(*jkP87jH7";
}
///

/// 获得密钥
///

/// 密钥
private byte[] GetLegalKey()
{
string sTemp = Key;
mobjCryptoService.GenerateKey();
byte[] bytTemp = mobjCryptoService.Key;
int KeyLength = bytTemp.Length;
if (sTemp.Length > KeyLength)
sTemp = sTemp.Substring(0, KeyLength);
else if (sTemp.Length < KeyLength)
sTemp = sTemp.PadRight(KeyLength, ' ');
return ASCIIEncoding.ASCII.GetBytes(sTemp);
}
///

/// 获得初始向量IV
///

/// 初试向量IV
private byte[] GetLegalIV()
{
string sTemp = "E4ghj*Ghg7!rNIfb&95GUY86GfghUb#er57HBh(u%g6HJ($jhWk7&!hg4ui%$hjk";
mobjCryptoService.GenerateIV();
byte[] bytTemp = mobjCryptoService.IV;
int IVLength = bytTemp.Length;
if (sTemp.Length > IVLength)
sTemp = sTemp.Substring(0, IVLength);
else if (sTemp.Length < IVLength)
sTemp = sTemp.PadRight(IVLength, ' ');
return ASCIIEncoding.ASCII.GetBytes(sTemp);
}
///

/// 加密方法
///

/// 待加密的串
/// 经过加密的串
public string Encrypto(string Source)
{
byte[] bytIn = UTF8Encoding.UTF8.GetBytes(Source);
MemoryStream ms = new MemoryStream();
mobjCryptoService.Key = GetLegalKey();
mobjCryptoService.IV = GetLegalIV();
ICryptoTransform encrypto = mobjCryptoService.CreateEncryptor();
CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Write);
cs.Write(bytIn, 0, bytIn.Length);
cs.FlushFinalBlock();
ms.Close();
byte[] bytOut = ms.ToArray();
return Convert.ToBase64String(bytOut);
}
///

/// 解密方法
///

/// 待解密的串
/// 经过解密的串
public string Decrypto(string Source)
{
byte[] bytIn = Convert.FromBase64String(Source);
MemoryStream ms = new MemoryStream(bytIn, 0, bytIn.Length);
mobjCryptoService.Key = GetLegalKey();
mobjCryptoService.IV = GetLegalIV();
ICryptoTransform encrypto = mobjCryptoService.CreateDecryptor();
CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Read);
StreamReader sr = new StreamReader(cs);
return sr.ReadToEnd();
}
using System.IO;
using System.Security.Cryptography;

private SymmetricAlgorithm mobjCryptoService;
private string Key;
///

/// 对称加密类的构造函数
///

public SymmetricMethod()
{
mobjCryptoService = new RijndaelManaged();
Key = "Guz(%&hj7x89H$yuBI0456FtmaT5&fvHUFCy76*h%(HilJ$lhj!y6&(*jkP87jH7";
}
///

/// 获得密钥
///

/// 密钥
private byte[] GetLegalKey()
{
string sTemp = Key;
mobjCryptoService.GenerateKey();
byte[] bytTemp = mobjCryptoService.Key;
int KeyLength = bytTemp.Length;
if (sTemp.Length > KeyLength)
sTemp = sTemp.Substring(0, KeyLength);
else if (sTemp.Length < KeyLength)
sTemp = sTemp.PadRight(KeyLength, ' ');
return ASCIIEncoding.ASCII.GetBytes(sTemp);
}
///

/// 获得初始向量IV
///

/// 初试向量IV
private byte[] GetLegalIV()
{
string sTemp = "E4ghj*Ghg7!rNIfb&95GUY86GfghUb#er57HBh(u%g6HJ($jhWk7&!hg4ui%$hjk";
mobjCryptoService.GenerateIV();
byte[] bytTemp = mobjCryptoService.IV;
int IVLength = bytTemp.Length;
if (sTemp.Length > IVLength)
sTemp = sTemp.Substring(0, IVLength);
else if (sTemp.Length < IVLength)
sTemp = sTemp.PadRight(IVLength, ' ');
return ASCIIEncoding.ASCII.GetBytes(sTemp);
}
///

/// 加密方法
///

/// 待加密的串
/// 经过加密的串
public string Encrypto(string Source)
{
byte[] bytIn = UTF8Encoding.UTF8.GetBytes(Source);
MemoryStream ms = new MemoryStream();
mobjCryptoService.Key = GetLegalKey();
mobjCryptoService.IV = GetLegalIV();
ICryptoTransform encrypto = mobjCryptoService.CreateEncryptor();
CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Write);
cs.Write(bytIn, 0, bytIn.Length);
cs.FlushFinalBlock();
ms.Close();
byte[] bytOut = ms.ToArray();
return Convert.ToBase64String(bytOut);
}
///

/// 解密方法
///

/// 待解密的串
/// 经过解密的串
public string Decrypto(string Source)
{
byte[] bytIn = Convert.FromBase64String(Source);
MemoryStream ms = new MemoryStream(bytIn, 0, bytIn.Length);
mobjCryptoService.Key = GetLegalKey();
mobjCryptoService.IV = GetLegalIV();
ICryptoTransform encrypto = mobjCryptoService.CreateDecryptor();
CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Read);
StreamReader sr = new StreamReader(cs);
return sr.ReadToEnd();
}
方法五：

using System.IO;
using System.Security.Cryptography;
using System.Text;

//默认密钥向量
private static byte[] Keys = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
/**//**//**////

/// DES加密字符串
///

/// 待加密的字符串
/// 加密密钥,要求为8位
/// 加密成功返回加密后的字符串，失败返回源串
public static string EncryptDES(string encryptString, string encryptKey)
{
try
{
byte[] rgbKey = Encoding.UTF8.GetBytes(encryptKey.Substring(0, 8));
byte[] rgbIV = Keys;
byte[] inputByteArray = Encoding.UTF8.GetBytes(encryptString);
DESCryptoServiceProvider dCSP = new DESCryptoServiceProvider();
MemoryStream mStream = new MemoryStream();
CryptoStream cStream = new CryptoStream(mStream, dCSP.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
cStream.Write(inputByteArray, 0, inputByteArray.Length);
cStream.FlushFinalBlock();
return Convert.ToBase64String(mStream.ToArray());
}
catch
{
return encryptString;
}
}

/**//**//**////

/// DES解密字符串
///

/// 待解密的字符串
/// 解密密钥,要求为8位,和加密密钥相同
/// 解密成功返回解密后的字符串，失败返源串
public static string DecryptDES(string decryptString, string decryptKey)
{
try
{
byte[] rgbKey = Encoding.UTF8.GetBytes(decryptKey);
byte[] rgbIV = Keys;
byte[] inputByteArray = Convert.FromBase64String(decryptString);
DESCryptoServiceProvider DCSP = new DESCryptoServiceProvider();
MemoryStream mStream = new MemoryStream();
CryptoStream cStream = new CryptoStream(mStream, DCSP.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
cStream.Write(inputByteArray, 0, inputByteArray.Length);
cStream.FlushFinalBlock();
return Encoding.UTF8.GetString(mStream.ToArray());
}
catch
{
return decryptString;
}
}
using System.IO;
using System.Security.Cryptography;
using System.Text;

//默认密钥向量
private static byte[] Keys = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
/**//**//**////

/// DES加密字符串
///

/// 待加密的字符串
/// 加密密钥,要求为8位
/// 加密成功返回加密后的字符串，失败返回源串
public static string EncryptDES(string encryptString, string encryptKey)
{
try
{
byte[] rgbKey = Encoding.UTF8.GetBytes(encryptKey.Substring(0, 8));
byte[] rgbIV = Keys;
byte[] inputByteArray = Encoding.UTF8.GetBytes(encryptString);
DESCryptoServiceProvider dCSP = new DESCryptoServiceProvider();
MemoryStream mStream = new MemoryStream();
CryptoStream cStream = new CryptoStream(mStream, dCSP.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
cStream.Write(inputByteArray, 0, inputByteArray.Length);
cStream.FlushFinalBlock();
return Convert.ToBase64String(mStream.ToArray());
}
catch
{
return encryptString;
}
}

/**//**//**////

/// DES解密字符串
///

/// 待解密的字符串
/// 解密密钥,要求为8位,和加密密钥相同
/// 解密成功返回解密后的字符串，失败返源串
public static string DecryptDES(string decryptString, string decryptKey)
{
try
{
byte[] rgbKey = Encoding.UTF8.GetBytes(decryptKey);
byte[] rgbIV = Keys;
byte[] inputByteArray = Convert.FromBase64String(decryptString);
DESCryptoServiceProvider DCSP = new DESCryptoServiceProvider();
MemoryStream mStream = new MemoryStream();
CryptoStream cStream = new CryptoStream(mStream, DCSP.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
cStream.Write(inputByteArray, 0, inputByteArray.Length);
cStream.FlushFinalBlock();
return Encoding.UTF8.GetString(mStream.ToArray());
}
catch
{
return decryptString;
}
}
方法六(文件加密)：

using System.IO;
using System.Security.Cryptography;
using System.Text;

//加密文件
private static void EncryptData(String inName, String outName, byte[] desKey, byte[] desIV)
{
//Create the file streams to handle the input and output files.
FileStream fin = new FileStream(inName, FileMode.Open, FileAccess.Read);
FileStream fout = new FileStream(outName, FileMode.OpenOrCreate, FileAccess.Write);
fout.SetLength(0);

//Create variables to help with read and write.
byte[] bin = new byte[100]; //This is intermediate storage for the encryption.
long rdlen = 0; //This is the total number of bytes written.
long totlen = fin.Length; //This is the total length of the input file.
int len; //This is the number of bytes to be written at a time.

DES des = new DESCryptoServiceProvider();
CryptoStream encStream = new CryptoStream(fout, des.CreateEncryptor(desKey, desIV), CryptoStreamMode.Write);

//Read from the input file, then encrypt and write to the output file.
while (rdlen < totlen)
{
len = fin.Read(bin, 0, 100);
encStream.Write(bin, 0, len);
rdlen = rdlen + len;
}

encStream.Close();
fout.Close();
fin.Close();
}

//解密文件
private static void DecryptData(String inName, String outName, byte[] desKey, byte[] desIV)
{
//Create the file streams to handle the input and output files.
FileStream fin = new FileStream(inName, FileMode.Open, FileAccess.Read);
FileStream fout = new FileStream(outName, FileMode.OpenOrCreate, FileAccess.Write);
fout.SetLength(0);

//Create variables to help with read and write.
byte[] bin = new byte[100]; //This is intermediate storage for the encryption.
long rdlen = 0; //This is the total number of bytes written.
long totlen = fin.Length; //This is the total length of the input file.
int len; //This is the number of bytes to be written at a time.

DES des = new DESCryptoServiceProvider();
CryptoStream encStream = new CryptoStream(fout, des.CreateDecryptor(desKey, desIV), CryptoStreamMode.Write);

//Read from the input file, then encrypt and write to the output file.
while (rdlen < totlen)
{
len = fin.Read(bin, 0, 100);
encStream.Write(bin, 0, len);
rdlen = rdlen + len;
}

encStream.Close();
fout.Close();
fin.Close();
}

VS2005 C# 本地和远程连接Sql2000、Access、Oracle数据库说明

2008-10-21T04:59:00.001-07:00
1.Access
(1)本地连接
string source = @" Provider = Microsoft.Jet.OLEDB.4.0 ; Data Source = D:c#connDBschool.mdb";
(2)远程链接（以下5种方法）:
１)建立VPN(Virtual Private Network)，然后把服务器中mdb文件所在的 Folder 共享即可。
ADO连接方法如下：
string source = @"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=服务器名文件夹 mydata.mdb;JetOLEDB:Database Password=datapass;Persist Security Info=False";
２)把数据库放在Web 服务器上，使ADO或RDO通过RDS（Remote Data Service）及IIS来实现:
a.如果服务器设置了ODBC DSN的话，连接方法如下：
"Provider=MS Remote;Remote Server=http://服务器名;RemoteProvider=MSDASQL;DSN=AdvWorks;Uid=dataUserName;Pwd=dataPassWord"
b.如果设置的是OLE DB Provider 的话，连接方法如下：
"Provider=MS Remote;Remote Server=http://服务器名;RemoteProvider=Microsoft.Jet.OLEDB.4.0; Data Source=数据库文件路径,"+ "admin,"+"" (数据库用户名为：admin；密码为空)
３)自己编写服务器程序，通过TCP/IP，传递Recordset.
４)使用第三方控件，如：ADO Anywhere或UDAParts RDB等.
５)使用XMLHTTP

示例代码：
OledbConnection myconn = null;

myconn =
new OledbConnection("192.168.1.155",
"DSN=mydata;DRIVER={Microsoft Access Driver (*.mdb)};UID=test;PWD=test;"); //其中服务器IP是 192.168.1.155 ;数据库名是 mydata ;数据库用户名这密码都是test

myconn.Open();
2.Sql server2000
(1)本地连接
// 下面是本地连接sql2000，采用下面两种连接字符串

string source = @" server = .kingsql;database = Northwind ; integrated security=SSPI ";

string source = @" server = .kingsql;database = Northwind ; uid = sa; pwd = sa ";
(2)远程连接
首先要保证客户端与SQL服务器连接。
具体如下说明：
1）ping 服务器IP测试连通与否
这个实际上是看和远程sql server 2000服务器的物理连接是否存在。如果不行，请检查网络，查看配置，当然得确保远程sql server 2000服务器的IP拼写正确。

2) 在Dos或命令行下输入telnet 服务器IP 端口，看能否连通
如: telnet 202.114.100.100 1433
通常端口值是1433，因为1433是sql server 2000的对于Tcp/IP的默认侦听端口。如果有问题，通常这一步会出问题。通常的提示是“……无法打开连接,连接失败"。
如果这一步有问题，应该检查以下选项。
1 检查远程服务器是否启动了sql server 2000服务。如果没有，则启动。
2 检查服务器端有没启用Tcp/IP协议，因为远程连接（通过因特网）需要靠这个协检查方法是，在服务器上打开开始菜单->程序-> Microsoft SQL Server->服务器网络实用工具，看启用的协议里是否有tcp/ip协议，如果没有，则启用它。
3 检查服务器的tcp/ip端口是否配置为1433端口。仍然在服务器网络实用工具里查看启用协议里面的tcp/ip的属性，确保默认端口为1433，并且隐藏服务器复选框没有勾上。
事实上，如果默认端口被修改，也是可以的，但是在客户端做telnet测试时，写服务器端口号时必须与服务器配置的端口号保持一致。如果隐藏服务器复选框被勾选，则意味着客户端无法通过枚举服务器来看到这台服务器，起到了保护的作用，但不影响连接，但是Tcp/ip协议的默认端口将被隐式修改为2433，在客户端连接时必须作相应的改变。
4 如果服务器端操作系统打过sp2补丁，则要对windows防火墙作一定的配置，要对它开放1433端口，通常在测试时可以直接关掉windows防火墙（其他的防火墙也关掉最好）。
5 检查服务器是否在1433端口侦听。如果服务器没有在tcp连接的1433端口侦听，则是连接不上的。检查方法是在服务器的dos或命令行下面输入netstat -a -n 或者是netstat -an，在结果列表里看是否有类似tcp 127.0.0.1 1433 listening的项。如果没有，则通常需要给sql server 2000打上至少sp3的补丁。其实在服务器端启动查询分析器，输入 select @@version 执行后可以看到版本号，版本号在8.0.2039以下的都需要打补丁。如果以上都没问题，这时你再做telnet 服务器ip 1433 测试，将会看到屏幕一闪之后光标在左上角不停闪动。恭喜你，你马上可以开始在企业管理器或查询分析器连接了。

3)检查客户端设置
程序->Microsoft SQL Server -> 客户端网络使用工具。像在服务器网络实用工具里一样，确保客户端tcp/ip协议启用，并且默认端口为1433（或其他端口，与服务器端保持一致就行）。

4)在企业管理器里或查询那分析器连接测试
企业管理器->右键SQlserver组->新建sqlserver注册->下一步->写入远程IP-> 下一步->选Sqlserver登陆->下一步->写入登陆名与密码（sa,password）->下一步->下一步->完成查询分析器->文件->连接->写入远程IP->写入登录名和密码（sa,password）->确定通常建议在查询分析器里做，因为默认情况下，通过企业管理器注册另外一台SQL Server的超时设置是4秒，而查询分析器是15秒。
修改默认连接超时的方法：
企业管理器->工具->选项->在弹出的"SQL Server企业管理器属性"窗口中，点击"高级"选项卡->连接设置->在登录超时（秒）后面的框里输入一个较大的数字查询分析器->工具->选项->连接->在登录超时（秒）后面的框里输入一个较大的数字通常就可以连通了，如果提示错误，则进入下一步。

5）错误产生的原因通常是由于SQL Server使用了"仅 Windows"的身份验证方式，因此用户无法使用SQL Server的登录帐户（如 sa ）进行连接。解决方法如下所示：
　 1 在服务器端使用企业管理器，并且选择"使用 Windows 身份验证"连接上 SQL Server。
　 2 展开"SQL Server组"，鼠标右键点击SQL Server服务器的名称，选择"属性"，再选择"安全性"选项卡。
　 3 在"身份验证"下，选择"SQL Server和 Windows "。
　 4 重新启动SQL Server服务。（在dos或命令行下面net stop mssqlserver停止服务, net start mssqlserver启动服务，也是一种快捷的方法）。

附注：在连接本地服务器时，通常使用的是命名管道协议（在服务器网络实用工具里可以看到启用的协议有这个），默认端口是445，因此在本地能连通是不能说明什么问题的，连接远程服务器是完全不同的协议）

3.Oracle
(1)ODBC（要求：Oracle Client 7.3以上版本）
"Driver={Microsoft ODBC for Oracle};Server=myServerAddress;Uid=myUsername;Pwd=myPassword;"
(2)OLEDB（要求：Oracle Client 8i以上版本）
"Provider=msdaora;Data Source=MyOracleDB;User Id=myUsername;Password=myPassword;"
(3)System.Data.OracleClient（要求:MDAC 2.6Oracle Client 8i Release 3 (8.1.7) 以上版本)
"Provider=msdaora;Data Source=MyOracleDB;User Id=myUsername;Password=myPassword;"
(4)ODP.NET（要求：Oracle Client 9i以上版本）
"Data Source=MyOracleDB;User Id=myUsername;Password=myPassword;Integrated Security=no;"
(5)OraDirect .net （要求：不需要安装Oracle客户端必须购买许可证）
"User ID=myUsername;Password=myPassword;Host=ora;Pooling=true;Min Pool Size=0;
Max Pool Size=100;Connection Lifetime=0;"
以下详看：
Oracle Data Provider for .NET FAQ
Remark:http://www.oracle.com/technology/tech/windows/odpnet/faq.html#install

C# 利用WinRAR (加密)压缩及解压缩

2008-10-21T04:58:00.000-07:00
本次示例主要实现：
1.压缩文件夹及其下文件
2.压缩文件夹下文件
3.压缩文件夹及其下文件为rar 还是 zip
4.解压缩
5.加密压缩及解加密压缩
-----------
示例代码如下：
protected void Button1_Click(object sender, EventArgs e)
{
string strtxtPath = "C:\\freezip\\free.txt";
string strzipPath = "C:\\freezip\\free.zip";
System.Diagnostics.Process Process1 = new System.Diagnostics.Process();
Process1.StartInfo.FileName = "Winrar.exe";
Process1.StartInfo.CreateNoWindow = true;

//// 1
////压缩c:\freezip\free.txt(即文件夹及其下文件freezip\free.txt)
////到c:\freezip\free.rar
//strzipPath = "C:\\freezip\\free";//默认压缩方式为 .rar
//Process1.StartInfo.Arguments = " a -r " + strzipPath + " " + strtxtPath;

//// 2
////压缩c:\freezip\free.txt(即文件夹及其下文件freezip\free.txt)
////到c:\freezip\free.rar
//strzipPath = "C:\\freezip\\free";//设置压缩方式为 .zip
//Process1.StartInfo.Arguments = " a -afzip " + strzipPath + " " + strtxtPath;

//// 3
////压缩c:\freezip\free.txt(即文件夹及其下文件freezip\free.txt)
////到c:\freezip\free.zip 直接设定为free.zip
//Process1.StartInfo.Arguments = " a -r "+strzipPath+" " + strtxtPath ;

//// 4
////搬迁压缩c:\freezip\free.txt(即文件夹及其下文件freezip\free.txt)
////到c:\freezip\free.rar 压缩后原文件将不存在
//Process1.StartInfo.Arguments = " m " + strzipPath + " " + strtxtPath;

//// 5
////压缩c:\freezip\下的free.txt(即文件free.txt)
////到c:\freezip\free.zip 直接设定为free.zip 只有文件而没有文件夹
//Process1.StartInfo.Arguments = " a -ep " + strzipPath + " " + strtxtPath;

//// 6
////解压缩c:\freezip\free.rar
////到 c:\freezip\
//strtxtPath = "c:\\freezip\\";
//Process1.StartInfo.Arguments = " x " + strzipPath + " " + strtxtPath;

//// 7
////加密压缩c:\freezip\free.txt(即文件夹及其下文件freezip\free.txt)
////到c:\freezip\free.zip 密码为123456 注意参数间不要空格
//Process1.StartInfo.Arguments = " a -p123456 " + strzipPath + " " + strtxtPath;

//// 8
////解压缩加密的c:\freezip\free.rar
////到 c:\freezip\ 密码为123456 注意参数间不要空格
//strtxtPath = "c:\\freezip\\";
//Process1.StartInfo.Arguments = " x -p123456 " + strzipPath + " " + strtxtPath;

//// 9
////-o+ 覆盖已经存在的文件
//// -o- 不覆盖已经存在的文件
//strtxtPath = "c:\\freezip\\";
//Process1.StartInfo.Arguments = " x -o+ " + strzipPath + " " + strtxtPath;

////10
//// 只从指定的zip中
//// 解压出free1.txt
//// 到指定路径下
//// 压缩包中的其他文件不予解压
//strtxtPath = "c:\\freezip\\";
//Process1.StartInfo.Arguments = " x " + strzipPath + " " +" free1.txt" + " " + strtxtPath;

//// 11
//// 通过 -y 对所有询问回应为"是" 以便即便发生错误也不弹出WINRAR的窗口
//// -cl 转换文件名为小写字母
//strtxtPath = "c:\\freezip\\";
//Process1.StartInfo.Arguments = " t -y -cl " + strzipPath + " " + " free1.txt";

Process1.Start();
if (Process1.HasExited)
{
int iExitCode = Process1.ExitCode;
if (iExitCode == 0)
{
Response.Write(iExitCode.ToString() + " 正常完成");
}
else
{
Response.Write(iExitCode.ToString() + " 有错完成");
}
}
}

更多WinRAR命令(引自WinRAR帮助文档)

a 添加文件到压缩文件

c 添加压缩文件注释

d 从压缩文件删除文件

e 从压缩文件解压压缩，忽略路径

f 刷新压缩文件中的文件

i 在压缩文件中查找字符串

k 锁定压缩文件

m 移动文件和文件夹到压缩文件

r 修复受损的压缩文件

rc 重建丢失的卷

rn 重命名压缩文件

rr[N] 添加数据恢复记录

rv[N] 创建恢复卷

s[name] 转换压缩文件成为自解压文件类型

s- 删除自解压模块

t 测试压缩文件

u 从压缩文件中更新文件

x 以完整路径名称从压缩文件解压压缩

-ac 在压缩或解压后清除存档属性
-ad 附加压缩文件名到目标路径中
-af<类型> 指定压缩文件格式
-ag[格式] 以当前日期生成压缩文件名
-ao 添加有存档属性设置的
-ap 设置内部压缩文件路径
-as 同步化压缩文件内容
-av 应用用户身份校验信息
-av- 禁用添加用户身份校验信息
-cfg- 忽略默认配置和环境变量
-cl 将文件名转换成为小写
-cu 将文件名转换成为大写
-df 压缩后删除压缩文件
-dh 打开共享的文件
-ds 不排序压缩的文件
-ed 不添加空文件夹
-en 不添加“压缩文件结束”块
-ep 从名称中排除路径
-ep1 从名称中排除主文件夹
-ep2 扩大成完整路径
-ep3 扩展包含盘符的完整路径
-e[+]<属性> 设置文件排除和包含属性
-f 刷新文件
-hp[密码] 加密文件数据和头
-ibck 在后台运行 WinRAR
-ieml 使用E-mail发送压缩文件
-iicon<名称> 指定自解压图标
-iimg<名称> 指定自解压图片
-ilog[名称] 记录错误到文件中
-inul 关闭错误信息
-ioff 关闭 PC 电源
-k 锁定压缩文件
-kb 保留坏掉的解压文件
-m 设置压缩方式
-mc<参数> 设置高级压缩参数
-md 选择字典大小
-ms 指定文件存储
-n<文件> 仅包含指定的文件
-n@<列表文件> 使用指定的列表文件包含文件
-os 保存 NTFS 数据流
-oc 设置 NTFS “压缩”属性
-ow 处理文件用户身份校验信息
-o+ 覆盖已存在的文件
-o- 不要覆盖已存在的文件
-p[密码] 设置密码
-r 返回子文件夹
-r0 只返回与通配符匹配的子文件夹
-ri 设置优先级和休眠时间
-rr[N] 添加数据恢复记录
-rv[N] 创建恢复卷
-s 创建固实压缩文件
-s 以文件数量创建固实组
-se 以文件扩展名创建固实组
-sfx[名称] 创建自解压文件
-sv 创建互不依赖的固实压缩文件
-sv- 创建互相依赖的固实压缩文件
-s- 禁用固实算法
-t 压缩后测试文件
-ta<日期> 只处理指定日期之后修改的文件
-tb<日期> 只处理指定日期之前修改的文件
-tk 保持原有压缩文件时间
-tl 以最新的文件设置压缩文件时间
-tn<时间> 处理较新于指定时间的文件
-to<时间> 处理较旧于指定时间的文件
-ts 保存或恢复文件时间(修改,创建,访问)
-u 更新文件
-v[k|b|f|m|M|g|G] 创建分卷压缩
-vd 创建分卷压缩前清除磁盘内容
-ver 文件版本控制
-vn 使用旧风格的卷命名法则
-vp 每次分卷压缩前暂停
-x<文件> 排除指定的文件
-x@<文件列表> 使用指定的列表文件来排除指定的文件
-y 假设全部的询问回应皆为“是”
-z<文件> 从文件读取压缩文件注释

怎么给XP系统文件夹加密?

2008-10-21T04:57:00.004-07:00
1.打开要进行加密保护的文件夹中，在空白处单击鼠标右键，选择“自定义文件夹...”选项
2.选择“自定义”并在复选框中选择“选择或编辑该文件夹的Html模板”，单击“下一步”
3.在选择模板类型中选择“标准”，单击“下一步”，最后单击“完成”
4.完成以上操作后，打开被定义的文件夹，利用查找功能找到Folder.htt文件，然后编辑此文件，首先在文件中找到

C#

c#2.0泛型学习

C#编程--基础知识点

.NET 2.0下读取数据库中的全部表以及表内的字段名

C#通过ADO.NET建表点实现方法

汉字转换为拼音的函数收藏

关于.NET使用自定义XML做参数配置文件

一种简便实效的配置文件读写方法

MS SQL数据类型及长度限制

C#实现USB接口的程序代码

C#编程 忘记密码功能的实现方法

用Visual C#制作新闻阅读器

使用c#捕获windows的关机事件

一个用C#过滤HTML代码的函数

关于C#在lucene.net下的中文切词

详解Visual C＃数据库编程

使用C#编写查询IP段功能的程序

C# 中的常用正则表达式总结

C#也能动态生成Word文档并填充数据

C#和ASP.NET开发的一些小技巧及注意事项

如何才能学好C＃

C#语言基础常见问题汇总

C#的四个基本技巧

提高C#编程水平的50个要诀

C#合并多个结构一样的Excel

使用C#创建SQL Server的存储过程

c#数据库操作的3种典型用法

利用C#远程存取Access数据库

c#一种简单快速改变窗体风格和肤色的方法源码及其控件

用 C# 编程实现读写Binary

C#操作ACCESS数据库（创建,压缩,备份,恢复）

C#接口的作用

运用C#完成分布式数据库查询

利用c#来获取汉字首字母

C#加密方法汇总

VS2005 C# 本地和远程连接Sql2000、Access、Oracle数据库说明

C# 利用WinRAR (加密)压缩及解压缩

怎么给XP系统文件夹加密?

C#编程忘记密码功能的实现方法