Đố án tốt nghiệp " Tìm hiểu ngôn ngữ C# và viết một ứng dụng minh họa"

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

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





GIÁO VIÊN HNG DN
NGUYN TN TRN MINH KHANG







TP. HCM 2002


Li cám n

 có th hoàn tt đc bài đ án này, trc tiên phi k đn công sc ca thy
Nguyn Tn Trn Minh Khang. Chúng em kính li cm n đn thy đã tn tình hng

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

2.1 Lp, đi tng và kiu.......................................................................................6
2.2 Phát trin “Hello World”....................................................................................8
Chng 3 Nhng c s ca ngôn ng C# .................................................................12
3.1 Các kiu............................................................................................................12
3.2 Bin và hng.....................................................................................................14
3.3 Biu thc ..........................................................................................................16
3.4 Khong trng....................................................................................................16
3.5 Câu lnh ...........................................................................................................16
3.6 Toán t .............................................................................................................19
3.7 To vùng tên.....................................................................................................21

3.8 Ch th tin x lý ..............................................................................................22
Chng 4 Lp và đi tng.......................................................................................24
4.1 nh ngha lp..................................................................................................24
4.2 To đi tng...................................................................................................25
4.3 S dng các thành viên tnh.............................................................................27
4.4 Hy đi tng ..................................................................................................29
4.5 Truyn tham s.................................................................................................30
4.6 Np chng phng thc và hàm dng.............................................................32
4.7 óng gói d liu vi property..........................................................................33
Chng 5 Tha k và a hình...................................................................................35
5.1 c bit hoá và tng quát hoá..........................................................................35
5.2 S k tha.........................................................................................................35
5.3 a hình.............................................................................................................37
5.4 Lp tru tng .................................................................................................38
5.5 Lp gc ca tt c các lp: Object...................................................................39
5.6 Kiu Boxing và Unboxing ...............................................................................40
5.7 Lp lng ...........................................................................................................42
Chng 6 Np chng toán t.....................................................................................44

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

11.1 Ném và bt bit l ..........................................................................................73
11.2 i tng Exception......................................................................................80
11.3 Các bit l t to ............................................................................................82
11.4 Ném bit l ln na. .......................................................................................83
Chng 12 Delegate và Event ...................................................................................87
12.1 Delegate (y thác, y quyn) .........................................................................87
12.2 Event (S kin) ............................................................................................101
Chng 13 Lp trình vi C#....................................................................................109
13.1 ng dng Windows vi Windows Form.....................................................109
Chng 14 Truy cp d liu vi ADO.NET ...........................................................144
14.1 C s d liu và ngôn ng truy vn SQL ....................................................144
14.2 Mt s loi kt ni hin đang s dng.........................................................144
14.3 Kin trúc ADO.NET ....................................................................................145
14.4 Mô hình đi tng ADO.NET.....................................................................146
14.5 Trình cung cp d liu (.NET Data Providers)............................................148
14.6 Khi s vi ADO.NET ................................................................................148
14.7 S dng trình cung cp d liu đc qun lý ..............................................151
14.8 Làm vic vi các điu khin kt buc d liu .............................................152

14.9 Thay đi các bn ghi ca c s d liu........................................................161
Chng 15 ng dng Web vi Web Forms............................................................173
1.1 Tìm hiu v Web Forms............................................................................173
15.1 Các s kin ca Web Forms ........................................................................174
15.2 Hin th chui lên trang................................................................................175
15.3 iu khin xác nhn hp..............................................................................178
15.4 Mt s ví d mu minh ha .........................................................................179
Chng 16 Các dch v Web...................................................................................192
Chng 17 Assemblies và Versioning ....................................................................196
17.1 Tp tin PE.....................................................................................................196
17.2 Metadata.......................................................................................................196

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

Chng 23 Website dy hc ngôn ng C#..............................................................251
23.1 Hin trng và yêu cu...................................................................................251
23.2 Phân tích hng đi tng...........................................................................258
23.3 Thit k hng đi tng.............................................................................262




Tóm tt

 tài này tp trung tìm hiu toàn b các khái nim liên quan đn ngôn ng C#.
