Nghiên cứu & thực hành với phần mềm LabView tại trung tâm nghiên cứu MICA

MụC lục
Giới thiệu đề tài.................................................................................................................6
Phần I: Giới thiệu sơ bộ về nền .NET và ngôn ngữ C#..................................................8
I. Giới thiệu sơ bộ về .NET..........................................................................................8
I.1. Giới thiệu chung về nền .NET (.NET platform) .................................................8
I.2. Kiến trúc phân lớp nền .NET.................................................................................8
I.3. Những đặc trng của nền .NET ............................................................................9
I.3.1. Phát triển đa ngôn ngữ ....................................................................................9
I.3.2. Chơng trình ứng dụng độc lập với hệ điều hành và bộ vi xử lí......................10
I.3.3. Quản lí bộ nhớ tự động..................................................................................10
I.3.4. Hỗ trợ phiên bản............................................................................................10
I.4. Những thành phần của nền .NET .......................................................................10
Nh chúng ta đã xem ở phần trớc, có nhiều thành phần trong nền .NET. Trong
phần này chúng ta sẽ trình bày các thành phần nổi bật về tính chất và vai trò của
chúng trong cả hệ thống.........................................................................................11
I.4.1. CLR ...............................................................................................................11
I.4.2. Mã quản lí và mã không quản lí ( Managed/Unmanaged Code ).................11
I.4.3. Ngôn ngữ trung gian , hệ thống kiểu thông thờng và CLS............................12
I.4.4. Th viện lớp cơ sở của .NET...........................................................................12
I.4.5. Assembly và metadata...................................................................................12
I.4.6. Chơng trình dịch Just in time.........................................................................13
I.4.7. Quản lí bộ nhớ ( Garbage Collection )..........................................................13
I.4.8. Vòng đời của mã............................................................................................14
II. Giới thiệu sơ bộ ngôn ngữ lập trình C# ...........................................................14
II.1. Lập trình hớng đối tợng trong C# .....................................................................14
II.2. Những đặc điểm của ngôn ngữ C#.....................................................................15
II.2.1. Các toán tử....................................................................................................15
II.2.2. Các kiểu dữ liệu:...........................................................................................15
II.2.3. Các câu lệnh.................................................................................................16
II.2.4. Cấu tạo của một chơng trình C#...................................................................16
II.3. C# và những vấn đề nâng cao.............................................................................18

II.3.1. C# với cơ sở dữ liệu......................................................................................18
II.3.2. C# với Internet..............................................................................................18
Phần II: Đồ họa trong C#..............................................................................................19
I. Giới thiệu về GDI+.................................................................................................19
II. Kiến trúc của GDI+...............................................................................................19
II.1. Đồ họa Vector 2D..............................................................................................20
II.2. Hình ảnh.............................................................................................................20
II.3. In ấn v hiển thị font chữ ...................................................................................20
III. Kiến trúc lớp của GDI+.......................................................................................20
IV. Một số điểm mới trong GDI+..............................................................................21
1
IV.1. Bút vẽ Gradient.................................................................................................21
IV.2. Đờng cong Spline..............................................................................................22
IV.3. Đối tợng đồ họa độc lập....................................................................................22
IV.4. Chức năng chuyển đổi v đối t ợng ma trận.....................................................22
IV.5. Vùng ảnh co giãn đợc.......................................................................................23
IV.6. Đổ bóng Alpha..................................................................................................23
V. Thay đổi trong mô hình lập trình..........................................................................23
V.1. Ngữ cảnh thiết bị, Handles v các đối t ợng đồ họa...........................................23
V.2. Bút vẽ, bút phủ, đồ họa, hình ảnh v Font chữ ..................................................24
VI. Giới thiệu các đối tợng đồ họa cơ bản trong GDI+.............................................24
VI.1. Đồ họa Vector...................................................................................................24
VI.2. Hình ảnh v Metafile .......................................................................................25
VI.3. Các loại hệ tọa độ ............................................................................................26
VI.4. Các phép chuyển đổi........................................................................................27
Phần III: Đa luồng trong C#..........................................................................................28
I. Khái niệm đa luồng................................................................................................28
I.1. Đa nhiệm ( multitasking )....................................................................................28
I.2. Đa luồng ( multitasking)......................................................................................28
II. Đa luồng trong C#.................................................................................................29

II.1. Cấu trúc các lớp điều khiển luồng của C# ........................................................30
II.2. Tổng quát các phơng thức của lớp Thread ........................................................31
II.2.1. Tạo luồng ( create thread )...........................................................................32
II.2.2. Nhập luồng ( join thread )............................................................................33
II.2.3. Dừng một luồng............................................................................................34
II.2.4. Hủy một luồng..............................................................................................34
II.3. Vòng đời của một luồng....................................................................................34
II.4. Sự u tiên của luồng và định thời gian biểu cho luồng........................................35
II.5. Đồng bộ hóa các luồng:.....................................................................................37
II.5.1. Lớp Interlocked:...........................................................................................37
II.5.2. Sử dụng lệnh C# lock:..................................................................................37
II.5.3. Monitor:........................................................................................................38
Phần IV: XML và C#....................................................................................................42
I. Lịch sử các ngôn ngữ đánh dấu.............................................................................42
I.1. Khái niệm đánh dấu (markup).........................................................................42
I.2. Ngôn ngữ đánh dấu..............................................................................................44
II. Tổng quan về ngôn ngữ XML...............................................................................45
II.1. Ngôn ngữ XML là gì?........................................................................................45
II.2. Các u điểm của XML.........................................................................................46
II.3. Các ứng dụng XML............................................................................................46
II.3.1. Mathematical Markup Language (MathML)...............................................46
II.3.2. Resource Description Framework(RDF) ....................................................46
II.3.3. XML Linking Language(XLink).................................................................47
II.3.4. Synchronized Multimedia Intergration Language(SMIL)...........................47
II.3.5. Extensible Stylesheet Language(XSL).........................................................47
II.4. Tơng lai XML.....................................................................................................47
2
III. Cấu trúc và cú pháp XML....................................................................................48
III.1. Cấu trúc XML...................................................................................................48
III.1.1. Cấu trúc logic..............................................................................................48

III.1.2. Cấu trúc vật lí .............................................................................................49
III.2. Cú pháp XML...................................................................................................50
III.2.1. Các thẻ gán và phần tử................................................................................50
III.2.2. Các thuộc tính và chú giải...........................................................................51
IV. XML trong C#.....................................................................................................52
IV.1. Tạo một tài liệu XML.......................................................................................52
IV.2. Duyệt tài liệu XML...........................................................................................54
IV.3. Quá trình Serializing.........................................................................................56
IV.4. Quá trình Deserializing.....................................................................................59
Phần V: Lập trình mạng trong C#...................................................................................60
I. Giới thiệu về lập trình mạng...................................................................................60
I.1. Nhận dạng máy....................................................................................................60
I.2. Socket...................................................................................................................61
I.3. Server phục vụ nhiều clients................................................................................64
II. Giao tiếp với Web..................................................................................................66
II.1. Gửi và nhận các yêu cầu HTTP..........................................................................66
II.2. Các yêu cầu Web không đồng bộ ......................................................................68
II.3. Dịch vụ Web.......................................................................................................68
Phần VI: Một vài so sánh C# với các ngôn ngữ khác...................................................70
I. Sự khác nhau giữa C# và C/C++.............................................................................70
I.1. Về môi trờng........................................................................................................70
I.2. Về các lệnh..........................................................................................................70
I.3. Về tổ chức chơng trình........................................................................................71
II. Sự khác biệt giữa C# và Java.................................................................................71
II.1. Về kiểu dữ liệu...................................................................................................71
II.2. Về truy cập thành phần......................................................................................72
II.3. Các tham số ref và out.......................................................................................72
II.4. Giao diện (Interfaces)........................................................................................73
II.5. Về 2 từ khoá khai báo import và using..............................................................73
III. Sự khác biệt giữa C# và VB 6.0..........................................................................73

