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) ) ekvs3a^
013: { B^/MwD>%
014: count++; #zTy7ZS,0
015: } ):'wxIVGI
016: } 86OrJdD8
017: -y-}g[`
018: return count; 3A!a7]fW
019: } >O?WRCB
020: } sNDo@u7
021: } 5P\>$N1p
注意,这个例子中的namespace应与第一个的一致,因为它们是同一个库中的.NumberOfDigits方法计算了参数中的数字的个数. VkFh(Br<{
第三个文件是FunctionClient.cs 4%J0e'iN
我们知道,一个库一旦建立,就可以被别的类利用(废话,要不然怎么叫库呢?).下面的C#程序就利用了我们刚才建立的库中的类. uP'L6p5
000: // Libraries\FunctionClient.cs KMwV;r
001: using System; P)`^rJ6
002: using Functions; FuiR\"Ww
003: class FunctionClient xT"V9t[f
004: { QCW4gIp
005: public static void Main(string[] args) D_d>A+
006: { xRD+!3
007: Console.WriteLine("Function Client"); ;[::&qf
008: ;|WUbc6&g
009: if ( args.Length == 0 ) OM[MRZEh G
010: { D{N8q^Cs9
011: Console.WriteLine("Usage: FunctionTest ... "); kw$7G1Q
012: return; ~{I.qv)>M~
013: } d <}'eBT'
014: \:4*h
015: for ( int i = 0; i < args.Length; i++ ) ^[7Mp
016: { +a!3*G@N+
017: int num = Int32.Parse(args); H ni^S
018: Console.WriteLine( ML_VD*t9
019: "The Digit Count for String [{0}] is [{1}]", euB1}M
020: args, fB3Jp~$
021: DigitCount.NumberOfDigits(args)); pq{`WgA^
022: Console.WriteLine( @!P2f
023: "The Factorial for [{0}] is [{1}]", <2U@O` gC
024: num, {KWVPeh
025: Factorial.Calc(num) ); G1z*e.+y
026: } Xj\ToO
027: } :cC$1zv@
028: } Q]K` p(
在002行中,一个using Functions指明了引用Functions.DLL这个类. gsyOf*Q$
如果我们在命令行中键入如下命令,就可以看到输出: s$Y>nH~T
FunctionTest 3 5 10 gTho:;q7a
输出: :ZXd%
Function Client zvV&Hks-
The Digit Count for String [3] is [1] F-/z@tM
The Factorial for [3] is [6] m=01V5_
The Digit Count for String [5] is [1] lAU99(GXV
The Factorial for [5] is [120] .rtA sbp.!
The Digit Count for String [10] is [2] L~6%Fi&n4
The Factorial for [10] is [3628800] \C3I6Qx
注意:当你运行这个.EXE文件时,它引用的DLL文件可以是在当前目录,子目录,或是CORPATH这个环境变量.CORPATH这个环境变量是在.NET环境中的类路径,用来指引系统寻找类.说白了,就是JAVA中的CLASSPATH,明白了吧,呵呵. XYo,5-
好了,又完了一篇,今天的任务完成了,可以休息了.唉,有什么好玩的呢? !kE5]<H\
C#中的版本处理 EbILAJ
　　现在我要说的是C#中的版本处理.其实这是任何一个软件必须要考虑的问题.每个软件都不只一个版本(除了我写的以外),因此版本处理显得非常地重要.JAVA很好地处理了这个问题,而我个人认为C#借鉴了JAVA的处理方法,所以,也做得很好. cX-M9Cz
在C#中,如果你在声明一个方法的时候用了virtual这个关键字,那么,在派生类中,你就可以使用override或者new关键字来弃用它或是忽略它.如果你在父类中用了virtual这个关键字,而在其派生类中又没有用override或new关键字,而直接引用一个同名方法的话,编译器将会报错,并将以new方式,即忽略派生类中的方法的方式来运行.下面的例子可以帮助你来理解: N]+6<
000: // Versioning\versioning.cs Q~(Gll;
001: public class MyBase bgorW"'
002: { r"dIB@
003: public virtual string Meth1() ]W5*R07
004: { 7'IIB1v.\
005: return "MyBase-Meth1"; Q~U\f$N
006: } j?2~6W/[
007: public virtual string Meth2() ({!!b"B2
008: { ""-wM~^D
009: return "MyBase-Meth2"; }YDi/b7
010: } 5tlRrf
011: public virtual string Meth3() 3IMvtg
012: { [ \_o_W
013: return "MyBase-Meth3"; :.x(( FU
014: } "|8oFf)l@B
015: } aO&U=!
016: 5%Qxx\q
017: class MyDerived : MyBase *2zp>(%
018: { BmX'%5ho
019: public override string Meth1() a#j,0FKv
020: { IIR+qJ__|
021: return "MyDerived-Meth1"; y&$n[j
022: } #|b*l/t8
023: public new string Meth2() wm`<+K
024: { t*(bF[?
025: return "MyDerived-Meth2"; x4^nT=?6_
026: } D;Qx9^.
027: public string Meth3() // 系统在这里将会有一个警告,并且将会隐藏方法Meth3() aRMlE*yW
028: ~n]5iGz
029: _@ao$)q{J
030: { *?X&Y8Kf
031: return "MyDerived-Meth3"; u<S`"MR:J
032: } #%E`~&[
033: *E/Bfp1LIe
034: public static void Main() [9">}l
035: { LIID(s!bX
036: MyDerived mD = new MyDerived(); ~71U s
037: MyBase mB = (MyBase) mD; ;JkSZs3
038: Ce}`z L
039: System.Console.WriteLine(mB.Meth1()); =d{6=2Pt
040: System.Console.WriteLine(mB.Meth2()); 4zMvHe
041: System.Console.WriteLine(mB.Meth3()); [bh?p+V
042: } 40kAGs>_
043: } i6if\B
输出: G)7U&B
MyDerived-Meth1 60+zoL'
MyBase-Meth2 I0}.!
MyBase-Meth3 ukR0E4p
可以很明显地看出来,后两个new关键字的输出是父类中的方法的输出,所以可以看出,new这个关键字的作用是如果在以前的版本中有这个方法,就沿用以前的方法,而不用我现在方法内容.而virtual的方法的作用正好相反,它的作用是如果在父类中有这样一个方法,则用我现在写的方法内容,让以前的滚蛋!不过,这里用new好象不太好,让人误解(糟了,盖痴又要打我了!&*%$#@). XJ<"S p
如果你把第037行去掉,把039-041中的mB全部改为mD，输出又变为: \L*%?~
MyDerived-Meth1 _w\9 \<%
MyDerived-Meth2 6eSo.@*l
MyDerived-Meth3 CQWXLQED>
这又说明了什么呢,说明了派生类的对象只有在被父类重塑的时候,override和new关键字才会生效.呵呵,这样说的确有点难以理解,大家只有自己动手,才能搞清楚这其中的机关,所谓"实践是检验C#的唯一标准",哈哈! DsHF9Mn
在C#中,你可以自由地为在派生类中为加入一个方法,或者覆盖父类的方法,如下所示,非常地简单: D]@(LbMG4
class Base {} b9j}QK
class Derived: Base '##?PQ*u
{ A^OwT#
public void F() {} c]9gf\WW
} mo| D
和: 5T;LWS
class Base ahl|N`
{ gnp.!-
public void F() {} t=P+m
} qd0G sr}j
class Derived: Base /!H24[tnk1
{ =z# trQ{
public void F() {} 9+1{a.JO
} :=NXwY3~M
好了,这一节又完了,明天见! JQM_96\
C#中的结构(struct) _BewaI;w
　　我要说的是C#中的,注意,我在这里说的结构不是指的C#的语言结构.这里所说的是一种与类(class)相对的东西,下面我就与类相对比,来说一说这个struct. wo`.sB&T
下面的这个例子讲述了如何建立一个具有属性,方法和一个字段的结构.并讲述如何使用他. #<0Hvde
000: // Structs\struct1.cs B[uyr)$
001: using System; :xsZz$
002: struct SimpleStruct `PUqz&
003: { i<ES/U\
004: private int xval; UPfE\KN+p#
005: public int X M}|(:o3Yo
006: { 07.p {X R
007: get { lju5+0BSb
008: return xval; 2y!n c%
009: } m^ xTV-#l@
010: set { e)e(f"t6Q
011: if (value < 100) wC{sP"D
012: xval = value; TZgtu+&
013: } E^-c,4'F
014: } |P5dv>tb F
015: public void DisplayX() Oa/^A-'Q
016: { *Dg@fxCQ
017: Console.WriteLine("The stored value is: {0}", xval); Wg}KQ6 6
018: } 9~UR(Ts}l
019: } hCQOwk#
020: d8wGXNd7B
021: class TestClass [E9iuym
022: { B /;(#{U;
023: public static void Main() v^&HZk=(
024: { tiZH;t';<
025: SimpleStruct ss = new SimpleStruct(); =IL\T8y09
026: ss.X = 5; 1GN^uia7
027: ss.DisplayX(); [Hx}#Kds
028: } !RKuEg4hQ
029: } u#ya 8
这个例子的输出是: gT8(LDJ
The stored value is: 5 MD[hqshoh
从上面的例子中我们可以看到结构和类似乎是一样的.的确,如果你用类去重亲写这个程序,结果是一样的.但是,很明显,两个一样的东西是不可能一起出现的. 结构(struct)是值(value)型的,而类是参考型的.这样,你就可以用结构建立像内建类型那样的对象了. F8w7N$/V",
还有就是如果你用一个new关键字建立一个类的实例的时候,它是以堆(heap)来分配的,而用new来建立一个结构的的实例的时候,它是以栈(stack)来分配.这会给我们提高很多性能(M$说的).好了,让我们再来看下面的例子吧: {7e(0QK
000: // Structs\struct2.cs FS"Ja`>j~
001: using System; I=L["]
002: )?72 +X
003: class TheClass eCI'<^
004: { t!\aDkxo %
005: public int x; R2)@Q
006: } C@qWour
007: EE'2<"M
008: struct TheStruct ?A@y4<8R|
009: { :j]6vp6
010: public int x; }%XB*pzQ
011: } +`F(wk["m
012: ["nWIs[h
013: class TestClass DGJ:#UE
014: { U.TZd"
015: public static void structtaker(TheStruct s) _f!ko<52
016: { I[%IW4jJ
017: s.x = 5; EP38Ho=[
018: } .w4|$.H
019: public static void classtaker(TheClass c) z_'^=9m
020: { Qy:yz
021: c.x = 5; _h1bVd-
022: } Sj ovL@X
023: public static void Main() @JSWqi>
024: { 0eO!,/
025: TheStruct a = new TheStruct(); $PMr)U
026: TheClass b = new TheClass(); >9w^C1"
027: a.x = 1; />xEpR3_A
028: b.x = 1; a@? $#>
029: structtaker(a); ^6Aa^|
030: classtaker(b); 8g=O0Gb
031: Console.WriteLine("a.x = {0}", a.x); $@VJ@JAe
032: Console.WriteLine("b.x = {0}", b.x); i7dDklj4
033: } ,.Ofv):=
034: } 4b}p[9k
这个例子的输出是: xiW}P% bf
a.x = 1b.x = 5 GIlaJ!/
从这个例子例子可以看出,当一个结构被传递到一个方法时,被传递的只不过是一个副本,而一个类被传递时,被传递的是一个参考.所以a.x=输出的是1,不变,而b.x却变了. z"6o|]9I
还有的区别就是结构可以不用new来实例化,而类却要.如果你不用new来实例化一个结构,那么所有的字段将仍然处于未分配状态,直到所有的字段被初始化.和类一样,结构可以执行接口.更重要的是,结构没有继承性,一个结构不能从别的类继承,也不能是别的类的基类. z_(l]Ern}
例三: HP*)^`6X
interface IImage w(HVC
{ 4s m [y8
void Paint(); i<S\x
} -(57C*#ap
struct Picture : IImage %>K(IRpMW
{ Rc)]A&J
public void Paint() .yF-<Y
{ n*GB`I*g
// painting code goes here ZvuY]=^3
} 5^uX!_r`
private int x, y, z; // other struct members _U}|Le@ e
} 3+>R%TX6i<
好了,关于结构我就讲到这了,以后还会讲到的. dtuCA"D
C#中的ADO数据库访问 .;?ha'
这一节我要讲的是大家非常关心的,肯定也是非常感兴趣的部分.嘿嘿,也是我写教程最拿手的部分----ADO数据库访问.想到这,我就想起我在去年写的"访问数据库"系列文章,嘿嘿!所以呢,如果你觉得对记录集之类的东西比较难理解的话,我推荐你先看一看我的那几篇文章.好了,让我们开始吧! og$dv 23
什么是ADO(ActiveX Data Objects译作ActiveX数据对象),ADO是一个非常简单的思想,一种让你仅用一种方式去访问数据的思想.ADO不算一个新的思想,仅是采用现有的数据访问技术,将其融合起来.如果你不理解ADO,想一想ODBC吧!其实我们在搞ASP的时候,就用到了ADO,还记得吗,那个曾经被我们用过无数次的set conn=Server.CreateObject("ADODB.Connection")吗?是的,就是它.至于ADO的一些概念性的东西,请大家自行查阅资料,不过,其实不了解也没有关系,只把它想象成一个M$给我们的访问数据的工具吧! yMW3mx301j
OK,下面的例子是以一个M$ ACCESS 2000的数据库为基础的,它的结构如下,表名是Categories,文件名是BugTypes.mdb ,赶快建一个吧: 9ZOQNN<ex
Category ID Category Name _ (b4|hJ'
1 Bugbash stuff Wda?$3!^q
2 Appweek Bugs @%g:'^/
3 .NET Reports gB#!g@
4 Internal support ${Lrj}93
好的,我先把所有的程序都写出来,然后我们来一句一句的品尝: v0r:qku
000: // ADO\adosample.cs C=c&.-Nb9
001: using System; J*g<]P&p0
002: using System.Data; jGLmgJG-P
003: using System.Data.ADO; ~H''RzN
004: y2%[/L:u~
005: public class MainClass -)J*(7F(6^
006: { SMvlEj^
007: public static void Main () T>|+cg
008: { nILUo2e~
009: // 设定好连接字符串和选择命令字符串010: string strAccessConn = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=BugTypes.MDB"; 6+sz4
011: string strAccessSelect = "SELECT * FROM Categories"; |vi=h2*
012: 1q'_J?Xmd
013: //建立记录集,并把Categories这个表填进去 s,-<P1}/
014: DataSet myDataSet = new DataSet(); P3bRv^
015: myDataSet.Tables.Add("Categories"); CEk[&39"
016: Iv7BIK^0
017: //建立ADO实例018: ADOConnection myAccessConn = new ADOConnection(strAccessConn); \.P'8As
019: ADODataSetCommand myAccessDataSetCmd = new ADODataSetCommand(); (O ;R~Io
020: myAccessDataSetCmd.SelectCommand = new ADOCommand(strAccessSelect,myAccessConn); mC]Krnx
021: tklS=R^Vn
022: myAccessConn.Open(); F\+9u$=
023: try j; /@A lZl
024: { SFWS<H(IN
025: myAccessDataSetCmd.FillDataSet(myDataSet,"Categories"); 1|*%
026: } t":^:i'M
027: finally !OV+2suu1
028: { fpNq
029: myAccessConn.Close(); 2wU,k(F_
030: } S@\&^1;4Hv
031: un6W|{4]
032: try {w>ofyqfp&
033: { CNiJuj`
034: // 一个记录集可以包含多个表,我们把它们放到一个数组中035: DataTable[] dta = myDataSet.Tables.All; fNr*\=$
036: foreach (DataTable dt in dta) U&kdR+dB
037: { Mn\L55?E(
038: Console.WriteLine("Found data table {0}", dt.TableName); sC.cMZe
039: } @6jKjI
040: Z1H
041: //下面的两行程序展示了两种从一个记录集中得到这个数据集中的表格数的方法 >taT V_,
042: Console.WriteLine("{0} tables in data set", myDataSet.Tables.Count); R{4[.
043: Console.WriteLine("{0} tables in data set", dta.Length); wj$3L3
044: //下面的几行程序说明了如何从一个记录集中依靠表格的名称来取得信息 g[2[ zIB=
045: Console.WriteLine("{0} rows in Categories table", myDataSet.Tables["Categories"].Rows.Count); "=f,4Zbj
046: //列的信息是自动从数据库中得到的,所以我们可以用以下的代码047: Console.WriteLine("{0} columns in Categories table", myDataSet.Tables["Categories"].Columns.Count); '@^<c#h]=
048: DataColumn[] drc = myDataSet.Tables["Categories"].Columns.All; aLevml2:T
049: int i = 0; j~2t^Qz
050: foreach (DataColumn dc in drc) -J!k|GK#MX
051: { Iq;a!Lya-
052: //打印出列的下标和列的名称和数据类型053: Console.WriteLine("Column name[{0}] is {1}, of type {2}",i++ , dc.ColumnName, dc.DataType); #$t93EI
054: } ZCuh^
055: DataRow[] dra = myDataSet.Tables["Categories"].Rows.All; {flxZ}
056: foreach (DataRow dr in dra) _#UhXXD
057: { z<"\I60Fe
058: //打印出CategoryID和CategoryName059: Console.WriteLine("CategoryName[{0}] is {1}", dr[0], dr[1]); U,/9fzgd
060: } kD+B8TrW
061: } XK l3B=h
062: catch (Exception e) 9OF(UFgS
063: { (j}Wt8
064: Console.WriteLine("Oooops. Caught an exception:\n{0}", e.Message); i#lO{ ]
065: } t;%MSedn
066: } AK;G_L
067: } nRZ T~S4
看起来,这个例子是有一些复杂的,只怪我例子选的不好,呵呵.不过,细细分析一下,还是可以理解的.我现在说一下这个例子中几个特别的东东.第一就是不象在ASP中,一个命令字符串被须被当作一个命令对象. b|Ed@C
020做的正是这个事情.注意,在015行有一个myDataSet.Tables.Add("Categories")语句,这并不是把数据库中的Categories这个表填进去,只不过是建一个空表,而 p t{/|P
025才是真的填充数据. .Wyx#9
这个例子的输出是: () HIcu*i
Found data table Categories 4s&koH(x
1 tables in data set `4]-B@ 7_
1 tables in data set Yi"jj;!^S
4 rows in Categories table D/zp_9B
2 columns in Categories table =dC5q{
Column name[0] is CategoryID, of type Int32 ET]`
Column name[1] is CategoryName, of type System.String nG5:H.)
CategoryName[1] is Bugbash stuff Se5jxV
CategoryName[2] is Appweek Bugs X15e~;&
CategoryName[3] is .NET Reports u|8V7*)3
CategoryName[4] is Internal support