Bi vì C# đc Microsoft phát trin nh là mt thành phn ca khung ng dng
.NET Framework và hng Internet nên đ tài này bao gm hai phn sau:
Phn 1: Tìm hiu v ngôn ng C#
Vic tìm hiu bao gm c các kin thc nn tng v công ngh .NET Framework,
chun b cho các khái nim liên quan gia C# và .NET Framework. Sau đó tìm
hiu v b cú pháp ca ngôn ng này, bao gm toàn b tp lnh, t khóa, khái
nim v lp trình hng đi tng theo C#, các h tr lp trình hng
component ... Sau cùng là cách lp trình C# vi ng dng Window cho máy đ
bàn và C# vi các công ngh hin đi nh ASP.NET. ADO.NET, XML cho lp
trình Web.

Phn 2: Xây dng mt ng dng
Phn này là báo cáo v ng dng minh ha cho vic tìm hiu  trên. Tên ng
dng là Xây dng mt Website dy hc C#. ây là ng dng Web cài đt bng
ngôn ng C# và ASP.NET. Trong đó ASP.NET đc dùng đ xây dng giao
din tng tác vi ngi dùng; còn C# là ngôn ng lp trình bên di. ng dng
có thao tác c s d liu (Microsoft SQL Server) thông quan mô hình
ADO.NET.

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

(Application Programming Interface - API) mi m cho các dch v và h điu hành
Windows, c th là Windows 2000, nó cng mang li nhiu k thut khác ni bt
ca Microsoft sut t nhng nm 90. Trong s đó có các dch v COM+, công ngh
ASP, XML và thit k hng đi tng, h tr các giao thc dch v web mi nh
SOAP, WSDL và UDDL vi trng tâm là Internet, tt c đc tích hp trong kin
trúc DNA.
Nn tng .NET bao gm bn nhóm sau:
1. Mt tp các ngôn ng, bao gm C# và Visual Basic .Net; mt tp các công c
phát trin bao gm Visual Studio .Net; mt tp đy đ các th vin phc v
cho vic xây dng các ng dng web, các dch v web và các ng dng
Windows; còn có CLR - Common Language Runtime: (ngôn ng thc thi
dùng chung) đ thc thi các đi tng đc xây dng trên bô khung này.
2. Mt tp các Server Xí nghip .Net nh SQL Server 2000. Exchange 2000,
BizTalk 2000, … chúng cung cp các chc nng cho vic lu tr d liu quan
h, th đin t, thng mi đin t B2B, …
C# và .Net Framework Gvhd: Nguyn Tn Trn Minh Khang
3
3. Các dch v web thng mi min phí, va đc công b gn đy nh là d
án Hailstorm; nhà phát trin có th dùng các dch v này đ xây dng các ng
dng đòi hi tri thc v đnh danh ngi dùng…
4. .NET cho các thit b không phi PC nh đin thoi (cell phone), thit b game
1.2 .NET Framework
.Net h tr tích hp ngôn ng, tc là ta có th k tha các lp, bt các bit l, đa
hình thông qua nhiu ngôn ng. .NET Framework thc hin đc vic này nh vào
đc t Common Type System - CTS (h thng kiu chung) mà tt c các thành phn
.Net đu tuân theo. Ví d, mi th trong .Net đu là đi tng, tha k t lp gc
System.Object.
Ngoài ra .Net còn bao gm Common Language Specification - CLS (đc t ngôn
ng chung). Nó cung cp các qui tc c bn mà ngôn ng mun tích hp phi tha
mãn. CLS ch ra các yêu cu ti thiu ca ngôn ng h tr .Net. Trình biên dch

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:

