Phat-trien-ung-dung-tren-Windows.pdf

TRƢỜNG ĐẠI HỌC KIÊN GIANG
KHOA THÔNG TIN & TRUYỀN THÔNG
BÀI GIẢNG
PHÁT TRIỂN ỨNG DỤNG TRÊN WINDOWS
Biên soạn:
ThS. Nguyễn Bá Quang Lâm
ThS. Nhan Thanh Nhã
LƢU HÀNH NỘI BỘ
2018

2
MỤC LỤC
CHƢƠNG 1: GIỚI THIỆU VỀ .NET FRAMEWORK ............................................................ 4
1.1. Giới thiệu về .Net Framework & C#.................................................................................... 4
1.2. Cấu trúc của một ứng dụng .Net. ......................................................................................... 9
CHƢƠNG 2: LẬP TRÌNH .NET (C#)...................................................................................... 14
2.1. Cấu trúc lập trình C# căn bản ............................................................................................ 14
2.2. Khai báo biến trong C#...................................................................................................... 15
2.3. Kiểu dữ liệu trong C# ........................................................................................................ 15
2.4. Input/Output trong C# căn bản .......................................................................................... 16
2.5. Cấu trúc điều khiển trong lập trình C#............................................................................... 16
2.5.1. Cấu trúc if ................................................................................................................... 17
2.5.2. Cấu trúc switch … case............................................................................................... 17
2.5.3. Cấu trúc vòng lặp trong lập trình C# .......................................................................... 19
2.5.4. Arrays - Mảng trong C#.............................................................................................. 22
BÀI TẬP CHƢƠNG 2.............................................................................................................. 24
CHƢƠNG 3: HƢỚNG ĐỐI TƢỢNG (OOP) TRONG C# ..................................................... 28
3.1. Lớp (class) trong C# .......................................................................................................... 28
3.2. Đối tƣợng (Objects) ........................................................................................................... 28
3.3. Hàm tạo (Constructors) và hàm hủy (Destructors) trong C#............................................. 28
3.4. Fuction Overloading .......................................................................................................... 30
3.5. Thừa kế trong C# ............................................................................................................... 31
3.6. Overriding (ghi đè), Polymorphism (đa hình) trong C# .................................................... 33
3.6.1. Overriding................................................................................................................... 33
3.6.2. Polymorphism............................................................................................................. 37
3.7. Abstract Class trong C# ..................................................................................................... 39
3.8. Namespaces........................................................................................................................ 39
3.9. Enumerator trong C#.......................................................................................................... 40
BÀI TẬP CHƢƠNG 3:............................................................................................................. 43
CHƢƠNG 4: LẬP TRÌNH GIAO DIỆN VỚI C#.................................................................... 49
4.1. Môi trƣờng phát triển Visual Studio. Net .......................................................................... 49
4.1.1. Khởi động visual studio.NET ..................................................................................... 49
4.1.2. Mở một dự án của visual basic ................................................................................... 49
4.1.3. Các công cụ của VS.NET ........................................................................................... 50
4.1.4. Bộ thiết kế Windows Forms Designer........................................................................ 51
4.2. Xây dựng Windows Forms ................................................................................................ 51
4.3. Các điều khiển chính trong C#........................................................................................... 55
4.3.1. TextBox ...................................................................................................................... 56
4.3.2. Label (Nhãn) ............................................................................................................. 56
4.3.3. LinkLabel Control....................................................................................................... 57
4.3.4. ListBox Control .......................................................................................................... 58
4.3.5. ComboBox Control..................................................................................................... 60
4.3.6. CheckBox Control ...................................................................................................... 60
4.3.7. RadioButton (Điều khiển nút lựa chọn) ..................................................................... 61
4.3.8. Button Control (Nút nhấn) ......................................................................................... 61
4.3.9. ListView ..................................................................................................................... 63
4.3.10. Điều khiển TreeView................................................................................................ 72

3
4.3.11. GroupBox.................................................................................................................. 80
4.3.12. Picture Box................................................................................................................ 80
4.3.13. ImageList .................................................................................................................. 80
4.3.14. Timer......................................................................................................................... 81
4.3.15. Menu ......................................................................................................................... 84
4.3.16. Làm việc với hộp thoại ............................................................................................. 87
4.3.17. Tạo control động trong Windows Form.................................................................... 91
4.3.18. Sử dụng những lớp thừa kế CommonDialog ............................................................ 91
4.4. Xây dựng ứng dụng MDI................................................................................................... 93
4.5. Quản lý lỗi trong lập trình C#............................................................................................ 94
BÀI TẬP CHƢƠNG 4.............................................................................................................. 96
CHƢƠNG 5: LẬP TRÌNH VỚI CƠ SỞ DỮ LIỆU................................................................. 99
5.1. Cơ sở dữ liệu...................................................................................................................... 99
5.1.1. Bảng (Table) ............................................................................................................... 99
5.1.2. Thao tác với hệ quản trị dữ liệu MSSQL Server ........................................................ 99
5.1.3. Truy vấn dữ liệu từ một bảng.................................................................................... 100
5.2. Giới thiệu về ADO.NET.................................................................................................. 104
5.2.1. Data Provider ............................................................................................................ 105
5.2.2. Kết nối....................................................................................................................... 106
5.2.3. Data Adapter............................................................................................................. 107
5.2.4. Data Command ......................................................................................................... 107
5.2.5. Data Reader............................................................................................................... 108
5.2.6. DataSet...................................................................................................................... 109
5.2.7. Data Binding............................................................................................................. 110
5.3. Thêm, cập nhật, xóa dữ liệu trong cơ sở dữ liệu.............................................................. 112
5.3.1. Thêm mới dữ liệu vào cơ sở dữ liệu ......................................................................... 112
5.3.2. Cập nhật dữ liệu trong cơ sở dữ liệu......................................................................... 113
5.3.3. Xóa dữ liệu trong cơ sở dữ liệu................................................................................. 114
5.4. Sử dụng file CSDL trong SQLEXPRESS 2008 .............................................................. 115
BÀI TẬP CHƢƠNG 5............................................................................................................ 125

4
CHƢƠNG 1: GIỚI THIỆU VỀ .NET FRAMEWORK
1.1. Giới thiệu về .Net Framework & C#
Ngày 13/02/2002, Microsoft chính thức giới thiệu bộ công cụ lập trình mới của
mình – Visual Studio.NET. Sau 4 năm không ra phiên bản mới cho bộ Visual Studio 98,
lần này Microsoft quyết tâm đặt cƣợc vào thắng lợi của công nghệ mới: Microsoft .NET.
Trong thời đại công nghệ thông tin, dữ liệu trở nên quan trọng đến nỗi ngƣời ta
mong muốn tất cả mọi thứ nhƣ điện thoại di động, máy tính xách tay, các máy PDA
(Personal Digital Assistant) đều phải kết nối với nhau để chia sẻ dữ liệu và việc sử dụng
các phần mềm để quản lý, sử dụng những dữ liệu đó là "không biên giới". Ứng dụng phải
sẵn sàng để sử dụng từ trên máy tính cũng nhƣ trên điện thoại di động 24/24 giờ, ít lỗi, xử
lý nhanh và bảo mật chặt chẽ.
Các yêu cầu này làm đau đầu những chuyên gia phát triển ứng dụng khi phần mềm
chủ yếu viết cho hệ thống này không chạy trên một hệ thống khác bởi nhiều lý do nhƣ
khác biệt về hệ điều hành, khác biệt về chuẩn giao tiếp dữ liệu, mạng. Thời gian và chi
phí càng trở nên quý báu vì bạn không phải là ngƣời duy nhất biết lập trình. Làm sao sử
dụng lại những ứng dụng đã viết để mở rộng thêm nhƣng vẫn tƣơng thích với những kỹ
thuật mới?
Sun Microsystems đi đầu trong việc cung cấp giải pháp với Java. Java chạy ổn
định trên các hệ điều hành Unix hay Solaris của Sun từ máy chủ tới các thiết bị cầm tay
hay thậm chí trên các hệ điều hành Windows của Microsoft (một ví dụ rõ ràng đó là hầu
hết các điện thoại di động thế hệ mới đều có phần mềm viết bằng Java). Kiến trúc lập
trình dựa trên Java bytecode và thi hành trên máy ảo Java (JVM – Java Virtual Marchine)
cho phép các ứng dụng Java chạy trên bất cứ hệ điều hành nào. Mô hình lập trình thuần
hƣớng đối tƣợng của Java giúp các lập trình viên tuỳ ý sử dụng lại và mở rộng các đối
tƣợng có sẵn. Các nhà cung cấp công cụ lập trình dựa vào đây đểø gắn vào các môi
trƣờng phát triển ứng dụng bằng Java của mình đủ các thƣ viện lập trình nhằm hỗ trợ các
lập trình viên.
Sức mạnh của Java dƣờng nhƣ quá lớn đến nỗi Microsoft từng phải chống trả bằng
cách loại bỏ Java Virtual Marchine khỏi các phiên bản hệ điều hành Windows mới của
mình nhƣ Windows XP. Tuy nhiên, Microsoft thừa hiểu rằng dù không cung cấp JVM,
Sun cũng có thể tự cung cấp các JVM package cho những ngƣời dùng Windows. Đó là lý
do tại sao nhà khổng lồ quyết định bắt tay xây dựng lại từ đầu một nền tảng phát triển
ứng dụng mới: Microsoft.NET Framework.
Vì ra đời khá muộn so với Java, .Net bị coi là khá giống với bậc "tiền bối" của nó.
.NET sử dụng kỹ thuật lập trình thuần hƣớng đối tƣợng nhƣ Java và cũng thi hành trên
một máy ảo là CLR (Common Language Runtime).

5
Bộ thƣ viện của .NET Framework bao gồm hơn 5000 lớp đối tƣợng đủ sức hỗ trợ
hầu hết các yêu cầu từ phía lập trình viên. Công nghệ mã nguồn mở đƣợc đƣa vào .NET
thay cho COM và DCOM đang đƣợc các lập trình viên của Microsoft sử dụng. Với
COM, những thành phần (COMponent) đã đƣợc xây dựng nhƣ các lớp thƣ viện hay các
control chỉ có thể sử dụng lại. Bạn không thể mở rộng chúng hay viết lại cho thích hợp
với ứng dụng của mình. Trong .NET, mọi thành phần đều có thể kế thừa và mở rộng, một
kỹ thuật mới đƣợc đƣa ra thay cho COM là Assembly. Distributed Component hay
DCOM là kỹ thuật dùng để phối hợp các thành phần trên nhiều máy tính giờ đây đƣợc
thay thế trong .NET bởi chuẩn công nghệ mới là SOAP và XML Web Service.
Cùng với SOAP (Simple Objects Access Protocol), XML Web Service mở rộng
khả năng của DCOM từ chỗ chỉ phối hợp các máy trong Intranet, nằm sau Firewall ra
Internet. Các công ty . Con giờ đây mặc sức xây dựng các phần mềm độc lập của mình
những vẫn có thể phối hợp với nhau để đem tới khách hàng các dịch vụ e-commerce đa
dạng nhƣng thống nhất.
XML (eXtended Markup Language) - chuẩn lƣu trữ và trao đổi dữ liệu mới nhất,
hiệu quả nhất hiện nay cũng đƣợc .NET hỗ trợ khá đầy đủ. Chỉ cần một công cụ chuyển
đổi đơn giản mà thậm chí bạn cũng có thể tự viết (đƣơng nhiên khi bạn đã biết về XML),
các dữ liệu trƣớc kia của bạn dù ở bất cứ dạng lƣu trữ nào cũng có thể chuyển về dạng
XML để sử dụng trong các ứng dụng mới hay trao đổi với hệ thống ứng dụng khác. .NET
giờ đây cũng sử dụng kỹ thuật truy cập cơ sở dữ liệu mới là ADO.NET để bổ sung cho kỹ
thuật ADO - trƣớc kia vốn là thành phần mạnh nhất trong MDAC (Microsoft Data
Access).
Component gồm có 3 phần DB-Lib, OLEDB và ADO)- khả năng làm việc với dữ
liệu XML. Chúng ta cũng nên biết rằng kể từ SQL Server 2000, XML đã đƣợc hỗ trợ
trong phần mềm quản trị cơ sở dữ liệu nổi tiếng nhất của Microsoft và phiên bản SQL
Server sắp tới chắc chắn không xem nhẹ XML chút nào. Cùng với
XML, SOAP và Web service đang là những vũ khí mạnh nhất mà Microsoft sử
dụng để qua mặt Java. Cũng không thể quên CLR, máy ảo của các ứng dụng viết bằng
.NET. Common Language Runtime (CLR) đƣợc sử dụng để thực hiện các đoạn chƣơng
trình ở dạng mã IL (Immediate Language). Điều này có nghĩa là dầu bạn lập trình bằng
ngôn ngữ nào bạn thích, một khi có thể biên dịch sang mã IL, Chúng ta sẽ yên tâm rằng
CLR sẽ thi hành nó một cách suôn sẻ. Giống nhƣ JVM của Java, CLR bao gồm trong nó
nhiều thành phần quản lý ứng dụng khi thi hành nhƣ JIT (Just In Time compiler) để biên
dịch ngay tại thời điểm thi hành những đoạn lệnh IL cần thiết hay Garbage Collector giữ
vai trò thu gom "rác" mà ứng dụng để sót lại nhằm sử dụng hiệu quả bộ nhớ. Ngoài ra,
CLR không quên hỗ trợ việc quản lý các ứng dụng trƣớc đây viết trên kỹ thuật COM. Nó
đảm bảo cho Chúng ta không phải bỏ đi những gì đã "dày công xây đắp" trƣớc đây mà
vẫn có thể phối hợp nó với các ứng dụng mới viết trên .NET.