Kết luận...........................................................................................................................75
Tài liệu tham khảo..........................................................................................................76
Phụ lục.............................................................................................................................77
I. Mô tả chơng trình minh họa...................................................................................77
II. Hớng dẫn sử dụng chơng trình..............................................................................78
III. Hớng dẫn cài đặt chơng trình...............................................................................78
3
Danh sách các hình vẽ
Hình 1 Kiến trúc nền .NET.............................................................................................9
Hình 2 Cấu trúc CLR....................................................................................................11
Hình 3 Tô màu bằng bút vẽ Gradient tuyến tính .......................................................21
Hình 4 Đờng Bézier đợc tô bởi bút phủ Gradient.........................................................22
Hình 5 Chuyển đổi đồ thị..............................................................................................22
Hình 6 Co giãn vùng ảnh..............................................................................................23
Hình 7 Các mức độ trong suốt của màu nền.................................................................23
Hình 8 Hệ trục toạ độ của GDI+ ..................................................................................25
Hình 9 Dịch chuyển hệ toạ độ......................................................................................26
Hình 10 Vòng đời của một luồng.................................................................................36
Hình 11 Vòng luân phiên thực hiện luồng....................................................................36
Hình 12 Minh hoạ soạn thảo trong WordPad...............................................................42
Hình 13 Mã của văn bản đọc bằng NotePad.................................................................43
Hình 14 Mã của văn bản Word đọc bằng NotePad......................................................43
Hình 15 Tạo văn bản HTML trong NotePad................................................................44
Hình 16 Cấu trúc của XML..........................................................................................48
Hình 17 Khai báo thành phần trong XML ...............................................................49
Hình 18 Minh họa cấu trúc cây của ví dụ.....................................................................51
Hình 19 Kết quả chơng trình tạo tài liệu trên IE 6.0....................................................54
Hình 20 Kết quả ví dụ Serializing trên IE 6.0...............................................................58

4

Danh s¸ch c¸c thuËt ng÷ viÕt t¾t
 IE 6.0 = Internet Explorer 6.0
 CLS = Common Language Spcification
 CLR = Common Language Runtime
 IDE = Integrated Development Environment
 API = Application Programming Interface
 VB = Visual Basic
 VC = Visual C
 VS = Visual Studio
 XML = Extensible Markup Language
 MSIL = IL = Microsoft Intermediate Language
 COM = Component Object Model
 IDL = Interface Definition Language
 DLL = Dynamic Link Library
 GC = Garbage Collection
 JIT = Just In Time compiler
 ADO = ActiveX Data Object
 MS = Microsoft
 SQL = Structured Query Language
 GDI = Graphic Device Independence
 WMF = Window MetaFile
 EMF = Enhanced MetaFile
 CPU = Central Processing Unit
 RTF = Rich Text Format
 HTML = Hyper Text Markup Language
 SGML = Standard Generalized Markup Language
5
Giới thiệu đề tài
Trong nhiều năm, các lập trình viên C và C++ luôn phải đối mặt với những vấn

đề đau đầu nh: sử dụng con trỏ, quản lí bộ nhớ, truyền tham trị, tham biến, xử lý danh
sách, xây dựng th viện, đa kế thừa, xây dựng giao diện thân thiện với ngời dùng Vì
vậy họ luôn mong muốn, tìm kiếm một ngôn ngữ thay thế có khả năng cũng nh tính
uyển chuyển mạnh nh C và C++ hơn nữa lại đơn giản hơn. Vào giữa những năm 90, thế
giới lập trình có sự thay đổi lớn với sự bùng nổ Internet ( Internet Boom ) và sự ra đời
của ngôn ngữ lập trình Java. Ngay từ khi ra đời, Java đã cho thấy khả năng to lớn của
nó trong việc phát triển các ứng dụng trên internet. Hơn nữa Java còn thnàh công với
tuyên bố write once, run anywhere cố thể tạm dich là : viết một lần, chạy trên mọi
nền. Thành công đó xuất phát từ ý tởng tách rời mã khi biên dịch chơng trình và mã
khi chạy chơng trình, đây là điểm khác biệt lớn so với những ngôn ngữ lập trình C hay
C++. Java đa ra một khái niệm mới : máy ảo. Máy ảo thực hiện các công việc nh biên
dịch ra mã máy, quản lí bộ nhớ hay nói cách khác, máy ảo đóng vai trò giao tiếp
giữa ứng dụng Java và môi trờng ( hệ điều hành, hay phần cứng) làm cho ứng dụng
Java độc lập với môi trờng. Tuy nhiên tốc độ phát triển Java lại chậm dần, và không thể
đấp ứng đợc những đòi hỏi ngày càng cao của ngời dùng. Các hãng phát triển Java
chậm đa ra một môi trờng tích hợp IDE phục vụ cho phát triển các dự án phần mềm.
Việc lập trình các ứng dụng trên Windows bằng Java không thuận tiện, Java có nhiều
hạn chế trong việc giao tiếp với các ngôn ngữ khác nh C++, Visụal Basic Java không
có sự phát triển đồng nhất theo xu hớng thuận tiện cho ngời sử dụng, phải mất nhiều
năm Java mới hỗ trợ đợc điều khiển Mouse wheel, khó sử dụng th viện API của hệ
điều hành, phiên bản Visual J++ của Microsoft phát triển thì lại mang nhiều nét không
giống với nguyên bản. Windows XP ra đời với tuyên bố không hỗ trợ máy ảo Java,
không tích hợp máy ảo Java vào trình duyệt IE 6.0 đã làm uy tín của Java suy giảm
nặng nề. Cuối cùng thì ngôn ngữ mà các lập trình viên mong đợi cũng xuất hiện, đánh
dấu chấm hết cho cuộc tìm kiếm ngôn ngữ lập trình kéo dài nhiều năm của các lập
trình viên. Đợc bắt đầu nghiên cứu từ năm 1997, vào năm 2001, Microsoft giới thiệu
một platform mới --.Net, đi cùng với nó là một ngôn ngữ mới - C#.
C# đợc coi nh ngôn ngữ mang tính cách mạng của Microsoft. Dựa trên kinh
nghiệm của các ngôn ngữ trớc đó nh C, C++ và VB, C# đợc thiết kế nhằm sử dụng đơn
giản, hoàn toàn hớng đối tợng. Với sự tích hợp C# với VS. Net, việc phát triển các ứng

dụng Windows và Web nhanh và đơn giản. Có thể truy cập vào các th viện lớp của
.Net, C# hỗ trợ phát triển các ứng dụng ASP.Net và dịch vụ Web. Bên cạnh đó, C# tăng
cờng năng suất lập trình bằng việc xoá bỏ đi những lỗi thông thờng có trong C và C++.
Java thành công nhất trên 2 lĩnh vực: lập trình các ứng dụng trên server và trong
giảng dạy khoa học tính trong các trờng học. C# cũng có khả năng vợt trội Java trên hai
lĩnh vực đó. Trong đề tài này, chúng em không thể trình bày hết mọi vấn đề liên quan
đến ngôn ngữ C#, chúng em chỉ xin giới thiệu sơ bộ về .NET và C# cùng với một số
vấn đề nâng cao trong ngôn ngữ C# nh sau:
1. Giới thiệu sơ bộ về nền .NET và ngôn ngữ C#
6
2. Đồ hoạ trong C#
3. Đa luồng trong C#
4. XML và C#
5. Lập trình mạng trong C#
6. Một vài so sánh C# với các ngôn ngữ khác
Trong đề tài này, chúng em không dám chắc mọi trình bày, đánh giá là chính
xác, xác đáng. Trong khi làm đề tài có một số thuật ngữ Anh khó chuyển tải đúng
nghĩa sang tiếng Việt nên đợc giữ nguyên. Chúng em kính mong thầy thông cảm và
góp ý sửa chữa những điểm cha tốt trong báo cáo.

7
Phần I: Giới thiệu sơ bộ về nền .NET và ngôn
ngữ C#
Nếu nh Java ra đời, nổi tiếng với tuyên bố: write once, run anywhere, thì ngay
từ khi chào đời, C# và .NET đợc các nhà thiết kế gắn với tuyên bố: Every language,
one platform, có thể tạm dịch là: mọi ngôn ngữ đều chạy trên một nền. Nền đó chính
là .NET ( .NET Framework). Vậy .NET là gì ? Chúng ta sẽ cùng nhau tìm hiểu về
.NET qua các vấn đề sau :
- Giới thiệu chung về nền .NET
- Những đặc điểm của nền .NET