ngôn ng truy vn có cu trúc) cho phép ta thao tác d liu thông qua mt giao tip
SQL chun. Ngoài ra còn mt tp các lp gi là ADO.Net cng cho phép thao tác
d liu. Lp XML h tr thao tác d liu XML, tìm kim và din dch XML.
Trên lp d liu và XML là lp h tr xây dng các ng dng Windows (Windows
forms), ng dng Web (Web forms) và dch v Web (Web services).
1.3 Biên dch và ngôn ng trung gian (MSIL)
Vi .NET chng trình không biên dch thành tp tin thc thi, mà biên dch thành
ngôn ng trung gian (MSIL - Microsoft Intermediate Language, vit tt là IL), sau
đó chúng đc CLR thc thi. Các tp tin IL biên dch t C# đng nht vi các tp
tin IL biên dch t ngôn ng .Net khác.
Khi biên dch d án, mã ngun C# đc chuyn thành tp tin IL lu trên đa. Khi
chy chng trình thì IL đc biên dch (hay thông dch) mt ln na bng trình
Just In Time - JIT, khi này kt qu là mã máy và b x lý s thc thi.
Trình biên dch JIT ch chy khi có yêu cu. Khi mt phng thc đc gi, JIT
phân tích IL và sinh ra mã máy ti u cho tng loi máy. JIT có th nhn bit mã
ngun đã đc biên dch cha, đ có th chy ngay ng dng hay phi biên dch li.
CLS có ngha là các ngôn ng .Net cùng sinh ra mã IL. Các đi tng đc to theo
mt ngôn ng nào đó s đc truy cp và tha k bi các đi tng ca ngôn ng
khác. Vì vy ta có th to đc mt lp c s trong VB.Net và tha k nó t C#.
C# và .Net Framework Gvhd: Nguyn Tn Trn Minh Khang
5
1.4 Ngôn ng C#
C# là mt ngôn ng rt đn gin, vi khong 80 t khoá và hn mi kiu d liu
dng sn, nhng C# có tính din đt cao. C# h tr lp trình có cu trúc, hng đi
tng, hng thành phn (component oriented).
Trng tâm ca ngôn ng hng đi tng là lp. Lp đnh ngha kiu d liu mi,
cho phép m rng ngôn ng theo hng cn gii quyt. C# có nhng t khoá dành
cho vic khai báo lp, phng thc, thuc tính (property) mi. C# h tr đy đ
khái nim tr ct trong lp trình hng đi tng: đóng gói, tha k, đa hình.
nh ngha lp trong C# không đòi hi tách ri tp tin tiêu đ vi tp tin cài đt nh

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
{

static void Main( )
{

// s dng đi tng console ca h thng
System.Console.WriteLine("Hello World");
}
}
Sau khi biên dch và chy HelloWorld, kt qu là dòng ch “Hello World” hin th
trên màn hình.
2.1 Lp, đi tng và kiu
Bn cht ca lp trình hng đi tng là to ra các kiu mi. Mt kiu biu din
mt vt gì đó. Ging vi các ngôn ng lp trình hng đi tng khác, mt kiu
trong C# cng đnh ngha bng t khoá class (và đc gi là lp) còn th hin ca
lp đc gi là đi tng.
Xem Ví d 2-1 ta thy cách khai báo mt lp
HelloWorld. Ta thy ngay là cách
khai báo và ni dung ca mt lp hoàn toàn ging vi ngôn ng Java và C++, ch
có khác là cui khai báo lp không cn du “;”
2.1.1 Phng thc
Các hành vi ca mt lp đc gi là các phng thc thành viên (gi tt là phng
thc) ca lp đó. Mt phng thc là mt hàm (phng thc thành viên còn gi là
hàm thành viên). Các phng thc đnh ngha nhng gì mà mt lp có th làm.
Cách khai báo, ni dung và cách s dng các phng thc ging hoàn toàn vi Java
và C++. Trong ví d trên có mt phng thc đc bit là phng thc Main() (nh
hàm
main() trong C++) là phng thc bt đu ca mt ng dng C#, có th tr v
kiu
void hay int. Mi mt chng trình (assembly) có th có nhiu phng thc
Main nhng khi đó phi ch đnh phng thc
Main() nào s bt đu chng trình.

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:

Console.WriteLine(…).
2.1.4 Namespaces - Vùng tên
Console là mt trong rt nhiu (c ngàn) lp trong b th vin .NET. Mi lp đu
có tên và nh vy có hàng ngàn tên mà lp trình viên phi nh hoc phi tra cu
mi khi s dng. Vn đ là phi làm sao gim bt lng tên phi nh.
Ngoài vn đ phi nh quá nhiu tên ra, còn mt nhn xét sau: mt s lp có mi
liên h nào đó v mt ng ngha, ví d nh lp Stack, Queue, Hashtable … là các
lp cài đt cu trúc d liu túi cha. Nh vy có th nhóm nhng lp này thành mt
nhóm và thay vì phi nh tên các lp thì lp trình viên ch cn nh tên nhóm, sau đó
có th thc hin vic tra cu tên lp trong nhóm nhanh chóng hn. Nhóm là mt
vùng tên trong C#.
Mt vùng tên có th có nhiu lp và vùng tên khác. Nu vùng tên A nm trong vùng
tên B, ta nói vùng tên A là vùng tên con ca vùng tên B. Khi đó các lp trong vùng
tên A đc ghi nh sau:
B.A.Tên_lp_trong_vùng_tên_A

