TRNG I HC KHOA HC T NHIÊN
KHOA CÔNG NGH THÔNG TIN
B MÔN CÔNG NGH PHN MM
PHM VN VIT - TRNG LP V

TÌM HIU NGÔN NG C# VÀ
VIT MT NG DNG MINH HA

 ÁN TT NGIP
GIÁO VIÊN HNG DN
NGUYN TN TRN MINH KHANG

TP. HCM 2002
TRNG I HC KHOA HC T NHIÊN
KHOA CÔNG NGH THÔNG TIN
B MÔN CÔNG NGH PHN MM

dn và giúp đ trong thi gian thc hin đ án này.
Chúng em xin t lòng bit n sâu sc đi vi gia đình đã đng viên, to điu kin đ
thc hin tt bài đ án. Xin cám n cha, m, anh, ch, em!
Chúng em cng xin chân thành cm n đn các thy cô khoa Công ngh thông tin
trng i hc Khoa hc T nhiên Thành ph H Chí Minh đã truyn đt nhng kin
thc, kinh nghim quí báu cho chúng em trong quá trình hc tp ti trng.
Chúng em cng xin chân thành cm n đn các bn bè đã giúp đ tài liu, trao đi hc
thut mi có th thc hin đ án này. Xin gi li cm n đn các bn H Ngc Huy,
Trn Th Anh, Bùi Thanh Tun...
Thành ph H Chí Minh, ngày 03 tháng 8 nm 2002
Sinh viên
Phm Vn Vit
Trng Lp V Mc lc

Li cám n.......................................................................................................................3
Mc lc............................................................................................................................4
Tóm tt.............................................................................................................................1
Phn 1 Tìm hiu ngôn ng C#.........................................................................................1
Chng 1 C# và .Net Framework................................................................................2
1.1 Nn tng ca .NET.............................................................................................2
1.2 .NET Framework ...............................................................................................3
1.3 Biên dch và ngôn ng trung gian (MSIL).........................................................4
1.4 Ngôn ng C#......................................................................................................5
Chng 2 Khi đu......................................................................................................6

6.1 Cách dùng t khoá operator.............................................................................44
6.2 Cách h tr các ngôn ng .Net khác................................................................44
6.3 S hu ích ca các toán t ...............................................................................44
6.4 Các toán t logic hai ngôi ................................................................................45
6.5 Toán t so sánh bng........................................................................................45
6.6 Toán t chuyn đi kiu (ép kiu) ...................................................................45
Chng 7 Cu trúc.....................................................................................................48
7.1 nh ngha cu trúc..........................................................................................48
7.2 Cách to cu trúc..............................................................................................49
Chng 8 Giao din...................................................................................................50
8.1 Cài đt mt giao din .......................................................................................50
8.2 Truy xut phng thc ca giao din ..............................................................52
8.3 Np chng phn cài đt giao din ....................................................................54
8.4 Thc hin giao din mt cách tng minh ......................................................55
Chng 9 Array, Indexer, and Collection .................................................................58
9.1 Mng (Array) ...................................................................................................58
9.2 Câu lnh foreach ..............................................................................................59
9.3 Indexers............................................................................................................62

9.4 Các giao din túi cha......................................................................................65
9.5 Array Lists........................................................................................................65
9.6 Hàng đi...........................................................................................................65
9.7 Stacks ...............................................................................................................66
9.8 Dictionary.........................................................................................................66
Chng 10 Chui.......................................................................................................67
10.1 To chui mi ................................................................................................67
10.2 Phng thc ToString() .................................................................................67
10.3 Thao tác chui................................................................................................68
10.4 Thao tác chui đng.......................................................................................70
Chng 11 Qun lý li...............................................................................................72