6
Một điểm nữa không thể bỏ qua khi giới thiệu về .NET Framework, đó là thành
phần Common Language Specification. Vai trò của thành phần này là đảm bảo sự tƣơng
tác giữa các đối tƣợng bất chấp chúng đƣợc xây dựng trong ngôn ngữ nào, miễn là chúng
cung cấp đƣợc những thành phần chung của các ngôn ngữ muốn tƣơng tác. Thành phần
Common Language Runtime đƣợc xây dựng với mục đích mô tả các yêu cầu cần thiết
của một ngôn ngữ để có thể sử dụng trong lập trình và biên dịch thành mã IL. Một khi đã
ở dạng mã IL, ứng dụng đã có thể chạy trên CLR và nhƣ thế bạn đã có khả năng dùng
ngôn ngữ lập trình mà mình yêu thích để tận dụng các khả năng mạnh mẽ của .NET.
Trƣớc đây, các lập trình viên đã quen dùng Visual C++ hay Visual Basic 6 hay
Visual InterDEV mỗi khi cần xây dựng một loại ứng dụng khác phải chuyển qua lại giữa
các môi trƣờng lập trình khác nhau của Visual Studio 98 và chợt nhận ra rằng VB 6
không có điểm mạnh này của C++ hoặc C++ không làm nhanh đƣợc chức năng kia của
VB 6,… sẽ cảm thấy nhẹ nhàng vì với .NET giờ đây, mọi sức mạnh của các ngôn ngữ lập
trình đều nhƣ nhau. .NET Framework hỗ trợ một bộ thƣ viện lập trình đồ sộ hơn 5000 lớp
đối tƣợng để bạn đủ khả năng xây dựng các loại ứng dụng từ kiểu console (ứng dụng
dòng lệnh), ứng dụng trên Windows cho tới các ứng dụng Web, các service của hệ điều
hành và các Web service trên Internet.
Trƣớc khi chấm dứt phần giới giới thiệu, cũng cần phải đề cập đến bộ control đồ
sộ và mới mẻ của .NET. Rất nhiều điều khiển mới đƣợc thêm vào .NET Framework để
hỗ trợ cho các ứng dụng có giao diện đồ hoạ trên Windows và trên Web một "diện mạo"
mới. Những công cụ này không chỉ hỗ trợ chuẩn font chữ Unicode nhƣng còn kết hợp với
khả năng xây dựng ứng dụng mang tính "quốc tế" khi ngƣời lập trình phải đáp ứng nhiều
ngôn ngữ, nhiều định dạng ngày giờ hay tiền tệ khác nhau.
Microsoft không quên đem lại một môi trƣờng phát triển ứng dụng sử dụng giao
diện đồ hoạ, tích hợp nhiều chức năng, tiện ích khác nhau để hỗ trợ tối đa cho các lập
trình viên, đó chính là Visual Studio.NET.
.NET Framework là thành phần quan trọng nhất trong kỹ thuật phát triển ứng dụng
dựa trên .NET. Visual Studio sẽ giúp ngƣời lập trình nắm bắt và tận dụng tốt hơn những
chức năng của .NET Framework. Phần dƣới đây giới thiệu những kiến thức cơ bản nhất
về .NET Framework trƣớc khi chúng ta thực sự bắt tay vào làm việc với Visual
Studio.NET và C#.
C # là một ngôn ngữ lập trình hiện đại đƣợc phát triển bởi Microsoft và đƣợc phê
duyệt bởi European Computer Manufacturers Association (ECMA) và International
Standards Organization (ISO). C # đƣợc phát triển bởi Anders Hejlsberg và nhóm của
ông trong việc phát triển .Net Framework.

7
C # đƣợc thiết kế cho các ngôn ngữ chung cơ sở hạ tầng (Common Language
Infrastructure – CLI), trong đó bao gồm các mã (Executable Code) và môi trƣờng thực thi
(Runtime Environment) cho phép sử dụng các ngôn ngữ cấp cao khác nhau trên đa nền
tảng máy tính và kiến trúc khác nhau.
Ngôn ngữ ra đời cùng với .NET
 Kết hợp C++ và Java.
 Hƣớng đối tƣợng.
 Hƣớng thành phần.
 Mạnh mẽ (robust) và bền vững (durable).
 Mọi thứ trong C# đều Object oriented. Kể cả kiểu dữ liệu cơ bản.
 Chỉ cho phép đơn kế thừa.Dùng interface để khắc phục.
 Lớp Object là cha của tất cả các lớp.
 Cho phép chia chƣơng trình thành các thành phần nhỏ độc lập nhau.
 Mỗi lớp gói gọn trong một file, không cần file header nhƣ C/C++.
 Bổ sung khái niệm namespace để gom nhóm các lớp.
 Bổ sung khái niệm “property” cho các lớp.
 Khái niệm delegate & event.
Vai trò C# trong .NET Framework
 .NET runtime sẽ phổ biến và đƣợc cài trong máy client.
o Việc cài đặt App C# nhƣ là tái phân phối các thành phần .NET
o Nhiều App thƣơng mại sẽ đƣợc cài đặt bằng C#.
 C# tạo cơ hội cho tổ chức xây dựng các App Client/Server n-tier.
 Kết nối ADO.NET cho phép truy cập nhanh chóng & dễ dàng với SQL Server,
Oracle…
 Cách tổ chức .NET cho phép hạn chế những vấn đề phiên bản.
 ASP.NET viết bằng C#.

8
o GUI thông minh.
o Chạy nhanh hơn (đặc tính của .NET)
o Mã ASP.NET ko còn là mới hỗn độn.
o Khả năng bẫy lỗi tốt, hỗ trợ mạnh trong quá trình xây dựng App
Web.
Quá trình dịch CT C#
 Mã nguồn C# (tập tin *.cs) đƣợc biên dịch qua MSIL. MSIL: tập tin .exe hoặc .dll
 MSIL đƣợc CLR thông dịch qua mã máy.
 Dùng kỹ thuật JIT (just-in-time) để tăng tốc độ.
Hình 1.1: Quá trình dịch chƣơng trình C#
Các loại ứng dụng C#
Sử dụng C#, ta có thể tạo ra rất nhiều kiểu ứng dụng, ở đây ta quan tâm đến ba kiểu ứng
dụng chính: Console, Window và ứng dụng Web
- Ứng dụng Console
 Giao tiếp với ngƣời dùng bằng bàn phím.
 Không có giao diện đồ họa (GUI).
Ứng dụng Console là ứng dụng có giao diện text, chỉ xử lý nhập xuất trên màn hình
Console, tƣơng tự với các ứng dụng DOS trƣớc đây.
Ứng dụng Console thƣờng đơn giản, ta có thể nhanh chóng tạo chƣơng trình hiển thị kết
xuất trên màn hình. Do đó, các minh hoạ, ví dụ ngắn gọn ta thƣờng sử dụng dạng chƣơng
trình Console để thể hiện.

9
Trong hộp thoại New Project, kích biểu tƣợng ứng dụng ConSole (Console Application).
Trong ô name, gõ tên chƣơng trình (dự án). Trong ô Location, gõ tên của thƣ mục mà ta
muốn Visual Studio lƣu dự án. Nhấn OK.
- Ứng dụng Windows Form
 Giao tiếp với ngƣời dùng bằng bàn phím và mouse.
 Có giao diện đồ họa và xử lý sự kiện.
Là ứng dụng đƣợc hiển thị với giao diện cửa sổ đồ họa. Chúng ta chỉ cần kéo và thả các
điều khiển (control) lên cửa sổ Form. Visual Studio sẽ sinh mã trong chƣơng trình để tạo
ra, hiển thị các thành phần trên cửa sổ.
- Ứng dụng Web
 Kết hợp với ASP .NET, C# đóng vài trò xử lý bên dƣới (underlying code).
 Có giao diện đồ họa và xử lý sự kiện.
Môi trƣờng .NET cung cấp công nghệ ASP.NET giúp xây dựng những trang Web động.
Để tạo ra một trang ASP.NET, ngƣời lập trình sử dụng ngôn ngữ biên dịch nhƣ C# hoặc
C# để viết mã. Để đơn giản hóa quá trình xây dựng giao diện ngƣời dùng cho trang Web,
.NET giới thiệu công nghệ Webform. Cách thức tạo ra các Web control tƣơng tự nhƣ khi
ta xây dựng ứng dụng trên Window Form.
1.2. Cấu trúc của một ứng dụng .Net.
Trong phần này, chúng ta tìm hiểu các thành phần bên trong .NET Framework.
Hình 1.2. Cấu trúc của một ứng dụng .Net

10
.NET Framework cần đƣợc cài đặt và sử dụng trên một hệ điều hành. Hiện tại,
.NET Framework chỉ có khả năng làm việc trên các hệ điều hành Microsoft Win32 và
Win64 mà thôi. Trong thời gian tới, Microsoft sẽ đƣa hệ thống này lên Windows CE cho
các thiết bị cầm tay và có thể mở rộng cho các hệ điều hành khác nhƣ Unix.
Cung cấp các chức năng xây dựng ứng dụng
Với vai trò quản lý việc xây dựng và thi hành ứng dụng, .NET Framework cung
cấp các lớp đối tƣợng (Class) để bạn có thể gọi thi hành các chức năng mà đối tƣợng đó
cung cấp. Tuy nhiên, lời kêu gọi của bạn có đƣợc "hƣởng ứng" hay không còn tuỳ thuộc
vào khả năng của hệ điều hành đang chạy ứng dụng của bạn.
Các chức năng đơn giản nhƣ hiển thị một hộp thông báo (Messagebox) sẽ đƣợc
.NET Framework sử dụng các hàm API của Windows. Chức năng phức tạp hơn nhƣ sử
dụng các COMponent sẽ yêu cầu Windows phải cài đặt Microsoft Transaction Server
(MTS) hay các chức năng trên Web cần Windows phải cài đặt Internet Information
Server (IIS).
Nhƣ vậy, bạn cần biết rằng lựa chọn một hệ điều hành để cài đặt và sử dụng .NET
Framework cũng không kém phần quan trọng. Cài đặt .NET Framework trên các hệ điều
hành Windows 2000, 2000 Server, XP, XP.NET, 2003 Server sẽ đơn giản và tiện dụng
hơn trong khi lập trình.
Common Language Runtime
Là thành phần "kết nối" giữa các phần khác trong .NET Framework với hệ điều
hành. Common Language Runtime (CLR) giữ vai trò quản lý việc thi hành các ứng dụng
viết bằng .NET trên Windows. CLR sẽ thông dịch các lời gọi từ chƣơng trình cho
Windows thi hành, đảm bảo ứng dụng không chiếm dụng và sử dụng tràn lan tài nguyên
của hệ thống. Nó cũng không cho phép các lệnh "nguy hiểm" đƣợc thi hành. Các chức
năng này đƣợc thực thi bởi các thành phần bên trong CLR nhƣ Class loader, Just In Time
compiler, Garbage collector, Exception handler, COM marshaller, Security engine,…
Trong các phiên bản hệ điều hành Windows mới nhƣ XP.NET và Windows 2003,
CLR đƣợc gắn kèm với hệ điều hành. Điều này đảm bảo ứng dụng viết ra trên máy tính
của chúng ta sẽ chạy trên máy tính khác mà không cần cài đặt, các bƣớc thực hiện chỉ
đơn giản là một lệnh copy của DOS!
Bộ thƣ viện các lớp đối tƣợng
Nếu phải giải nghĩa từ "Framework" trong thuật ngữ .NET Framework thì đây là
lúc thích hợp nhất. Framework chính là một tập hợp hay thƣ viện các lớp đối tƣợng hỗ trợ
ngƣời lập trình khi xây dựng ứng dụng. Có thể một số ngƣời trong chúng ta đã nghe qua
về MFC và JFC. Microsoft Foundation Class là bộ thƣ viện mà lập trình viên Visual C++

