C#进阶教程

卫

级别: 店掌柜

发帖: 5692

铜板: 103378

人品值: 1520

贡献值: 26

交易币: 0

好评度: 5373

信誉值: 0

金币: 0

所在楼道

只看楼主更多操作楼层直达

0 发表于: 2006-04-22

简述：C#中的库(libraries)
　　言归正传,我现在要说的是库(libraries),和大家一起学习如何用C#建立一个DLL文件.说起DLL,肯定是无人不知,无人不晓,这个WINDOWS的典型代表,同时也经常是大家功击的对象.呵呵,不管怎么样,学还是要学的.我们下面就开始,如何用命令行方式将一个C#程序编译成DLL,和如何在客户端使用他.
这个例子包括两个文件,一个是Factorial.cs,作用是计算一个数字的阶乘.还有一个是DigitCounter.cs,作用是计算传过来的字符串参数中的数字的数目.
我们可以这样来建立库,在命令行方式下这样做:
csc /target:library /out:Functions.dll Factorial.cs DigitCounter.cs
下面讲一下各个参数的用法:
/target:library:向系统指出输出的是一个DLL库,而不是一个EXE的可执行文件.
/out:Functions.dll:指定输出的DLL的文件名,即Functions.dll,一般地,如果你省略了第一个参数,那么默认的文件名将是第一个文件的文件名,即Factorial.dll.
下面我们再来建立一个文件,即使用这个库的文件,叫客户端文件,FunctionClient.cs.建立好后,用下面的语名编译:
csc /out:FunctionTest.exe /R:Functions.DLL FunctionClient.cs
下面说一下这个编译语句的用法:
/out:FunctionTest.exe:指出输出的文件名是FunctionTest.exe
/R:Functions.DLL:指出要引用的库,如果不是在当前目录下,必须要指出其的完整路径.
下面我就把这几个文件的代码写在下面:
000: // Libraries\Factorial.cs
001: using System;
002:
003: namespace Functions
004: {
005: public class Factorial
006: {
007: public static int Calc(int i)
008: {
009: return((i <= 1) ? 1 : (i * Calc(i-1)));
010: }
011: }
012: }
这是Factorial.cs这个文件的代码.在003行中,namespace的意思是名字空间,据M$的介绍,库必须根据它的名字空间打包,以使.NET能够正确地载入你的类.
下面是DigitCounter.cs这个文件的内容:
000: // Libraries\DigitCounter.cs
001: using System;
002:
003: namespace Functions
004: {
005: public class DigitCount
006: {
007: public static int NumberOfDigits(string theString)
008: {
009: int count = 0;
010: for ( int i = 0; i < theString.Length; i++ )
011: {
012: if ( Char.IsDigit(theString) ) _8J.fT$${
013: { p38-l'{#
014: count++; JR21>;l#2
015: } HM1Fz\Sf
016: } q~o<*W
017: :\c ^*K(9
018: return count; m?}6)\ob
019: } p27~>xQ
020: } P|E| $)m
021: } rJ4S%6w
注意,这个例子中的namespace应与第一个的一致,因为它们是同一个库中的.NumberOfDigits方法计算了参数中的数字的个数. FVbb2Y?R
第三个文件是FunctionClient.cs f~R(D0@
我们知道,一个库一旦建立,就可以被别的类利用(废话,要不然怎么叫库呢?).下面的C#程序就利用了我们刚才建立的库中的类. R+z2}}Z!`
000: // Libraries\FunctionClient.cs %)1?TU
001: using System; ;[YG@-"XZ
002: using Functions; 7Q9 w?y~c
003: class FunctionClient "+nRGEs6
004: { U9 s&
005: public static void Main(string[] args) ?e4YGOe.
006: { t%)7t9j
007: Console.WriteLine("Function Client"); #gN&lY:CFn
008: bsli0FJSh'
009: if ( args.Length == 0 ) _J#zY-j
010: { lfgq=8d
011: Console.WriteLine("Usage: FunctionTest ... "); Qd{CMmx
012: return; ;ef}}K
013: } lrE5^;/s1
014: ? :%@vM
015: for ( int i = 0; i < args.Length; i++ ) ec;o\erPG
016: { I$G['`XX/
017: int num = Int32.Parse(args); {dlXLx!B
018: Console.WriteLine( ^uc=f2=>,
019: "The Digit Count for String [{0}] is [{1}]", {}n^cq
020: args, iWkWR"ysy
021: DigitCount.NumberOfDigits(args)); |YWD8 +
022: Console.WriteLine( adcE'fA<_
023: "The Factorial for [{0}] is [{1}]", EME|k{W
024: num, ;JT-kw6l5K
025: Factorial.Calc(num) ); `$9x1dx
026: } a58H9w"u)
027: } fTec
028: } 9W5lSX#^;
在002行中,一个using Functions指明了引用Functions.DLL这个类. *N<]Xy@
如果我们在命令行中键入如下命令,就可以看到输出: ,ZNq,$j
FunctionTest 3 5 10 ;igIZ$&
输出: |wMN}bq|T
Function Client sll\g
The Digit Count for String [3] is [1] Z5n1@a__
The Factorial for [3] is [6] %[TR^Th6
The Digit Count for String [5] is [1] :3Ox~o
The Factorial for [5] is [120] |HQW0
The Digit Count for String [10] is [2] M|h3Wt~7
The Factorial for [10] is [3628800] !f[_+CD
注意:当你运行这个.EXE文件时,它引用的DLL文件可以是在当前目录,子目录,或是CORPATH这个环境变量.CORPATH这个环境变量是在.NET环境中的类路径,用来指引系统寻找类.说白了,就是JAVA中的CLASSPATH,明白了吧,呵呵. TIDO@NwF
好了,又完了一篇,今天的任务完成了,可以休息了.唉,有什么好玩的呢? ]%H`_8<gc
C#中的版本处理 q54]1TQ
　　现在我要说的是C#中的版本处理.其实这是任何一个软件必须要考虑的问题.每个软件都不只一个版本(除了我写的以外),因此版本处理显得非常地重要.JAVA很好地处理了这个问题,而我个人认为C#借鉴了JAVA的处理方法,所以,也做得很好. tDcT%D {:
在C#中,如果你在声明一个方法的时候用了virtual这个关键字,那么,在派生类中,你就可以使用override或者new关键字来弃用它或是忽略它.如果你在父类中用了virtual这个关键字,而在其派生类中又没有用override或new关键字,而直接引用一个同名方法的话,编译器将会报错,并将以new方式,即忽略派生类中的方法的方式来运行.下面的例子可以帮助你来理解: q<|AZ2Ai
000: // Versioning\versioning.cs tcI*a>
001: public class MyBase (?c"$|^J
002: { FVKTbvYn
003: public virtual string Meth1() bAqA1y3=
004: { .L~AL|2_
005: return "MyBase-Meth1"; (w3YvG.
006: } 2/^3WY1U
007: public virtual string Meth2() ES7s1O$#
008: { C,r;VyW6BI
009: return "MyBase-Meth2"; *i%d,w0+
010: } ~36!?&eA8
011: public virtual string Meth3() d7upz]K9g
012: { q|(HsLs
013: return "MyBase-Meth3"; tyFzSrfc
014: } ^nz.j
015: } KZE,bi:~
016: rb.N~
017: class MyDerived : MyBase n_A3#d<9
018: { vk^xT
019: public override string Meth1() 2[W&s&
020: { =:pJ
021: return "MyDerived-Meth1"; 8nV+e~-w
022: } "!^"[mX4
023: public new string Meth2() CA~-rv
024: { q<1~ vA9
025: return "MyDerived-Meth2"; *GPiOA a
026: } )ez9"# MH'
027: public string Meth3() // 系统在这里将会有一个警告,并且将会隐藏方法Meth3() |Rk@hzM2S
028: PJH&
029: TC*g|d @b
030: { q2E_A
031: return "MyDerived-Meth3"; ;e*!S}C,
032: } 57c8xk[.2
033: UaeXY+O
034: public static void Main() "chDg(jMZ
035: { ~9@UjQ^)F
036: MyDerived mD = new MyDerived(); )SGq[B6@I
037: MyBase mB = (MyBase) mD; hwv/AnX~O
038: 4kx N<]
039: System.Console.WriteLine(mB.Meth1()); /\n-P'}
040: System.Console.WriteLine(mB.Meth2()); 'H;*W|:-]
041: System.Console.WriteLine(mB.Meth3()); iH@UTE;
042: } > ~O.@|
043: } tWcHb #
输出: VOLj>w
MyDerived-Meth1 gPPkT"
MyBase-Meth2 |+9&rAg
MyBase-Meth3 dy[X3jQB
可以很明显地看出来,后两个new关键字的输出是父类中的方法的输出,所以可以看出,new这个关键字的作用是如果在以前的版本中有这个方法,就沿用以前的方法,而不用我现在方法内容.而virtual的方法的作用正好相反,它的作用是如果在父类中有这样一个方法,则用我现在写的方法内容,让以前的滚蛋!不过,这里用new好象不太好,让人误解(糟了,盖痴又要打我了!&*%$#@). (sZ"iGn%
如果你把第037行去掉,把039-041中的mB全部改为mD，输出又变为: 6'f;-2
MyDerived-Meth1 #H~64/
MyDerived-Meth2 FYQS)s
MyDerived-Meth3 ;2QP7PrSY
这又说明了什么呢,说明了派生类的对象只有在被父类重塑的时候,override和new关键字才会生效.呵呵,这样说的确有点难以理解,大家只有自己动手,才能搞清楚这其中的机关,所谓"实践是检验C#的唯一标准",哈哈! |A(Iti{v
在C#中,你可以自由地为在派生类中为加入一个方法,或者覆盖父类的方法,如下所示,非常地简单: tCt#%7J;a
class Base {} 9->if/r,o
class Derived: Base t?FBG4
{ R:qW;n%AF
public void F() {} H Pz+Dm
} !4+<<(B=E
和: 1'Dai`
class Base p!%pP}I
{ OjA,]Gv6
public void F() {} Q~9^{sHZjP
} `R^gU]Z,
class Derived: Base $6IJP\
{ Nh+H9
public void F() {} iy.\=Cs$N
} &rR2,3r=
好了,这一节又完了,明天见! N;%6:I./
C#中的结构(struct) F#E3q|Q"BS
　　我要说的是C#中的,注意,我在这里说的结构不是指的C#的语言结构.这里所说的是一种与类(class)相对的东西,下面我就与类相对比,来说一说这个struct. @=u3ZVD
下面的这个例子讲述了如何建立一个具有属性,方法和一个字段的结构.并讲述如何使用他. JucY[`|JV
000: // Structs\struct1.cs jL}v9$
001: using System; OY({.uVdX
002: struct SimpleStruct FS1z`wYP
003: { E]r?{t`]
004: private int xval; w0unS`\4
005: public int X |R:'\+E
006: { wMN]~|z>
007: get { |_U= z;Y
008: return xval; >9J:Uo1z
009: } Tlr v={
010: set { Xch~ 1K
011: if (value < 100) .=; ;
012: xval = value; `Pnoxm'
013: } ~gt@P
014: } dj%!I:Q>u
015: public void DisplayX() W2!+z{:m
016: { A3*!"3nU
017: Console.WriteLine("The stored value is: {0}", xval); X@FN|Rdh
018: } qqU 64E
019: } hi[pVk~B)
020: 5!9zI+S|=`
021: class TestClass Flb&B1
022: { ],].zlN
023: public static void Main() EoDA]6?Lj
024: { -UT}/:a
025: SimpleStruct ss = new SimpleStruct(); !}$$:
026: ss.X = 5; sDV Q#}a
027: ss.DisplayX(); hE-M$LmN@
028: } 7 X4LJf
029: } \l3h0R
这个例子的输出是: i@J;G`
The stored value is: 5 > Nr#O
从上面的例子中我们可以看到结构和类似乎是一样的.的确,如果你用类去重亲写这个程序,结果是一样的.但是,很明显,两个一样的东西是不可能一起出现的. 结构(struct)是值(value)型的,而类是参考型的.这样,你就可以用结构建立像内建类型那样的对象了. #X"@<l4F
还有就是如果你用一个new关键字建立一个类的实例的时候,它是以堆(heap)来分配的,而用new来建立一个结构的的实例的时候,它是以栈(stack)来分配.这会给我们提高很多性能(M$说的).好了,让我们再来看下面的例子吧: kG*~|ma
000: // Structs\struct2.cs fF kj+
001: using System; |wj?ed$ f
002: +ck}l2&#
003: class TheClass FN73+-:n:j
004: { i}?>g-(
005: public int x; Y<8vw d
006: } /a o5FL
007: U/BR*Zn]*
008: struct TheStruct Tm?#M&'
009: { {(}By/_
010: public int x; Y <qm{e
011: } 9_s`{(0?
012: ?bu>r=oIO]
013: class TestClass F6dP,(
014: { L/^I*p,
015: public static void structtaker(TheStruct s) HpnWoDM
016: { 8~gLqh8^V
017: s.x = 5; "zy7C*)>r
018: } #LOwGJ$yVz
019: public static void classtaker(TheClass c) 40 0#v|b
020: { v.5+7,4
021: c.x = 5; )dSi/
022: } 4X|zmr:A
023: public static void Main() SX-iAS[<
024: { T]p-0?=4vv
025: TheStruct a = new TheStruct(); uW3!Yg@
026: TheClass b = new TheClass(); pD+k*
027: a.x = 1; OZ!^ak
028: b.x = 1; L8 @1THY
029: structtaker(a); 3f;>" P}
030: classtaker(b); S21,VpW\
031: Console.WriteLine("a.x = {0}", a.x); t0?\l)
032: Console.WriteLine("b.x = {0}", b.x); POR\e|hRT]
033: } VLN_w$iEq
034: } !{41!O,K#
这个例子的输出是: G*v,GR
a.x = 1b.x = 5 ?0xgRe<
从这个例子例子可以看出,当一个结构被传递到一个方法时,被传递的只不过是一个副本,而一个类被传递时,被传递的是一个参考.所以a.x=输出的是1,不变,而b.x却变了. &jr3B;g!C
还有的区别就是结构可以不用new来实例化,而类却要.如果你不用new来实例化一个结构,那么所有的字段将仍然处于未分配状态,直到所有的字段被初始化.和类一样,结构可以执行接口.更重要的是,结构没有继承性,一个结构不能从别的类继承,也不能是别的类的基类. KY]C6kh
例三: N,U8YO
interface IImage ;jTN| i'
{ 7"xd1l?zz
void Paint(); 6S\8$
} {FTqu.
struct Picture : IImage WOf 4o
{ 7J&4akT{9
public void Paint() u>/ TE
{ \5cpFj5%
// painting code goes here }4S6Xe
} ;6hOx(>`=
private int x, y, z; // other struct members 2)~> R
} (_{yB[z>`
好了,关于结构我就讲到这了,以后还会讲到的. '[O;zJN;
C#中的ADO数据库访问 h`.&f
这一节我要讲的是大家非常关心的,肯定也是非常感兴趣的部分.嘿嘿,也是我写教程最拿手的部分----ADO数据库访问.想到这,我就想起我在去年写的"访问数据库"系列文章,嘿嘿!所以呢,如果你觉得对记录集之类的东西比较难理解的话,我推荐你先看一看我的那几篇文章.好了,让我们开始吧! da~],MN
什么是ADO(ActiveX Data Objects译作ActiveX数据对象),ADO是一个非常简单的思想,一种让你仅用一种方式去访问数据的思想.ADO不算一个新的思想,仅是采用现有的数据访问技术,将其融合起来.如果你不理解ADO,想一想ODBC吧!其实我们在搞ASP的时候,就用到了ADO,还记得吗,那个曾经被我们用过无数次的set conn=Server.CreateObject("ADODB.Connection")吗?是的,就是它.至于ADO的一些概念性的东西,请大家自行查阅资料,不过,其实不了解也没有关系,只把它想象成一个M$给我们的访问数据的工具吧! 3{(/x1a,4
OK,下面的例子是以一个M$ ACCESS 2000的数据库为基础的,它的结构如下,表名是Categories,文件名是BugTypes.mdb ,赶快建一个吧: ua `RJ
Category ID Category Name NW)1#]gg%
1 Bugbash stuff gv{ >`AN
2 Appweek Bugs j1HW._G
3 .NET Reports ^y4Z+Gu[
4 Internal support W|(1Y D
好的,我先把所有的程序都写出来,然后我们来一句一句的品尝: kz7(Z'pw
000: // ADO\adosample.cs e(8Ba X_
001: using System; /JU.?M35
002: using System.Data; Oz#{S:24M+
003: using System.Data.ADO; d*Fj3Wkx
004: Q)z8PQl O
005: public class MainClass BDZ?Ez\Sg
006: { xi;`ecqS<
007: public static void Main () VOh4#%Vj
008: { $,fX:x
009: // 设定好连接字符串和选择命令字符串010: string strAccessConn = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=BugTypes.MDB"; f'3$9x
011: string strAccessSelect = "SELECT * FROM Categories"; VgS_s k
012: O%HHYV%[m
013: //建立记录集,并把Categories这个表填进去 ,wdD8ZT'Ip
014: DataSet myDataSet = new DataSet(); hwNf~3eJk
015: myDataSet.Tables.Add("Categories"); h3@v+Z<}
016: t<?,F
017: //建立ADO实例018: ADOConnection myAccessConn = new ADOConnection(strAccessConn); P}`H ~N~
019: ADODataSetCommand myAccessDataSetCmd = new ADODataSetCommand(); B^jc3 VsR
020: myAccessDataSetCmd.SelectCommand = new ADOCommand(strAccessSelect,myAccessConn); J!7MZLb
021: |IUWF%~^$+
022: myAccessConn.Open(); U|j`e5)
023: try O!bOp=
024: { 5.J.RE"M
025: myAccessDataSetCmd.FillDataSet(myDataSet,"Categories"); "Os_vlapHo
026: } ps DetP
027: finally SOvF[,+
028: { dN[\xVcj
029: myAccessConn.Close(); R .2wqkY
030: } Ef13Q]9|
031: &Z|P2dI
032: try VTHH&$ZNq
033: { -1ub^feJ,
034: // 一个记录集可以包含多个表,我们把它们放到一个数组中035: DataTable[] dta = myDataSet.Tables.All; n>U5R_T
036: foreach (DataTable dt in dta) 2jCfT>`3
037: { DkAAV9*
038: Console.WriteLine("Found data table {0}", dt.TableName); yyy|Pw4:Z
039: } I[X772K
040: &~U ]~;@
041: //下面的两行程序展示了两种从一个记录集中得到这个数据集中的表格数的方法 B@ KQ]4-
042: Console.WriteLine("{0} tables in data set", myDataSet.Tables.Count); NSA-}2$
043: Console.WriteLine("{0} tables in data set", dta.Length); Tc3yS(aq
044: //下面的几行程序说明了如何从一个记录集中依靠表格的名称来取得信息 ^\,E&=/}M
045: Console.WriteLine("{0} rows in Categories table", myDataSet.Tables["Categories"].Rows.Count); K@w{"7}
046: //列的信息是自动从数据库中得到的,所以我们可以用以下的代码047: Console.WriteLine("{0} columns in Categories table", myDataSet.Tables["Categories"].Columns.Count); _``=cc
048: DataColumn[] drc = myDataSet.Tables["Categories"].Columns.All; ^@NU}S):yN
049: int i = 0; k2UVm$}u
050: foreach (DataColumn dc in drc) F`]2O:[
051: { _ZkI)o
052: //打印出列的下标和列的名称和数据类型053: Console.WriteLine("Column name[{0}] is {1}, of type {2}",i++ , dc.ColumnName, dc.DataType); Y% 5eZ=z
054: } ZO$%[ftb
055: DataRow[] dra = myDataSet.Tables["Categories"].Rows.All; jsi!fx2Rm
056: foreach (DataRow dr in dra) "|KP'<8%
057: { w_u\sSQ`!
058: //打印出CategoryID和CategoryName059: Console.WriteLine("CategoryName[{0}] is {1}", dr[0], dr[1]); qK&d]6H R
060: } 3>VL}Ui}
061: } CF5`-wj/#
062: catch (Exception e) @cB$iP=Z4
063: { ~z;FP$U
064: Console.WriteLine("Oooops. Caught an exception:\n{0}", e.Message); O463I.XAP
065: } 2*#|Nj=^
066: } 4d;8`66O
067: } gEE\y{y
看起来,这个例子是有一些复杂的,只怪我例子选的不好,呵呵.不过,细细分析一下,还是可以理解的.我现在说一下这个例子中几个特别的东东.第一就是不象在ASP中,一个命令字符串被须被当作一个命令对象. Qv/=&_6
020做的正是这个事情.注意,在015行有一个myDataSet.Tables.Add("Categories")语句,这并不是把数据库中的Categories这个表填进去,只不过是建一个空表,而 *<ewS8f*6
025才是真的填充数据. *$ %a:q1U
这个例子的输出是: XACm[NY_
Found data table Categories ]-QA'Lq
1 tables in data set ,:\|7F
1 tables in data set e'b(gD}
4 rows in Categories table W-zP/]Dh
2 columns in Categories table mF^v~
Column name[0] is CategoryID, of type Int32 _n>,!vH
Column name[1] is CategoryName, of type System.String AbmAKA@
CategoryName[1] is Bugbash stuff EG |A_m85
CategoryName[2] is Appweek Bugs e.V:)7Uc
CategoryName[3] is .NET Reports PBkt~=j
CategoryName[4] is Internal support