17.3 Ranh gii an ninh.........................................................................................196
17.4 S hiu phiên bn (Versioning) ...................................................................196
17.5 Manifest........................................................................................................196
17.6 a Module Assembly...................................................................................197
17.7 Assembly ni b (private assembly)............................................................198
17.8 Assembly chia s (shared assembly)............................................................198
Chng 18 Attributes và Reflection ........................................................................200
18.1 Attributes......................................................................................................200
18.2 Attribute mc đnh (intrinsic attributes).......................................................200
18.3 Attribute do lp trình viên to ra..................................................................201
18.4 Reflection .....................................................................................................203
Chng 19 Marshaling và Remoting.......................................................................204
19.1 Min ng Dng (Application Domains) .....................................................204
19.2 Context .........................................................................................................206
19.3 Remoting......................................................................................................208
Chng 20 Thread và S ng B .........................................................................215
20.1 Thread ..........................................................................................................215
20.2 ng b hóa (Synchronization) ...................................................................216
20.3 Race condition và DeadLock.......................................................................221
Chng 21 Lung d liu........................................................................................223
21.1 Tp tin và th mc .......................................................................................223
21.2 c và ghi d liu........................................................................................230
21.3 Bt đng b nhp xut .................................................................................235
21.4 Serialization..................................................................................................238
21.5 Isolate Storage..............................................................................................244
Chng 22 Lp trình .NET và COM.......................................................................246
22.1 P/Invoke .......................................................................................................246
22.2 Con tr..........................................................................................................248
Phn 2 Xây dng mt ng dng minh ha..................................................................250



1

Phn 1
Tìm hiu ngôn ng C#
C# và .Net Framework Gvhd: Nguyn Tn Trn Minh Khang
2 Chng 1 C# và .Net Framework
Mc tiêu ca C# là cung cp mt ngôn ng lp trình đn gin, an toàn, hin đi,
hng đi tng, đt trng tâm vào Internet, có kh nng thc thi cao cho môi
trng .NET. C# là mt ngôn ng mi, nhng tích hp trong nó nhng tinh hoa ca
ba thp k phát trin ca ngôn ng lp trình. Ta có th d dàng thy trong C# có
nhng đc trng quen thuc ca Java, C++, Visual Basic, …
 tài này đt trng tâm gii thiu ngôn ng C# và cách dùng nó nh là mt công
c lp trình trên nn tng .NET. Vi ngôn ng C++, khi hc nó ta không cn quan
tâm đn môi trng thc thi. Vi ngôn ng C#, ta hc đ to mt ng dng .NET,
nu l là ý này có th b l quan đim chính ca ngôn ng này. Do đó, trong đ tài
này xét C# tp trung trong ng cnh c th là nn tng .NET ca Microsoft và trong
các ng dng máy tính đ bàn và ng dng Internet.
Chng này trình bày chung v hai phn là ngôn ng C# và nn tng .NET, bao
gm c khung ng dng .NET (.NET Framework)
1.1 Nn tng ca .NET
Khi Microsoft công b C# vào tháng 7 nm 2000, vic khánh thành nó ch là mt
phn trong s rt nhiu s kin mà nn tng .Net đc công công b. Nn tng .Net
là bô khung phát trin ng dng mi, nó cung cp mt giao din lp trình ng dng

tuân theo CLS s to các đi tng có th tng hp vi các đi tng khác. B th
vin lp ca khung ng dng (Framework Class Library - FCL) có th đc dùng
bi bt k ngôn ng nào tuân theo CLS.
.NET Framework nm  tng trên ca h điu hành (bt k h điu hành nào không
ch là Windows). .NET Framework bao bao gm:
•
Bn ngôn ng chính thc: C#, VB.Net, C++, và Jscript.NET
• Common Language Runtime - CLR, nn tng hng đi tng cho phát trin
ng dng Windows và web mà các ngôn ng có th chia s s dng.
•
B th vin Framework Class Library - FCL.
Hình 1-1 Kin trúc khung ng dng .Net