11
sử dụng trong khi Java Foundation Class là bộ thƣ viện dành cho các lập trình viên Java.
Giờ đây, có thể coi .NET Framework là bộ thƣ viện dành cho các lập trình viên .NET
Với hơn 5000 lớp đối tƣợng để gọi thực hiện đủ các loại dịch vụ từ hệ điều hành,
chúng ta có thể bắt đầu xây dựng ứng dụng bằng Notepad. Exe!!!… Nhiều ngƣời lầm
tƣởng rằng các môi trƣờng phát triển phần mềm nhƣ Visual Studio 98 hay Visual
Studio.NET là tất cả những gì cần để viết chƣơng trình.
Thực ra, chúng là những phần mềm dùng làm "vỏ bọc" bên ngoài. Với chúng,
chúng ta sẽ viết đƣợc các đoạn lệnh đủ các màu xanh, đỏ; lỗi cú pháp báo ngay khi đang
gõ lệnh; thuộc tính của các đối tƣợng đƣợc đặt ngay trên cửa sổ properties, giao diện
đƣợc thiết kế theo phong cách trực quan… Nhƣ vậy, chúng ta có thể hình dung đƣợc tầm
quan trọng của .NET Framework. Nếu không có cái cốt lõi .NET Framework, Visual
Studio.NET cũng chỉ là cái vỏ bọc! Nhƣng nếu không có Visual Studio.NET, công việc
của lập trình viên .NET cũng lắm bƣớc gian nan!
Base class library – thƣ viện các lớp cơ sở
Đây là thƣ viện các lớp cơ bản nhất, đƣợc dùng trong khi lập trình hay bản thân
những ngƣời xây dựng .NET Framework cũng phải dùng nó để xây dựng các lớp cao
hơn. Ví dụ các lớp trong thƣ viện này là String, Integer, Exception,…
ADO.NET và XML
Bộ thƣ viện này gồm các lớp dùng để xử lý dữ liệu. ADO.NET thay thế ADO để
trong việc thao tác với các dữ liệu thông thƣờng. Các lớp đối tƣợng XML đƣợc cung cấp
để bạn xử lý các dữ liệu theo định dạng mới: XML. Các ví dụ cho bộ thƣ viện này là
SqlDataAdapter, SqlCommand, DataSet, XMLReader, XMLWriter,…
ASP.NET
Bộ thƣ viện các lớp đối tƣợng dùng trong việc xây dựng các ứng dụng Web.
ASP.NET không phải là phiên bản mới của ASP 3.0. Ứng dụng web xây dựng bằng
ASP.NET tận dụng đƣợc toàn bộ khả năng của .NET Framework. Bên cạnh đó là một
"phong cách" lập trình mới mà Microsoft đặt cho nó một tên gọi rất kêu : code behind.
Đây là cách mà lập trình viên xây dựng các ứng dụng Windows based thƣờng sử dụng –
giao diện và lệnh đƣợc tách riêng. Tuy nhiên, nếu bạn đã từng quen với việc lập trình ứng
dụng web, đây đúng là một sự "đổi đời" vì bạn đã đƣợc giải phóng khỏi mớ lệnh HTML
lộn xộn tới hoa cả mắt. Sự xuất hiện của ASP.NET làm cân xứng giữa quá trình xây dựng
ứng dụng trên Windows và Web.
ASP.NET cung cấp một bộ các Server Control để lập trình viên bắt sự kiện và xử
lý dữ liệu của ứng dụng nhƣ đang làm việc với ứng dụng Windows. Nó cũng cho phép
chúng ta chuyển một ứng dụng trƣớc đây viết chỉ để chạy trên Windows thành một ứng

12
dụng Web khá dễ dàng. Ví dụ cho các lớp trong thƣ viện này là WebControl,
HTMLControl, …
Web services
Web services có thể hiểu khá sát nghĩa là các dịch vụ đƣợc cung cấp qua Web
(hay Internet). Dịch vụ đƣợc coi là Web service không nhằm vào ngƣời dùng mà nhằm
vào ngƣời xây dựng phần mềm. Web service có thể dùng để cung cấp các dữ liệu hay
một chức năng tính toán.
Ví dụ, công ty du lịch của bạn đang sử dụng một hệ thống phần mềm để ghi nhận
thông tin về khách du lịch đăng ký đi các tour. Để thực hiện việc đặt phòng khách sạn tại
địa điểm du lịch, công ty cần biết thông tin về phòng trống tại các khách sạn. Khách sạn
có thể cung cấp một Web service để cho biết thông tin về các phòng trống tại một thời
điểm. Dựa vào đó, phần mềm của bạn sẽ biết rằng liệu có đủ chỗ để đặt phòng cho khách
du lịch không? Nếu đủ, phần mềm lại có thể dùng một Web service khác cung cấp chức
năng đặt phòng để thuê khách sạn. Điểm lợi của Web service ở đây là bạn không cần một
ngƣời làm việc liên lạc với khách sạn để hỏi thông tin phòng, sau đó, với đủ các thông tin
về nhiều loại phòng ngƣời đó sẽ xác định loại phòng nào cần đặt, số lƣợng đặt bao nhiêu,
đủ hay không đủ rồi lại liên lạc lại với khách sạn để đặt phòng. Đừng quên là khách sạn
lúc này cũng cần có ngƣời để làm việc với nhân viên của bạn và chƣa chắc họ có thể liên
lạc thành công.
Web service đƣợc cung cấp dựa vào ASP.NET và sự hỗ trợ từ phía hệ điều hành
của Internet Information Server.
Window form
Bộ thƣ viện về Window form gồm các lớp đối tƣợng dành cho việc xây dựng các
ứng dụng Windows based. Việc xây dựng ứng dụng loại này vẫn đƣợc hỗ trợ tốt từ trƣớc
tới nay bởi các công cụ và ngôn ngữ lập trình của Microsoft. Giờ đây, ứng dụng chỉ chạy
trên Windows sẽ có thể làm việc với ứng dụng Web dựa vào Web service. Ví dụ về các
lớp trong thƣ viện này là: Form, UserControl,…
Phân nhóm các lớp đối tƣợng theo loại
Một khái niệm không đƣợc thể hiện trong hình vẽ trên nhƣng cần đề cập đến là
Namespace. Đây là tên gọi một nhóm các lớp đối tƣợng phục vụ cho một mục đích nào
đó. Chẳng hạn, các lớp đối tƣợng xử lý dữ liệu sẽ đặt trong một namespace tên là Data.
Các lớp đối tƣợng dành cho việc vẽ hay hiển thị chữ đặt trong namespace tên là Drawing.
Một namespace có thể là con của một namespace lớn hơn. Namespace lớn nhất trong
.NET Framework là System.

13
Lợi điểm của Namespace là phân nhóm các lớp đối tƣợng, giúp ngƣời dùng dễ
nhận biết và sử dụng. Ngoài ra, Namespace tránh việc các lớp đối tƣợng có tên trùng với
nhau không sử dụng đƣợc. .NET Framework cho phép chúng ta tạo ra các lớp đối tƣợng
và các Namespace của riêng mình. Với hơn 5000 tên có sẵn, việc đặt trùng tên lớp của
mình với một lớp đối tƣợng đã có là điều khó tránh khỏi. Namespace cho phép việc này
xảy ra bằng cách sử dụng một tên đầy đủ để nói đến một lớp đối tƣợng. Ví dụ, nếu muốn
dùng lớp WebControls, chúng ta có thể dùng tên tắt của nó là WebControls hay tên đầy
đủ là System.Web.UI.WebControls.
Hình 1.3. Hệ thống không gian tên (Namespace)
Đặc điểm của bộ thƣ viện các đối tƣợng .NET Framework là sự trải rộng để hỗ trợ
tất cả các ngôn ngữ lập trình .NET nhƣ chúng ta thấy ở hình vẽ trên. Điều này sẽ giúp
những ngƣời mới bắt đầu ít bận tâm hơn trong việc lựa chọn ngôn ngữ lập trình cho mình
vì tất cả các ngôn ngữ đều mạnh ngang nhau. Cũng bằng cách sử dụng các lớp đối tƣợng
để xây dựng ứng dụng, .NET Framework buộc ngƣời lập trình phải sử dụng kỹ thuật lập
trình hƣớng đối tƣợng (sẽ đƣợc nói tới trong các chƣơng sau).

14
CHƢƠNG 2: LẬP TRÌNH .NET (C#)
.NET là nền tảng cho phép phát triển những ứng dụng mới hoàn toàn trên cả hai
môi trƣờng Win và Web. Khi sử dụng .NET, đòi hỏi phải sử dụng một ngôn ngữ để khai
thác hết sức mạnh của nó. C# là ngôn ngữ chúng tôi lựa chọn để sử dụng và giới thiệu
đến bạn. C# đƣợc phát triển từ C/C++ và giữ nguyên tên trong gia đình C, ký tự # đƣợc
sử dụng nhƣ một sự khẳng định về tính sắc bén của ngôn ngữ này, do đó C# đƣợc phát
âm là C sharp
2.1. Cấu trúc lập trình C# căn bản
Hello World là chƣơng trình đầu tiên để mở đầu cho việc học một ngôn ngữ lập
trình nào đó, với C# cũng thế, hãy bắt đầu với “C# Hello World”
Ví dụ 1:
Sau đây là chƣơng trình C# Hello World, mã nguồn nhƣ sau:
/*This is Hellow World C# Program*/
using System;
using System.Collections.Generic;
using System.Text;
namespace HelloWorld
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Welcome to C# World");
}
}
}
Kết quả xuất hiện của chương trình như sau

15
2.2. Khai báo biến trong C#
Các biến trong C# đƣợc khai báo theo công thức nhƣ sau:
AccessModifier DataType VariableName;
Trong đó,
AccessModifier: xác định ƣu tiên truy xuất tới biến
Datatype: định nghĩa kiểu lƣu trữ dữ liệu của biến
VariableName: là tên biến
Cấp độ truy xuất tới biến đƣợc mô tả nhƣ bảng dƣới đây
Access
Modifier Mô tả
public
Truy
cập
tại bất
kỳ nơi đâu
protected
Cho phép truy xuất bên trong một lớp nơi biến
này được định
nghĩa, hoặc từ các lớp con của lớp đó.
private
Chỉ
truy
xuất ở
bên
trong lớp nơi mà biến được định
nghĩa.
2.3. Kiểu dữ liệu trong C#
Các kiểu dữ liệu đƣợc sử dụng trong ngôn ngữ C# đƣợc mô tả theo bảng dƣới đây
Data Type Mô tả Ví dụ
object kiểu dữ liệu cơ bản của tất
cả các kiểu khác
object obj =
null;

16
string Được sử dụng để lưu trữ
những giá trị kiểu chữ cho
biến
string str =
"Welcome";
int Sử dụng để lưu trữ giá trị
kiểu số nguyên
int ival = 12;
byte sử dụng để lưu trữ giá byte byte val = 12;
float Sử dụng để lưu trữ giá trị
số thực
float val =
1.23F;
bool Cho phép một biến lưu trữ
giá trị đúng hoặc sai
bool val1 =
false;
bool val2 = true;
char Cho phép một biến lưu trữ
một ký tự
char cval = 'a';
2.4. Input/Output trong C# căn bản
Input /output trong C# đƣợc thực hiện thông qua việc sử dụng hàm của lớp
Console trong namespace System.
Hai hàm thƣờng sử dụng nhất cho thao tác Input/Output là:
Console.WriteLine();
Console.ReadLine();
Trong đó,
Console.WriteLine(): được sử dụng để xuất hiện kết quả
Console.ReadLine(): được sử dụng để đọc kết quả nhận vào.
2.5. Cấu trúc điều khiển trong lập trình C#
C# cung cấp hai cấu trúc điều khiển thực hiện việc lựa chọn điều kiện thực thi
chƣơng trình