- Những thành phần của .NET
I. Giới thiệu sơ bộ về .NET
I.1. Giới thiệu chung về nền .NET (.NET platform)
Nền .NET là một khái niệm mới trong khoa học máy tính; nó vợt ra ngoài khuôn
khổ của một ngôn ngữ lập trình, một bộ th viện; nó cha phải là một hệ điều hành,
chúng ta có thể hiểu đơn giản nó là một nền để từ đó có thể phát triển các ứng dụng cả
trên Windows lẫn trên Internet thuận tiện hơn. Nền .NET đợc thiết kế để phục vụ các
mục đích sau:
o Cung cấp một môi trờng lập trình hớng đối tợng tuyệt đối, mã của chơng
trình đợc thực thi trên một máy hay cững có thể thực thi từ một máy từ xa
thông qua Internet.
o Giảm thiểu tối đa xung đột giữa các version của một phần mềm
o Đem lại một môi trờng cho phép các ngôn ngữ lập trình có thể giao tiếp
với nhau, tích hợp với nhau
Chú ý: chúng ta cũng cần phải phân biệt giữa hai thuật ngữ: .NET và nền
.NET. .NET bao gồm 3 thành phần cơ bản :
o Nền .NET: một nền cho phép phát triển các ứng dụng
o Các sản phẩm .NET: bao gồm tất cả các sản phẩm của Microsoft dựa
trên nền .NET.
o Các dịch vụ .NET: các dịch vụ đợc cung cấp bởi Microsoft phục vụ cho
việc phát triển các ứng dụng chạy trên nền .NET.
Nh vậy nền .NET chỉ là một thành phần của .NET.
Nền .NET gồm hai thành phần chính: Common language runtime ( CLR ) và th
viện lớp nền .NET. Hai thành phần này sẽ đợc trình bày cụ thể ở những phần sau.
I.2. Kiến trúc phân lớp nền .NET
8
Hình 1 biểu diễn kiến trúc nền .NET. Mỗi ngôn ngữ thuộc gia đình .NET ( phiên
bản đầu tiên gồm các ngôn ngữ : VC.NET, VB.NET, C#, sau đó có thêm VJ# )
Hình 1 Kiến trúc nền .NET
đều đợc dịch sang ngôn ngữ trung gian Microsoft ( MSIL hay gọi ngắn là IL ) ngôn

ngữ dựa theo tiêu chuẩn của Common Language Specification ( CLS ). Có 3 loại ứng
dụng cơ bản là: các ứng dụng Web, các dịch vụ Web, các ứng dụng Form trên
Windows. Những ứng dụng này sử dụng các đối tợng, phơng thức từ th viện lớp cơ sở
và chạy trong môi trờng CLR.
I.3. Những đặc trng của nền .NET
Những đặc trng chủ chốt của nền .NET chủ yếu nằm trong CLR, th viện lớp cơ
sơ và CLS. Chúng em chỉ xin trình bày một số đặc trng chúng em cho là dễ nhận biết
và nắm bắt nhất
I.3.1. Phát triển đa ngôn ngữ
Trớc đây, vấn đề sử dụng đa ngôn ngữ ( multilanguage ) hay giao thoa ngôn ngữ
lập trình ( cross language ) đã đợc đề cập nhiều khi phát triển các ứng dụng. Đa
ngôn ngữ có thể hiểu là việc sử dụng nhiều ngôn ngữ phát triển một ứng dung, mỗi
ngôn ngữ viết lên một phần ứng dụng. Với giải pháp này, ngời lập trình có thể sử dụng
một ngôn ngữ mà mình quen thuộc kết hợp sử dụng lại những đoạn mã đợc viết trên
những ngôn ngữ khác phù hợp với mục đích của một phần chơng trình nhất định để xây
dựng lên một ứng dụng hoàn chỉnh. Một phơng pháp truyền thống để thực hiện giải
pháp này là xây dựng nên các th viện động .dll. Phơng pháp này đợc áp dụng trong VS
6.0. Mỗi ngôn ngữ đều có thể xây dựng nên một th viện .dll. Một ngôn ngữ khác sẽ sử
dụng file .dll đó nh là một phần th viện của mình. Phơng pháp th hai là sử dụng mô
hình đối tợng hớng thành phần COM ( trong đề tài này sẽ không trình bày về COM,
9
ở đây chúng em chỉ điểm qua). Cả hai phơng pháp trên đều sử dụng ngôn ngữ định
nghĩa giao diện ( IDL ). Với nền .NET, chúng ta có thể thực hiện việc phối hợp ngôn
ngữ dễ dàng hơn. Nền .NET cho phép ngôn ngữ này có thể tích hợp với ngôn ngữ khác
bằng việc sử dụng ngôn ngữ trung gian là MSIL Tất cả các ngôn ngữ khi soạn thảo có
thể khác nhau, sau đó đợc dich bởi một chơng trình dịch thích hợp, chúng đều trở thành
dạng ngôn ngữ trung gian, khác biệt giữa các ngôn ngữ hoàn toàn bị xoá bỏ. Ngôn ngữ
trung gian sẽ đợc đa vào CLR để thực thi.
I.3.2. Chơng trình ứng dụng độc lập với hệ điều hành và bộ vi xử lí
Ngôn ngữ trung gian IL là ngôn ngữ độc lập với bộ vi xử lí, nó là ngôn ngữ ở cấp

cao hơn ngôn ngữ máy. Khi nào cần thực thi, IL sẽ đợc dịch ra ngôn ngữ máy thích
hợp. Bất cứ hệ điều hành nào hỗ trợ nền .NET thì ứng dụng .NET sẽ chạy và không
gặp khó khăn gì. Đối với các hệ điều hành thuộc họ Windows từ Win 98 trở nên đều hỗ
trợ nền .NET. Tháng 6 2001, khi mới cho ra đời .NET, Microsoft đã thông báo rằng
họ đã đạt đợc thoả thuận phát triển .NET trên Unix, tuy nhiên đến nay vẫn cha có kết
quả chính thức. Tháng 10 2001, Microsoft cho phép Ximian, ngời đã phát triển giao
diện GNOME thông dụng trên Linux, phát triển một chơng trình dịch C# và CLR trên
Linux. Phiên bản đầu tiên có tên Mono có thể tìm trên www.go-mono.net. Công việc
hiện đang tiến hành ở giai đoạn xây dựng th viện cơ sở trên Linux.
I.3.3. Quản lí bộ nhớ tự động
Rò rỉ bộ nhớ luôn là vấn đề phức tạp trong lập trình khi ta không quản lý nổi
những vùng nhớ đã đợc cấp phát. Trong Visual Basic, quản lý bộ nhớ đợc thực hiện bởi
kĩ thuật đếm số lần truy cập. Trong C và C++, cách tốt nhất để quản lý bộ nhớ là tự
mình trả lại cho hệ điều hành những vùng nhớ không dùng nữa. Trong .NET, có một bộ
phận là GC( Garbage Collection ) làm nhiệm vụ thu hồi lại vùng nhớ hiệu quả hơn
những cách trên.
I.3.4. Hỗ trợ phiên bản
Những lập trình viên đã từng lập trình với th viện động DLL chắc hẳn đều biết
đến thuật ngữ DLL Hell. DLL Hell có thể miêu tả nh sau : bạn đang sử dụng một ch-
ơng trình ứng dụng với một DLL phiên bản 1.0, sau đó bạn cài thêm một ứng dụng
khác cũng sử dụng một DLL giống nh vậy với phiên bản 1.1. Khi đó ứng dụng cữ lập
tức sẽ có vấn đề, có thể không chạy. Khi bạn thay thế DLL đó với DLL phù hợp với
ứng dụng cũ thì ứng dụng mới lại không chạy. Trong .NET, các thành phần của đối t-
ợng luôn đợc phân tách riêng rẽ, một ứng dụng chỉ load những thành phần đã đợc xây
dựng, kiểm tra chạy thử với ứng dụng đó. Sau khi một ứng dụng đã cài đặt và chạy thử
thành công thì nó luôn chạy. .NET thực hiện vấn đề này bằng cách sử dụng thêm thành
phần là assemblies. Những thành phần đợc đóng gói lại trong một assembly. Assembly
có chứa thông tin về phiên bản, và CLR trong .NET sẽ sử dụng thông tin này để nạp
đúng những thành phần phục vụ cho ứng dụng

I.4. Những thành phần của nền .NET
10
Nh chúng ta đã xem ở phần trớc, có nhiều thành phần trong nền .NET. Trong
phần này chúng ta sẽ trình bày các thành phần nổi bật về tính chất và vai trò của chúng
trong cả hệ thống.
I.4.1. CLR
CLR có thể đợc coi nh trái tim của nền .NET. CLR nằm ở cấp cuối cùng trong sơ
đồ phân cấp của nền .NET, trực tiếp giao tiếp với hệ điều hành hay các thiết bị phần
cứng. Vai trò của nó là nhận mã IL, dịch chuyển sang mã máy thích hợp. Từ IL trở
xuống CLR giống nhau cho mọi ngôn ngữ thuộc dòng .NET, điều này giải quyết đợc
vấn đề đa ngôn ngữ trong một ứng dụng
Hình 2 Cấu trúc CLR
I.4.2. Mã quản lí và mã không quản lí ( Managed/Unmanaged Code )
Những mã đợc soạn thảo, dịch nhằm mục đích đợc chạy trong môi trờng CLR
thì đợc gọi là mã mã quản lí ( managed code ). Có thể hiểu đơn giản hơn, mã quản lí là
loại mã mà chơng trình thực thi mã đó đợc quản lí bởi CLR và nó đợc thừa hởng mọi
dịch vụ mà CLR có. Thông thờng, mã quản lí là những mã đợc tích hợp sẵn ở trong các
th viện lớp hay những mã đợc dịch bởi một chơng trình dịch tuân theo chuẩn CLS tạo ra
ngôn ngữ trung gian. Mã không quản lí (unmanaged code) là những mã không đợc
soạn thảo, dịch trong môi trờng .NET và không nhằm mục đích chạy trong CLR tuy
nhiên CLR vẫn nạp những mã này vào chạy, nó chỉ không hỗ trợ các dịch vụ cho loại
mã này. Điển hình cho loại mã này là các th viện DLL có từ trớc .NET và th viện
11
Memory Management
Including
Garbage Collection
Execution Support
CIL Compiler
Common Type system
Security

C
I
L
Class
Loader
M
A
C
H
I
N
E
C
O
D
E
Windows APIs, những chơng trình .NET sử dụng Windows APIs có nghĩa là nó đã sử
dụng mã không quản lý.
I.4.3. Ngôn ngữ trung gian , hệ thống kiểu thông thờng và CLS
Ngôn ngữ trung gian MSIL trong .NET, hệ thống kiểu thông thờng và CLS là 3
yếu tố gắn liền với nhau tạo nên khả năng phối hợp đa ngôn ngữ và độc lập với môi tr-
ờng của các ứng dụng .NET.
Hệ thống kiểu thông thờng ( common type system ) bao gồm các kiểu dữ liệu mà
các ngôn ngữ .NET có thể sử dụng cũng nh qui cách ngời dùng phải tuân theo để xây
dựng nên những kiểu dữ liệu của ngời dùng. Các kiểu dữ liệu trong hệ thống kiểu thông
thờng đợc chia thành 2 loại :
Loại tham trị: những kiểu tham trị trực tiếp lu trữ các dữ liệu, đợc cấp
phát ở vùng nhớ stack. Những dữ liệu kiểu này thờng là kiểu dữ liệu xây
dựng sẵn nh Int, long, boolean,.. hay kiểu struct do ngời dùng định nghĩa.
Loại tham biến: kiểu tham biến la giữ địa chỉ chỉ tới một vùng dữ liệu,

chúng đợc cấp phát ở vùng nhớ Heap. Những dữ liệu kiểu này thờng là
các biến đối tợng.
CLS ( common language specification) là một tập hợp các đặc điểm ngôn ngữ
mà tất cả các ngôn ngữ lập trình trên .NET phải tuân theo, nó cũng bao gồm các kiểu
dữ liệu và các qui cách trong hệ thống kiểu thông thờng. Những ngời muốn phát triển
một ngôn ngữ trên .NET thì cũng phải dựa theo CLS để xây dựng chơng trình dịch gọi
là chơng trình dịch CLS .
Ngôn ngữ trung gian IL đợc dịch ra từ mã nguồn của một ngôn ngữ lập trình cấp
cao bằng một chơng trình dịch CLS, ngôn ngữ trung gian IL sau đó đợc CLR dịch lại
một lần nữa ra mã máy để thực thi.
I.4.4. Th viện lớp cơ sở của .NET
.NET có một th viện đố sộ những kiểu dữ liệu có thể sử dụng lại, đợc tích hợp
chặt chẽ với CLR. Th viện lớp này hoàn toàn hớng đối tợng, cung cấp những kiểu dữ
liệu mà chúng ta có thể sử dụng rất nhiều chức năng từ đó. Nhờ sử dụng th viện lớp cơ
sở chúng ta có thể phát triển các kiểu ứng dụng sau:
ứng dụng vào ra Console
Những ứng dụng Windows với giao diện đồ hoạ
Những ứng dụng ASP.NET
Dịch vụ Web
Các th viện
Khi muốn lập trình trên Windows chúng ta có thể sử dung các lớp Form, Button,
CheckBox, Text để phát triển các giao diện đồ hoạ. Khi muốn phát triển một ứng
dụng Web, chúng ta có thể sử dụng các lớp Web Forms. Tất cả các ngôn ngữ của .NET
đều sử dụng th viện này, điều này làm cho việc sử dụng đa ngôn ngữ cũng dễ dàng hơn.
I.4.5. Assembly và metadata
Nếu chúng ta muốn trình bày kĩ về assembly và metadata thì cần phải có một đề
tài chuyên về mảng này, trong giới hạn đề tài này, chúng em chỉ xin trình bày mang
12
tính khái niệm về hai vấn đề trên. Assembly có thể hiểu nh là một gói cả mã chơng
trình, các thành phần, các tài nguyên. Một assembly bao gồm thông tin metadata, mã

chơng trình ở dạng IL, các file tài nguyên ví dụ nh các file ảnh, âm nhạc, các th viện
thành phần.
Metadata là tập hợp dữ liệu ở dạng nhị phân diễn tả các thành phần của chơng
trình. Metadata đợc lu trữ ở file có thể thực thi ( executable hay .exe , .dll) cùng với mã
IL của chơng trình. Metadata chứa những loại dữ liệu cụ thể sau:
Tên assembly
Số hiệu phiên bản
Culture : thông tin về loại ngôn ngữ mà assembly hỗ trợ
Thông tin về strong name
Danh sách tất cả các file đợc đóng gói
Thông tin về tham chiếu kiểu dữ liệu: CLR sử dụng thông tin này để tìm
ra những file định nghĩ kiểu dữ liệu đó.
Thông tin phục vụ cho tham chiếu đến các assembly khác
CLR hoàn toàn dựa những thông tin này để điều khiển ứng dụng. Assembly và
metadata đợc tạo ra ngay khi ta biên dịch mã nguồn
I.4.6. Chơng trình dịch Just in time
Chơng trình dịch Just In Time là nằm trong CLR, có nhiệm vụ chuyển mã IL
sang mã máy thích hợp. Trong .NET có 3 loại chơng trình dịch JIT:
Pre-JIT: loại JIT này dịch ngay toàn bộ mã IL sang mã máy khi nó đợc
gọi tới.
Econo-JIT: loại này sử dụng cho các hệ thống hạn chế bộ nhớ, nó dịch mã
IL sang mã máy từng bit một, những mã máy sau khi đợc dịch và đa vào
thực thi nó còn đợc để ở vùng nhớ đệm, nếu hết vùng nhớ đệm JIT sẽ xoá
các mã máy này.
Normal JIT: đây là loại ngầm định, dịch mã IL chỉ khi nó đợc gọi tới, mã
máy sau khi dịch sẽ đợc đa vào thực thi đòng thời đợc đặt vào trong bộ
nhớ đệm.
I.4.7. Quản lí bộ nhớ ( Garbage Collection )
Những ngời lập trình thờng gặp nhiều khó khăn khi giải quyết vấn đề cấp phát
bộ nhớ, rò rỉ bộ nhớ, công việc này làm giảm năng suất lập trình. Để giải quyết vấn đề

này, .NET đa ra hệ thống thu gom bộ nhớ GC. Khi chơng trình đòi cấp phát thêm bộ
nhớ, bộ phận cấp phát bộ nhớ trong phần quản lí bộ nhớ trong CLR sẽ thc hiện, nếu
không còn đủ bộ nhớ nó sẽ thông báo là không còn bộ nhớ để cấp phát. GC bắt chạy,
nó giả định rằng tất cả mọi thứ trong bộ nhớ đều có thể thu hồi. Sau đó, nó xem toàn bộ
bộ nhớ dành cho chơng trình ứng dụng, xây dựng nên một đồ thị diễn tả tất cả các vùng
bộ nhớ đợc tham chiếu bởi chơng trình và tham chiếu lẫn nhau. Sau xây dựng xong đồ
thị, GC tiến hành thu gọn bộ nhớ Heap bằng cách di chuyển tất cả các vùng nhớ thật sự
dùng về vị trí mới bắt đầu tại một vùng nhớ Heap còn trống. Cuối cùng nó cập nhật lại
các con trỏ trỏ đến các vùng bộ nhớ vừa đợc di chuyển. Chúng ta có thể thấy dờng nh
13
GC thực hiện rất nhiều việc, tuy nhiên nó đợc thực thực hiện tự động bằng CLR, giảm
nhẹ đi rất nhiều công việc của ngời lập trình.
I.4.8. Vòng đời của mã
Trong phần này, chúng em sẽ giới thiệu về trình làm việc của một ứng dụng
.NET từ khi soạn thảo mã nguồn đến khi chạy chơng trình :
Bắt đầu từ việc soạn thảo mã nguồn trên một ngôn ngữ .NET quen thuộc
trên một hệ soạn thảo văn bản thông thờng.
Dùng một chơng trình dịch .NET dịch mã nguồn ra mã IL, đồng thời xây
dựng assembly cho ứng dụng.
Khi chơng trình ứng dụng thực thi, hệ điều hành sẽ đọc header của chơng
trình và đa CLR vào quản lí chơng trình, CLR đọc các thông tin metadata,
điều khiển Loader nạp các th viện cần thiết vào bộ nhớ.
Hàm _CorExeMain đợc chèn vào điểm nhập của chơng trình.
Bộ phận Loader nhảy vào điểm nhập chơng trình và gọi hàm
_CorExeMain thực thi.
Khi _CorExeMain thực thi, nó gọi chơng trình dịch JIT ra thực thi.
JIT dịch mã IL sang mã máy và đa vào thực thi đồng thời đợc dự trữ ở bộ
nhớ đệm để khi cần không phải dịch lại.

II. Giới thiệu sơ bộ ngôn ngữ lập trình C#

Có thể coi ngôn ngữ lập trình C# là ngôn ngữ lập trình đơn giản vì nó chỉ có
khoảng 80 từ khoá và khoảng 12 kiểu dữ liệu xây dựng sẵn ( built-in) tuy nhiên nó hỗ
trợ tất cả các mô hình lập trình : lập trình cấu trúc, lập trình hớng đối tợng và lập trình
hớng thành phần ( COM ).
II.1. Lập trình hớng đối tợng trong C#
C# là ngôn ngữ hoàn toàn hớng đối tợng. Tính chất hớng đối tợng có thể trình
bày tóm tắt nh sau:
Tất cả đều là đối tợng. Trong C#, mọi thực thể đều đợc biểu diễn là đối
tợng, đi cùng với nó là các thuộc tính, hành vi ( method ) của thực thể đó.
Nh vậy, một thuộc tính hay một method chắc chắn phải thuộc về một đối
tợng nào đó.
Một chơng trình ứng dụng bao gồm nhiều đối tợng. Khi chúng muốn một
đối tợng thực hiện một công việc hay đối tợng này muốn đối tợng kia thực
hiện một công việc, chúng ta hay các đối tợng giao tiếp với nhau bằng
cách gửi thông điệp. Thông điệp có thể hiểu nh một lời gọi hàm gọi một
method của đối tợng nào đó làm việc.
Mỗi đối tợng có một vùng nhớ riêng.
14
Mỗi đối tợng có một kiểu dữ liệu riêng, kiểu dữ liệu đợc định nghĩa bởi
một class ( lớp ).
Mỗi đối tợng có một giao diện để giao tiếp với các đối tợng khác và một
phần dữ liệu đợc che giấu đối với các đối tợng khác.
Ngoài ra, C# cúng cho phép ngời lập trình thực hiện các hoạt động sử dụng lại
dữ liệu nh kế thừa, đa hình thái và kết tập.
II.2. Những đặc điểm của ngôn ngữ C#

C# đợc xây dựng từ những ngôn ngữ tiền đặc biệt là C và C++ cho nên những
đặc điểm ngôn ngữ của C# rất giống với ngôn ngữ C, C++. Trong phần này, chúng em
sẽ trình bày một vài đặc điểm của C#.
II.2.1. Các toán tử

Trong C# có các toán tử thông thờng sau:
Các toán tử một toán hạng: ++,- -, !,~
Các toán tử hai toán hạng: *, /, %, +, -
Các toán tử gán: =, *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, !=
Các toán tử quan hệ: <, >, <=, >=, is, as, ==, !=
Các toán tử lô- gíc: &, ^, !, &, |, <<, >>
Các toán tử điều kiện: &&, ||, ?:
Toán tử sizeof xác định kích thớc một kiểu dữ liệu.
Trong C# cũng cho phép chồng toán tử và định nghĩa các toán tử mới theo các
qui tắc sau:
Toán tử một toán hạng: type_of_x operation op(x)
Toán tử hai toán hạng: type_of_x,y operation op(x,y)
Trong C# không cho phép định nghĩa lại toán tử gán.
II.2.2. Các kiểu dữ liệu:
C# hỗ trợ hai loại kiểu dữ liệu là kiểu tham trị và kiểu tham biến. Kiểu tham trị
bao gồm các kiểu đơn giản nh char, int, float. Kiểu tham biến gồm các kiểu lớp, kiểu
Interface, kiểu mảng hay nói cách khác tất cả các đối tợng đều là tham biễn.
Kiểu tham trị khác kiểu tham biến ở chỗ: những biến tham trị la trữ trực tiếp dữ
liệu của nó, trái lại biến tham biến la trữ con trỏ trỏ tới đối tợng.
C# cung cấp một tập các kiểu đợc định nghĩa trớc hầu hết đã có trong C và C++.
Ngoài ra , C# lại đa thêm vào kiểu boolean, string giống nh trong Pascal.
C# cho phép chuyển kiểu giống nh C nà C++.
15
II.2.3. Các câu lệnh
C# kế thừa hầu hết các câu lệnh từ C và C++, tuy nhiên cũng có một vài bổ xung
và thay đổi đánh chú ý. Chúng ta sẽ điểm qua các câu lệnh sau:

Các lệnh đợc gán nhãn và lệnh goto: các lệnh đợc gắn nhẵn có một nhãn
đứng đằng trớc. Các lệnh goto sẽ nhảy đến các nhãn này và thực thi câu
lệnh đợc gán nhãn

Lẹnh if: lệnh if sẽ chọn một biểu thức để làm việc dựa trên giá trị một
biểu thức lô- gic . Một lệnh if có thể có thêm lệnh else để thực thi câu lệnh
khác khi giá trị biểu thức là sai.
Lệnh swich: lệnh switch thực thi một những lệnh phụ thuộc vào giá trị
một biểu thức cho trớc.
Các lệnh lặp: các lệnh lặp trong C# bao gồm các lệnh lặp while, do
while, for nh trong C
Lệnh lặp foreach ( giống nh trong VB): một lệnh lặp foreach liệt kê các
thành phần trong một tập hợp, thực thi một câu lệnh cho mỗi thành phần
của tập hợp đó.
Các lệnh throw, try, catch: các lệnh phục vụ cho quá trình quản lí lỗi trong
thời gian chạy ( runtime error ) gồm có phát ra một lỗi ( throw ), cặp
lệnh try catch đón nhận một lỗi và đa ra hành động xử lí lỗi.
II.2.4. Cấu tạo của một chơng trình C#
Nếu nh trong C, đơn vị chơng trình lớn nhất là các hàm ( modul), trong Java và
C++, đơn vị chơng trình lớn nhất là các lớp ( class) thì trong C#, đơn vị chơng trình lớn
nhất là không gian tên (namespace). Một chơng trình C# chứa một hay nhiều không
gian tên, trong đó một không gian tên chứa dữ liệu của chơng trình, các không gian tên
còn lại là các không gian tên chứa phần dữ liệu ở các chơng trình khác đợc khai báo với
từ khoá using sử dụng nh là phần th viện, ví dụ :
Namespace 1:
namespace Microsoft.CSharp.Introduction
{
public class HelloMessage
{
public string GetMessage() {
return "Hello, world";
}
}
}

Namespace 2:
using Microsoft.CSharp.Introduction;
class Hello
{
static void Main() {
HelloMessage m = new HelloMessage();
System.Console.WriteLine(m.GetMessage());
}
}
Trong một namespace có thể lồng một hay nhiều namespace khác, ví dụ:
16
namespace Microsoft
{
namespace CSharp
{
namespace Introduction
{....}
}
}
Dới namespace là các đơn vị chơng trình có thể coi là cùng cấp : lớp (class), cấu
trúc (struct), giao diện (Interface).
Lớp: lớp đợc dùng để định nghĩa những kiểu đối tợng mới. Trong một lớp
có thể có các hằng số, các trờng, phơng thức, thuộc tính, sự kiện, toán tử,
hàm dựng, hàm huỷ. Đối với mỗi thành phần của lớp thì có các thuộc tính
truy cập sau:
- public: tất cả các đối tợng khác đều có thể truy cập đến các thành
phần này.
- protected: chỉ những đối tợng kế thừa từ một đối tợng mới có thể
truy cập vào thành phần protected của lớp cha.
- Internal: những đối tợng đợc định nghĩa trong một assembly ( các

file định nghĩa chúng cùng nằm trong 1 assembly) có thể truy cập những
thành phần Internal của nhau. Những thành phần Internal là những thành
phần không khai báo thuộc tính truy cập.
- Private: thành phần này chỉ đợc truy cập từ những thành phần trong
cùng 1 lớp.
Cấu trúc ( struct): chúng ta có thể xây dựng một loại struct nằm ngoài các
lớp và nằm trong 1 namespace nên có thể coi nó là một đơn vị chơng trình
ngang với class. Struct cũng khá giống với class khi nó cũng có các biến
dữ liệu thành phần với thuộc tính truy cập của chúng, hàm khởi tạo. Tuy
nhiên struct lại là dữ liệu kiểu tham trị còn class là dữ liệu kiểu tham biến,
struct không cho phép kế thừa.
Giao diện ( Interface ): ngôn ngữ C++ cho phép đa thừa kế, từ đó sinh ra
các nhập nhằng, rắc rối khi truy cập các thành phần của các lớp cha.
Trong C# không cho phép chúng ta thực hiện đa thừa kế từ nhiều lớp. Tuy
nhiên để thực hiện đa thừa kế, C# tạo ra một đơn vị chơng trình mới là
Interface, thay vì khai báo thừa kế từ nhiều lớp, chúng ta có thể khai báo
thừa kế từ một lớp và thực thi nhiều Interface. Qua đó, chúng ta cũng có
thể thực hiện đa kế thừa. Một Interface có thể chứa các phơng thức, thuộc
tính, sự kiện , ví dụ:
interface IExample
{
string this[int index] { get; set; }
event EventHandler E;
void F(int value);
string P { get; set; }
}
public delegate void EventHandler(object sender, Event e);
Mọi ứng dụng trên C# đều có hàm main. Hàm main chính là điểm vào của chơng
trình (entry point), chơng trình bắt đầu từ hàm main và kết thúc ở đây. Trong hàm main
17

chúng ta có thể khởi tạo các đối tợng ( trong lập trình giao diện Windows) hay gọi các
hàm khác thực thi ( trong lập trình Console ). Hàm main phải là static và xây dựng
trong một lớp, có thể trả lại giá trị Int hay không trả về giá trị.
II.3. C# và những vấn đề nâng cao
II.3.1. C# với cơ sở dữ liệu
C# cho phép thao tác thuận tiện với các loại cơ sở dữ liệu SQL Server 2000, MS
access, Oracle, bằng th viện lớp ADO.NET. ADO.NET là phiên bản mới nhất của
chiến lợc truy cập cơ sở dữ liệu vạn năng của Microsoft. Th viện lớp ADO.NET chia
thành 2 loại là lớp kết nối và lớp không kết nối. Lớp kết nối là trình điều khiển kết nối
cơ sở dữ liệu (Data Provider) cụ thể, có nghĩa là chúng ta phải sử dụng một .NET Data
Provider mà chúng hỗ trợ cơ sở dữ liệu cần làm việc. Trong khi đó lớp không kết nối sử
dụng bất kì .NET data Provider nào. Khi chúng ta cần thiết phải truy cập, xử lí dữ liệu
nguồn với các thao tác select, insert, delete, update chúng ta phải sử dụng lớp kết nối,
ngợc lại nếu chỉ thao tác trên dữ liệu tạm thời thì dùng lớp không kết nối.
Loại lớp kết nối gồm 4 lớp sau:
Connection: Lớp kết nối cơ sở dữ liệu.
DataAdapter: Lớp chứa dữ liệu.
Command: lớp chứa lệnh.
DataReader: Lớp đọc dữ liệu.
Loại lớp không kết nối gồm các lớp sau:
Lớp DataSet: DataSet nắm giữ Tables và Relations
Lớp DataTable: DataTable nắm giữ các Rows, Column
Lớp DataView: DataView tạo nên các view cho dữ liệu
II.3.2. C# với Internet
Từ giữa những năm 90, thế giới lập trình có sự thay đổi từ lập trình ứng dụng
trên các máy riêng lẻ chuyển sang lập trình các ứng dụng trên Internet. Các chơng trình
ứng dụng trên Web có các u điểm nh : chi phí thấp, truy cập thuận tiện từ các nơi khác
nhau Đối với các site tĩnh (static site) dù là đơn giản nhất cũng cần phải lập trình để
quản lí Web Form. Lớp HttpHandler cung cấp những phơng thức đơn giản, rõ ràng để
quản lí các Web Form. Đối với các site động (Dynamic site), ASP.NET là th viện hoàn

hảo để tạo ra những trang Web có nội dung thay đổi theo thời gian đặc biệt là thơng
mại điện tử. Đối với mạng ngang hàng Peer-To-Peer, C# có các công cụ mạnh để tạo
nên các hệ thống mạng ngang hàng có khả năng chia sẻ các tài nguyên.
18
PhÇn II: §å häa trong C#
Đồ họa là một phần không thể thiếu trong các ngôn ngữ lập trình cũng như các
bộ công cụ phát triển nhất là trong thời đại các giao diện đồ họa người sử dụng phát
triển mạnh như hiện nay. Thực tế là hiện nay giao diện đẹp và thân thiện đóng góp
một phần không nhỏ trong thành công của các phần mềm. Trong phần này chúng ta
sẽ khảo sát các công cụ đồ họa GDI+ của C# và tổng quát hơn là của môi trường phát
triển ứng dụng .NET.
I. Giíi thiÖu vÒ GDI+
GDI+ là một phân hệ của hệ điều hành MS Windows XP cung cấp những tính
năng dựng hình 2D cơ bản như đồ họa vector, xử lý hình ảnh. Đúng như tên của nó
đã hàm ý, GDI+ là phiên bản cải tiến của GDI (thế hệ giao diện thiết bị đồ họa trước
của Windows). Nó chịu trách nhiệm hiển thị và dựng hình trên màn hình, máy in.
GDI+ được trang bị thêm nhiều tính năng mới và tối ưu các tính năng sẵn có.
GDI+ cho phép lập trình viên viết mã độc lập ứng dụng. Điều này có nghĩa là
lập trình viên chỉ việc viết mã để hiển thị thông tin mà không cần quan tâm đến thiết
bị hiển thị cụ thể bên dưới. Người lập trình chỉ việc gọi các hàm cung cấp bởi các lớp
của GDI+ và các hàm này đến lượt chúng sẽ chịu trách nhiệm giao tiếp với một
driver của thiết bị cụ thể. GDI cách ly ứng dụng khỏi phần cứng và như vậy cho phép
lập trình viên viết mã độc lập thiết bị.
Các lớp được quản lý của GDI+ là một phần của kiến trúc Microsoft .NET,
môi trường để xây dựng, phân phối và chạy các dịch vụ Web XML và các ứng dụng
khác.
II. KiÕn tróc cña GDI+
Các dịch vụ của GDI+ được chia thành 3 lớp rộng sau:
 Hình học vector 2D
 Hình ảnh.

 Typography.
Sau đây chúng ta sẽ xem xét lần lượt từng lớp này:
19
II.1. §å häa Vector 2D
Đồ họa vector liên quan đến việc vẽ các thực thể đồ họa cơ sở như đường
thẳng, đường cong hay khối hình được cho bởi một tập hợp các điểm trên một hệ tọa
độ. Ví dụ, một đường thẳng có thể được xác định bằng 2 điểm cuối của nó, 1 hình
chữ nhật có thể được xác định bằng cách chỉ ra 1 điểm xác định đỉnh trái trên và 1
cặp số xác định chiều cao và chiều rộng của nó. Một đồ thị đơn giản có thể được xác
định bởi 1 mảng các điểm được nối với nhau bởi đường thẳng. 1 đường Bézier spline
là một đường cong tinh vi được xác định bởi 4 điểm điều khiển.
GDI+ cung cấp các lớp và cấu trúc lưu trữ thông tin về các thực thể cơ sở, các
lớp lưu trữ thông tin về cách thức mà các thực thể này được dựng và các lớp chịu
trách nhiệm hiển thị hình ảnh lên thiết bị. Ví dụ, cấu trúc Rectangle lưu trữ thông tin
về vị trí và kích cỡ của hình chữ nhật; lớp Pen lưu trữ thông tin về màu sắc, độ rộng
đường thẳng và kiểu đường thẳng; Còn lớp Graphics có các phương thức cho dựng
đường thẳng, hình chữ nhật, đồ thị và các hình hình học khác. Còn có thêm vài lớp
Brush lưu trữ thông tin về cách thức mà các hình này được tô màu.
Ta có thể ghi lại hình ảnh vector (thực chất là một chuỗi các lệnh dựng hình)
trong một metafile. GDI+ cung cấp lớp Metafile để ghi lại, hiển thị và lưu các
metafile. Các lớp MetafileHeader và MetaHeader cho phép ta lưu trữ thông tin trong
phần header của metafile.
II.2. H×nh ¶nh
Có một số loại hình ảnh có thể rất khó hoặc không thể được hiển thị với các kỹ
thuật của đồ họa vector. Ví dụ, hình ảnh trên thanh công cụ hoặc các hình icon có thể
khó mô tả bởi một tập các đường thẳng và đường cong. Một bức ảnh độ phân giải
cao thậm chí còn khó tạo hơn với các ký thuật đồ họa vector. Các hình ảnh dạng này
được lưu trữ dưới dạng các ảnh bitmap (một dãy các số biểu diễn màu sắc của từng
điểm trên màn hình. GDI+ cung cấp lớp Bitmap để xử lý, hiển thị và lưu các ảnh
bitmap.

II.3. In Ên v hiÓn thÞ font ch÷à
Phần in ấn và hiển thị font chữ chịu trách nhiệm hiển thị văn bản bằng nhiều
loại font, cỡ chữ và kiều khác nhau. GDI+ cung cấp một số lượng rất ấn tượng hỗ trợ
cho các nhiệm vụ phức tạp này. Một trong những các đặc tính mới của GDI+ là
chống răng cưa, cho phép hiển thị chữ viết mịn hơn trên các màn hình CRT phẳng và
màn hình LCD.
III. KiÕn tróc líp cña GDI+
20
Giao diện lớp được quản lý của GDI+ chứa 60 lớp, 50 kiểu liệt kê, 8 kiểu cấu
trúc. Lớp Graphics là phần trung tâm của các chức năng của GDI+, nó chịu trách
nhiệm dựng đường thẳng, đường cong, hình ảnh và văn bản.
Rất nhiều lớp khác hoạt động chung với lớp Graphics. Ví dụ, phương thức
Graphics.DrawLine sử dụng một đối tượng Pen lưu trữ các thông tin về màu sắc, độ
rộng, kiểu mẫu... của đường thẳng cần vẽ. Phương thức Graphics.FillRectangle có
thể nhận 1 con trỏ đến một đối tượng LinearGradientBrush, nó chịu trách nhiệm tô
màu cho một hình chữ nhật có đổi màu theo 1 bảng màu Gradient. Các đối tượng
Font và StringFormat tác động lên cách thức mà đối tượng Graphics sẽ hiển thị văn
bản. Một đối tượng Matrix lưu trữ và thực hiện các thao tác chuyển đổi tọa độ trong
đối tượng Graphics được dùng để thực hiện các phép quay, tỉ lệ và lật ảnh.
GDI+ cung cấp một vài cấu trúc (ví dụ như Rectangle, Point hay Size) để tổ
chức dữ liệu đồ họa. Một vài lớp khác cũng phục vụ chủ yếu cho mục đích lưu trữ
các cấu trúc dữ liệu. Ví dụ lớp BitmapData hỗ trợ lớp Bitmap, lớp PathData hỗ trợ
cho lớp GraphicsPath.
GDI+ định nghĩa một vài kiểu liệt kê. Chúng là các tập hợp của các hằng có
liên quan. Ví dụ, tập liệt kê LineJoin bao gồm các thành phần Bevel, Milter và
Round xác định các kiểu nối 2 đoạn thẳng.
IV. Mét sè ®iÓm míi trong GDI+
IV.1. Bót vÏ Gradient
GDI+ mở rộng tính năng của GDI bằng cách thêm các bút vẽ gradient để tô
màu hình vẽ, đường thẳng và miền hình vẽ. Ta có thể dùng một bút vẽ Gradient

tuyến tính để phủ màu một hình vẽ với màu sắc thay đổi dần dần qua từng vùng trong
hình vẽ này. Hình vẽ sau minh họa điều này.
H×nh 3 T« mµu b»ng bót vÏ Gradient tuyÕn tÝnh
Khi ta phủ một hình vẽ với một bút vẽ gradient có rất nhiều tùy chọn quy định
cách thức màu sắc sẽ thay đổi từ vùng này đến vùng khác của hình. Một lựa chọn là
quy định màu ở trung tâm và màu ở biên, như vậy các điểm ảnh sẽ thay đổi màu sắc
một cách từ từ tính từ trung tâm ra biên. Hình sau minh họa của một ảnh được tạo ra
từ một cặp đường Bézier được tô bởi một bút phủ Gradient.
21
Hình 4 Đờng Bézier đợc tô bởi bút phủ Gradient
IV.2. Đờng cong Spline
GDI+ h tr ng cong Spline. Mt ng cong Spline l mt chui cỏc
ng cong c lp c hp li to thnh mt ng cong ln hn. ng
spline c xỏc nh bi mt mng cỏc im v i qua tt c cỏc im trong mng
ú. Mt ng spline l 1 ng cong trn i qua cỏc mi im trong mng. Hỡnh
sau cho thy 2 th: 1 ng c to bi 1 ng cong spline v ng cũn li
c to bng cỏch ni bng cỏc on thng.
IV.3. Đối tợng đồ họa độc lập
Trong GDI, mt th thuc v 1 ng cnh thit b, v th b hy khi m nú
c v ra. Trong GDI+, chc nng v c thc hin bi 1 i tng Graphics v
ta cú th to v duy trỡ mt vi i tng GraphicsPath riờng r vi i tng
Graphics. Mt i tng GraphicsPath khụng b hy bi hnh ng v, vỡ vy ta cú
th dựng mt i tng GraphicsPath v nhiu ln.
IV.4. Chức năng chuyển đổi v đối t ợng ma trận
GDI+ cung cp i tng Matrix, mt cụng c mnh thc hin cỏc phộp
bin i nh quay, dch... mt cỏch d dng v mm do. Mt i tng ma trn hot
ng cựng vi i tng s chu bin i. Vớ d i tng GraphicsPath cú phng
thc Tranform nhn vo i s l mt ma trn. 1 ma trn 3x3 cú th c dựng
thc hiờn mt phộp bin i hay mt dóy cỏc phộp bin i. Hỡnh sau minh ha 1
th trc v sau khi thc hin mt dóy cỏc chuyn i ( u tiờn l phộp t l, sau l

phộp quay).
Hình 5 Chuyển đổi đồ thị
22
IV.5. Vùng ảnh co giãn đợc
GDI+ m rng rt nhiu kh nng h tr vựng nh ca nú. Trong GDI, vựng
c lu trong h ta thit b v phộp bin i duy nht cú th ỏp dng vi 1
vựng nh l phộp dch chuyn. GDI+ lu tr vựng nh trong h ta chung v
cho phộp vựng ny chu bt k phộp chuyn i no lu tr c trong 1 ma trn
chuyn i. Hỡnh sau minh ha 1 vựng nh trc v sau 1 chui 3 phộp chuyn
i: t l, quay v dch chuyn.
Hình 6 Co giãn vùng ảnh
IV.6. Đổ bóng Alpha
Trong hỡnh trờn ta cú th thy vựng cha c chuyn i (c ph bi mu
) qua phn ó c chuyn i (ph bi cỏc ng sc mu xanh). iu ny c
thc hin thụng qua k thut búng Alpha c h tr bi GDI+. Vi k thut
búng Alpha ta cú th quy nh trong sut ca 1 mu. Khi mt mu phi hp vi 1
mu nn, nu mu cng trong sut ta nhỡn thy mu nn cng rừ. Hỡnh sau minh ha
cỏc mc trong sut.
Hình 7 Các mức độ trong suốt của màu nền
V. Thay đổi trong mô hình lập trình
V.1. Ngữ cảnh thiết bị, Handles v các đối t ợng đồ họa
Nu ó vit chng trỡnh dựng GDI, lp trỡnh viờn chc hn ó quen vi khỏi
nim ng cnh thit b. Mt ng cnh thit b l mt cu trỳc ca Windows lu tr
kh nng ca mt thit b hin th c th v cỏc thuc tớnh xỏc nh cỏch thc m cỏc
i tng s c v lờn thit b ú. Mt ng cnh thit b cho 1 mn hỡnh video
23
cng c liờn kt vi 1 ca s trong mn hỡnh hin th. u tiờn ta s nhn c
mt handle tr n 1 ng cnh thit b (HDC). Ta s chuyn handle ny cho hm
GDI thc hin cụng vic v.
Vi GDI+ ta khụng phi lo v vic s dng cỏc handle cng nh ng cnh

thit b. n gin l ta ch phi to 1 i tng Graphics v gi cỏc phng thc ca
nú vi 1 phong cỏch hng i tng quen thuc. i tng Graphics l trung tõm
ca GDI+ cng nh ng cnh thit b l trung tõm ca GDI. Ng cnh thit b v i
tng Graphics cú vai trũ tng t nhau nhng cú mt s khỏc bit c bn gia mụ
hỡnh lp trỡnh da trờn cỏc handle (hay con tr) trong GDI v mụ hỡnh lp trỡnh
hng i tng trong GDI+.
i tng Graphics, ging nh ng cnh thit b, c liờn kt vi mt ca s
c th trờn mn hỡnh v cú cỏc thuc tớnh quy nh cỏch thc v cỏc i tng. Tuy
nhiờn i tng Graphics li khụng b trúi cht vi mt i tng bỳt v, bỳt tụ,
th, hỡnh nh hay font ch nh mt ng cnh thit b. Vớ d, trc khi ta dựng mt
ng cnh thit b v mt ng thng ta phi gi phng thc SelectObject
liờn kt mt i tng bỳt v vi 1 ng cnh thit b. iu ny thng c bit n
nh vic chn mt bỳt v vo ng cnh thit b. Mi ng thng c v trong ng
cnh thit b s dựng bỳt ó chn. Vi GDI+, ta chuyn i tng bỳt v Pen nh
mt tham s cho phng thc v ng thng DrawLine ca lp Graphics. Ta cú th
dựng cỏc bỳt v khỏc nhau trong mt dóy cỏc thao tỏc v ng thng m khụng cn
phi liờn kt mt i tng bỳt v vi 1 i tng Graphics.
V.2. Bút vẽ, bút phủ, đồ họa, hình ảnh v Font chữ
Cỏc i tng Bỳt v, bỳt ph, ha, hỡnh nh v Font ch cú th c to ra
v lu tr riờng bit vi i tng Graphics. Rt nhiu phng thc v ca lp
Graphics nhn cỏ i tng ny lm cỏc tham s. õy l iu trỏi ngc vi GDI
khi ta phi chn cỏc i tng ny vo ng cnh thit b v chuyn handle ca
ng cnh thit b nh mt i s n hm v.
VI. Giới thiệu các đối tợng đồ họa cơ bản trong GDI+
VI.1. Đồ họa Vector
GDI+ v cỏc ng thng, hỡnh ch nht v cỏc hỡnh khỏc trờn 1 h trc ta
. Ta cú th chn rt nhiu h ta nhng h ta mc nh cú im gc l gúc
trỏi trờn ca mn hỡnh. n v o ca h trc ta mc nh l pixel.
24
H×nh 8 HÖ trôc to¹ ®é cña GDI+

Đồ họa vector của GDI+ hỗ trợ một số lớp cơ bản rất hữu ích sau:
 Lines
 Rectangles
 Ellipses
 Arcs
 Polygons
 Cardinal splines
 Bézier splines
Lớp Graphics trong GDI+ cung cấp các phương thức để vẽ các đối tượng trên
DrawLine, DrawRectangle, DrawEllipse, DrawPolygon, DrawArc, DrawCurve và DrawBezier. DrawBezier.
Mỗi phương thức trên đều được overload để nhận một vài danh sách tham số. Tất cả
các phương thức đều làm việc kết hợp với một đối tượng bút vẽ Pen. Để vẽ bất kỳ
thứ gì ta phải tạo ít nhất 2 đối tượng: một đối tượng Graphics và một đối tượng Pen.
Đối tượng Pen lưu trữ thông tin về thuộc tính như độ rộng đường và màu sắc cho
hình được vẽ.
VI.2. H×nh ¶nh v Metafileà
Lớp Image là một lớp cơ sở trừu tượng cung cấp các phương thức làm việc với
các ảnh raster (dạng ảnh bitmap) và các ảnh vector. Các lớp Bitmap và Metafile đều
kế thừa lớp Image. Lớp Bitmap mở rộng khả năng của lớp Image bằng cách cung cấp
thêm các phương thức cho tải, lưu giữ và xử lý các ảnh raster. Lớp Metafile mở rộng
thêm khả năng ghi lại các hình ảnh vector.
GDI+ cung cấp lớp Metafile để ta có thể ghi lại và hiển thị các metafile. Một
metafile còn gọi là một hình ảnh vector là một hình ảnh được lưu lại như một chuỗi
các lệnh vẽ. Những lệnh vẽ được lưu trong 1 đối tượng Metafile có thể được lưu
trong bộ nhớ hay lưu trong 1 file hoặc một đối tượng stream.
GDI+ có thể hiển thị các metafile được lưu dưới các định dạng sau:
 Windows Metafile (WMF)
 Enhanced Metafile (EMF)
25