C# và .Net Framework Gvhd: Nguyn Tn Trn Minh Khang
4
Thành phn quan trng nht ca .NET Framework là CLR, nó cung cp môi trng
cho ng dng thc thi, CLR là mt máy o, tng t máy o Java. CLR kích hot
đi tng, thc hin kim tra bo mt, cp phát b nh, thc thi và thu dn chúng.
Trong Hình 1-1 tng trên ca CLR bao gm:
• Các lp c s
•
Các lp d liu và XML
• Các lp cho dch v web, web form, và Windows form.
Các lp này đc gi chung là FCL, Framework Class Library, cung cp API
hng đi tng cho tt c các chc nng ca .NET Framework (hn 5000 lp).
Các lp c s tng t vi các lp trong Java. Các lp này h tr các thao tác nhp
xut, thao tác chui, vn bn, qun lý bo mt, truyn thông mng, qun lý tiu trình
và các chc nng tng hp khác …
Trên mc này là lp d liu và XML. Lp d liu h tr vic thao tác các d liu
trên c s d liu. Các lp này bao gm các lp SQL (Structure Query Language:

C++. Hn th, C# h tr kiu su liu mi, cho phép su liu trc tip trong tp tin
mã ngun. n khi biên dch s to tp tin su liu theo đnh dng XML.
C# h tr khái nim giao din, interfaces (tng t Java). Mt lp ch có th k
tha duy nht mt lp cha nhng có th cài đt nhiu giao din.
C# có kiu cu trúc, struct (không ging C++). Cu trúc là kiu hng nh và b gii
hn.Cu trúc không th tha k lp hay đc k tha nhng có th cài đt giao din.
C# cung cp nhng đc trng lp trình hng thành phn nh property, s kin và
dn hng khai báo (đc gi là attribute). Lp trình hng component đc h tr
bi CLR thông qua siêu d liu (metadata). Siêu d liu mô t các lp bao gm các
phng thc và thuc tính, các thông tin bo mt ….
Assembly là mt tp hp các tp tin mà theo cách nhìn ca lp trình viên là các th
vin liên kt đng (DLL) hay tp tin thc thi (EXE). Trong .NET mt assembly là
mt đon v ca vic tái s dng, xác đnh phiên bn, bo mt, và phân phi. CLR
cung cp mt s các lp đ thao tác vi assembly.
C# cng cho truy cp trc tip b nh dùng con tr kiu C++, nhng vùng mã đó
đc xem nh không an toàn. CLR s không thc thi vic thu dn rác t đng các
đi tng đc tham chiu bi con tr cho đn khi lp trình viên t gii phóng.

Khi đu Gvhd: Nguyn Tn Trn Minh Khang
6 Chng 2 Khi đu
Chng này ta s to, biên dch và chy chng trình “Hello World” bng ngôn ng
C#. Phân tích ngn gn chng trình đ gii thiu các đc trng chính yu trong
ngôn ng C#.
Ví d 2-1 Chng trình Hello World
class HelloWorld
{


Khi đu Gvhd: Nguyn Tn Trn Minh Khang
7
2.1.2 Các ghi chú
C# có ba kiu ghi chú trong đó có hai kiu rt quen thuc ca C++ là dùng:
"//" và
"
/* … */". Ngoài ra còn mt kiu ghi chú na s trình bày  các chng k.
Ví d 2-2 Hai hình thc ghi chú trong C#
class HelloWorld
{

static void Main( ) // ây là ghi trên mt dòng
{

/* Bt đu ghi chú nhiu dòng
Vn còn trong ghi chú
Kt thúc ghi chú bng */
System.Console.WriteLine("Hello World");
}
}
2.1.3 ng dng dng console
“Hello World” là mt ng dng console. Các ng dng dng này thng không có
giao din ngi dùng đ ha Các nhp xut đu thông qua các console chun (dng
dòng lnh nh DOS).
Trong ví d trên, phng thc
Main() vit ra màn hình dòng “Hello World”. Do
màn hình qun lý mt đi tng
Console, đi tng này có phng thc
WriteLine() cho phép đt mt dòng ch lên màn hình.  gi phng thc này ta
dùng toán t “.”, nh sau:

Nu chng trình s dng nhiu ln phng thc Console.WriteLine, t System s
phi vit nhiu ln. iu này có th khin lp trình viên nhàm chán. Ta s khai báo
rng chng trình có s dng vùng tên System, sau đó ta dùng các lp trong vùng
tên System mà không cn phi có t System đi trc.
Ví d 2-3 T khóa using
// Khai báo chng trình có s dng vùng tên System
using System;

class HelloWorld
{

static void Main( )
{

// Console thuc vùng tên System
Console.WriteLine("Hello World");
}
}
2.1.7 Phân bit hoa thng
Ngôn ng C# cng phân bit ch hoa thng ging nh Java hay C++ (không nh
VB). Ví d nh
WriteLine khác vi writeLine và c hai cùng khác vi
WRITELINE. Tên bin, hàm, hng … đu phân bit ch hoa ch thng.
2.1.8 T khoá static
Trong Ví d 2-1 phng thc
Main() đc khai báo kiu tr v là void và dùng t
khoá static. T khoá static cho bit là ta có th gi phng thc
Main() mà không
cn to mt đi tng kiu
HelloWorld.

Cách đt đim ngt (breakpoint) và làm sao chy cho đn đim ngt
• Làm th nào chy tng bc và chy vt qua mt phng thc.
• Làm sao đ quan sát và hiu chnh giá tr ca bin, d liu thành viên, …
Cách đn gin nht đ đt đim ngt là bm chut trái vào phía l trái, ti đó s hin
lên mt chm đ.
Khi đu Gvhd: Nguyn Tn Trn Minh Khang
11

Hình 2-3 Minh ha mt đim ngt
Cách dùng trình g ri hoàn toàn ging vi trình g ri trong VS 6.0. Nó cho phép
ta dng li  mt v trí bt k, cho ta kim tra giá tr tc thi bng cách di chuyn
chut đn v tr bin. Ngoài ra, khi g ri ta cng có th xem giá tr các bin thông
qua ca s Watch và Local.
 chy trong ch đ g ri ta chn Debug å Start hay nhn
F5
, mun chy tng
bc ta bm F11 và chy vt qua mt phng thc ta bm F10.
Nhng c s ca ngôn ng C# Gvhd: Nguyn Tn Trn Minh Khang
12 Chng 3 Nhng c s ca ngôn ng C#
Trong chng này s trình bày v h thng kiu trong C#; phân bit kiu dng sn
(int, long, bool, …) vi các kiu do ngi dùng đnh ngha. Ngoài ra, chng này
cng s trình bày cách to và dùng bin, hng; gii thiu kiu lit kê, chui, kiu
đnh danh, biu thc, và câu lnh. Phn hai ca chng trình bày v các cu trúc
điu kin và các toán t logic, quan h, toán hc, …
3.1 Các kiu
C# buc phi khai báo kiu ca đi tng đc to. Khi kiu đc khai báo rõ ràng,
trình biên dch s giúp ngn nga li bng cách kim tra d liu đc gán cho đi

8
Int64 S nguyên có du (- 9223372036854775808 ..
9223372036854775807)
ulong 8 Uint64 S nguyên không du (0 .. 0xffffffffffffffff.)
3.1.1.1 Chn mt kiu đnh sn
Tu vào tng giá tr mun lu tr mà ta chn kiu cho phù hp. Nu chn kiu quá
ln so vi các giá tr cn lu s làm cho chng trình đòi hi nhiu b nh và chy
chm. Trong khi nu giá tr cn lu ln hn kiu thc lu s làm cho giá tr các bin
b sai và chng trình cho kt qu sai.
Kiu char biu din mt ký t Unicode. Ví d “\u0041” là ký t “A” trên bng
Unicode. Mt s ký t đc bit đc biu din bng du “\” trc mt ký t khác.
Bng 3-2 Các ký t đc bit thông dng
Ký t Ngha
\’ du nháy đn
\”
du nháy đôi
\\ du chéo ngc “\”
\0
Null
\a Alert
\b
lùi v sau
\f Form feed
\n
xung dòng
\r v đu dòng
\t
Tab ngang
\v Tab dc
3.1.1.2 Chuyn đi kiu đnh sn

hn. Enum không có hàm thành viên. Ví d to mt enum tên là Ngay nh sau:
enum Ngay {Hai, Ba, Tu, Nam, Sau, Bay, ChuNhat};
Theo cách khai báo này enum ngày có by giá tr nguyên đi t 0 = Hai, 1 = Ba, 2 =
T … 7 = ChuNhat.
Ví d 3-1 S dng enum Ngay
using System;
public class EnumTest
{
enum Ngay {Hai, Ba, Tu, Nam, Sau, Bay, ChuNhat };

public static void Main()
{
int x = (int) Ngay.Hai;
int y = (int) Ngay.Bay;
Console.WriteLine("Thu Hai = {0}", x);
Console.WriteLine("Thu Bay = {0}", y);
}
}

Kt qu
Thu Hai = 0
Thu Bay = 5
Nhng c s ca ngôn ng C# Gvhd: Nguyn Tn Trn Minh Khang
15
Mc đnh enum gán giá tr đu tiên là 0 các tr sau ln hn giá tr trc mt đn v,
và các tr này thuc kiu int. Nu mun thay đi tr mc đnh này ta phi gán tr
mong mun.
Ví d 3-2 S dng enum Ngay (2)
using System;
namespace ConsoleApplication

modifiers (tùy chn): public, protected, internal, private
(các b t xác đnh phm vi truy xut)
identifer: tên ca enum
base_type (tùy chn): kiu s, ngoi tr char
enumerator
-
list
: danh sách các thành viên.
3.2.4 Chui
Chui là kiu dng sn trong C#, nó là mt chui các ký t đn l. Khi khai báo
mt bin chui ta dùng t khoá string. Ví d khai báo mt bin string lu chui
"Hello World"
string myString = "Hello World";
3.2.5 nh danh
nh danh là tên mà ngi lp trình chn đi din mt kiu, phng thc, bin,
hng, đi tng… ca h. nh danh
phi
bt đu bng mt ký t hay du “_”.
nh danh không đc trùng vi t khoá C# và phân bit hoa thng.
Nhng c s ca ngôn ng C# Gvhd: Nguyn Tn Trn Minh Khang
16
3.3 Biu thc
Bt k câu lnh đnh lng giá tr đc gi là mt biu thc (expression). Phép gán
sau cng đc gi là mt biu thc vì nó đnh lng giá tr đc gán (là 32)
x = 32;
vì vy phép gán trên có th đc gán mt ln na nh sau
y = x = 32;
Sau lnh này y có giá tr ca biu thc x = 32 và vì vy y = 32.
3.4 Khong trng
Trong C#, khong trng, du tab, du xung dòng đu đc xem là khong trng

static void SomeMethod( )
{
Nhng c s ca ngôn ng C# Gvhd: Nguyn Tn Trn Minh Khang
17
Console.WriteLine("Greetings from SomeMethod!");
}
}
Kt qu:
In Main! Calling SomeMethod( )...
Greetings from SomeMethod!
Back in Main( ).
Cách th hai đ to các câu lnh r nhánh không điu kin là dùng t khoá: goto,
break, continue, return, hay throw. Cách t khóa này s đc gii thiu trong các
phn sau.
3.5.2 Lnh r nhánh có điu kin
Các t khóa if-else, while, do-while, for, switch-case, dùng đ điu khin dòng chy
chng trình. C# gi li tt c các cú pháp ca C++, ngoi tr switch có vài ci tin.
3.5.2.1 Lnh If .. else …
Cú pháp:
if ( biu thc logic )
khi lnh;
hoc
if ( biu thc logic )
khi lnh 1;
else
khi lnh 2;
Ghi chú: Khi lnh là mt tp các câu ln trong cp du “{…}”. Bt k
ni đâu có câu lnh thì  đó có th vit bng mt khi lnh.
Biu thc logic là biu thc cho giá tr dúng hoc sai (true hoc false). Nu “biu
thc logic” cho giá tr đúng thì “khi lnh” hay “khi lnh 1” s đc thc thi,