System là vùng tên cha nhiu lp hu ích cho vic giao tip vi h thng hoc các
lp công dng chung nh lp Console, Math, Exception….Trong ví d HelloWorld
trên, đi tng
Console đc dùng nh sau:
System.Console.WriteLine("Hello World");
Khi đu Gvhd: Nguyn Tn Trn Minh Khang
8
2.1.5 Toán t chm “.”
Nh trong Ví d 2-1 toán t chm đc dùng đ truy sut d liu và phng thc
mt lp (nh Console.WriteLine()), đng thi cng dùng đ ch đnh tên lóp trong
mt vùng tên (nh System.Console).
Toán t du chm cng đc dùng đ truy xut các vùng tên con ca mt vùng tên
Vùng_tên.Vùng_tên_con.Vùng_tên_con_con
2.1.6 T khoá using

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.

2.2 Phát trin “Hello World”
Có hai cách đ vit, biên dch và chy chng trình HelloWorld là dùng môi trng
phát trin tích hp (IDE) Visual Studio .Net hay vit bng trình son tho vn bn
và biên dch bng dòng lnh. IDE Vs.Net d dùng hn. Do đó, trong đ tài này ch
trình bày theo hng làm vic trên IDE Visual Studio .Net.
Khi đu Gvhd: Nguyn Tn Trn Minh Khang
9
2.2.1 Son tho “Hello World”
 to chng trình “Hello World” trong IDE, ta chn Visual Studio .Net t thanh
thc đn. Tip theo trên màn hình ca IDE chn File > New > Project t thanh
thc đn, theo đó xut hin mt ca s nh sau:

Hình 2-1 To mt ng dng console trong VS.Net
 to chng trình “Hello World” ta chn Visual C# Project > Console
Application, đin HelloWorld trong ô Name, chn đng dn và nhn OK. Mt ca
s son tho xut hin.
Khi đu Gvhd: Nguyn Tn Trn Minh Khang
10

Hình 2-2 Ca s son tho ni dung mã ngun
Vs.Net t to mt s mã, ta cn chnh sa cho phù hp vi chng trình ca mình.
2.2.2 Biên dch và chy “Hello World”
Sau khi đã đy đ mã ngun ta tin hành biên dch chng trình: nhn “Ctrl–Shift–
B” hay chn Build > Build Solution. Kim tra xem chng trình có li không  ca
s Output cui màn hình. Khi biên dch chng trình nó s lu li thành tp tin .cs.
Chy chng trình bng “Ctrl–F5” hay chn Debug > Start Without Debugging.
2.2.3 Trình g ri ca Visual Studio .Net
Trình g ri ca VS.Net rt mnh hu ích. Ba k nng chính yu đ s dng ca
trình g ri là:
•

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

tng có hp l không, đng thi cp phát đúng kích thc b nh cho đi tng.
C# phân thành hai loi: loai d liu dng sn và loi do ngi dùng đnh ngha.
C# cng chia tp d liu thành hai kiu: giá tr và tham chiu. Bin kiu giá tr đc
lu trong vùng nh stack, còn bin kiu tham chiu đc lu trong vùng nh heap.
C# cng h tr kiu con tr ca C++, nhng ít khi đc s dng. Thông thng con
tr ch đc s dng khi làm vic trc tip vi Win API hay các đi tng COM.
3.1.1 Loi d liu đnh sn
C# có nhiu kiu d liu đnh sn, mi kiu ánh x đn mt kiu đc h tr bi
CLS (Commom Language Specification), ánh x đ đm bo rng đi tng đc
to trong C# không khác gì đi tng đc to trong các ngôn ng .NET khác Mi
kiu có mt kích thc c đnh đc lit kê trong bng sau
Bng 3-1 Các kiu dng sn
Kiu
Kích thc
(byte)
Kiu .Net Mô t - giá tr
byte 1 Byte Không du (0..255)
char 1 Char Mã ký th Unicode
bool 1 Boolean true hay false
sbyte 1 Sbyte Có du (-128 .. 127)
short 2 Int16 Có du (-32768 .. 32767)
ushort 2 Uint16 Không du (0 .. 65535)
int 4 Int32 Có du (-2147483647 .. 2147483647)
Nhng c s ca ngôn ng C# Gvhd: Nguyn Tn Trn Minh Khang
13
uint 4 Uint32 Không du (0 .. 4294967295)
float 4 Single S thc (ả ±1.5*10-45 .. ả ±3.4*1038)
double 8 Double S thc (ả ±5.0*10-324 .. ả ±1.7*10308)
decimal 8 Decimal s có du chm tnh vi 28 ký s và du chm
long

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

