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.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

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

đề đ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

- 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

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


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 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 đề

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ử

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";
}
}
}

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

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.

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

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

Đồ 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