17
2.5.1. Cấu trúc if
Cấu trúc if trong C# đƣợc mô tả nhƣ sau:
if (biểu thức điều kiện)
{
// câu lệnh thực thi nếu biểu thức điều kiện đúng
}
[else
{
// câu lệnh thực thi nếu biểu thức điều kiện sai
}]
Ví dụ:
if (20 % 4 > 0)
{
Console.WriteLine("Số 20 không chia hết cho 4");
}
else
{
Console.WriteLine("Số 20 chia hết cho số 4");
}
2.5.2. Cấu trúc switch … case
Cấu trúc swtich….case có cấu trúc nhƣ sau:
// switch ... case
switch (variable)
{
case value:
Câu lệnh thực thi
break;

18
case value:
break;
case value:
break;
default:
break;
}
Ví dụ:
int x = 20 % 4;
switch (x)
{
case 1:
Console.WriteLine("20 chia cho 4
được số dư là 1"); break;
case 0:
Console.WriteLine("20 chia hết cho 4");
break;
default:
Console.WriteLine("Không thuộc tất cả các
trường hợp trên"); break;

19
}
2.5.3. Cấu trúc vòng lặp trong lập trình C#
C# cung cấp các cấu trúc vòng lặp chƣơng trình
While
Do… while
For
Foreach
Sau đây, xin giới thiệu công thức và ví dụ sử dụng các vòng lặp trên
2.5.3.1. Vòng lặp While
Cấu trúc vòng lặp while
while (condition)
{
// câu lệnh
}
Thực thi câu lệnh hoặc một loạt những câu lệnh đến khi điều kiện không đƣợc thỏa
mãn.
Ví dụ:
using System;
class WhileTest
{
public static void Main()
{
int n = 1;

20
while (n < 6)
{
Console.WriteLine("Current value of
n is {0}", n); n++;
}
}
}
2.5.3.2. Vòng lặp do
Cấu trúc vòng lặp do
do
{
// câu lệnh
}
white (condition)
Thực thi câu lệnh ít nhất một lần đến khi điều kiện không đƣợc thỏa mãn.
Ví dụ:
using System;
public class TestDoWhile
{
public static void Main ()
{
int x;
int y = 0;
do
{
x = y++;
Console.WriteLine(x);
}

21
while(y < 5);
}
}
2.5.3.3. Vòng lặp for
Cấu trúc vòng lặp for
for (initialization; condition; increment / decrement)
{
// thực thi câu lệnh
}
Ví dụ:
using System;
public class ForLoopTest
{
public static void Main()
{
for (int i = 1; i <= 5; i++)
Console.WriteLine(i);
}
}
2.5.3.4. Vòng lặp foreach
Cấu trúc vòng lặp foreach
foreach (var item in collection )
{
// thực hiện thông qua tương ứng với
// từng mục trong mảng hay tập hợp
}

22
Hãy xem ví dụ sau để hiểu cách sử dụng của vòng lặp foreach truycập đến từng
phần từ của mảng.
using System;
public class UsingForeach
{
public static int Main()
{
int[] intArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
foreach (int item in intArray)
{
Console.Write("{0} ", item);
}
Console.ReadLine();
return 0;
}
}
Kết quả:
1 2 3 4 5 6 7 8 9 10
2.5.4. Arrays - Mảng trong C#
Mảng là một nhóm những biến có cùng một kiểu dữ liệu. Những biến này đƣợc
lƣu trữ trong bộ những vùng bộ nhớ kế tiếp do đó mảng cho phép truy xuất và thực thi
đến từng phần tử trong mảng.
Công thức khai báo một mảng nhƣ sau:
Datatype []variableName = new Datatype[number of elements];
Trong đó,
number of elements: là số phần tử của mảng
Datatype: kiểu dữ liệu mà mảng lưu trữ
variableName: là tên mảng.
Ví dụ:

23
// mảng kiểu int
int[] iarray = new int[5];
// mảng kiểu string
string[] sarray = new string[6];
Ví dụ: cách khai báo khác
string[] sarray2 = { "Welcome", "to", "KGU" };
Khi lập trình, tùy theo điều kiện chƣơng trình mà bạn có thể chọn lựa một trong
hai cách trên.

24
BÀI TẬP CHƢƠNG 2
1. Viết chƣơng trình tính các tổng sau:
a. S=1+2+3+..+n
b. S=1+3+5+…+2n-1
c. S=2+4+6+…+2n
d. S=-1+2-3+…+(-1)n
n
Với n nhập vào từ bàn phím.
2. Viết chƣơng trình giải phƣơng trình bậc nhất
3. Viết chƣơng trình giải phƣơng trình bậc hai.
4. Viết chƣơng trình cho phép nhập vào một số từ bàn phím, kiểm tra xem số đó có phải
là số nguyên tố không.
5. Thực hiện các thao tác sau trên mảng một chiều a gồm các số nguyên, số lƣợng phần
tử phần tử là n.
a. Các thao tác nhập xuất
b. Nhập mảng.
c. Xuất mảng.
d. Các thao tác kiểm tra
e. Mảng có phải là mảng toàn số chẵn?
f. Mảng có phải là mảng tăng dần?
g. Các thao tác tính toán
h. Có bao nhiêu số chia hết cho 4 nhƣng không chia
hết cho 5.
i. Tính tổng các số nguyên tố có trong mảng.
j. Các thao tác tìm kiếm
k. Tìm vị trí số nguyên tố đầu tiên trong mảng nếu có.
l. Tìm số nhỏ nhất trong mảng.
m. Tìm số dƣơng nhỏ nhất trong mảng.
n. Các thao tác xử lý
o. Tách mảng trên thành hai mảng b và c, mảng b chứa các số nguyên dƣơng,
mảng c chứa các số còn lại.
p. Sắp xếp mảng giảm dần.

25
q. Sắp xếp mảng sao cho các số dƣơng đứng đầu mảng giảm dần, kế đến là các số
âm tăng dần, cuối cùng là các số 0.
6. Viết chƣơng trình nhập vào một mảng gồm n số nguyên rồi thiết kế các hàm cho các
thao tác bên dƣới.
- Xuất các phần tử vừa nhập
- Xuất các phần tử theo thứ tự ngƣợc lại
- Xuất các phần tử chẵn
- Xuất các phần tử lẻ
- Xuất các phần tử âm
- Xuất các phần tử dƣơng
- Xuất các phần tử chia hết cho 2
- Xuất các phần tử chia hết cho 3 và 5
- Xuất các phần tử là số nguyên tố
- Xuất các phần tử không là snt
- Xuất các phần tử là số chín phƣơng
- Xuất ra phần tử lớn nhất
- Xuất ra phần tử lẻ lớn nhất
- Xuất ra phần tử chẵn nhỏ nhất
- Xuất ra phần tử lẻ lớn nhất, tổng cộng có bao nhiêu phần tử lẻ
- Xuất ra phần tử chẵn nhỏ nhất, tổng cộng có bao nhiêu phần tử chẵn
- Nhập vào 1 số đếm xem số đó xuất hiện bao nhiêu lần trong dãy, tại
những vị trí nào.
- Nhập vào 2 số, liệt kê tất cả các số là ƣớc chung của 2 số vừa nhập
- Cho biết tổng các phần tử chẵn
- Cho biết tổng các phần tử lẻ
- Tính tổng phần tử chẵn nhỏ nhất và phần tử lẻ nhỏ nhất
- Sắp xếp dãy tăng dần
- Sắp xếp dãy giảm dần
- Sắp xếp các phần tử lẻ tăng dần
- Sắp xếp các phần tử chẵn giảm dần.
- Sắp xếp các phần tử nguyên tố tăng dần

26
- Nhập 1 số kiểm tra xem số đó có trong mảng không
- Nhập 1 số, in ra phần tử có chỉ số là số vừa nhập
- Nhập vào một số in ra vị trí xuất hiện đầu tiên của số vừa nhập, nếu không
có thông báo là không tìm thấy.
- Nhập vào một số in ra vị trí xuất hiện cuối cùng của số vừa nhập, nếu
không có thông báo là không tìm thấy
- Nhập vào một số in ra tất cả các vị trí xuất hiện của số vừa nhập, nếu
không có thông báo là không tìm thấy.
- Thêm một phần tử có nội dung x vào đầu mảng
- Thêm một phần tử có nội dung x vào cuối mảng
- Thêm một phần tử có nội dung x vào vị trí i trong mảng
- Xoá phần tử đầu mảng
- Xoá phần tử cuối mảng
- Xoá phần tử tại vị trí i trong mảng
- Xoá phần tử có nội dung x đầu tiên trong mảng
- Xoá phần tử có nội dung x trong mảng
- Xoá tất cả các phần tử có nội dung x trong mảng
- Xoá các phân tử trùng nhau trong mảng (chỉ giữ lại 1 phần tử).
7. Viết chƣơng trình nhập vào một dãy các số theo thứ tự tăng, nếu nhập sai quy cách thì
yêu cầu nhập lại. In dãy số sau khi đã nhập xong. Nhập thêm một số mới và chèn số đó
vào dãy đã có sao cho dãy vẫn đảm bảo thứ tự tăng. In lại dãy số để kiểm tra.
8. Viết chƣơng trình nhập vào một mảng số tự nhiên. Hãy xuất ra màn hình:
- Dòng 1 : gồm các số lẻ, tổng cộng có bao nhiêu số lẻ.
- Dòng 2 : gồm các số chẵn, tổng cộng có bao nhiêu số chẵn.
- Dòng 3 : gồm các số nguyên tố.
- Dòng 4 : gồm các số không phải là số nguyên tố.
9. Viết chƣơng trình thực hiện việc đảo một mảng một chiều.
Ví dụ : 1 2 3 4 5 7 9 10 đảo thành 10 9 7 5 4 3 2 1 .
10. Viết chƣơng trình nhập vào mảng các số nguyên kết thúc nhập khi nhập số 0 (Số 0
không đƣợc lƣu vào mảng). Xuất các phần tử vừa nhập theo thứ tự tăng dần và không có
phần tử trùng nhau.
11. Viết chƣơng trình trộn hai dãy có thứ tự thành một dãy có thứ tự.

27
12. Viết chƣơng trình nhập vào một ma trận (mảng hai chiều) các số nguyên, gồm m
hàng, n cột. In ma trận đó lên màn hình. Nhập một số nguyên khác vào và xét xem có
phần tử nào của ma trận trùng với số này không ? Ở vị trí nào? Có bao nhiêu phần tử ?
13. Viết chƣơng trình để chuyển đổi vị trí từ dòng thành cột của một ma trận (ma trận
chuyển vị) vuông 4 hàng 4 cột. Sau đó viết cho ma trận tổng quát cấp m*n.
Ví dụ:
1 2 3 4 1 2 9 1
2 5 5 8 2 5 4 5
9 4 2 0 3 5 2 8
1 5 8 6 4 8 0 6
14. Viết chƣơng trình nhập vào hai ma trận A và B có cấp m, n. In hai ma trận lên màn
hình. Tổng hai ma trận A và B là ma trận C đƣợc tính bởi công thức:
cij= aij +bij ( i=0,1,2,...m-1; j=0,1,2...n-1)
Tính ma trận tổng C và in kết quả lên màn hình.
15. Viết chƣơng trình in ra bảng mã Assci từ 0 đến 255
16. Viết chƣơng trình nhập vào một ký tự in ra ký tự in hoa của ký tự đó. Nếu ký tự nhập
vào là ký tự in hoa thì thông báo là phải nhập ký tự thƣờng, nếu nhập không phải ký tự
thì báo phải nhập ký tự từ a đến z. (Ví dụ: Nhập a in A, Nhập A in phải nhập ký tự
thƣờng, Nhập 0 in phai nhập ký tự từ a đến z)
17. Viết chƣơng trình nhập vào một chuỗi, In ra chuỗi đó.
18. Viết chƣơng trình nhập vào một chuỗi, in ra chuỗi in hoa của chuỗi vừa nhập
19. Viết chƣơng trình nhập vào một chuỗi, Đỗi ký tự đầu mỗi từ thành in hoa.
20. Viết chƣơng trình nhập vào một chuỗi, đếm xem chuỗi đó có bao nhiêu ký tự kể cả
khoảng trắng
21. Nhƣ câu 8 nhƣng không tính khoảng trắng
22. Viết chƣơng trình nhập vào một chuỗi, đếm xem chuỗi có bao nhiêu từ (ví dụ: Nhập
“NGUYEN BA QUANG LAM”, Xuất có 4 từ.
23. Viết chƣơng trình nhập vào 1 chuỗi đảo ngƣợc các từ trong chuỗi (ví dụ: Nhập
“NGUYEN BA QUANG LAM”, Xuất “LAM QUANG BA NGUYEN”).
24. Viết chƣơng trình nhập vào một chuỗi và một ký tự
a. Đếm số lần xuất hiện của ký tự đó trong chuỗi
b. Cho biết các vị trí mà ký tự đó xuất hiện
c. Tìm vị trí của ký tự liền sau ký tự đó trong chuỗi.

28
CHƢƠNG 3: HƢỚNG ĐỐI TƢỢNG (OOP) TRONG C#
3.1. Lớp (class) trong C#
Một Class là một khái niệm mô tả cho những thực thể có chung tính chất và hành vi.
Class định nghĩa những thuộc tính và hành vi đƣợc dùng cho những đối tƣợng của lớp đó.
Do đó có thể nói Class là một khuôn mẫu cho các đối tƣợng.
Cú pháp để tạo một class
AccessModifier class className
{
// thân class
}
3.2. Đối tƣợng (Objects)
Đối tƣợng là một đại diện, hay có thể nói là một sản phẩm của một class. Tất cả
các đối tƣợng đều có chung những thuộc tính và hành vi mà class định nghĩa. Cách tạo
đối tƣợng giống nhƣ cách tạo một biến có kiểu dữ liệu là Class.
AccessModifier ClassName ObjectName = new ClassName();
Ƣu điểm của việc sử dụng Class và Đối tƣợng
Có một số những ƣu điểm của việc sử dụng Class và đối tƣợng trong phát triển phần
mềm. Những ƣu điểm nổi bật nhất đƣợc liệt kê nhƣ sau:

Duy trì code bằng việc mô hình hóa

Đóng gói những sự phức tạp trong mã lênh từ ngƣời dùng

Khả năng sử dụng lại

Cung cấp đơn kế thừa để thực thi nhiều phƣơng thức.
3.3. Hàm tạo (Constructors) và hàm hủy (Destructors) trong C#
Constructors

29
Constructors là những hàm đặc biệt cho phép thực thi, điều khiển chƣơng trình ngay khi
khởi tạo đôi tƣợng. Trong C#, Constructors có tên giống nhƣ tên của Class và không trả
lại giá trị.
Ví dụ
class Library
{
private int ibooktypes;
//Constructor
public Library()
{
ibooktypes = 7;
}
public Library(int value)
{
ibooktypes = value;
}
}
Destructors
Là một hàm đặc biệt đƣợc sử dụng để làm sạch bộ nhớ. Cách khai báo giống nhƣ
Constructor nhƣng không có tham số và đƣợc bắt đầu bằng dấu “~”.
Ví dụ
class Library
{
private int ibooktypes;
//Constructor
public Library()
{
ibooktypes = 7;

30
}
public Library(int value)
{
ibooktypes = value;
}
~ Library()
{
//thực thi câu lệnh
}
}
3.4. Fuction Overloading
Method Overloading xuất hiện khi trong một class có từ hai hàm có cùng tên. Có hai kiểu
Method Overloading:
Function Overloading dựa trên số lƣợng tham số truyền vào
Function Overloading dựa trên kiểu giá trị tham số truyền vào.
Ví dụ
class Library
{
// Function Overloading
public void insertbooks(int id)
{
//
}
public void insertbooks(int id, int type)
{
//
}
public void insertbooks(string id, int type)

31
{
//
}
}
Ba hàm insertbooks ở trên là một ví dụ về function overloading trong lập trình C#. Trong
khi hàm thứ nhất và thứ 2 là overloading theo số lƣợng tham số, và hàm thứ 3 với hàm
thứ 2 là overloading theo kiểu tham số truyền vào.
3.5. Thừa kế trong C#
Một trong những ƣu điểm nổi bật của lập trình hƣớng đối tƣợng đó là thừa kế, đó
là sự sử dụng lại những thuộc tính và hành vi của một lớp. Có hai kiểu kế thừa trong lập
trình, đơn kế thừa và đa kế thừa.
C# cung cấp mô hình đơn kế thừa.
Ví dụ về kế thừa trong C#.
/* Ví dụ về thừa kế trong lập trình C# */
using System;
using System.Text;
namespace __OOP_Inheritance
{
class Program
{
{
Dog objDog = new Dog(4);
objDog.displayProperties();
Chicken objChicken = new Chicken(2);
objChicken.displayProperties();
Console.Read();

32
}
}
class Animal
{
protected int ifoots;
protected string sName;
protected void setFoot(int ival)
{
ifoots = ival;
}
protected void setName(string sVal)
{
sName = sVal;
}
public void displayProperties()
{
Console.WriteLine(sName + " have " +
ifoots.ToString()+ " foots");
}
}
class Dog : Animal
{
public Dog(int ival)
{
setName("Dog");
ifoots = ival;
}
}
class Chicken : Animal

33
{
public Chicken(int ival)
{
setName("Chicken");
setFoot(ival);
}
}
}
Kết quả khi thực thi chương trình
Ở ví dụ trên, Dog và Chicken là hai lớp kế thừa từ lớp Animal, do đó các thuộc
tính nhƣ số chân, ifoots và tên sName đƣơng nhiên xuất hiện trong hai lớp này và cho
phép sử dụng. Tƣơng tự, các hàm nhƣ setName(), setFoot(), displayProperties() tại lớp
Animal cũng đƣợc kế thừa xuống hai lớp Dog và Chicken. Do đó ta có thể gọi những
hàm này, và kết quả hiển thị khi gọi hàm displayProperties() theo đối tƣợng objDog và
objChicken khác nhau nhƣ hình trên.
3.6. Overriding (ghi đè), Polymorphism (đa hình) trong C#
3.6.1. Overriding
Ghi đè – override :
- Là Phƣơng thức đã xuất hiện ở lớp cha và xuất hiện tiếp ở lớp con.
- Khi đối tƣợng thuộc lớp con gọi phƣơng thức thì sẽ chọn lựa và chạy theo phƣơng thức
trong lớp con.
- Nếu lớp con không có phƣơng thức đó thì mới lên kiếm ở lớp cha để chạy
- Ghi đè là hình thức đa hình (polymorphism) trong quá trình thực thi (Runtime).
Ví dụ

34
/* Ví dụ về thừa kế,overrding trong lập trình C# */
using System;
using System.Text;
namespace __OOP_Inheritance
{
class Program
{
{
Dog objDog = new Dog(4);
objDog.displayProperties();
Chicken objChicken = new Chicken(2);
objChicken.displayProperties();
Tiger objTiger = new Tiger(4);
objTiger.displayProperties();
Console.Read();
}
}
class Animal
{
protectedint ifoots;
protectedstring sName;
protectedvoid setFoot(int ival)
{
ifoots = ival;
}
protectedvoid setName(string sVal)

35
{
sName = sVal;
}
public virtual void displayProperties()
// chú ý hàm này
{
Console.WriteLine(sName + " has " +
}
}
class Dog : Animal
{
public Dog(int ival)
{
setName("Dog");
ifoots = ival;
}
}
class Chicken : Animal
{
public Chicken(int ival)
{
setName("Chicken");
setFoot(ival);
}
public void displayProperties()
{

36
base.displayProperties();
Console.WriteLine(sName + " have " +
ifoots.ToString() + " foots (from Chicken class)");
}
}
class Tiger : Animal
{
public Tiger(int ival)
{
setFoot(ival);
}
public override void displayProperties() // chú ý hàm
này
{
Console.WriteLine("Tiger has " +
}
}
}
Kết quả thực hiện chương trình
Hàm displayProperties() trong lớp Tiger overrides hàm displayProperties() trong lớp
Animal.
Nếu một hàm đƣợc định nghĩa trong lớp con có cùng tên, kiểu với hàm trong lớp cha, khi
ấy hàm trong lớp con sẽ overrides (làm ẩn) hàm trong lớp cha. Đó đƣợc gọi là overriding.

37
3.6.2. Polymorphism
Đa hình (Polymorphism) từ này có nghĩa là có nhiều hình thức. Trong mô hình lập
trình hƣớng đối tƣợng, đa hình thƣờng đƣợc diễn tả nhƣ là "một giao diện, nhƣng nhiều
chức năng".
Đa hình có thể là tĩnh hoặc động. Trong đa hình tĩnh, phản ứng với một chức năng
đƣợc xác định tại thời gian biên dịch. Trong đa hình động, nó đƣợc quyết định tại thời
gian chạy (run-time).
Ví dụ
using System;
using System.Text;
namespace __OOP_polymorphism
{
class Program
{
{
Child objchild = new Child();
Console.WriteLine("Result is " +
objchild.methodA().ToString()); Console.Read();
}
}
class Parent
{
public int methodA()
{
return methodB() * methodC();
}

38
public virtual int methodB()
{
return 1;
}
public int methodC()
{
return 2;
}
}
class Child : Parent
{
public override int methodB()
{
return 3;
}
}
}
Kết quả chạy trương trình
Nhƣ bình thƣờng của mô hình kế thừa, kết quả trả về khi gọi hàm methodA() từ
đối tƣợng của lớp Child phải là “Result is 2”. Nhƣng trong kết quả trên, kết quả là
“Result is 6”. Kết quả này do hàm methodB() tại lớp Child đã override hàm methodB()
tại lớp Parent.
Vậy ta có thể khái quát Polymorphism nhƣ sau:

Polymorphism không chỉ đơn giản là overriding, mà nó là overrding thông minh.

Khác biệt giữ Overriding và Polymorphism đó là trong Polymorphism, sự quyết
định gọi hàm đƣợc thực hiện khi chƣơng trình chạy.

39
3.7. Abstract Class trong C#
Abstract Class là lớp dùng để định nghĩa những thuộc tính và hành vi chung của
những lớp khác. Một Abstract class đƣợc dùng nhƣ một lớp cha của các lớp khác. Từ
khóa abstract đƣợc dùng để định nghĩa một abstract class. Những lớp đƣợc định nghĩa
bằng cách dùng từ khóa abstract thì không cho phép khởi tạo đối tƣợng của lớp ấy.
abstract class Shape
{
public abstract float calculateArea();
public void displaySomething()
{
Console.WriteLine("Something is displayed");
}
}
class Circle:Shape
{
float radius;
public override float calculateArea()
{
return radius * 22 / 7;
}
}
Khi thực thi chƣơng trình, bạn không thể tạo đối tƣợng cho lớp Shape, vì nó là abstract
class.
3.8. Namespaces
Khái niệm Namespace
Đƣờng mang tên vị tƣớng danh tiếng Trần Hƣng đạo đều có tại Sài Gòn và Hà
Nội, vậy làm sao để phân biệt khi ngƣời nƣớc ngoài muốn hỏi về đƣờng Trần Hƣng Đạo.
Cách đơn giản nhất đó là khi muốn gọi tên đƣờng Trần Hƣng Đạo tại Hà Nội thì ta gọi

40
“đƣờng Trần Hƣng Đạo tại Hà Nội” và tƣơng tự tại Sài Gòn là “đƣờng Trần Hƣng Đạo
tại Sài Gòn” và chắc chắn chúng ta sẽ có câu trả lời cho vị khách đó.
Hà Nội, Sài Gòn trong ví dụ trên là một ví dụ cho Namespace.
Vậy có thể hiểu Namespace là một gói những thực thể có thuộc tính và hành vi độc
lập với bên ngoài. Những ƣu điểm của namespace đƣợc liệt kê nhƣ sau:
-
Tránh đƣợc sự trùng lặp tên giữa các class.
-
Cho phép tổ chức mã nguồn một cách có khoa học và hợp lý.
Khai báo một Namespace
namespace NamespaceName
{
// nơi chứa đựng tất cả các class
}
Trong đó,
Namespace: là từ khóa khai báo một NameSpace
NamespaceName: là tên của một Namespace
Ví dụ
namespace CSharpProgram
{
class Basic
{
}
class Advance
{
}
}
3.9. Enumerator trong C#
Enums là một loạt tên của những hằng số. Đƣợc sử dụng để định nghĩa những kiểu
dữ liệu có một loạt những giá trị xác định.

41
Ví dụ sau mô tả về Enumerator
using System;
using System.Text;
namespace __OOP_polymorphism
{
class Program
{
{
// Enummerator
EnumDemo eobj = newEnumDemo();
eobj.getWeekDay(DayinWeek.Saturday);
Console.Read();
}
}
public enum DayinWeek
{
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,
Sunday
}
public class EnumDemo

42
{
public void getWeekDay(DayinWeek dayoff)
{
Console.WriteLine("My weekday is " + dayoff.ToString());
}
}
}

43
BÀI TẬP CHƢƠNG 3:
Bài 1. (Có hƣớng dẫn) Xây dựng một ứng dụng Console cơ bản quản lý danh sách các
cuốn sách, mỗi cuốn sách này chứa các thông tin nhƣ sau: tên sách, tên tác giả, nhà xuất
bản, năm xuất bản, số hiệu ISBN (International Standard Book Number) và danh mục các
chƣơng sách (chỉ chứa tên chƣơng).
Thực hiện theo các yêu cầu sau:
- Xây dựng một interface có tên là IBook, mô tả property và method cần thiết cho các
lớp dạng Book thực thi.
- Xây dựng lớp Book kế thừa từ IBook, thực hiện các mô tả trong IBook và các chi
tiết riêng của Book.
- Xây dựng lớp BookList quản lý danh sách các đối tƣợng Book, lớp này chứa các
thao tác trên danh sách các đối tƣợng Book.
- Thực thi giao diện IComparable, định nghĩa quan hệ thứ tự trong phƣơng thức
CompareTo…
- Sử dụng giao diện IComparer, hỗ trợ sắp xếp theo nhiều tiêu chuẩn khác nhau…
Viết hàm Main thực thi yêu cầu sau:
o Cho nhập vào một mảng chứa những cuốn sách.
o Xuất danh sách thông tin những cuốn sách.
o Lần lƣợt xuất danh sách ra theo thứ tự đƣợc sắp theo tên tác giả, tên sách,
năm xuất bản.
Hƣớng dẫn:
Bƣớc 1: Tạo ứng dụng Console có tên BookManaging
Bƣớc 2: Tạo giao diện IBook đƣợc minh họa nhƣ hình, gồm các mô tả
 index
 Property Title
 Property Author
 Property Publisher
 Property Year
 Property ISBN

44
 Một phƣơng thức void Show() không tham số
Bƣớc 3: Định nghĩa lớp Book, lớp này có thực thi giao diện Ibook
class Book : IBook
{
// nội dung của lớp Book
}
Khai báo các field cho lớp Book

45
Thực thi lần lƣợt các property mô tả trong IBook, hình sau minh họa một cách cài đặt bộ
chỉ mục cho các chƣơng sách
Định nghĩa phƣơng thức Show (phƣơng thức này có mô tả trong IBook)

46
Phần định nghĩa phƣơng thức Show Định nghĩa phƣơng thức Input()
Phần định nghĩa phƣơng thức Input
Bƣớc 4: Tạo lớp BookList để quản lý danh sách các đối tƣợng Book, đây là dạng
container class

47
Bƣớc 5: Tạo đoạn code demo nhƣ sau
Bài 2. Bổ sung chức năng hỗ trợ để sắp xếp danh sách book theo một thứ tự nào đó, ví dụ
sắp danh sách theo thứ tự alphabet của title, thứ tự theo author, thứ tự theo publisher, thứ
tự theo năm…
Có 2 cách thực hiện:
Thực thi giao diện IComparable
Sử dụng giao diện IComparer, tạo các lớp hỗ trợ sắp xếp theo các tiêu chuẩn khác
nhau
Bài 3. Tạo một lớp Account chứa các thông tin tài khoản ngân hàng nhƣ sau:
 Account ID: mã số tài khoản o First Name
 Last Name
 Balance: số dƣ tài khoản
- Viết các phƣơng thức constructor, phƣơng thức hiển thị thông tin tài khoản,
phƣơng thức nhập thông tin tài khoản (từ bàn phím).
- Tạo lớp AccountList chứa danh sách các Account, sử dụng ArrayList để lƣu
trữ danh sách này. Viết các phƣơng thức sau
 NewAccount: thêm một account mới vào danh sách o SaveFile: lƣu danh
sách account vào file
 LoadFile: lấy danh sách account từ file vào danh sách

48
 Report: xuất ra màn hình tất cả danh sách các account
Bài 4.
 Bổ sung thêm chức năng Remove xóa một account ra khỏi danh sách. Sử dụng
BinarySearch của ArrayList để xác định chỉ mục của đối tƣợng có khóa nào đó,
theo tiêu chí so sánh trong các lớp IComparer đƣợc xây dựng hỗ trợ cho Account.
 Sắp xếp danh sách theo thứ tự tăng dần của Account ID, First Name, Balance.

49
CHƢƠNG 4: LẬP TRÌNH GIAO DIỆN VỚI C#
4.1. Môi trƣờng phát triển Visual Studio. Net
VS.NET là bộ công cụ giúp phát triển các ứng dụng từ ứng dụng desktop đến ứng
dụng mạng. Nó là môi trƣờng để phát triển tất cả các ngôn ngữ nhƣ C#, Visual C++
,
Visual C#.Net hết sức mạnh mẽ và thuận lợi.
4.1.1. Khởi động visual studio.NET
Việc khởi động VS.NET cũng tƣơng tự nhƣ các phần mềm khác nhƣ ms.Word hay
excel. Nếu lần đầu khởi động VS.NET sẽ yêu cầu xem bạn chạy nó với ƣu tiên ứng dụng
và ngôn ngữ nào. Bạn chọn Visual C# và start vs. Net là xong. Màn hình bắt đầu nhƣ sau:
Hình 4.1. Màn hình khởi động của VS.NET
Nếu trang start page không hiện chọn menu View | Other Windows | Start Page.
4.1.2. Mở một dự án của visual basic
 Tại trang start page, bạn có thể click vào project của phần Open.
 Duyệt đến thƣ mục chứa dự án

50
 Mở file . Sln. Khi này trang Start Page sẽ tạm ẩn đi, một cửa sổ mới xuất
hiện:
Hình 4.2. Cửa sổ sau khi mở dự án
4.1.3. Các công cụ của VS.NET
Công cụ trong vs.NET rất phong phú. Bạn có thể khám phá từ từ. Sau đây
là mô phỏng màn hình làm việc của bộ vs.NET:
- Nhắp chuột vào nút start màu xanh trên standard bar để chạy chƣơng trình
(cũng có thể ấn phim F5).
Menu
Bar
Tools
Box
Windows Form Designer
Standard Toolbar Solution Explorer
Properties Windows
Output Windows

51
Hình 4.3. Các công cụ của VS.NET
4.1.4. Bộ thiết kế Windows Forms Designer
VS.NET có một bộ thiết kế form trực quan, Chúng ta sẽ làm quen dần dần bởi vì
thƣờng trong các dự án phát triển có thể có rất nhiều Form.
Góc phải màn hình là cửa sổ Solution Explorer. Hiển thị nó View | Solution
Explorer. Cửa sổ này chứa toàn bộ các phần tử có sử dụng trong dự án.
Double Click vào file . Vb trong cửa sổ Solution Explorer bạn sẽ thấy tất cả các
file chứa form.
Nhấp chuột vào biểu tƣợng View Designer trong solution để hiển thị form
thiết kế ở dạng trực quan.
Chạy một chƣơng trình Visual Basic
- Nhấp chuột vào nút start màu xanh trên standard bar để chạy chƣơng trình
(F5).
Cửa sổ thuộc tính Properties
Cho phép thay đổi thông số của đối tƣợng thiết kế form sau này.
Hãy thử mở giao diện chƣơng trình bất kỳ và click vào một phần tử bất kỳ rồi thay
đổi thử các thuộc tính của chúng xem sao.
Di chuyển và thay đổi kích thƣớc cửa sổ công cụ lập trình
Tất cả các cửa sổ của bộ công cụ vs.NET đều có thể di chuyển cũng nhƣ
thay đổi đƣợc nhƣ các cửa sổ thông thƣờng
Xem trợ giúp
Có thể xem trợ giúp trực tuyến hay cài bộ MSDN để xem trợ giúp. Có nhiều cách
xem trợ giúp khác nhau.
4.2. Xây dựng Windows Forms
Visual Studio .NET Integrated Development Environment (IDE)cung cấp cho
bạn những giao diện chung cho việc phát triển nhiều loại dự án khác nhau trên nền tảng
.NET. IDE cho phép khả năng thiết kế giao diện ngƣời dùng cho ứng dụng, viết mã lệnh,
biên dịch, và kiểm lỗi cho ứng dụng. Visual Studio .NET cung cấp nhiều ngôn ngữ để
phát triển ứng dụng trong bộ .NET của Microsoft nhƣ: Visual Basic, Visual C#, Visual
C++….
Tạo một dự án trong Visual Studio .Net

52
Chạy ứng dụng Visual Studio 2010 từ menu Start Program Microsoft Visual Studio
2010 Microsoft Visual Studio 2010. Tạo mới ứng dụng bằng cách nhấn vào menu File
New Project. Cửa sổ tạo mới Project xuất hiện.
Hình 4.4: Cửa sổ tạo Project
Trong cửa sổ New Project, Project Types pane hiển thị danh mục những kiểu
project mà bạn có thể tạo trong VS. Chúng ta quan tâm tới hai loại project đó là Visual
C# và Setup and Deployment. Trong khi Visual C# là kiểu dự án cho phép tạo ra ứng
dụng bằng ngôn ngữ C#, thì Setup and Deployment là kiểu project để triển khai dự án
đến ngƣời dùng cuối.
Chọn Visual C# Windows tại Project Types.
Ở cửa sổ Templates, một số mẫu ứng dụng có sẵn để giúp ngƣời phát triển nhanh
chóng tạo ra ứng dụng phù hợp theo yêu cầu. Có các kiểu project template sau cần chú ý
nhất:
Windows Application: đƣợc dùng đẻ tạo những ứng dụng Windows.
Class Library: sử dụng để tạo ra những compnent sử dụng lại trong các dự án khác
Windows Controls Library: tạo những công cụ cho môi trƣờng ứng dụng Window
Console Application: tạo ra ứng dụng console chạy từ dòng lệnh, giao diện ký tự.

53
Chọn Windows Application
Đặt tên cho dự án đầu tiên là WindowForm tại Name
Chọn thƣ mục lƣu trữ dự án tại Location
Click OK
Một Windows Form là một cửa sổ đƣợc xuất hiện trong một ứng dụng. Mỗi Windows
Form là một lớp đƣợc kế thừa từ lớp Form nằm trong Namespace
System.Windows.Forms
Hình 4.5: Windows Form
Thuộc tính Windows Form
Những thuộc tính chung của Windows Form đƣợc liệt kê theo bảng sau
Properties Mô tả
Name
Là thuộc tính để xác định tên của form, mặc
định, thuộc tính Name của form đầu tiên trong
ứng dụng là Form1
Backcolor Thuộc tính xác định màu nền của form
BackgroundIma
ge
Thuộc tính xác định hình nền cho form
Font
Thuộc tính xác định kiểu, kích thước, và loại
font được hiển thị trên form và trong những

54
controls trong form.
Size Kích thước của form bao gồm: Width và Height
Start
Position
Thuộc tính xác định vị trị mặc định xuất hiện
của Form trên màn hình máy tính người sử dụng,
có các thuộc tính sau:
- Manual - vị trí và kích thước của form phục
thuộc vào vị trí xuất hiện của nó
- CenterScreen - xuất hiện ở chính giữa màn hình
- WindowsDefaultLocation - form xuất hiện tại vị
trí mặc định của Windows theo kích thước của
form.
- Windows DefaultBounds - form được hiển thị tại
vị trí mặc định của Windows và các chiều của
chúng phụ thuộc vào hệ điều hành Windows.
- Center Parent - form được mở như một cửa sổ
con của một form khác và xuất hiện tại vị trí
chính giữa so với form cha.
Text Xác định tiêu đề của form tại Title Bar
WindowState
Xác định trạng thái xuất hiện của form: normal,
maximized, hay minimized.
Sự kiện trong Windows Form
Những sự kiện trong Windows Form đƣợc liệt kê nhƣ bảng sau
Events Mô tả
Click
Sự kiện này xảy ra khi người dùng click vào bất
kỳ nơi nào trên Windows Form
Closed Sự kiện này xảy ra khi một form được đóng lại
Deactivate
Sự kiện xảy ra khi một form bị mất trạng thái sử
dụng
Load
Sự kiện xảy ra khi một form được tải trong bộ nhớ
cho lần đầu tiên.
MouseMove
Sự kiện này xuất hiện khi chuột được rê trên một
form
MouseDown Sự kiện xảy ra khi chuột được nhấn trên form

55
MouseUp Sự kiện xảy ra khi chuột được thả trên form.
Hàm thao tác với Windows Form
Show() Được sử dụng để xuất hiện một
form bằng cách set thuộc tính
Visible của form ấy là True
Form1 frmObj = new
Form1();
frmObj.Show();
Activate() Sử dụng để kích hoạt trạng
thái sử dụng của Form và đưa
trạng thái sử dụng về Form ấy.
frmObj.Activate();
Close() Dùng để đóng một Form frmObj.Close();
SetDesktop
Location()
Hàm này dùng để định vị trí
của Form trên màn hình
SetDesktopLocation
(100,150)
4.3. Các điều khiển chính trong C#
Hình 4.6. Các điều khiển chính trong C#

56
4.3.1. TextBox
TextBox là điều khiển cho phép nhận giá trị từ ngƣời dùng trên một Form. Mặc định giá
trị lớn nhất mà TextBox nhận là 2048 ký tự.
Hình 4.7: TextBox Control
Thuộc tính Mô tả Ví dụ
Text
Xác định giá trị hiển
thị bên trong TextBox
txtUserName.Text=
”pta30000”;
Multiline
Cho phép TextBox hiển
thị nhiều dòng chữ.
txtContent.Multil
ine = true;
PasswordChar
Thuộc tính này cho
phép lấy một ký tự làm
đại diện cho tất cả
các ký tự khác được
nhập vào từ người dùng
txtPassword.Passw
ordChar=”*”;
4.3.2. Label (Nhãn)
Label Control đƣợc sử dụng để hiển thị chữ trên form và không cho phép ngƣời dùng
thay đổi. Label đƣợc sử dụng để mô tả thông tin cho những control khác trên Form.
Hình 4.8: Label Control
Dòng chữ xuất hiện bên trên TextBox đó là Label, có mục đích giải thích cho
TextBox.
Thuộc tính
Name: tên của nhãn
Text: là kí tự hiển thị
Font: thuộc tính của chữ gồm nhiều thuộc tính con
Background: màu nền, hình ảnh nền
Transparent: trong suốt

57
Backcolor: mầu nền của nhãn
Visited color: mầu của nhãn khi ngƣời dùng sử dụng
Forecolor: màu của nhãn
Autosize: cỡ chữ tự động
Borderstyle: kiểu đƣờng viền
Image: ảnh chèn vào nhãn
Locked: khoá không cho di chuyển nhãn
Visible: ẩn nhãn khi chƣơng trình thực hiện
Textalign:Canh lề chuỗi trình bày trên điều khiển Label
Flatstyle: hiển thị theo hệ thống
Sự kiện
Click: khi ngƣời dùng ấn chuột vào đối tƣợng
Mouse move: khi ngƣời dùng di chuyển chuột vào đối tƣợng
Linklable: dùng để liên kết
4.3.3. LinkLabel Control
LinkLabel đƣợc sử dụng để hiển thị một chuỗi nhƣ một liên kết. Khi bạn nhấn vào
liên kết, nó sẽ mở ra một form khác hoặc một Website.
Để mở ra một form khác, .NET cung cấp sự kiện LinkClicked, bạn thực hiện nhƣ sau:
private void
linkLabel1_LinkClicked(object
sender,
LinkLabelLinkClickedEventArgs e) {
Form1 frmobj = new Form1();
frmobj.Show();
}
Để mở một website, bạn có thể dụng đoạn mã sau đặt bên trong sự kiện Link
private void linkLabel1_LinkClicked(object sender,
LinkLabelLinkClickedEventArgs e) {
System.Diagnostics.Process.Start(
"http://www.vnkgu.edu.vn");
}

58
4.3.4. ListBox Control
ListBox đƣợc sử dụng để hiển thị một danh sách phần tử đến ngƣời dùng. Một
ngƣời dùng có thể chọn một trong những phần tử này.
Có thể thêm danh mục những phần tử vào trong một ListBox bằng cách,
chọn ListBox, tại cửa sổ Properties Window, chọn thuộc tính Items, nhấn vào nút và
cửa sổ String Collection Editor xuất hiện nhƣ hình dƣới.
Hình 4.9: ListBox Control
Nhập vào danh sách các phần tử, sau đó nhấn OK. Bạn cũng có thể thêm những phần tử
vào ListBox tại lúc chạy chƣơng trình bằng cách sử dụng phƣơng thức Add() của thuộc
tính Items trong ListBox.
lstitems.Items.Add("ĐH Luật TPHCM");
lstitems.Items.Add("ĐH CNTT ĐHQG TPHCM");
Những thuộc tính thƣờng sử dụng nhất của ListBox đƣợc liệt kê theo bảng dƣới đây
SelectionM
ode
Xác định cách thức mà người dùng
lựa chọn những phần tử trong
ListBox. Có 4 giá trị
ListBox1.Selec
tionMode =
SelectionMode.

59
- None: người dùng không thể chọn
bất cứ phần tử nào trong ListBox
- One: người sử dụng chỉ chọn một
giá trị từ ListBox
- MultiSimple: cho phép người sử
dụng chọn nhiều phần tử từ
ListBox.
- MultiExtended: người dùng có thể
chọn nhiều phần tử và sử dụng phím
SHIFT, CTRL và phím mũi tên để
chọn những phần tử từ ListBox.
MultiSimple;
Sorted
Thuộc tính xác định khi nào những
phần tử trong ListBox có thể được
sắp xếp
ListBox1.Sorte
d = true;
SelectedIn
dex
Thuộc tính cho phép gán hoặc nhận
vị trí được chọn hiện tại trong
ListBox.
ListBox1.Selec
tedIndex = 2;
SelectedIt
em
Thuộc tính này được dùng để gán
hoặc nhận phần tử đang được chọn
MessageBox.Sho
w(ListBox1.Sel
ectedItem)
Hình 4.10: Ví dụ sử dụng ListBox

60
4.3.5. ComboBox Control
ComboBox (Hộp điều khiển lựa chọn) đƣợc sử dụng để hiển thị danh sách những
phần tử thả xuống. ComboBox là sự kết hợp của TextBox cho phép ngƣời dùng nhập giá
trị và một danh sách thả xuống cho phép ngƣời sử dụng chọn phần tử.
Hình 4.11: ComboBox
Hầu hết những thuộc tính của ComboBox giống nhƣ thuộc tính của ListBox, nhƣng
ComboBox có thuộc tính Text.
Thuộc tính Text: cho phép gán hoặc nhận giá trị đƣợc ngƣời sử dụng nhập vào từ
ComboBox.
Để thêm những phần tử vào ComboBox, tƣơng tự nhƣ với ListBox, bằng cách sử dụng
phƣơng thức Add() của thuộc tính Items.
ComboBox1.Items.Add(“VietNam”);
ComboBox1.Items.Add(“Thailand”);
4.3.6. CheckBox Control
Control này đƣợc dùng để gán tùy chọn Yes/No hoặc True/False. Những thuộc tính
thƣờng sử dụng của CheckBox
Text
Thuộc tính này sử dụng để nhận
hoặc gán chuỗi ký tự là tiêu đề
của Checkbox
CheckBox1.Text =
“Yes”;
Checked
Là thuộc tính được sử dụng để
xác định checkbox được chọn
checkBox1.Checked
= true;
Sự kiện:
Click: Xảy ra khi ngƣời dùng nhấp chuột lên CheckBox

61
Hình 4.12: Minh hoạ sử dụng Check Box
4.3.7. RadioButton (Điều khiển nút lựa chọn)
RadioButton đƣợc dùng để cung cấp sự lựa chọn một trong một nhóm tiêu chí cho
ngƣời dùng. Chỉ một RadioButton đƣợc chọn trong một nhóm. Tất cả các RadioButton
đặt trực tiếp trên biểu mẫu (Có nghĩa là không thuộc GroupBox hoặc PictureBox) sẽ
đƣợc xem nhƣ một nhóm, nếu ngƣời dùng muốn tạo một nhóm các RadioButton khác bắt
buộc phải đặt chúng trong phạm vi của một GroupBox hoặc Picture Box.
Thuộc tính: Những thuộc tính thƣờng sử dụng của RadioButton giống nhƣ
CheckBox, bao gồm: Text, Checked.
Sự kiện: giống nhƣ CheckBox
4.3.8. Button Control (Nút nhấn)
Button đƣợc sử dụng để thực hiện một tác vụ khi ngƣời sử dụng nhấn vào nó.
Dùng để xác nhận 1 hành động hay thao tác của ngƣời dùng.
Thuộc tính:
- Name: Tên của Button.
- Text: Chuỗi hiển thị trên Button.
- Image: Hình ảnh trên Button.
- FlatStyle: Hình dạng của Button (Flat, Popup, Standard,
And System.)
private void
ckbDam_CheckedChanged(object sender,
EventArgs e)
{
if(ckbDam.Checked)
txtHoten.Font =new
Font("Arial",12,FontStyle.Bold);
else
txtHoten.Font = new
Font("Arial", 12,FontStyle.Regular);
}

62
- Font: Xác lập Font chữ cho Button.
private void button1_Click(object sender, EventArgs e)
{
this.button1.Text = this.Text;
}
Đoạn mã lệnh trên thực hiện việc gán Caption của
button1 bởi Caption của Form.
Sự kiện
- Click: Xảy ra khi ngƣời dùng nhấp chuột vào Button.
VD: Tính N! Với N nhập từ bản phím.
Sự kiện Button_Click()
private void button1_Click(object sender, EventArgs e)
{
int N = Convert.ToInt16(txtN.Text);
int S=1;
for (int i = 1; i <= N; i++)
S = S * i;
lblResult.Text = "Kết quả: " + S.ToString();
}
Hình 4.13: Minh hoạ sử dụng Button

63
4.3.9. ListView
Thêm một ListView control vào ứng dụng
Có 2 cách thêm một ListView vào ứng dụng:
- Kéo thả ListView từ Toolbox vào Form:
Hình 4.13: ListView Control
- Sử dụng code để add ListView vào Form:
ListView myListView = new ListView(); // Khai báo một
ListView control.
myListView.Size = new System.Drawing.Size(390, 100); //
Kích thước hiển thị
this.Controls.Add(myListView);// Add ListView control vừa
khai báo vào Form
Thay đổi chế độ xem (Changing the display modes)
- Tùy chỉnh thuộc tính View trong cửa sổ Properties
của Listview. Sẽ có 4 thuộc tính hiển thị để chúng ta
lựa chọn: LargeIcon, Details, SmallIcon, List Tile.

64
- Sử dụng code để tùy chỉnh thuộc tính view:
Ví dụ:
myListView.View = View.SmallIcon;
Add các item vào ListView (Khi ListView không theo cách hiển thị Details)
- Sử dụng thuộc tính Items trong cửa sổ Properties. Khi click vào button … ở thuộc tính
Items. Thì cửa sổ nhƣ hình dƣới sẽ hiện ra để bạn add item vào.
- Mỗi Item add sẽ có các thuộc tính nhƣ: Text, ForeColor, Text, ImageIndex…
- Chúng ta cũng có thể viết code để add các item vào ListView với mục đích tƣơng tự
cách làm trên. Ví dụ:
myListView.Items.Add("Công Nghệ Thông Tin");
myListView.Items.Add("Bách Khoa");
myListView.Items.Add ("Khoa Học Tự Nhiên");

65
myListView.Items.Add("Nhân Văn");
myListView.Items.Add("Kinh Tế - Luật");
Và kết quả sẽ là:
Add các cột vào ListView (Adding columns to the ListView)
- Chúng ta cũng có thể thực hiện một cách đơn giản nhƣ cách add các items ở trên:
- Hoặc cũng có thể sử dụng code:
myListView.Columns.Add("Tên Trường", 200);
myListView.Columns.Add("Số lượng sinh viên", 100);
- Lƣu ý: Để có thể hiển thị các columns thì chúng ta phải chọn chế độ xem là Details
myListView.View = View.Details;

66
Add sub Item vào Listview (Khi ListView ở chế độ xem Details)
- Sử dụng giống nhƣ cách add các items trong phần 3 đã trình bày. Ở chúng ta click vào
thuộc tính SubItem một cửa sổ mới sẽ hiện ra khá giống với cửa sổ add items
- Giờ chúng ta có thể add các item con cho item chính một cách bình thƣờng giống nhƣ
khi add item chính.
- Chúng ta cũng có thể sử dụng code để add các giá trị con cho item nhƣ:
// Add subitem
ListViewItem cntt = new ListViewItem("Công Nghệ Thông
Tin");

67
ListViewItem.ListViewSubItem svcntt = new
ListViewItem.ListViewSubItem(cntt, "3.000 sinh viên");
cntt.SubItems.Add(svcntt);
myListView.Items.Add(cntt);
ListViewItem bk = new ListViewItem("Bách Khoa");
ListViewItem.ListViewSubItem svbk = new
ListViewItem.ListViewSubItem(bk, "18.00 sinh viên");
bk.SubItems.Add(svbk);
myListView.Items.Add(bk);
ListViewItem khtn = new ListViewItem("Khoa Học Tự Nhiên");
ListViewItem.ListViewSubItem svkhtn = new
ListViewItem.ListViewSubItem(khtn, "20.000 sinh viên");
khtn.SubItems.Add(svkhtn);
myListView.Items.Add(khtn);
ListViewItem nv = new ListViewItem("Khoa Học Xã Hội & Nhân
Văn");
ListViewItem.ListViewSubItem svnv = new
ListViewItem.ListViewSubItem(nv, "15.000 sinh viên");
nv.SubItems.Add(svnv);
myListView.Items.Add(nv);
ListViewItem ktl = new ListViewItem("Kinh Tế - Luật");
ListViewItem.ListViewSubItem svktl = new
ListViewItem.ListViewSubItem(ktl, "10.000 sinh viên");
ktl.SubItems.Add(svktl);
myListView.Items.Add(ktl);
- Và kết quả sẽ là:

68
Thêm Style cho SubItems
Trong chế độ xem Details, chúng ta muốn thêm các hiển thị khác nhau của cách
SubItems từ Item cha chúng ta sử dụng thuộc tính UseItemStyleForSubItem =
true;
Nhƣ vậy chúng ta sẽ xác định đƣợc các kiểu khác nhau cho các subitems.
Ví dụ:
ListViewItem ktl = new ListViewItem("Kinh Tế - Luật");
ktl.UseItemStyleForSubItems = true;
Xóa item (Removing item)
Việc xóa các item của ListView đƣợc thực hiện rất đơn giản.
- Để xóa toàn bộ các item trong ListView có tên là myListView ta thực hiện lệnh
myListView.Clear();
- Để xóa item nào ta gọi phƣơng thức Remove():
ListViewItem cntt = new ListViewItem("Công Nghệ Thông
Tin");
cntt.Remove();
- Xóa item ở vị trí thứ a trong ListView ta sử dụng phƣơng thức RemoveAt():

69
myListView.Items.RemoveAt(2);
Liên kết hình ảnh với danh sách các items
- Đây là một tính năng làm đẹp cho ListView. Để liên kết các items trong danh sách
chúng ta cần phải có một imageList với một tập hợp các ảnh. Điều này đƣợc thực hiện
trong trong phƣơng thức ListView.Items.Add(…), sử dụng đối số imageIndex – là chỉ
mục liên kết với hình ảnh trong imageList.
- Đầu tiên kéo một imageList từ Toolbox vào Form (tên mặc định sẽ là imageList1)
- Trong thuộc tính Images của imageList1 sẽ đƣợc sử dụng để add hình ảnh vào
imageList1 nhƣ:
– Bây giờ ta sử dụng đối số imageIndex trong phƣơng thức add item vào listview để liên
kết hình ảnh với imageList1:
myListView.SmallImageList = imageList1; // Liên kết danh
sách hình ảnh nhỏ với imageList1
ListViewItem cntt = new ListViewItem("Công Nghệ Thông Tin",
0);
ListViewItem.ListViewSubItem svcntt = new
ListViewItem.ListViewSubItem(cntt, "3.000 sinh viên");

70
cntt.SubItems.Add(svcntt);
myListView.Items.Add(cntt);
ListViewItem bk = new ListViewItem("Bách Khoa", 1);
ListViewItem.ListViewSubItem svbk = new
ListViewItem.ListViewSubItem(bk, "18.00 sinh viên");
bk.SubItems.Add(svbk);
myListView.Items.Add(bk);
ListViewItem khtn = new ListViewItem("Khoa Học Tự
Nhiên",2);
ListViewItem.ListViewSubItem svkhtn = new
ListViewItem.ListViewSubItem(khtn, "20.000 sinh viên");
khtn.SubItems.Add(svkhtn);
myListView.Items.Add(khtn);
ListViewItem nv = new ListViewItem("Khoa Học Xã Hội & Nhân
Văn", 3);
ListViewItem.ListViewSubItem svnv = new
ListViewItem.ListViewSubItem(nv, "15.000 sinh viên");
nv.SubItems.Add(svnv);
myListView.Items.Add(nv);
ListViewItem ktl = new ListViewItem("Kinh Tế - Luật", 4);
- Lƣu ý đối số thứ 2 trong phƣơng thức add item chính là chỉ mục tham chiếu tới hình
ảnh trong imageList1.
- Và kết quả mà chúng ta có đƣợc:

71
Thêm CheckBox vào trƣớc mỗi item trong ListView (Adding checkbox to the
listview)
- Đôi khi chúng ta cần một checkbox đứng trƣớc mỗi item trong danh sách của Listview
ví dụ nhƣ: khi chọn các món hàng trong danh sách các hàng hóa… Ta thực hiện phƣơng
thức sau đây:
myListView.CheckBoxes = true;
- Bây giờ chúng ta có thể xử lý sự kiện item nào đƣợc chọn bằng cách thêm xử lý
trong sự kiện
myListView.ItemChecked += new
ItemCheckedEventHandler(myListView_ItemChecked);
- Hình ảnh minh họa ListView khi thêm checkbox:

72
4.3.10. Điều khiển TreeView
Với control TreeView trong Windows Form, chúng ta có thể hiển thị một hệ thống phân
cấp các node cho những ngƣời dùng. Giống nhƣ cửa sổ phía bên trái trong Windows
Explorer trong hệ điều hành Windows. Mỗi một node trong TreeView có thể chứa những
node khác – đƣợc gọi là những node con (child nodes). Bạn có thể hiển thị các node cha
hay các node con giống nhƣ expanded hay collapsed. Bạn cũng có thể hiển thị TreeView
với các checkbox bằng cách thiết lập thuộc tính cho Checkboxs cho node = true.
Bạn cũng thể thực hiện việc lựa chọn hay xóa các node bằng cách thiết lập thuộc tính
Checked của node là true hay false.
Hình 4.14: TreeView
Thêm và xóa các node với TreeView.
TreeView control chứa các node ở cấp cao
nhất trong Nodes Collection.
Mỗi TreeNode đề có nodes collection của
mình để chứa các node con. Cả 2 thuôc tính
collection là của kiểu TreeNodeCollection
với các hàm thành viên cho phép bạn thêm
(add) hoặc xóa (remove) và sắp xếp các
node ở một cấp đơn trong hệ thống phân cấp
các node.

73
- Sử dụng phƣơng thức Add bằng thuộc tính Nodes của TreeView
//Adds new node as a child node of the currently selected
node.
TreeNode newNode = new TreeNode("Text for new node");
treeView1.Nodes.Add(newNode);
TreeNode newNode1 = new TreeNode("Text for new node 1");
treeView1.Nodes.Add(newNode1);
TreeNode newNode2 = new TreeNode("Welcome to TreeView
Control Tutorial");
TreeNode node1 = new TreeNode("C#");
TreeNode node2 = new TreeNode("VB.NET");
TreeNode node3 = new TreeNode("C++");
TreeNode[] array = new TreeNode[] {node1, node2, node3};
TreeNode programmingLanguage = new TreeNode("Programming
Language", array);
treeView1.Nodes.Add(programmingLanguage);
Kết quả của ví dụ trên:
- Sử dụng phƣơng thức Remove để xóa một node đơn, Clear để xóa tất cả các node.
// Removes currently selected node, or root if nothing //
is selected.

74
treeView1.Nodes.Remove(newNode1);
// Clears all nodes.
treeView1.Nodes.Clear();
Add thông tin tùy chỉnh vào TreeView
Tạo một lớp node mới dẫn xuất từ lớp TreeNode, trong đó có một trƣờng tùy biến để ghi
lại một đƣờng dẫn tập tin.
class myTreeNode : TreeNode {
public string FilePath;
public myTreeNode(string fp)
{
FilePath = fp;
this.Text = fp.Substring(fp.LastIndexOf(""));
}
}
- Chúng ta có thể sử dụng node mới đƣợc dẫn xuất nhƣ một tham số trong các lời gọi
hàm.
Trong ví dụ dƣới đây, đƣờng dẫn đặt ra cho các vị trí của trƣờng Text là thƣ mục My
Document. Điều này có thể đƣợc thực hiện bởi ta có thể giả định rằng hầu hết các máy
chạy hệ điều hành windows sẽ có thƣ mục này. Điều này cũng cho phép ngƣời dùng với
các mức độ truy cập hệ thống tối thiểu một cách an toàn khi chạy ứng dụng.
// Lưu ý: sử dụng ký tự @ khi sử dụng đường dẫn xác định.
treeView1.Nodes.Add(new myTreeNode
(System.Environment.GetFolderPath
(System.Environment.SpecialFolder.Personal)+
@"TextFile.txt"));
- Sử dụng Casting để chuyển đổi kiểu của các đối tƣợng.
private void treeView1_NodeMouseClick(object sender,
TreeNodeMouseClickEventArgs e)
{
myTreeNode myNode = (myTreeNode)e.Node;
MessageBox.Show("Node selected is " + myNode.FilePath);

75
}
Xác định node nào trong TreeView đã đƣợc click
- Sử dụng EventArgs object để trả về một tham chiếu đến đối tƣợng node đƣợc click.
- Xác định đƣợc node đƣợc click bằng cách kiểm tra lớp TreeViewEventArgs có chứa dữ
liệu liên quan đến sự kiện này.
private void treeView1_AfterSelect(object sender,
TreeViewEventArgs e)
{
// Determine by checking the Text property.
MessageBox.Show(e.Node.Text);
}
Duyệt qua tất cả các node của TreeView
- Tạo một thủ tục đệ quy (recursive) để kiểm tra mỗi node.
- Gọi thủ tục.
Ví dụ dƣới đây minh họa việc làm thế nào để in các thuộc tính Text của các đối tƣợng
TreeNode.
private void PrintRecursive(TreeNode treeNode)
{
// in ra các node.
listBox1.Items.Add(treeNode.Text);
MessageBox.Show(treeNode.Text);
// Sử dụng đệ quy để in ra từng node.
foreach (TreeNode tn in treeNode.Nodes)
{
PrintRecursive(tn);
}
}
// Gọi thủ tục sử dụng TreeView private void
CallRecursive(TreeView treeView)

76
{
// IN ra từng node sử dụng đệ quy.
TreeNodeCollection nodes = treeView.Nodes;
foreach (TreeNode n in nodes)
{
PrintRecursive(n);
}
}
Gọi lại phƣơng thức trên trong sự kiện button click.
private void btnPrintNode_Click(object sender, EventArgs e)
{
PrintRecursive(treeView1.SelectedNode);
}
Kết quả của ví dụ:
Thiết lập icon cho các node trong TreeView
- Để tạo icon cho mỗi node của TreeView ta phải có một imageList chứa các hình cần sử
dụng.
1. Thiết lập thuộc tính imageList của TreeView = imageList mà ta muốn sử dụng
treeView1.ImageList = imageList1;
Việc này hoàn toàn có thể đƣợc thực hiện bằng cách tùy chỉnh thuộc tính Image List của
TreeView trong giao diện thiết kế.
2. Thiết lập thuộc tính ImageIndex và SelectedImageIndex của node.
Việc thiết lập này có thể thực hiện theo 2 cách:

77
- Click vào button của mục ImageIndex trong thanh properties từ giao diện thiết kế
của TreeView trên Form.
- Sử dụng code:
TreeNode newNode = new TreeNode("Text for new node");
newNode.ImageIndex = 0;
treeView1.Nodes.Add(newNode);
TreeNode newNode1 = new TreeNode("Text for new node 1");
newNode1.ImageIndex = 1;
TreeNode newNode2 = new TreeNode("Welcome to TreeView
Control Tutorial");
newNode2.ImageIndex = 2;
TreeNode node1 = new TreeNode("C#");
TreeNode node2 = new TreeNode("VB.NET");
TreeNode node3 = new TreeNode("C++");
TreeNode[] array = new TreeNode[] { node1, node2, node3 };
TreeNode programmingLanguage = new TreeNode("Programming
Language", array);
programmingLanguage.ImageIndex = 6;
treeView1.Nodes.Add(programmingLanguage);
– Kết quả sẽ là:

78
Đính kèm một ShortCut Menu cho một TreeView Node
- Khởi tạo một TreeView control với các thiết lập thuộc tính thích hợp, tạo ra một node
gốc, và sau đó thêm các node con.
- Tạo một ContexMenuStrip và sau đó thêm một ToolScriptMenuItem cho mỗi thao tác
mà bạn muốn thực hiện trong thời gian chƣơng trình thực thi.
- Thiết lập thuộc tính ContextMenuStrip của Tree Node thích hợp vào menu shortcut bạn
tạo ra.
- Khi thuộc tính này đƣợc thiết lập, menu chuột phải sẽ tự hiển thị khi bạn bấm chuột
phải vào node.
Ví dụ:
// Declare the TreeView and ContextMenuStrip
private TreeView menuTreeView;
private ContextMenuStrip docMenu;
public void InitializeMenuTreeView()
{
// Create the TreeView.
menuTreeView = new TreeView();
menuTreeView.Size = new Size(200, 200);

79
// Create the root node.
TreeNode docNode = new TreeNode("Documents");
// Add some additional nodes.
docNode.Nodes.Add("phoneList.doc");
docNode.Nodes.Add("resume.doc");
// Add the root nodes to the TreeView.
menuTreeView.Nodes.Add(docNode);
// Create the ContextMenuStrip.
docMenu = new ContextMenuStrip();
//Create some menu items.
ToolStripMenuItem openLabel = new ToolStripMenuItem();
openLabel.Text = "Open";
ToolStripMenuItem deleteLabel = new
ToolStripMenuItem();
deleteLabel.Text = "Delete";
ToolStripMenuItem renameLabel = new
ToolStripMenuItem();
renameLabel.Text = "Rename";
//Add the menu items to the menu.
docMenu.Items.AddRange(new
ToolStripMenuItem[]{openLabel,deleteLabel,
renameLabel});
// Set the ContextMenuStrip property to the
ContextMenuStrip.
docNode.ContextMenuStrip = docMenu;

Phat-trien-ung-dung-tren-Windows.pdf

Phat-trien-ung-dung-tren-Windows.pdf

Recommandé

Recommandé

Contenu connexe

Similaire à Phat-trien-ung-dung-tren-Windows.pdf

Similaire à Phat-trien-ung-dung-tren-Windows.pdf (20)

Phat-trien-ung-dung-tren-Windows.pdf