Mt đi tng có th chuyn t kiu này sang kiu kia theo hai hình thc: ngm
hoc tng minh. Hình thc ngm đc chuyn t đng còn hình thc tng minh
cn s can thip trc tip ca ngi lp trình (ging vi C++ và Java).
short x = 5;
int y ;
y = x;
// chuyn kiu ngm đnh - t đng
x = y; // li, không biên dch đc
x = (short) y; // OK
Nhng c s ca ngôn ng C# Gvhd: Nguyn Tn Trn Minh Khang
14
3.2 Bin và hng
Bin dùng đ lu tr d liu. Mi bin thuc v mt kiu d liu nào đó.
3.2.1 Khi to trc khi dùng
Trong C#, trc khi dùng mt bin thì bin đó phi đc khi to nu không trình
biên dch s báo li khi biên dch. Ta có th khai báo bin trc, sau đó khi to và
s dng; hay khai báo bin và khi gán trong lúc khai báo.
int x; // khai báo bin trc
x = 5;
// sau đó khi gán giá tr và s dng

int y = x; // khai báo và khi gán cùng lúc
3.2.2 Hng
Hng là mt bin nhng giá tr không thay đi theo thi gian. Khi cn thao tác trên
mt giá tr xác đnh ta dùng hng. Khai báo hng tng t khai báo bin và có thêm
t khóa const  trc. Hng mt khi khi đng xong không th thay đi đc na.
const int HANG_SO = 100;
3.2.3 Kiu lit kê
Enum là mt cách thc đ đt tên cho các tr nguyên (các tr kiu s nguyên, theo
ngha nào đó tng t nh tp các hng), làm cho chng trình rõ ràng, d hiu

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

{
enum Ngay: byte { Hai=2,Ba,Tu,Nam,Sau,Bay,ChuNhat=10 };

class EnumTest
{

static void Main(string[] args)
{

byte x = (byte)Ngay.Ba;

byte y = (byte)Ngay.ChuNhat;
Console.WriteLine("Thu Ba = {0}", x);
Console.WriteLine("Chu Nhat = {0}", y);
Console.Read();
}
}
}
Kt qu:
Thu Ba = 3
Chu Nhat = 10
Kiu enum ngày đc vit li vi mt s thay đi, giá tr cho Hai là 2, giá tr cho Ba
là 3 (Hai + 1) …, giá tr cho ChuNhat là 10, và các giá tr này s là kiu byte.
Cú pháp chung cho khai báo mt kiu enum nh sau
[attributes] [modifiers] enum identifier [:base-type]
{
enumerator-list
};
attributes
(tùy chn): các thông tin thêm (đ cp sau)

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

(whitespace). Do đó, du cách dù ln hay nh đu nh nhau nên ta có:
x = 32;
cng nh
x = 32;
Ngoi tr khong trng trong chui ký t thì có ý ngha riêng ca nó.
3.5 Câu lnh
Cng nh trong C++ và Java mt ch th hoàn chnh thì đc gi là mt câu lnh
(statement). Chng trình gm nhiu câu lnh, mi câu lnh kt thúc bng du “;”.
Ví d:
int x; // là mt câu lnh
x = 23; // mt câu lnh khác
Ngoài các câu lnh bình thng nh trên, có các câu lnh khác là: lnh r nhánh
không điu kin, r nhánh có điu kin và lnh lp.
3.5.1 Các lnh r nhánh không điu kin
Có hai loi câu lnh r nhánh không điu kin. Mt là lnh gi phng thc: khi
trình biên dch thy có li gi phng thc nó s tm dng phng thc hin hành
và nhy đn phng thc đc gi cho đn ht phng thc này s tr v phng
thc c.
Ví d 3-3 Gi mt phng thc
using System;
class Functions
{

static void Main( )
{
Console.WriteLine("In Main! Calling SomeMethod( )...");
SomeMethod( );
Console.WriteLine("Back in Main( ).");
}

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,

ngc li “khi lnh 2” s thc thi. Mt đim khác bit vi C++ là biu thc trong
câu lnh if phi là biu thc logic, không th là biu thc s.
3.5.2.2 Lnh switch
Cú pháp:
switch ( biu_thc_la_chn )
{
case biu_thc_hng :
khi lnh;
lnh nhy;
[
default :
khi lnh;
lnh nhy; ]
}
Biu thc la chn là biu thc sinh ra tr nguyên hay chui. Switch s so sánh
biu_thc_la_chn vi các biu_thc_hng đ bit phi thc hin vi khi lnh
nào. Lnh nhy nh break, goto…đ thoát khi câu switch và bt buc phi có.