You are on page 1of 106

CHỈ DẪN CHO KHÓA HỌC...................................................................................................

4
1. Đối tượng ...................................................................................................................... 4
2. Kỹ năng cần có.............................................................................................................. 4
3. Trang thiết bị và phần mềm .......................................................................................... 4
4. Thời lượng học.............................................................................................................. 4
5. Mục tiêu của khóa học .................................................................................................. 5
BÀI 1. KHÁI NIỆM VÀ QUY TẮC.................................................................................... 6
1. Khái niệm...................................................................................................................... 6
2. Các bước xây dựng chương trình.................................................................................. 6
3. Lựa chọn ngôn ngữ lập trình......................................................................................... 7
4. Cú pháp Visual Basic.NET ........................................................................................... 8
5. Bài kiểm tra................................................................................................................... 8
BÀI 2. VISUAL STUDIO. NET VÀ IDE ............................................................................ 9
1. Giới thiệu Visual Studio.NET....................................................................................... 9
2. Khởi động Visual Studio............................................................................................. 10
3. My Profile ................................................................................................................... 11
4. Tạo một dự án mới...................................................................................................... 11
5. Cửa sổ dự án mới ........................................................................................................ 12
6. Cửa sổ thiết kế biểu mấu (Form) ................................................................................ 13
7. Cửa sổ hộp công cụ (Toolbox)................................................................................... 13
8. Di chuyển và thay đổi kích thước nút lệnh ................................................................. 14
9. Thêm mã cho nút lệnh................................................................................................. 14
10. Dịch chương trình ................................................................................................... 15
11. Dịch thành công ...................................................................................................... 15
12. Dịch có lỗi............................................................................................................... 16
13. Bắt đầu chương trình của bạn ................................................................................. 17
14. Hiển thị hộp thông báo............................................................................................ 17
15. Cửa sổ Xuất chương trình - Output......................................................................... 18
16. Lưu chương trình của bạn ....................................................................................... 18
17. Các tệp tin và thư mục chương trình....................................................................... 18
18. Bài kiểm tra............................................................................................................. 19
BÀI 3. GIẢ MÃ LỆNH ...................................................................................................... 20
1. Các kiểu đoạn mã lệnh ................................................................................................ 20
2. Giả mã lệnh là gì? ....................................................................................................... 20
3. Chú thích mã lệnh ....................................................................................................... 22
4. Giả mã lệnh được dùng với mục đích chú thích ......................................................... 23
5. Thụt lề và khoảng trắng .............................................................................................. 23
6. Bài kiểm tra................................................................................................................. 24
BÀI 4. BIỂU MẪU - FORM .............................................................................................. 25
1. Các ứng dụng Windows.............................................................................................. 25
2. Thiết kế form............................................................................................................... 25
3. Sử dụng các biểu mẫu (form)...................................................................................... 26
4. Các thuộc tính của form.............................................................................................. 27
5. Điều khiển và thuộc tính của form.............................................................................. 28
5.1. Các nhãn (Labels) ................................................................................................... 28
5.2. Hộp văn bản (TextBox) .......................................................................................... 29
5.3. Nút lựa chọn (Radio Button)................................................................................... 29
5.4. Ô đánh dấu (CheckBox).......................................................................................... 30
5.5. Hộp danh sách đổ xuống (ComboBox).................................................................. 30
1
5.6. Nút Lệnh (Command Button) ................................................................................. 30
6. Kích hoạt sự kiện ........................................................................................................ 32
7. Hộp thông báo (MessageBoxes) ................................................................................. 33
8. Bài kiểm tra................................................................................................................. 34
BÀI 5. CÁC THUỘC TÍNH VÀ PHƯƠNG PHÁP ........................................................... 35
1. Mã lệnh bắt đầu ở đâu................................................................................................. 35
2. Đọc thuộc tính bằng mã lệnh ...................................................................................... 35
3. Gán thuộc tính bằng mã lệnh ...................................................................................... 37
4. IntelliSense và dấu chấm ............................................................................................ 38
5. Phương thức ................................................................................................................ 40
6. Gọi phương thức bằng mã lệnh................................................................................... 41
7. Bài kiểm tra................................................................................................................. 42
BÀI 6. GÁN VÀ BIẾN....................................................................................................... 43
1. Lệnh Gán..................................................................................................................... 43
2. Kiểu dữ liệu................................................................................................................. 43
3. Các kiểu dữ liệu cơ bản............................................................................................... 44
4. Biến là gì? ................................................................................................................... 45
5. Tại sao sử dụng biến? ................................................................................................. 45
6. Khai báo biến .............................................................................................................. 46
7. Khai báo biến ở đâu? .................................................................................................. 46
8. Khởi tạo biến............................................................................................................... 47
9. Sử dụng biến ............................................................................................................... 48
10. Tăng tốc sử dụng biến............................................................................................. 49
11. Các kiểu biến khác .................................................................................................. 51
12. Bài kiểm tra............................................................................................................. 52
BÀI 7. TOÁN TỬ............................................................................................................... 53
1. Toán tử ........................................................................................................................ 53
2. Toán tử số học............................................................................................................. 53
3. Toán tử chuỗi .............................................................................................................. 54
4. Toán tử Not ................................................................................................................. 54
5. Trong các đoạn lệnh gán ............................................................................................. 54
6. Hoạt động của Toán tử................................................................................................ 55
7. Toán tử so sánh ........................................................................................................... 56
8. Hoạt động của toán tử Not và toán tử ghép chuỗi ...................................................... 56
9. Tìm lỗi......................................................................................................................... 57
10. Chạy từng dòng mã lệnh ......................................................................................... 58
11. Bài kiểm tra............................................................................................................. 61
BÀI 8. CÂU LỆNH IF ĐƠN GIẢN ................................................................................... 62
1. Ra Quyết định ............................................................................................................. 62
2. Lô gíc Boolean............................................................................................................ 62
3. Toán tử Lô gíc............................................................................................................. 62
4. Toán tử so sánh ........................................................................................................... 64
5. Mã lệnh điều kiện........................................................................................................ 65
6. Lệnh If...Then ............................................................................................................. 66
7. Sử dụng nhiều Lệnh If ................................................................................................ 68
8. Sử dụng nhiều điều kiện ............................................................................................. 68
9. Nhiều lựa chọn ............................................................................................................ 69
10. Sử dụng toán tử lô gíc trong mã lệnh...................................................................... 70
11. Bài kiểm tra............................................................................................................. 71
2
BÀI 9. CÂU LỆNH IF PHỨC TẠP ................................................................................... 72
1. Lệnh If…Then mở rộng.............................................................................................. 72
2. Lệnh If…Then lồng nhau............................................................................................ 72
3. Điều kiện ngược lại..................................................................................................... 74
4. If…Then…Else........................................................................................................... 75
5. Chế độ chạy từng lệnh trong lệnh If ........................................................................... 76
6. Bài kiểm tra................................................................................................................. 78
BÀI 10. VÒNG LẶP XÁC ĐỊNH .................................................................................... 79
1. Vòng Lặp .................................................................................................................... 79
2. For…Next ................................................................................................................... 79
3. Chạy từng lệnh một trong lệnh For…Next ................................................................. 80
4. Bài toán cộng 1000 ..................................................................................................... 82
5. Đổ rác.......................................................................................................................... 83
6. Vòng lặp trong vòng lặp ............................................................................................. 84
7. Thoát khỏi vòng lặp - biển Exit .................................................................................. 84
8. Bài kiểm tra................................................................................................................. 86
BÀI 11. CÁC VÒNG LẶP KHÔNG XÁC ĐỊNH ........................................................... 87
1. Vòng lặp không xác định ............................................................................................ 87
2. Vòng lặp Do While…Loop......................................................................................... 87
3. Chạy lệnh Do While…Loop trong chế độ gỡ lỗi........................................................ 88
4. Vòng lặp Do Until…Loop .......................................................................................... 90
5. Hoạt động của lệnh lặp ............................................................................................... 91
6. Dạng khác của lệnh lặp ............................................................................................... 93
7. Lệnh Exit Do............................................................................................................... 94
8. Bài kiểm tra................................................................................................................. 95
BÀI 12. HÀM ................................................................................................................... 96
1. Thủ tục là gì? .............................................................................................................. 96
2. Viết thủ tục của bạn .................................................................................................... 96
3. Gọi thủ tục của bạn ..................................................................................................... 97
4. Viết và gọi thủ tục có tham số .................................................................................... 98
5. Viết hàm của bạn ...................................................................................................... 100
6. Gọi Hàm.................................................................................................................... 101
7. Các thủ tục và hàm có sẵn......................................................................................... 102
8. Một số hàm xử lý chuỗi ............................................................................................ 102
9. Bộ sinh số ngẫu nhiên ............................................................................................... 104
10. Các hàm chuyển đổi kiểu ...................................................................................... 105
11. Bài kiểm tra........................................................................................................... 106

3
CHỈ DẪN CHO KHÓA HỌC

1. Đối tượng
Học viên của khóa học là các sinh viên, học sinh trung học và những ai mong muốn:
 Hiểu biết nhiều hơn về vai trò của lập trình.
 Học các khái niệm và cú pháp cơ bản về lập trình.
 Khám phá các cơ hội nghề nghiệp trong lĩnh vực lập trình.
 Phát triển nền tảng vững chắc cho đào tạo tiếp về lập trình.

2. Kỹ năng cần có
Khóa học này đòi hỏi học sinh phải có các kỹ năng sau:
 Cơ bản đã làm quen với việc sử dụng máy tính, chẳng hạn như sử dụng Internet hay
ứng dụng xử lý văn bản.
 Biết sử dụng chuột và bàn phím để sử dụng giao diện của Microsoft Windows®.
 Có thể thực hiện các thao tác quản lý tệp tin đơn giản như: mở và lưu các tệp tin, tạo
các thư mục chứa các tệp tin.

3. Trang thiết bị và phần mềm


 Microsoft Windows (2000, NT 4 hoặc XP) – khuyến cáo dùng Windows XP
 Microsoft Visual Studio 2003 – hiện tại đã có Microsoft Visual Studio 2005
 Internet Explorer Version 6.0 trở lên

4. Thời lượng học


Mỗi buổi học cần khoảng 50 phút, tổng thời lượng ước tính là 90 giờ.

4
5. Mục tiêu của khóa học
Sau khi hoàn thành khóa học này, học viên sẽ có thể:
 Mô tả được các ngôn ngữ lập trình khác nhau và khả năng của các ngôn ngữ lập trình
đó.
 Mô tả khái niệm về cú pháp và sự biến thiên cú pháp trong các ngôn ngữ lập trình
khác nhau.
 Nhận biết các cách khác nhau mà chúng ta tương tác với các chương trình trong cuộc
sống hàng ngày của mình.
 Mô tả lôgíc lập trình thông qua giả mã lệnh.
 Vẽ biểu đồ lôgíc chương trình.
 Sử dụng Visual Studio IDE, nhận biết các thành phần IDE và các ngôn ngữ mô tả cơ
cấu NET.
 Xây dựng và chạy một chương trình trên Visual Studio.
 Nhận biết các phần tử biểu mẫu phổ biến bao gồm các đối tượng biểu mẫu, hộp công
cụ và các sự kiện.
 Xác định các thuộc tính bằng cách sử dụng cửa sổ thuộc tính và mã lệnh.
 Xác định các biến.
 Khai báo các biến chuỗi và các biến nguyên.
 Tạo các lệnh gán bằng việc sử dụng các toán tử số học đơn giản.
 Thực hiện việc sửa lỗi đơn giản.
 Sử dụng cửa sổ Autos.
 Tạo các lệnh “If” đơn giản và phức tạp bằng ngôn ngữ lập trình Visual Basic và C#.
 Chạy đoạn mã một số lần nhất định.
 Tạo các vòng lặp “For”, “Do Until” và “Do While” bằng Visual Basic.
 Tạo các vòng lặp “For” và “While” bằng ngôn ngữ lập trình C#.
 Gọi các hàm đã có sẵn.
 Tự viết và gọi các hàm đó.

5
BÀI 1. KHÁI NIỆM VÀ QUY TẮC

1. Khái niệm
Các chương trình được sử dụng để giải quyết các vấn đề và thực hiện các loại việc như:
viết thư, tạo các bảng tính và cân đối sổ sách, theo dõi thu chi, quản lý thông tin về khách
hàng...

Một chương trình máy tính được tạo bởi các dòng mã lệnh viết bằng một ngôn ngữ lập
trình giống như tiếng Anh. Bạn có thể chọn để viết chương trình bằng một trong số các ngôn
ngữ lập trình dựa trên khả năng của ngôn ngữ và nhu cầu của bạn. Sau khi bạn viết chương
trình, nó được biên dịch thành ngôn ngữ mà máy tính có thể hiểu và thực hiện.

Mã lệnh bạn viết quyết định những gì chương trình sẽ làm. Mã lệnh xác định điều gì xảy
ra khi bạn nháy chuột vào nút hoặc chọn một mục từ danh sách. Mã lệnh bạn cung cấp “tính
thông minh” của chương trình… nó quyết định chương trình sẽ làm như thế nào, trong thời
gian bao lâu, nó sẽ thực hiện những tính toán gì. Bạn có thể viết mã lệnh để giải toán, viết
văn bản, trả lời các hành động người dùng, tập hợp dữ liệu hoặc hiển thị thông tin.

2. Các bước xây dựng chương trình


• Quyết định chương trình gì sẽ làm.
• Thiết kế giao diện người dùng.
• Quyết định sử dụng ngôn ngữ lập trình nào.
• Thiết kế kiến trúc chương trình và các thành phần của chương trình sẽ làm việc với
nhau như thế nào.
• Gán mã lệnh và thiết kế các kiểu.
• Quyết định ai sẽ viết mã cho các thành phần của chương trình.
• Quản lý lịch phát triển và theo dõi lượng thời gian tiêu tốn để viết mã lệnh.
• Đào tạo các lập trình viên để sử dụng các công cụ phát triển
• Cài đặt và quản lý các máy tính và mạng sử dụng bởi các lập trình viên.
• Viết mã lệnh!!!
• Tài liệu mã lệnh.
• Thiết kế cơ sở dữ liệu để lưu trữ thông tin chương trình cần hoặc tạo mới.
• Quản lý thiết kế đồ họa và hình ảnh minh họa.
• Quản lý thông tin nhập vào trong cơ sở dữ liệu
• Kiểm tra mã lệnh để đảm bảo chương trình làm việc
• Đóng gói mã lệnh trên cơ sở đó nó có thể được cài đặt trên máy tính của người dùng
hoặc máy chủ.
• Quyết định dựa trên các tính năng mới.
• Sửa chữa các lỗi người dùng tìm thấy
• Đào tạo người dùng sử dụng chương trình
• Viết tài liệu và giáo trình đào tạo cho chương trình.

6
3. Lựa chọn ngôn ngữ lập trình
Trên 50 năm qua, nhiều ngôn ngữ lập trình đã được phát triển. Giống như ngôn ngữ nói,
một số ngôn ngữ lập trình không còn được sử dụng nữa. Các ngôn ngữ lập trình khác đã
được sử dụng 20 hoặc 30 năm.

Một ngôn ngữ lập trình mới được xây dựng bằng việc sử dụng các tính năng tốt nhất của
một hoặc nhiều ngôn ngữ đang có, và kết hợp chúng để tạo thành một ngôn ngữ mới. Các
ngôn ngữ lập trình ngày nay phản ảnh các phát triển phần cứng máy tính và sự tiến triển của
phần mềm.

Các ngôn ngữ lập trình ra đời sớm nhất đã được lập trình theo điều kiện máy tính có thể
hiểu. Điều này có nghĩa các chương trình chỉ sử dụng các số 1 và 0. Mệt mỏi như thế nào!
Rốt cuộc, các chương trình gọi là các trình biên dịch đã được tạo ra để chuyển mã lệnh được
viết bằng ngôn ngữ giống tiếng Anh thành các số 1 và 0 mà máy tính có thể hiểu. Hầu hết tất
cả các ngôn ngữ lập trình hiện đại đều biên dịch được. Chúng được viết bằng ngôn ngữ lập
trình giống như tiếng Anh và sau đó được biên dịch, hoặc chuyển đổi thành mã mà máy có
thể đọc được.

Qua nhiều năm, các ngôn ngữ lập trình khác nhau đã được xây dựng để giải quyết các vấn
đề riêng. Ví dụ FORTRAN đã được phát triển để giải quyết một số vấn đề về số và thực hiện
tính toán. FORTRAN viết tắt từ FORmula TRANslating. COBOL đại diện cho ngôn ngữ
Common Business-Oriented và đã được phát triển chủ yếu cho các ứng dụng trong thương
mại. LISP viết tắt từ ListProcessing, được phát triển để khám phá về trí tuệ nhân tạo.

Các ngôn ngữ mới được phát triển có một hoặc nhiều lợi thế so với các ngôn ngữ trước.
Dưới đây là một số ví dụ:

• C: viết mã nhanh, hiệu quả


• Java: Không phụ thuộc nền
• BASIC: Dễ dàng sử dụng
• Visual Basic: Thiết kế giao diện người dùng sử dụng các form
• Perl: Thao tác văn bản

Khi bắt đầu một dự án lập trình bạn cần suy nghĩ về ngôn ngữ nào sẽ sử dụng. Ngôn ngữ
đó có tính năng bạn cần không? Nó có dễ dàng lập trình không? Bạn đã biết ngôn ngữ đó
chưa? Ngôn ngữ đó đã được cài trên máy tính của bạn chưa?

Ngôn ngữ Visual Basic.NET là một ngôn ngữ lập trình mạnh và dễ sử dụng. Nó có cú
pháp lệnh tường minh, bộ lệnh phong phú, linh hoạt. Hiện tại cộng đồng lập trình viên sử
dụng ngôn ngữ Visual Basic.NET rất đông cũng là một yếu tố chủ quan giúp bạn lựa chọn
ngôn ngữ này.

7
4. Cú pháp Visual Basic.NET
Như các ngôn ngữ nói, mỗi ngôn ngữ lập trình có một cú pháp riêng. Cú pháp là từ vựng,
ngữ pháp, chọn từ và cấu trúc tạo thành ngôn ngữ lập trình. Cú pháp định nghĩa các qui tắc
viết các dòng lệnh đúng và kết hợp các dòng này thành một chương trình đúng.

Việc học một ngôn ngữ lập trình bao gồm việc học cú pháp, cấu trúc và các qui tắc của
ngôn ngữ lập trình.

Khi bạn học một ngôn ngữ lập trình bạn phải học các cú pháp cũng như là chức năng và
khả năng của ngôn ngữ đó. Nên nhớ không phải ngôn ngữ lập trình có thể làm mọi thứ,
nhưng tất cả các ngôn ngữ lập trình hiện đại có các đặc điểm và tính năng mà bạn mong đợi.

Khi bạn học lập trình Visual Basic.NET, bạn cần học về các từ dành riêng, cấu trúc và các
đối tượng cơ bản tạo thành ngôn ngữ. Đầu tiên bạn phải hiểu một số thành phần cú pháp cơ
bản của ngôn ngữ.

Cú pháp chính trong Visual Basic.NET:

• Các dòng mã lệnh không có chỉ thị kết thúc dòng như dấu chấm phảy (;)
• Các dòng ghi chú bắt đầu bởi dấu nháy đơn (‘)
• Dấu ngoặc nhọn { và } không được dùng để chứa các khối mã lệnh
• Visual Basic.NET không phân biệt chữ hoa hoặc chữ thường. Điều đó có nghĩa rằng
“nguyen van a” và “NGUYEN VAN A” là như nhau.

5. Bài kiểm tra

8
BÀI 2. VISUAL STUDIO. NET VÀ IDE

1. Giới thiệu Visual Studio.NET


Visual Studio.NET của Microsoft là một công cụ phát triển giúp bạn viết các chương trình
bằng một số ngôn ngữ lập trình .NET khác nhau. Ví dụ, khi bạn thêm các nút vào trong form,
Visual Studio.NET thêm một số mã lệnh cho nút này một cách tự động. Visual Studio.NET
không thể viết tất cả các lệnh cho bạn. Nó không biết chương trình của bạn định làm gì.
Nhưng nó đảm bảo giảm thiểu được số lệnh bạn phải viết và làm giảm thời gian lập trình của
bạn.

Visual Studio.NET tự động tô màu cho lệnh của bạn phụ thuộc vào ý nghĩa của lệnh. Ví
như các chú thích luôn luôn có màu xanh lục và các từ khóa có màu xanh da trời, thậm chí
các lỗi cú pháp được gạch chân lượn sóng màu đỏ. Điều này giúp bạn sớm nhận biết và sửa
các lỗi lệnh.

Visual Studio.NET giúp bạn tổ chức các lệnh bằng cách sắp xếp chúng vào các tệp riêng
biệt. Theo cách đó bạn có thể chia các đoạn mã của mình thành các đơn vị chức năng. Ví dụ:
một tệp tách biệt sẽ lưu trữ mã lệnh cho từng form của bạn. Visual Studio.NET cho phép
biên dịch và chạy chương trình dễ dàng bằng vài
nháy chuột. Bạn có thể sử dụng tiện ích gỡ rối để
tìm các lỗi trong chương trình và hiển thị thông tin
lúc chương trình đang chạy.
Hơn nữa, Visual Studio.NET cho phép bạn phát
triển các chương trình bằng các ngôn ngữ khác
nhau, đó là các ngôn ngữ .NET. Bạn sử dụng chung
giao diện Visual Studio.NET quen thuộc cho từng
ngôn ngữ. Các ngôn ngữ .NET có trong Visual
Studio.NET bao gồm:

• Visual Basic.NET
• C# (đọc là C sáp)
• J# (đọc là J sáp)
• C++ (đọc là C cộng cộng)
• ASP.NET (Tạo trang Web)

9
2. Khởi động Visual Studio
Để mở Visual Studio:

1. Nháy nút Start


2. Chọn Programs
3. Chọn thư mục Visual Studio.Net 2003
4. Chọn ứng dụng Microsoft Visual Studio.Net 2003

Có một biểu tượng trên Desktop mà tôi có thể sử dụng để mở Visual Studio. Sử dụng biểu
tượng là cách khởi động nhanh Visual Studio.NET bằng cách nháy đúp chuột lên nó.

* IDE Start Page

Màn hình đầu tiên bạn thấy khi mở Visual Studio.NET là trang Start Page. Tab Projects sẽ
mặc định được chọn. Thông thường, bạn thấy một danh sách các dự án đang có. Vì lần đầu
tiên bạn sử dụng Visual
Studio.NET, nên không có dự
án nào được liệt kê.

Nhãn My Profile là nơi bạn


tùy chỉnh Visual Studio.NET
cho phù hợp với bạn.

Nháy tab My Profile để tùy


chỉnh nó.

10
3. My Profile
Đây là nơi bạn chọn bạn kiểu phát triển và đặt các tùy chọn Visual Studio.NET Studio cho
mình.

1. Chọn Visual Studio Developer từ


danh sách thả xuống Profile
2. Kiểm tra các tùy chọn mặc định

Keyboard Scheme: [Default
Settings]
Window Layout: Visual Studio
Default
Help Filter: (no filter)
3. Chọn Internal Help để hiển thị
trợ giúp
4. Chọn Show Start Page cho At
Startup setting
5. Chọn tab Projects ở phía trên của
trang Start Page để tiếp tục.

4. Tạo một dự án mới


Bây giờ bạn đã hoàn thành việc thiết lập môi
trường Visual Studio.NET, chúng ta sẽ khám phá tab
Projects. Bạn có thể hoặc bắt đầu một dự án mới hoặc
mở một dự án đang có từ tab này. Bạn sử dụng nút
Open Project ở phía dưới của màn hình Projects để
mở một dự án đang có. Sau khi bạn tạo một dự án đầu
tiên của mình, nó sẽ xuất hiện trong danh sách các dự
án đang có. Để mở một dự án đang có, chọn dự án từ
danh sách và nháy vào nút Open Project.

Tôi chỉ cho bạn cách tạo dự án cho chương trình


Hello World. Tiếp đó chúng ta sẽ viết chương trình.
Hello World là chương trình đầu tiên được viết bởi
nhiều lập trình viên nhất. Mục tiêu là tạo một hộp
thông điệp nói “Hello World”.

1. Nháy nút New Project để tạo một dự án mới.


Cửa sổ hộp thoại dự án mới được mở.

11
5. Cửa sổ dự án mới
Trên nhãn New Projects, bạn chú ý rằng trong khung bên trái trên có nhãn Project Types,
ở đây có nhiều kiểu dự án
có sẵn trong Visual
Studio.NET. Chúng tôi sẽ
chỉ nói về một số ít trong
số các loại dự án. Chương
trình Hello World sẽ là
một ứng dụng Windows
(Code Rules sẽ chỉ sử
dụng ứng dụng Windows,
do vậy đừng lo lắng về
các mẫu khác). Trên nhãn
này, bạn không chỉ chọn
Project Type và Template
còn bao gồm các tên dự
án và vị trí tệp tin các dự
án được lưu.

1. Chọn Visual Basic Projects trong mục


Project Type.
2. Chọn Windows Application trong khung
Template.
3. Nhập HelloWorld vào khung Name cho dự
án (Không có dấu cách trong tên tệp).
4. Chọn Thư mục lưu dự án của bạn.

Nháy nút OK. Dự án mới sẽ mở, hiển thị một


biểu mẫu tên là Form1.vb phía bên trái màn hình và
Solution Explorer trên phía bên phải của màn hình.

12
6. Cửa sổ thiết kế biểu mấu (Form)
Phần lớn các trường hợp bạn tạo
một ứng dụng Windows bắt đầu bởi
một form. Các form là phần của
chương trình mà người dùng thấy. Bạn
sẽ đặt các đối tượng lên form, như các
nút, các hộp văn bản. Khi một nút
được nháy, mã lệnh sẽ chạy để thực
hiện xử lý các yêu cầu cho nút đó.

Một form trắng có thể thấy trong


cửa sổ chính phía bên trái màn hình.
Cửa sổ này được gọi là cửa sổ thiết kế
form (tên nhãn đặt là Form1.vb
[Design]). Solution Explorer có thể
thấy phía bên phải. Vào thời điểm này
form không có các nút hoặc hộp văn
bản trên nó. Các thành phần đó sẽ
được tạo trên form sau.

7. Cửa sổ hộp công cụ (Toolbox)


Nhiều tính năng trong Visual Studio.NET được truy cập bằng việc bật các cửa sổ chức
năng tương ứng. Ví dụ để tạo nút và
hộp văn bản trên form, bạn sẽ bật
cửa sổ hộp công cụ. Hộp công cụ
hiển thị tất cả mọi thứ khác nhau mà
bạn có thể đưa vào form như: các nút
lệnh, các nút tùy chọn, hộp văn bản,
hộp danh sách thả xuống…

1. Chọn View Từ menu chính.

2. Chọn Toolbox – Cửa sổ


Toolbox mở ra.

Nháy đúp Button để thêm một nút


lệnh cho form (Nút lệnh được thêm
có thể bị ẩn phía sau hộp công cụ.
Bạn sẽ học cách di chuyển nó trong
mục tiếp theo.)

13
8. Di chuyển và thay đổi kích thước nút lệnh
Bạn đã thêm một nút lệnh cho form, hãy
di chuyển và thay đổi kích thước nút lệnh:

1. Nháy lên nút lệnh và kéo nó tới tâm


của biểu mẫu
2. Di chuyển con trỏ trên các hình
vuông màu trắng (các nút này dùng
để điều khiển kích thước của nút
lệnh)
3. Ấn và giữ nút chuột trái, kéo nút
điều khiển rộng hoặc thu hẹp kích
thước của nút lệnh.

9. Thêm mã cho nút lệnh


Khi chúng ta tạo nút lệnh Visual Studio.NET tự động thêm các dòng mã vào trong cửa sổ
lệnh. Hãy nhìn ví dụ dưới đây:

Public Class Form1


Inherits System.Windows.Forms.Form

Window Forms Designer Generated Code


Private Sub Button1_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles Button1.Click

End Sub

Đoạn mã Button1_Click được thực hiện khi người dùng nháy chuột vào nút lệnh. Nếu
chúng ta nháy nút lệnh ngay bây giờ, sẽ không có gì xảy ra. Chúng ta cần bảo cho ứng dụng
biết phải làm gì khi nút lệnh được nháy.

1. Sau khi bạn nháy đúp vào nút Button 1, cửa sổ mã lệnh mở ra.
2. Nháy lên dòng trắng phía trên End Sub
3. Nhập dòng mã lệnh phía bên dưới một cách chính xác như dưới đây.

MessageBox.Show("Hello, World.")

Dòng mã lệnh này chạy khi người dùng nháy chuột vào nút trên form.

14
10. Dịch chương trình
Đây là nơi mã lệnh mà bạn và Visual Studio.NET đã tạo ra được biên dịch thành các lệnh
mà máy tính có thể hiểu
được.

1. Chọn Build từ
thanh menu
chính.
2. Chọn Build
Solution từ menu
kéo xuống.

11. Dịch thành công


Sau khi bạn dịch thành công cửa sổ Output Window sẽ mở và hiển thị thông báo. Thông
báo này cho bạn biết là bạn đã dịch thành công chưa hay chương trình còn lỗi. Nếu dịch
thành công bạn sẽ nhìn thấy thông báo sau ở cửa sổ Output Window:

------ Build started: Project: HelloWorld, Configuration:


Debug .NET ------
Preparing resources...
Updating references...
Performing main compilation...
Building satellite assemblies...

---------------------- Done ----------------------


Build: 1 succeeded, 0 failed, 0 skipped

15
12. Dịch có lỗi
Giả sử rằng thay vì gõ MessageBox, bạn tạo ra lỗi bằng cách gõ mMessageBox. Cửa sổ
Output đưa ra một thông báo lỗi như dưới đây:

------ Build started: Project: HelloWorld, Configuration:


Debug .NET ------
Preparing resources...
Updating references...
Performing main compilation...
C:\VBNETProjects\HelloWorld\Form1.vb(59) : error BC30451:
Name 'mMessageBox' is not declared.
Building satellite assemblies...

---------------------- Done ----------------------


Build: 0 succeeded, 1 failed, 0 skipped

Khi có thể, Visual Basic


cũng gạch chân vị trí của lỗi.
Nháy đúp vào nơi thông báo
lỗi, con trỏ chuyển tới vị trí lỗi.
Đồng thời, một cửa sổ Task
List mở ra cho bạn thấy các lỗi.

Nếu bạn dịch không thành


công, quay lại và kiểm tra dòng
lệnh mà bạn đã gõ vào cho nút
lệnh xem đã đúng chưa. Sau đó
làm theo các bước dịch chương
trình mà chúng tôi đã chỉ cho
bạn.

16
13. Bắt đầu chương trình của bạn
Chương trình của bạn bây giờ dịch không còn lỗi, bạn đã có bước khởi đầu thuận lợi. Bây
giờ là lúc bắt đầu chạy chương trình đầu tiên.

1. Chọn Debug từ
thanh thực đơn
chính
2. Chọn Start từ thực
đơn kéo xuống.
(Form được hiển thị
và trong Form là nút
lệnh bạn đã thêm
vào.)
3. Nhấn Nút lệnh để
xem kết quả của
bạn.

14. Hiển thị hộp thông báo


Khi bạn nhấn Nút lệnh một hộp thông báo xuất hiện và hiển thị dòng chữ ” Hello, Word “
(“Chào, Thế giới”). Đó là những gì bạn muốn chương trình thực hiện! Xin chúc mừng! Bạn
vừa chạy chương trình Visual Basic.NET đầu tiên!

1. Nháy nút lệnh OK


để đóng hộp thông
báo. Hộp thông báo
biến mất, nhưng
form vẫn còn. Bạn
có thể nhấn nút lệnh
để tiếp tục hiển thị
Hộp thông báo.
2. Nhấn vào nút "X"
trên góc trên bên
phải của Form để
đóng chương trình..

17
15. Cửa sổ Xuất chương trình - Output
Một khi chương trình kết thúc, Thông tin gỡ rối(Debug) được hiển thị. Bạn có thể cuộn
cửa sổ Output để xem tất cả thông tin.

Các học viên khi bắt đầu học thường chưa sử dụng thông tin gỡ rối. Nó được đề cập ở đây
để các bạn không ngạc nhiên, bối rối khi thấy nó.

16. Lưu chương trình của bạn


Bây giờ đã đến lúc bạn lưu chương trình của mình. Phần này cũng giống như các chương
trình Windows khác.

1. Chọn File từ menu chính


2. Chọn Save All từ thanh menu kéo xuống
3. Để thoát Visual Studio.NET, chọn File từ menu chính
4. Chọn Exit từ menu kéo xuống.

17. Các tệp tin và thư mục chương trình


Khi bạn tạo một ứng dụng Visual Basic, có nhiều tệp được tạo ra. Bạn cần biết những tệp
nào được tạo và chúng có nghĩa gì. Hãy nhìn hình dưới đây để thấy các tệp và thư mục điển
hình.

Sử dụng Windows Explorer để chuyển đến nơi bạn lưu chương trình HelloWorld. Mở
rộng thư mục này bạn sẽ thấy các tệp mà Visual Studio.NET tạo ra cho chương trình.

Bạn sẽ thấy có các tệp sau:

• HelloWorld.sln là tệp giải pháp để quản lý tất cả


các tệp của giải pháp. Một giải pháp có thể tham
chiếu đến nhiều chương trình nhưng giải pháp
HelloWorld chỉ chứa duy nhất chương trình
HelloWorld.vbproj. Tệp HelloWorld.sln là một
tệp mà bạn cần khi mở một dự án đã có.
• Tệp Form1.vb chứa Form1 và các mã lệnh kết
hợp với Form1.

18
• Nhấp đúp vào thư mục Bin để mở nó. Thư mục Bin chứa tệp mã thực hiện gọi là
HelloWorld.exe. Tệp này có thể chạy trên máy tính khác ngay cả khi máy tính
không cài Visual Studio.NET.

18. Bài kiểm tra

19
BÀI 3. GIẢ MÃ LỆNH

1. Các kiểu đoạn mã lệnh


Rất nhiều lập trình viên viết chương trình dưới dạng giả mã lệnh trước và sau đó chuyển
chúng thành một ngôn ngữ lập trình thực sự. Điều này giúp họ xác định dòng lôgic của
chương trình và những gì chương trình cần phải làm.

Giả mã lệnh bao gồm các câu lệnh đơn giản viết dưới dạng tiếng Anh (hoặc ngôn ngữ mẹ
đẻ của bạn) chúng giải thích những gì chương trình cần phải làm. Sau khi bạn đã viết giả mã
lệnh thì việc viết mã thực sự dựa trên giả mã lệnh trở lên dễ dàng hơn. Giả mã lệnh đưa ra
được cấu trúc hoặc phác thảo của chương trình.

Một số kiểu câu lệnh cơ bản được hỗ trợ bởi tất cả các ngôn ngữ lập trình bao gồm:

• Biến được sử dụng để lưu trữ thông tin như là số hoặc văn bản. Chúng là nơi lưu
giữ thông tin, hoặc kết quả tính toán. Các câu lệnh gán đặt giá trị vào biến, giá trị
có thể là số, văn bản, các biến khác, hoặc giá trị tính toán. Các câu lệnh so sánh
được sử dụng để so sánh một giá trị hoặc một biến với một số, hoặc một giá trị
khác, hoặc một biến khác. Câu lệnh so sánh yêu cầu câu hỏi mà câu trả lời chỉ có
thể là “đúng” hoặc “sai”.
• Các câu lệnh Quyết định (Decision Statement) được sử dụng để tạo sự lựa chọn.
Sự lựa chọn dựa trên sự so sánh. Nếu câu trả lời của sự so sánh là “đúng” , thì sự
lựa chọn đầu tiên được thực hiện. Nếu câu trả lời của sự so sánh là “sai” , thì sự
lựa chọn thứ hai được thực hiện. Các lệnh quyết định, thường được gọi là câu lệnh
rẽ nhánh bởi vì dòng chương trình có thể đi theo hướng này, hoặc hướng khác.
• Các câu lệnh lặp được sử dụng để thực hiện các công việc có tính chất lặp đi lặp
lại. Câu lệnh lặp rút gọn số mã lệnh bạn cần viết khi chương trình thực hiện một
hành động lặp đi lặp lại. Khi bạn học cách viết chương trình bạn sẽ học cách sử
dụng những cấu trúc lệnh cơ bản để chương trình bạn viết ra thực hiện được đúng
ý định của bạn.

Khi bạn học Visual Basic.NET (hoặc bất cứ ngôn ngữ lập trình nào khác) công việc của
bạn sẽ là học cú pháp của nó để viết và sử dụng những lệnh cơ bản.

2. Giả mã lệnh là gì?


Giả mã lệnh không được viết trong ngôn ngữ lập trình thực sự. Nó bao gồm những câu
đơn giản miêu tả chương trình sẽ làm gì. Bạn có thể viết giả mã lệnh bằng ngôn ngữ Anh,
Tây Ban Nha, Latinh, hoặc bất kì một ngôn ngữ nào khác bởi vì máy tính chưa từng phải đọc
hoặc hiểu giả mã lệnh. Giả mã lệnh cần được viết rõ ràng sao cho bạn cũng như những lập
trình viên khác hiểu được. Bởi vì giả mã lệnh cung cấp khung làm việc hoặc các lệnh để viết
các mã lệnh thực sự của chương trình. Giả mã lệnh được viết bằng cách sử dụng các kiểu câu
lệnh cơ bản khác nhau như: lệnh gán, lệnh so sánh, lệnh quyết định,.v.v.

20
Ví dụ về cách sử dụng giả mã lệnh để thiết kế chương trình:

Ví dụ 1 - Viết một chương trình để tính toán chi phí xăng trung bình theo đô la trên một
ga lông trong một chuyến đi.

Để trả lời câu hỏi này, đầu tiên bạn sẽ thiết kế chương bằng giả mã lệnh. Đây là các bước
chương trình sẽ phải làm để tính chi phí xăng trung
bình trong chuyến đi:

1. Cộng tất cả số tiền xăng đã mua và gán giá


trị này cho biến tổng số tiền.

2. Cộng tất cả số ga lông xăng đã mua và gán


giá trị này cho biến tổng số ga lông.

3. Lấy biến tổng số tiền chia cho biến tổng số


ga lông và gán kết quả thu được cho biến
tổng số tiền trên tổng số ga lông.

4. Hiển thị thông báo cho biết chi phí trung


bình trên ga lông.

Giả mã lệnh cho biết chương trình cần làm cái gì một cách rõ ràng. Bây giờ bạn có thể
viết mã lệnh hoàn thành các nhiệm vụ phác thảo bằng giả mã lệnh.

Ví dụ 2 - Ví dụ này có thể lập trình cho một robot để thay lốp xì hơi.

1. Xác định lốp xẹp hơi (lệnh so sánh)


2. Xác định kích cỡ của lốp xẹp hơi (lệnh so sánh)
3. Nếu bạn có lốp đúng cỡ thay thế thì tiếp tục
4. Ngược lại lấy lốp thay thế từ kho lốp (lệnh so sánh và lệnh quyết định)
5. Sử dụng kích thuỷ lực kích Trục xe lên .
6. Sử dụng tuốc nơ vít tháo bỏ nắp đậy trục bánh xe để làm lộ đai ốc.
7. Sử dụng Cờ lê để gỡ bỏ toàn bộ đai ốc (lệnh lặp) .
8. Tháo bỏ lốp bị xẹp hơi.
9. Thay lốp mới.
10. Sử dụng Cờ lê để thay thế và siết chặt toàn bộ các đai ốc (lệnh lặp).
11. Nắp trục đậy bánh xe vào đúng vị trí của nó và siết chặt.
12. Hạ thấp kích thuỷ lực xuống.

Trong các giả mã lệnh ở trên có sự trộn lẫn các lệnh gán, lệnh so sánh, lệnh quyết định, và
lệnh lặp. Ví dụ bạn phải nhớ kích cỡ của lốp bị xẹp hơi - đó là một câu lệnh gán. Bạn phải so
sánh kích cỡ lốp cần được thay với kích cỡ của các lốp ở trong kho - đây là lệnh so sánh.
Lệnh quyết định được sử dụng cùng với lệnh so sánh. Nếu bạn có lốp đúng cỡ thay thế thì
tiếp tục, ngược lại lấy lốp thay thế từ kho.

21
Tháo ra và siết chặt các đai ốc có thể được xem như các quá trình lặp. Bạn cần lặp mỗi
quá trình một số lần cho đến khi tất cả các đai ốc đã được tháo ra và tất cả các đai ốc đã được
siết chặt.

3. Chú thích mã lệnh


Các ngôn ngữ lập trình hiện đại, bao gồm Visual Studio.NET, cho phép bạn thêm các chú
thích vào mã lệnh. Các chú thích không được biên dịch như một bộ phận của chương trình và
không được thực hiện khi chương trình chạy. Các chú thích là cách hữu ích để lập tài liệu cho
mã lệnh. Chúng giúp bạn nhớ mã lệnh làm gì. Chúng cũng giúp các lập trình viên khác hiểu
được mã lệnh bạn viết. Bạn nên chú thích mã lệnh. Viết chú thích thể hiện một người lập
trình là một lập trình viên chuyên nghiệp. Một lập trình viên chuyên nghiệp bỏ thời gian để
hiểu thấu đáo và lập tài liệu cho mã lệnh mà mình đã viết.

Bạn nên thêm chú thích vào mã lệnh khi bạn thay đổi hoặc thêm chức năng của nó. Bạn
cũng nên thêm chú thích vào các mã lệnh khó hiểu, mã lệnh tính toán các vấn đề riêng biệt,
các mã lệnh tính toán phức tạp.

Trong Visual Basic.NET bạn bắt đầu dòng ghi chú bằng dấu nháy đơn ('). Các dòng mã
lệnh khác bắt đầu bằng đấu nháy đơn được coi là các chú thích và sẽ không được biên dịch
hoặc thực hiện khi bạn chạy chương trình.

Chú thích có chức năng quan trọng khác bên cạnh chức năng làm tài liệu cho mã. Vì các
chú thích không được thực hiện nên bạn có thể sử dụng chúng như là một cách thức ngăn
không cho các dòng mã lệnh thực hiện. Điều này gọi là “biến thành chú thích” (commenting
out) dòng mã lệnh. Biến thành chú thích là một cách thức được dùng để giúp bạn tìm lỗi
trong mã lệnh. Nếu bạn tìm thấy lỗi trong chương trình bạn có thể biến thành chú thích dòng
mã lệnh hoặc toàn bộ khối mã lệnh cho đến khi không xuất hiện lỗi. Mã lệnh cuối cùng mà
bạn biến thành chú thích có thể là nơi xuất hiện lỗi.

Bây giờ tôi sẽ chỉ cho các bạn ví dụ về khoanh vùng mã lệnh. Để ý là có ba dòng mã lệnh.
Dòng thứ hai được khoanh vùng bằng cách đặt một dấu nháy đơn tại đầu dòng lệnh. Dòng
thứ hai sẽ không thực hiện, còn dòng thứ nhất và thứ ba sẽ chạy!

MessageBox.Show("Tôi đến từ")


'MessageBox.Show(" Một thành phố tên là")
MessageBox.Show(" San Francisco.")

22
4. Giả mã lệnh được dùng với mục đích chú thích
Bạn có thể sử dụng các chú thích để thiết kế và phác thảo chương trình. Bạn đã dùng giả
mã lệnh để miêu tả công việc mã lệnh sẽ làm. Vì thế hãy lợi dụng điều này. Copy và dán giả
mã lệnh vào trong chương trình và đặt dấu nháy đơn vào đầu từng dòng giả mã lệnh để
chuyển nó thành dòng chú thích. Hãy viết mã Visual Basic.NET dưới các dòng giả mã lệnh
và chương trình lúc này không chỉ là một chương trình đầy đủ mà nó còn được chú thích một
cách đầy đủ.

Đây là ví dụ, dựa trên giả mã lệnh tính chi phí xăng trung bình đô la trên ga lông trong
chuyến đi của chúng tôi. Để ý rằng giả mã lệnh cung cấp các chú thích.

'Cộng tất cả số tiền chúng ta đã trả cho tiền xăng và gán số này cho biến (tổng số đô la)
Dim totalDollars As Double
totalDollars = 88.76 + 100.8 + 120.3

' Cộng lại tổng số galông xăng chúng ta đã dùng và gán số này cho một biến thứ hai
(tổng số galông xăng)
Dim totalGallons As Double
totalGallons = 49.3 + 55.5 + 46.3

' Lấy biến thứ nhất (tổng số đô la) và chia nó cho biến thứ hai (tổng số galông xăng) và
gán kết quả cho biến thứ ba (Số tiền cho mỗi galông xăng).
Dim dollarsPerGallon As Double
dollarsPerGallon = totalDollars / totalGallons

' Hiển thị thông báo giá trung bình cho mỗi galông xăng.
MessageBox.Show (dollarsPerGallon)

5. Thụt lề và khoảng trắng


Đầu tiên các bạn có thể dễ ràng nhìn thấy các
chú thích được bắt đầu với một dấu nháy đơn.
Màu của dòng chú thích cũng được chuyển thành
màu xanh lá cây. Điều này giúp chúng ta phân
biệt dễ ràng giữa chú thích và mã lệnh. Thứ hai,
một dòng trắng được thêm vào trước dòng chú
thích, dòng trắng này ngắt các chú thích và mã
lệnh thành các nhóm tương ứng với chức năng
của chúng, Các dòng trắng này giúp cho lô gíc
chương trình rõ ràng và dễ hiểu.

Trong hầu hết các trường hợp Visual


Basic.NET tự động thêm khoảng trắng và làm thụt
đầu dòng các dòng mã lệnh, điều này giúp cho
việc đọc mã lệnh được dễ dàng. Nhưng bạn có thể
thêm khoảng trắng và thụt đầu dòng nếu bạn

23
muốn. Vì vậy đây là ý kiến của tôi về việc dùng thụt đầu dòng và khoảng trắng – sử dụng
chúng sao cho việc đọc mã lệnh cũng như chú thích được dễ ràng. Visual Basic.NET và các
ngôn ngữ .NET khác không quan tâm đến dòng trống hoặc thụt đầu dòng. Chúng bị bỏ qua
khi dịch chương trình. Trong khi Visual Basic.NET không quan tâm thì những dòng trắng và
thụt đầu dòng này sẽ giúp ai đó đọc mã lệnh do bạn viết dễ hơn.

6. Bài kiểm tra

24
BÀI 4. BIỂU MẪU - FORM

1. Các ứng dụng Windows


Ứng dụng Windows là một kiểu chương trình có giao diện người dùng để người dùng
tương tác với chương trình. Không phải chương trình nào cũng có giao diện người dùng, một
số chương trình chỉ chạy một lần hoặc chạy trong chế độ nền (background) mà không cần
yêu cầu dữ liệu từ người dùng sau khi đã chạy.

2. Thiết kế form
Các ứng dụng Windows sử dụng các biểu mẫu để cho phép bạn thiết kế những gì người
dùng thấy và tương tác với chương trình.

Đầu tiên khi bạn tạo một ứng dụng Window bằng Visual Basic, Visual Studio tự động
thêm một form với tên là Form1.vb vào dự án. Sau đó bạn có thể thêm các điều khiển Form
như là nút lệnh, nhãn, hộp văn bản, hộp danh sách kéo xuống, .v.v vào Form1 để cung cấp
các cách thức cho người dùng tương tác với chương trình của bạn. Ứng dụng có một form
“Form lốp xẹp hơi” dùng để nhập thông tin về lốp xẹp hơi. Đây là miêu tả và các chức năng
của các điều khiển cần thiết của form “Form lốp xẹp hơi”:

• Trong hộp văn bản, nhập vào số bảng đăng ký ô tô.


• Chọn lốp từ nhóm nút lựa chọn(radio button) lốp (lốp trái trước, lốp phải trước, lốp
trái sau, lốp phải sau).
• Sử dụng ô đánh dấu(checkbox) để đánh dấu là "Rush Job"(việc gấp).
• Chọn cỡ lốp từ hộp danh sách kéo xuống.
• Nhấn nút lệnh để tìm lốp trong kho.
• Dùng hộp văn bản hiển thị danh sách lốp hiện có kèm theo cả nhà sản xuất, số sê ri
mẫu, cỡ lốp, số sê ri kho, đơn giá.

Do vậy biểu mẫu lốp xẹp có hai hộp văn bản, bốn tùy chọn, một danh sách kéo xuống,
một hộp kiểm tra và một nút lệnh. Bạn có thể sắp đặt chúng trên Form theo nhiều cách khác
nhau.

Form cũng phải có hình thức đẹp. Nó không thể có các màu sắc kì quái hoặc gây cảm giác
khó chịu về mặt thị giác, giống như văn bản nhấp nháy, có thể làm rối trí người dùng. Và các
điều khiển trên form cũng phải được bố trí một cách gọn gàng và lô gíc. Phải suy nghĩ về thứ
tự mà người dùng sẽ nhập thông tin và tương tác với chương trình.

Đôi khi phải khuyến cáo người dùng rằng họ chưa nhập đủ các thông tin được yêu cầu
hoặc thông tin mà họ nhập vào là sai. Khi bạn thiết kế form, bạn thực sự phải suy nghĩ như
người dùng (tức là bạn phải đặt mình vào vị trí của người dùng) và cố gắng tưởng tượng tất
cả các cách thức mà một người dùng có thể tương tác với chương trình do bạn viết.

Cuối cùng, khi thiết kế form, bạn cần nhớ rằng tất cả các ứng dụng Windows đều tuân
theo chuẩn giao diện (chuẩn giao diện bao gồm việc chuẩn hoá các thao tác và hình thức thể
hiện của các điều khiển theo một quy tắc nào đấy). Người dùng thường mong đợi ứng dụng

25
của bạn tuân theo các hướng dẫn thiết kế nào đó và hành động theo một cách nào đó. Ví dụ:
Thực đơn (menu) lựa chọn đầu tiên của ứng dụng Window là “File", và bên dưới "File" sẽ là
thực đơn lựa chọn "Exit" mà người dùng chọn để kết thúc (close) chương trình. Người dùng
sẽ rất ngạc nhiên và cảm thấy khó chịu nếu họ nhấn nút lệnh “kết quả tính toán” mà chương
trình của bạn không đưa ra kết quả mà lại làm một việc gì đó chẳng liên quan như: thay đổi
màu của form chính thành màu đỏ, hay chuyển tất cả các tiêu đề của nút lệnh sang tiếng la
tinh.

3. Sử dụng các biểu mẫu (form)


Khi bạn tạo một ứng dụng Window mới, Visual
Studio tự động thêm một form tên là Form1.vb vào Gợi ý
ứng dụng. Đây là form chính, hoặc form khởi động, của
ứng dụng. Đây là form mà người dùng sẽ nhìn thấy khi Form1.vb có thể đổi tên thành một
họ chạy chương trình. Form chính như là bảng điều tên có ý nghĩa hơn. Điều này rất
nên làm trong các ứng dụng phức
khiển trung tâm. Từ form này người dùng có thể tạp
chuyển đến (thực hiện) bất kì phần nào của chương
trình.

Thông thường, một thanh thực đơn hoặc thanh công cụ được đặt ngang trên phần đầu của
form chính để cung cấp một phương tiện chuyển đến bất cứ bộ phận nào của ứng dụng. Từ
form chính người dùng chọn một mục của thực đơn hoặc nhấn chuột để mở form khác.
Những form này có thể được dùng để nhập hoặc xem thông tin hoặc tương tác với chương
trình theo một cách khác. Thường thì các form này có một mục đích xác định, kiểu như xem
kết quả, nhập danh sách các hiệu ứng phụ, hoặc chọn các thông số cài đặt cho chương trình.

Sau khi người dùng đã nhập vào hoặc xem thông tin trên một form, Nói chung họ thường
đóng form và trở về form chính. Mặc dù Visual Studio chỉ tự động thêm Form1, nhưng bạn
có thể tự thêm vào chương trình số form mà bạn cần.

Một kiểu form quan trọng khác là hộp thông báo. Bạn đã thực sự sử dụng form này rồi.
Trong chương trình “Chào Thế giới”, bạn đã sử dụng một hộp thông báo để hiển thị dòng
chữ "Chào, Thế giới". Hộp thông báo được sử dụng
thông báo trong form hội thoại chung. Sau khi người Gợi ý
dùng đọc thông báo, họ đóng hộp thông báo bằng cách Các học sinh sẽ đọc giáo trình
nhấn vào nút OK. nhưng thường không thực hiện
đúng như những gì mô tả trong tài
liệu. Các học sinh đạt hiệu quả
Vì vậy, bạn sẽ tự mình thiết kế form - form “lốp xẹp nhất nếu làm đúng những gì trong
hơi”. Sau đó bạn thêm một vài điều khiển vào form và cài sách hướng dẫn. Cần kiểm tra để
đặt các thuộc tính cho chúng. Tôi sẽ chỉ cho bạn cách tin chắc học sinh hiểu giáo trình
thức mà các điều khiển form đáp lại các sự kiện như là khóa học.
nhấn nút lệnh và chúng ta sẽ quay lại form đã được
Visual Studio xây dựng sẵn là: hộp thông báo.

26
4. Các thuộc tính của form
Khi bạn tạo mới một ứng dụng Window, Form1 được tự động thêm vào. Form1 có kích
thước mặc định là 300 x 300 điểm ảnh. Để kiểm tra điều này, sử dụng cửa sổ thuộc tính
(Properties Window). Bạn cũng có thể thay đổi kích cỡ của form bằng cách sử dụng cửa sổ
này.

Nhưng đầu tiên, bạn cần phải tạo một ứng dụng
Window và đặt tên cho nó là Lốp xẹp hơi (FlatTire).
Sau khi dự án được tạo, Chọn Form1 bằng cách
nhấn vào nó. Tiếp đến nhấn phím F4 để mở cửa sổ
thuộc tính

Khi Form1 được chọn, cửa sổ thuộc tính hiển


thị các thuộc tính của Form. Lưu ý rằng thuộc tính
Text được chọn theo mặc định.

1. Duyệt qua danh sách các thuộc tính của


biểu mẫu Form1 và chỉ ra thuộc tính
Size. Lưu ý rằng thuộc tính Size có một
dấu cộng bên cạnh. Điều này chỉ ra rằng
thuộc tính Size có thể được mở rộng để
hiển thị các thuộc tính khác.

2. Nháy vào ký hiệu dấu cộng bên cạnh thuộc tính Size. Các thuộc tính Height và
Width được hiển thị. Thuộc tính
Height của biểu mẫu là 300 và
Width là 300. Hãy thay đổi kích
thước của biểu mẫu Form1.

27
3. Nháy đúp lên thuộc Width để bôi
đen giá trị thuộc tính. Ấn phím
xóa để xóa giá trị thuộc tính.

4. Nhập số 450. Ấn phím Enter.


Điều này có nghĩa bạn chỉ thay
đổi thuộc tính Width của biểu
mẫu. Lưu ý độ rộng của biểu
mẫu được thay đổi ngay khi bạn
ấn phím Enter. Lưu ý giá trị
Width tiếp theo thuộc tính Size được gán cùng thời điểm.

Bây giờ hãy gán thuộc tính BackColor của Form1. Thuộc tính này là màu của biểu mẫu
và các điều khiển được đặt trên đó. Trong cửa sổ Properties, đến thuộc tính BackColor của
Form1. Nháy từ "Control". Một nút mũi tên chỉ xuống xuất hiện. Một cửa sổ bảng màu mở
ra. Chọn tab Custom. Nháy đúp một hình vuông tô màu để chọn màu.

Biên dịch và chạy ứng dụng. Để ý màu nền mới của form! Và nhìn xem, form bây giờ có
tiêu đề “form xẹp lốp” ("Flat Tire Form") và bây giờ nó không còn hình dạng là hình vuông
nữa, mà có hình dạng là hình chữ nhật!

Bây giờ bạn đã biết dùng cửa sổ thuộc tính để thay đổi thuộc tính của form. Cuộn dọc
theo các thuộc tính của Form1 và bạn sẽ quen thuộc với danh sách thuộc tính này. Cửa sổ
thuộc tính cho phép bạn thay đổi các thuộc tính của form tại thời điểm thiết kế form – Nghĩa
là, khi bạn đang xây dựng form. Như bạn sẽ thấy, cửa sổ thuộc tính không chỉ dành cho form.
Nó cũng cho phép bạn thay đổi thuộc tính của nút lệnh, hộp văn bản, và các điều khiển khác
của form.

5. Điều khiển và thuộc tính của form


Hiện tại bạn là một chuyên gia thêm các nút lệnh vào biểu mẫu, nhưng việc đó có một
chút hơi lặp lại. Bạn có thể thấy cửa sổ Toolbox có sẵn nhiều các điều khiển khác nhau của
form. Vì vậy bây giờ tôi có thể chỉ cho bạn cách sử dụng một số điều khiển chung nhất và
cách cài đặt các thuộc tính hữu ích nhất của chúng. Hãy bắt đầu với điều khiển nhãn (label).

5.1. Các nhãn (Labels)


Điều khiển nhãn được sử dụng để ghi nhãn (tiêu
đề) cho các điều khiển riêng biệt hoặc nhóm các điều Gợi ý
khiển trên form. Ngoài ra nó còn được sử dụng một Tất cả các điều khiển là các đối tượng
cách phổ biến để đưa ra các hướng dẫn hoặc chỉ ra nhưng không phải tất cả các đối tượng
thứ tự cho việc nhập thông tin trên form. là các điều khiển. Một đối tượng có thể
là mọi thứ trừ thuộc tính. Một thuộc tính
là tính chất của đối tượng như màu
Mở cửa sổ công cụ và nhấp đúp vào điều khiển hoặc độ rộng.
nhãn. Nhãn được thêm vào form. Kéo nó đến vị trí

28
thích hợp bằng cách giữ và nhấn chuột trái và di chuyển chuột.

Chọn Label1 và mở cửa sổ thuộc tính. Cửa sổ thuộc tính bây giờ hiển thị danh sách thuộc
tính của điều khiển nhãn. Cuộn đến thuộc tính Text (văn bản), nhấp đúp để chọn văn bản, và
dùng phím Backspace để xoá, sau đó gõ từ “Nhập giấy phép” vào.

5.2. Hộp văn bản (TextBox)


Hộp văn bản có thể được sử dụng để hiển thị thông tin cho người dùng hoặc thu thập
thông tin từ người dùng.

Trong cửa sổ hộp công cụ nhấp đúp vào điều khiển hộp văn bản. Textbox1 được thêm vào
form. Kéo Textbox1 đến vị trí bên phải của Label1.

Cuộn đến thuộc tính Text (văn bản), nhấp đúp, và nhấn phím backspace để xoá văn bản.
Đặt thuộc tính ReadOnly (chỉ đọc) thành False (sai) để cho người dùng có thể thêm văn bản
vào hộp văn bản. False sẽ là thuộc tính mặc định.

Hộp văn bản thường được dùng để hiển thị số lượng lớn thông tin. Nếu văn bản thực sự
dài bạn có thể cần thêm thanh cuộn (scrollbars) vào hộp văn bản.

Thêm hộp văn bản khác nữa vào. Đặt thuộc tính Multiline (nhiều dòng) thành True
(đúng). Đặt chiều cao là 100 điểm ảnh và chiều rộng là 100 điểm ảnh. Nếu thuộc tính
Multiline (nhiều dòng) được đặt là FALSE (sai), bạn sẽ không bao giờ có thể thay đổi được
thuộc tính Height (chiều cao). Đặt thuộc tính Scrollbars (thanh cuộn) thành thanh cuộn dọc
(Vertical). Đặt thuộc tính ReadOnly (chỉ đọc) thành True (đúng) để cho người dùng không
thể nhập văn bản vào trong hộp văn bản.

5.3. Nút lựa chọn (Radio Button)


Nút lựa chọn được sử dụng để cung cấp cho người dùng khả năng lựa chọn. Người dùng
chỉ có thể chọn một nút lựa chọn từ một nhóm các nút lựa chọn. Nó giống như sự thử nhiều
lựa chọn.

Trong hộp công cụ (Toolbox), nhấp đúp Nút lựa chọn. RadioButton1 được thêm vào
form. Chọn RadioButton1 trên form, nhấp phải chuột và chọn Copy từ thực đơn. Chỉ con trỏ
chuột vào Form1, nhấp chuột phải, và chọn Paste từ thực đơn để dán. Điều kỳ diệu, nút lựa
chọn RadioButton2 được thêm vào form. Lặp lại thao tác dán (Paste) để thêm RadioButton3
và RadioButton4 vào form.

Chọn RadioButton1 và mở cửa sổ thuộc tính. Cuộn đến thuộc tính Text (văn bản) và thay
đổi giá trị của nó từ “Nút lựa chọn 1” ("RadioButton1") thành “Trái, trước”. Và thay đổi
thuộc tính Text (văn bản) của các nút lựa chọn: “Nút lựa chọn 2” thành “Trái, sau”,
RadioButton3 thành “Phải, trước”, nút RadioButton4 thành "Phải, sau".

29
5.4. Ô đánh dấu (CheckBox)
Hộp văn bản có thể được sử dụng để hiển thị thông tin cho người dùng hoặc thu thập
thông tin từ người dùng.

Trên cửa sổ công cụ, nhấp đúp điều khiển văn bản. Hộp Textbox1 được thêm vào form.
Kéo Textbox1 sang bên phải của Label1. Cuộn đến thuộc tính văn bản, nhấp đúp, và nhấn
phím Backspace để xoá văn bản. Đặt thuộc tính ReadOnly (chỉ đọc) thành False (sai) để cho
người dùng có thể nhập văn bản vào trong hộp văn bản. Giá trị mặc định của thuộc tính
ReadOnly (chỉ đọc) là False (sai).

Ô đánh dấu cũng cung cấp cho người dùng khả năng lựa chọn. Người dùng có thể lựa
chọn một hoặc nhiều Ô đánh dấu từ nhóm Ô đánh dấu. Trên cửa sổ Hộp công cụ, nhấp đúp
điều khiển Ô đánh dấu. Điều khiển CheckBox1 được thêm vào form. Mở cửa sổ thuộc tính
và thay đổi thuộc tính Text (văn bản) thành “Công việc gấp” (Rush Job).

5.5. Hộp danh sách đổ xuống (ComboBox)


Hộp danh sách đổ xuống đưa ra một danh sách các sự lựa chọn cho người dùng. Khi
người dùng chọn một mục từ danh sách thì mục vừa được chọn sẽ được hiển thị trong Hộp
danh sách đổ xuống.

Trên cửa sổ công cụ, nhấp đúp vào điều khiển hộp danh sách đổ xuống. Hộp danh sách đổ
xuống ComboBox1 được thêm vào form.

Mở cửa sổ thuộc tính và thay đổi thuộc tính Text (văn bản) của hộp danh sách đổ xuống
thành "Chọn cỡ lốp". Cuộn đến thuộc tính Items (các mục chọn). Nhấp vào từ "Collection"
(tập hợp). Một nút có ba dấu chấm ở trên xuất hiện ở bên phải. Nhấn vào nút này, một cửa sổ
sẽ được mở ra, đây là nơi mà bạn có thể nhập vào một danh sách các mục để hiển thị trong
Hộp danh sách kéo xuống. Bạn phải đặt mỗi mục mà bạn nhập vào danh sách trên một dòng.
Sau khi nhập vào một dòng, bạn phải bấm phím Enter để tạo một dòng mới. Trong cửa sổ
này bạn thực hiện các thao tác sau: gõ 12, nhấn phím Enter, gõ 13, nhấn phím Enter, gõ 14,
nhấn phím Enter và gõ 15. Nhấn nút OK để đóng cửa sổ.

5.6. Nút Lệnh (Command Button)

Hộp văn bản có thể được sử dụng để hiển thị thông tin cho người dùng hoặc thu thập
thông tin từ người dùng. Trên hộp công cụ, nhấp đúp điều khiển văn bản. Hộp Textbox1
được thêm vào form. Kéo Textbox1sang bên phải của Label1. Cuộn đến thuộc Text tính (văn
bản), nhấp đúp, và nhấn phím Backspace để xoá văn bản. Đặt thuộc tính ReadOnly (chỉ đọc)
thành False (sai) để cho người dùng có thể nhập văn bản vào trong hộp văn bản. Giá trị
mặc định của thuộc tính chỉ đọc là False (sai).

Thêm nút lệnh vào form. Đặt thuộc tính Text (văn bản) thành "Lấy lốp". Thay đổi thuộc
tính BackColor (màu nền) thành đỏ. Tìm thuộc tính Font (phông chữ). Nhấp vào chữ “Font “
để hiển thị nút có ba dấu chấm. Nhấn vào nút này để hiển thị cửa sổ phông chữ . Trong cửa
sổ này, thay đổi thuộc tính Font Style (kiểu phông chữ) thành Bold (đậm nét). Nhấn nút OK
để đóng cửa sổ phông chữ.

30
Chạy chương trình. Nhấp vào các điều khiển form khác nhau và theo dõi kết quả.

• Điều gì xảy ra khi bạn nhấn vào hộp danh sách?


• Điều gì xảy ra khi bạn chọn một nút lựa chọn từ nhóm nút lựa chọn.
• Khác với nút lựa chọn, Ô đánh dấu thì sao?

Nhập văn bản vào trong hộp văn bản ở bên cạnh điều khiển gán nhãn “Nhập giấy phép”.
Để ý rằng hộp văn bản khác có màu xám và bạn không thể nhập văn bản vào đấy. Nhấn nút
"X" trên góc phải trên để đóng chương trình.

Bước tiếp theo sẽ là thêm mã lệnh VB.NET vào form và các điều khiển.

Bạn phải làm quen với các thuộc tính của từng điều khiển mà bạn đã thêm vào form. Bạn
có thể trình bày các điều khiển trên form sao cho form gọn gàng và dễ sử dụng hơn. Bạn có
thể thêm các nhãn để chú thích cho người dùng mục đích của các điều khiển và cung cấp các
thông tin chỉ dẫn cần thiết.

31
6. Kích hoạt sự kiện
Sự kiện được kích hoạt bởi các hành động của người dùng. Ví dụ, khi người dùng nhấn
nút lệnh, chọn một mục từ hộp danh sách, thay đổi văn bản trong hộp văn bản thì sự kiện
được sinh ra. Hành động nhấp hoặc nhấp đúp chuột của người dùng trên một điều khiển hoặc
di chuyển con trỏ ở trên hoặc ra khỏi điều khiển cũng làm phát sinh sự kiện. Bạn có thể sử
dụng những sự kiện này để thực hiện mã VB.NET kết hợp với chúng. Mã VB.NET là cái tạo
nên chương trình thực hiện nhiệm vụ phải làm.

Khi bạn viết ứng dụng Hello World, bạn nhấp đúp trên nút lệnh và cửa sổ mã lệnh được
mở ra để bạn có thể nhập mã lệnh cho sự kiện Button1_Click (nhấn nút lệnh Button1). Sự
kiện Button1_Click là sự kiện mặc định cho nút lệnh. Mỗi điều khiển đều có một sự kiện mặc
định. Khi bạn đang ở chế độ thiết kế, nhấp đúp vào điều khiển thì cửa sổ mã lệnh sẽ được mở
cho sự kiện mặc định.

Ví dụ:

• Đối với Nút lệnh (Button), sự kiện mặc định là sự kiện Click (xảy ra khi nút lệnh
được nhấn)
• Đối với Hộp văn bản (Textbox), sự kiện mặc định là sự kiện TextChanged (xảy ra khi
nội dung văn bản thay đổi)
• Đối với Nút lựa chọn (RadioButton), sự kiện mặc định là sự kiện CheckedChanged
(xảy ra khi thuộc tính kiểm tra - Checked thay đổi)
• Đối với Ô đánh dấu (CheckBox), sự kiện mặc định là sự kiện CheckedChanged (xảy
ra khi thuộc tính kiểm tra - Checked bị thay đổi)
• Đối với Hộp danh sách đổ xuống (ComboBox), sự kiện mặc định
SelectedIndexChanged (là sự kiện xảy ra chỉ số của mục được chọn thay đổi)

Để chỉ cho bạn công việc này như thế nào, xin được thêm mã lệnh vào sự kiện mặc định
của điều khiển của form “form lốp xẹp hơi”. Mã lệnh sẽ hiển thị một hộp thông báo để thông
báo kiểu của điều khiển đã gửi sự kiện. Trong chế độ thiết kế, nhấp đúp vào từng điều khiển
mà bạn đã thêm vào form. Cửa sổ mã lệnh sẽ mở cho sự kiện mặc định của từng điều khiển.
Nhập vào dòng mã lệnh sau đây vào từng thủ tục xử lý sự kiện.

MessageBox.Show(sender.GetType.Name)

Biên dịch và chạy ứng dụng. Nhấp vào các phần tử khác nhau, thay đổi văn bản trong hộp
soạn thảo và chọn một mục từ hộp danh sách đổ xuống. Với mỗi điều khiển, sự kiện mặc
định được kích hoạt làm xuất hiện hộp thông báo hiển thị kiểu của điều khiển đã gửi sự kiện.

Nếu form “form lốp xẹp” là một bộ phận của một ứng dụng thực tế, bạn sẽ thêm mã lệnh
vào các sự kiện mặc định để cung cấp chức năng mà chương trình yêu cầu. Ví dụ, khi bạn
nhấn nút Lấy lốp, thì danh sách các lốp hiện có được hiển thị trong hộp văn bản.

32
7. Hộp thông báo (MessageBoxes)
Thường thì bạn sẽ nhận thấy là chương trình của bạn cần tham gia hội thoại với người
dùng. Có thể Chương trình cần gửi thông báo đến hoặc thu thập các câu trả lời từ người
dùng, hoặc nhận các dữ liệu của người dùng. Những kiểu hội thoại này phổ biến cho nên
Visual Studio.NET có một đối tượng hộp thông báo để quản lý chúng.
Trong chương trình bạn viết đầu tiên, bạn đã sử dụng dòng mã lệnh để hiển thị một hộp hội
thoại.

MessageBox.Show("Hello World")

Hộp hội thoại là một kiểu form được xây dựng sẵn trong VB.NET. Để sử dụng nó bạn
không phải thêm hộp hội thoại vào dự án. Mà bạn chỉ cần gọi phương thức Show() của nó và
thêm nội dung cần thông báo cho phương thức Show() là đủ. Cú pháp sử dụng hộp hội thoại
như sau:

MessageBox.Show("Thông báo của bạn")

Để ý rằng thông báo mà bạn muốn hiển thị phải được bao trong cặp dấu nháy kép (“ “).

33
8. Bài kiểm tra

34
BÀI 5. CÁC THUỘC TÍNH VÀ PHƯƠNG PHÁP

1. Mã lệnh bắt đầu ở đâu


Cửa sổ thuộc tính dễ sử dụng, nhưng không linh hoạt. Làm thế nào nếu người dùng muốn
thay đổi màu nền của form khi họ đang sử dụng chương trình? Làm thế nào nếu họ cần thay
đổi cỡ và kiểu của phông chữ? Làm thế nào mà chương trình của bạn biết nếu người dùng
đánh dấu vào hộp đánh dấu hoặc nhấn vào một nút lựa chọn? Vì người dùng sẽ không thể
truy cập cửa sổ thuộc tính khi chương trình chạy được, thế thì họ có thể làm như thế nào?

Câu trả lời là: sử dụng mã lệnh Visual


Basic.NET! Bạn có thể làm tất cả những việc này,
và nhiều hơn thế nữa bằng cách sử dụng mã lệnh.
Bạn viết mã lệnh để đọc thuộc tính của điều khiển.
Bạn viết mã lệnh để thiết lập giá trị cho các thuộc
tính của chúng. Điều này rất đơn giản và rất hiệu
quả.

Mã lệnh được đặt ở đâu? Bạn có thể viết mã


lệnh trong trang mã lệnh của form. Trong hầu hết
các trường hợp bạn sẽ đặt các mã lệnh vào trong các
thủ tục xử lý sự kiện (event handlers) của điều
khiển. Ví dụ sự kiện nhấn nút: Khi người dùng thực
hiện một hành động, chẳng hạn như nhấn vào nút,
mã lệnh mà bạn viết cho thủ tục xử lý sự kiện được
thực hiện và thuộc tính của điều khiển được đọc hoặc đặt lại giá trị. Khi bạn thêm mã lệnh
vào sự kiện của điều khiển là bạn đang biến form thành một chương trình làm việc thực sự.

2. Đọc thuộc tính bằng mã lệnh


Tạo một ứng dụng Window và đặt tên là DocThuoctinh. Mở hộp công cụ và thêm một nút
lệnh vào Form1. Mở cửa sổ thuộc tính và thay đổi thuộc tính Text (văn bản) của Button1
thành "Đọc văn bản". Nhấp đúp vào nút Button1 để viết mã lệnh cho sự kiện nhấn nút
Button1. Gõ vào dòng lệnh sau:

MessageBox.Show(Button1.Text)

Dịch và chạy chương trình. Nhấn nút "Đọc văn bản". Một hộp thông báo được mở và hiển
thị nội dung “Đọc văn bản” đó là thuộc tính Text của nút lệnh Button1. Kiểm tra: mã lệnh
đọc thuộc tính Text của nút lệnh Button1 và sau đó hiển thị giá trị của nó bằng cách sử dụng
một thông báo.

Đây là một ví dụ khác. Thêm nút khác vào Form1. Sử dụng cửa sổ thuộc tính để thay đổi
thuộc tính Text của nút lệnh Button2 thành "Kích thước Form". Nhấp đúp vào nút Button2 để
mở cửa sổ soạn thảo mã lệnh cho sự kiện nhấn nút. Gõ dòng mã lệnh sau đây vào thủ tục xử
lý sự kiện nhấn nút lệnh Button2.

35
MessageBox.Show(Form1.ActiveForm.Height & "," & Form1.ActiveForm.Width)

Dịch và chạy chương trình. Nhấn vào nút lệnh "Kích thước Form". Một hộp thông báo
hiển thị: 300,300 (đó là kích thước của form, giả sử bạn cứ giữ nguyên kích thước form như
kích thước ban đầu của nó). Mã lệnh của bạn chỉ mới hiển thị thông báo chiều cao và chiều
rộng của Form1 được phân biệt bởi dấu phẩy.

Mã lệnh Visual Basic.NET có thể đọc tất cả các thuộc tính của form hoặc điều khiển form
- những thuộc tính được liệt kê trong cửa sổ thuộc tính. Mã lệnh của bạn có thể đọc các thuộc
tính như Height (chiều cao) và Width (chiều rộng), BackColor (màu nền), ForeColor (màu
chữ), và tọa độ X, tọa độ Y. Tuy nhiên, rất nhiều thuộc tính trong cửa sổ thuộc tính được cài
đặt khi thiết kế form và chúng không thay đổi được khi chương trình chạy.

Việc đọc các thuộc tính của form và điều khiển (như thuộc tính văn bản của hộp văn bản,
thuộc tính kiểm tra của Ô đánh dấu…) mà người dùng thay đổi khi họ sử dụng chương trình
thực sự mang lại lợi ích gì. Đây chính là cách chương trình thu thập thông tin từ người dùng.
Biển số xe mà Jen đã nhập vào là gì? Lốp nào là lốp hết hơi? Cliff đã chọn cỡ lốp nào?

Đây là ví dụ có tính thực hành hơn. Hãy viết mã lệnh chỉ ra rằng Ô đánh dấu đã được
đánh dấu hay chưa. Mở cửa sổ hộp công cụ và thêm Ô đánh dấu vào Form1. Thêm Nút lệnh
vào Form1. Mở cửa sổ thuộc tính và thay đổi thuộc tính Text của Nút lệnh thành “Check
Me” (đánh dấu tôi). Nhấp đúp vào Nút lệnh để soạn thảo sự kiện nhấn chuột. Gõ dòng lệnh
sau đây vào sự kiện nhấn chuột:

MessageBox.Show(CheckBox1.Checked)

Dịch và chạy chương trình. Nhấn vào nút “Check Me”. Hộp thông báo hiển thị cái gì?
đánh dấu vào Ô kiểm tra và lại nhấn nút “Click Me” . Bây giờ thì hộp thông báo hiển thị cái
gì? mỗi lần bạn nhấn vào nút lệnh hộp thông báo hiển thị trạng thái hiện tại của thuộc tính
Check (đánh dấu) của Ô kiểm tra. Nó sẽ thông báo True (Ô đánh dấu đã được đánh dấu).

Một ví dụ khác: Đọc và hiển thị các từ mà người dùng nhập vào hộp văn bản.

Thêm hộp văn bản vào Form1. Mở cửa sổ thuộc tính và chắc chắn rằng thuộc tính
ReadOnly của nó được đặt là False. Đặt thuộc tính Text của hộp văn bản là “Gõ vào đây” .
Thêm một nút lệnh vào Form1. Thay đổi thuộc tính Text của nó thành “Đọc văn bản”. Nhấn
Nút lệnh để soạn thảo mã lệnh cho sự kiện nhấn chuột. Gõ dòng mã lệnh sau vào sự kiện
nhấn chuột:

MessageBox.Show(TextBox1.Text)

Dịch và chạy chương trình. Nhấp đúp vào TextBox1 và nhấn phím Backspace để xoá văn
bản. Nhập văn bản vào TextBox1. Nhấn vào nút "Đọc văn bản”. Hộp thông báo hiển thị cái
gì? thay đổi văn bản trong TextBox1 và lại nhấn Nút "Đọc văn bản". Điều gì xảy ra?

36
3. Gán thuộc tính bằng mã lệnh
Một câu hỏi đặt ra là: Làm thế nào, nếu tôi muốn đặt thuộc tính của điều khiển khi người
dùng đang chạy chương trình?

Ví dụ, Tôi muốn ô đánh dấu "Rush Job" (công việc gấp) luôn luôn được đánh dấu tại thời
điểm ban đầu khi người dùng chạy chương trình. Tôi muốn chương trình hiển thị tất cả các
cỡ lốp hiện có, ở trong hộp văn bản khi người dùng nhấn chuột vào nút "Get Tires" (Lấy
lốp). Tôi muốn danh sách cỡ lốp hiện có được tự động nạp vào hộp danh sách đổ xuống ngay
sau khi người dùng nhập vào biển số xe ô tô.

Để đặt thuộc tính của điều khiển bằng Visual Basic .NET chúng ta sử dụng lệnh gán.
Lệnh gán đã được bàn đến ở bài Giả mã lệnh. Lệnh gán thực hiện việc gán cái này cho cái
khác. Mã lệnh của lệnh gán trông như một biểu thức đơn giản cùng với một dấu bằng đi cùng
nó.

TextBox1.Text = "Các Quy tắc Viết mã lệnh"

Biểu thức ở phía bên phải của dấu bằng được tính trước. Sau đó gán kết quả này cho biểu
thức ở bên trái của dấu bằng.

Dưới đây là một số ví dụ về cách sử dụng mã lệnh Visual Basic.NET để gán giá trị cho
thuộc tính. Ví dụ đầu tiên gán giá trị cho thuộc tính văn bản của hộp văn bản. Đây là một
cách tuyệt vời để hiển thị thông tin tới người dùng – nó được sử dụng thay vì luôn luôn xổ ra
một hộp thông báo.

Bắt đầu một ứng dụng Window mới và đặt tên nó là SetProperties (đặt thuộc tính). Thêm
hai hộp văn bản và một nút lệnh vào Form1. Sử dụng cửa sổ thuộc tính để đặt thuộc tính Text
(văn bản) của Button1 thành "Set Text" (cài đặt thuộc tính văn bản). Xoá nội dung văn bản
của thuộc tính Text của cả TextBox1 và TextBox2 bằng cách nhấp đúp vào thuộc tính Text
của chúng và nhấn phím backspace. Nhấp đúp vào Button1 để soạn thảo mã lệnh cho sự kiện
nhấn chuột, và thêm dòng mã lệnh sau vào thủ tục xử lý sự kiện:

TextBox2.Text = TextBox1.Text

Dịch và chạy chương trình. Nhập văn bản vào TextBox1 và nhấn nút "Set Text". Điều gì
xảy ra? Như bạn có thể thấy văn bản ở trong TextBox1 được “chép” sang TextBox2. Thuộc
tính Text của TextBox2 được gán giá trị của thuộc tính Text của TextBox1. Mã lệnh Visual
Basic.NET đọc thuộc tính Text của TextBox1 và sau đó dùng giá trị này gán cho thuộc tính
Text của TextBox2.

Hãy thêm mã lệnh sao cho ở thời điểm đầu tiên khi chạy chương trình Ô đánh dấu tự động
thứ nhất được đánh dấu và Ô đánh dấu thứ hai thì không bị đánh dấu. Thêm điều khiển Ô
đánh dấu vào Form1 và sử dụng cửa sổ thuộc tính để đặt thuộc tính Text của nó là "Rush
Job" (công việc gấp). Thêm một Ô đánh dấu vào Form1 và sử dụng cửa sổ thuộc tính để đặt
thuộc tính Text của nó là "Whenever" (bất cứ khi nào). Nhấp đúp vào Form1 (không nhấp
đúp phải là vào CheckBox1hoặc CheckBox2). Điều này sẽ mở cửa sổ soạn thảo mã lệnh cho
sự kiện Form1_Load (sự kiện nạp form) của Form1. Mã lệnh được viết trong thủ tục xử lý sự

37
kiện nạp Form được thi hành tại lần đầu tiên khi form được tạo ra và hiển thị, trước bất cứ
mã lệnh chương trình nào khác được thực hiện. Thêm vào hai dòng lệnh sau:

CheckBox1.Checked = True
CheckBox2.Checked = False

Dịch và chạy chương trình. Ô đánh dấu nào


được đánh dấu? mã lệnh của bạn tự động cài đặt
thuộc tính Checked (đánh dấu) cho hai ô đánh dấu
khi nạp form.

Hãy sử dụng mã lệnh để tự động chọn 14 trong


danh sách cỡ lốp của hộp danh sách đổ xuống.
Trước tiên, thêm một hộp danh sách đổ xuống vào
Form1. Sử dụng cửa sổ thuộc tính để cài đặt các
mục trong danh sách của nó là 12,13,14,15, 16.
Nhấn phím Enter để tạo dòng mới cho từng mục
trong danh sách. Nhấp đúp vào Form1 (không
phải là vào ComboBox1) để soạn thảo mã lệnh
cho sự kiện nạp Form. Thêm dòng mã lệnh sau:

ComboBox1.SelectedItem = "14"

4. IntelliSense và dấu chấm


IntelliSense hay còn gọi là cơ chế nhận biết thông minh. Nó là một bộ phận của Visual
Studio. Nó giúp bạn tiết kiệm rất nhiều thời gian trong việc viết mã lệnh. Nó biết bạn đang
làm việc với điều khiển nào và các thuộc tính của điều khiển đó. Nó hiển thị danh sách thuộc
tính và cho phép bạn chọn thuộc tính mà bạn muốn sử dụng. Thuộc tính được sử dụng phổ
biến nhất sẽ được làm sáng lên khi được hiển thị trong danh sách.

Ví dụ, thuộc tính Text của hộp văn bản được sáng lên đầu tiên. Sử dụng mũi tên lên và
xuống để tìm thuộc tính mà bạn cần. Khi bạn nhấn phím Tab, nó thêm thuộc tính vào mã
lệnh của bạn. Với IntelliSense bạn không cần phải nhớ tất cả các thuộc tính của tất cả các
điều khiển. Nó giúp bạn tránh được việc phải gõ rất nhiều mã lệnh.

Tạo một ứng dụng Window đặt tên là


IntelliSense. Thêm một hộp văn bản và
một nút lệnh vào Form1. Nhấp đúp vào
nút lệnh để soạn thảo mã lệnh cho sự kiện
nhấp chuột của nút lệnh Button1.

1. Gõ TextBox1 và nhấn phím có dấu


chấm (.) (đừng quên dấu chấm).
Ngay khi bạn gõ dấu chấm,
IntelliSense sẽ hiển thị danh sách
thuộc tính của TextBox1. Vì
TextBox1 là hộp văn bản, danh sách

38
này giống như danh sách của hộp văn
bản bất kỳ mà bạn thêm vào form.
Mặc định thuộc tính được chọn trong
danh sách của IntelliSense là thuộc
tính được sử dụng phổ biến nhất.
Trong trường hợp này thuộc tính Text
được lựa chọn mặc định.

2. Bây giờ gõ vào chữ "R". IntelliSense


chuyển đến thuộc tính đầu tiên trong
nhóm thuộc tính bắt đầu bởi chữ “R”
của danh sách. Khi bạn gõ chữ,
IntelliSense tìm thuộc tính đối sánh
sát nhất với những chữ bạn
đã gõ vào.

3. Sử dụng mũi tên xuống di chuyển


dọc theo danh sách và định vị lại
thuộc tính Text. Chọn thuộc tính
Text.

4. Nhấn phím Tab . Nhìn xem điều gì xảy ra! từ Text được thêm vào mã lệnh ngay sau
TextBox1. bây giờ gõ ="Ví dụ". Bây giờ mã lệnh là:

TextBox1.Text = "Ví dụ"

39
Bạn để ý rằng có một biểu tượng ngay bên cạnh mỗi phần tử
trong danh sách. Biểu tượng của thuộc tính là một bàn tay chỉ
vào một phần tử trong danh sách. Biểu tượng của phương thức là
một hộp màu tía hoặc hình thoi màu tía (tôi sẽ giải thích về
phương thức trong ít phút sau). Phụ thuộc vào điều khiển, bạn
cũng có thể nhìn thấy các biểu tượng khác được bổ sung cho các
thuộc tính của điều khiển.

Bạn có để ý rằng bạn phải gõ dấu chấm trước khi danh sách
IntelliSense xuất hiện? Bạn phải làm điều này vì Visual Basic.NET sử dụng cú pháp gọi là kí
pháp chấm (dot notation). Sau khi bạn gõ tên của điều khiển, ví dụ như TextBox1, bạn phải
gõ dấu chấm. Sau đó bạn gõ tên của thuộc tính. Dấu chấm là cái liên kết điều khiển với các
thuộc tính của nó. Đây là cú pháp cơ bản dùng để tham chiếu thuộc tính của form hoặc điều
khiển bằng cách sử dụng dấu chấm:

TênForm.thuộctínhForm
TênĐiềukhiển.ThuộcTínhĐiềukhiển

Đây là những ví dụ:

TextBox1.Text
CheckBox1.Checked
Form1.ActiveForm.Height

Chú ý rằng dấu chấm nối điều khiển với thuộc tính của nó. Trong ví dụ cuối, ActiveForm
(form tích cực) là thuộc tính của Form1 và Height là thuộc tính của ActiveForm. Cho nên,
cần hai dấu chấm để xâu chuỗi các thuộc tính lại với nhau. IntelliSense biết khi nào thì thuộc
tính hiện tại có thuộc tính con. Nếu IntelliSense không hiển thị danh sách thì tức là không có
các thuộc tính bổ sung và bạn phải bỏ đi dấu chấm cuối cùng. Hoặc bạn gõ tên của điều
khiển sai.

5. Phương thức

Chắc là bạn để ý là bên cạnh một số phần tử trong danh sách của IntelliSense có một biểu
tượng hình thoi màu tía ở bên cạnh. Chúng không phải là thuộc tính mà chúng là phương
thức. Thuộc tính là đặc điểm của điều khiển, ví dụ như màu sắc, số ghế, động cơ là các đặc
tính của ô tô. Phương thức là hành động của điều khiển, giống như hành động rẽ sang trái,
dừng lại là hành động của ô tô. Phương thức không thể truy cập được bằng cửa sổ thuộc tính
mà phải bằng mã lệnh.

Ví dụ, hầu hết các điều khiển đều có phương thức Hide và phương thức Show. Khi bạn
gọi phương thức Hide, bạn không thể nhìn thấy điều khiển mặc dù nó vẫn ở trên form. Khi
bạn gọi phương thức Show, điều khiển xuất hiện. Một vài phương thức cho phép bạn kích
hoạt một hành động. Thông thường thì hành động này được người dùng thực hiện. Ví dụ, Nút
lệnh có phương thức PerformClick, phương thức này cho phép mã lệnh của bạn nhấn nút
lệnh, bắt chước hành động nhấn nút lệnh của người dùng.

40
Một vài phương thức yêu cầu bạn phải gửi kèm một vài thông tin nào đó khi gọi nó.
Thông tin này ảnh hưởng đến cách thực thi của phương thức cũng như kết quả của việc thực
thi phương thức. Những thông tin này được gọi là tham số của phương thức. Một phương
thức có thể yêu cầu một hoặc nhiều tham số. Một số tham số có thể là tuỳ chọn (không bắt
buộc).

Ví dụ, phương thức Show của hộp thông báo kèm theo một tham số là một chuỗi văn bản.
Tham số này quyết định nội dung cần thông báo. Bạn đã sử dụng phương thức Show của hộp
thông báo nhưng chắc chắn bạn chưa hiểu rõ bạn đã gọi phương thức với một đối số.

MessageBox.Show("Hello World")

Trong mã lệnh ở trên chuỗi văn bản "Hello World" là một đối số của phương thức Show.
Đối số quyết định việc hộp thông báo hiển thị nội dung gì. Sự khác nhau chủ yếu giữa thuộc
tính và phương thức là phương thức thực hiện một hành động. Phương thức phải được gọi
bằng mã lệnh và không truy cập được bằng cửa sổ thuộc tính. Một vài phương thức có thể
yêu cầu một hoặc một vài tham số khi chúng được gọi. Một vài tham số trả về giá trị mà bạn
có thể sử dụng chúng trong mã lệnh.

6. Gọi phương thức bằng mã lệnh


Cú pháp gọi một phương thức hầu như là giống với việc đọc hoặc gán thuộc tính. Bạn sử
dụng dấu chấm để liên kết điều khiển với phương thức của nó. Một số phương thức, ví dụ
như Button.Hide và Button.Show không cần đối số. Một số khác, ví dụ như
MessageBox.Show, cần một đối số để biết nó hiển thị nội dung gì. Cú pháp gọi phương thức
như sau:

TênĐiềukhiển.TênPhươngThức (tham số 1, tham số 2,... tham số n)

Bạn còn nhớ khi sử dụng phương thức Show của hộp thông báo bạn đã cung cấp cho nó
một đối số:

MessageBox.Show(“Hello, World”)

Như bạn có thể thấy, một sự khác nhau lớn giữa việc gọi một phương thức và việc đọc
hoặc gán giá trị của một thuộc tính là không sử dấu bằng trong mã lệnh gọi phương thức.

Bây giờ bạn sẽ tìm hiểu cách ẩn và hiển thị điều khiển, xoá văn bản trong hộp văn bản và
đặt vị trí con trỏ vào trong hộp văn bản bằng mã lệnh thông qua ví dụ. Để bắt đầu, tạo một
ứng dụng Window tên là PhuongThuc. Thêm hai nút lệnh và một hộp văn bản vào Form1.
Thay đổi tiêu đề của Button1 thành "Hiển thị". Thay đổi tiêu đề của Button2 thành "Ẩn".
Trong sự kiện nhấn chuột của Button1 gõ vào dòng lệnh sau.

TextBox1.Show()

Trong sự kiện nhấn chuột của Button2 gõ vào dòng lệnh sau.

TextBox1.Hide()

41
Dịch và chạy chương trình. Nhấn vào nút "Hiển thị" và "Ẩn". Mỗi lần bạn nhấn nút lệnh
là một lần bạn gọi phương thức của nó.

Thêm nút lệnh thứ ba vào Form1. Đặt thuộc tính Text của Button3 thành "Khởi động lại”.
Thêm dòng mã lệnh sau vào sự kiện nhấn chuột của nút lệnh Button3.

TextBox1.ResetText()
TextBox1.Focus()

Phương thức ResetText xoá nội dung thuộc tính Text của hộp văn bản. Phương thức
Focus đặt con trỏ vào trong hộp văn bản.

Dịch và chạy chương trình. Nhập văn bản vào trong hộp văn bản và nhấn nút "Khởi động
lại”. Văn bản trong hộp văn bản sẽ bị xoá và con trỏ được tự động đặt vào trong hộp văn bản
– hộp văn bản ở trạng thái sẵn sàng nhận văn bản mà người dùng gõ vào.

7. Bài kiểm tra

42
BÀI 6. GÁN VÀ BIẾN

1. Lệnh Gán
Bây giờ bạn đã biết cách sử dụng mã lệnh để đọc và gán giá trị cho thuộc tính của điều
khiển. Khi bạn đặt giá trị cho một thuộc tính là bạn đang sử dụng câu lệnh gán. Chúng ta đã
nói về chúng trong phần giả mã lệnh. Lệnh gán thực hiện việc gán cái này cho cái khác. Mã
lệnh của lệnh gán có dạng là một biểu thức đơn giản có chứa một dấu bằng.

TextBox1.Text = "Code Rules"

Bây giờ là các quy tắc lệnh gán!

Một điều mà bạn phải biết về lệnh gán là, phần bên phải dấu bằng bao giờ cũng được tính
giá trị trước. Sau đó mới gán giá trị tính được đó cho biểu thức ở phần bên trái của dấu bằng.
Trong mã lệnh dưới đây, "Quy tắc mã lệnh" được định giá trước. Sau đó gán giá trị này cho
TextBox1.Text.

TextBox1.Text = "Quy tắc mã lệnh"

2. Kiểu dữ liệu
Một điều mà bạn luôn phải nhớ là phần bên trái của biểu thức đòi hỏi phần bên phải là
một kiểu dữ liệu nào đó (chuỗi, số, màu sắc,v.v.). Điều đó có nghĩa là như thế nào. Xem
dòng mã lệnh dưới đây:

TextBox1.Text = "Quy tắc mã lệnh"

Ở đây, phía bên trái của biểu thức là thuộc tính Text của TextBox1, nó chỉ có thể được
gán bởi chuỗi văn bản, vì thế phía bên phải cũng phải là một chuỗi văn bản. Nếu phía bên
phải là một kiểu khác (không phải là kiểu chuỗi) thì một lỗi sẽ xảy ra khi bạn biên dịch
chương trình. Vì "Quy tắc mã lệnh" là chuỗi văn bản, đúng như thuộc tính Text yêu cầu nên
lỗi không xảy ra.

Mã lệnh sau sẽ không biên dịch được bởi vì chúng ta đang cố gắng gán kiểu color (màu
sắc) cho kiểu Text (kiểu chuỗi).

TextBox1.Text = TextBox1.ForeColor 'lỗi

Mã lệnh sau là đúng bởi vì phía bên phải của biểu thức có giá trị nguyên và thuộc tính
Height chỉ có thể được gán bằng một số nguyên.

TextBox1.Height = 200

Dòng lệnh này sai bởi vì Visual Basic .NET không cho phép gán một giá trị thập phân cho
biến hoặc thuộc tính kiểu nguyên.

43
TextBox1.Height = 200.5

Nhớ rằng, khi bạn sử dụng câu lệnh gán, phía


bên phải của câu lệnh gán phải có giá trị đúng kiểu
mà biểu thức bên trái yêu cầu.

3. Các kiểu dữ liệu cơ bản


NET Framework cung cấp một số kiểu cơ bản. Bạn đã sử dụng kiểu chuỗi để gán giá trị
cho thuộc tính Text của nút lệnh. Bạn đã sử dụng kiểu số nguyên để gán giá trị cho thuộc tính
Height (chiều cao) của form. Thậm chí bạn đã sử dụng kiểu Boolean (True hoặc False) để
gán giá trị cho thuộc tính Visible (nhìn thấy) của hộp văn bản.

Đây là một vài ví dụ về giá trị của từng kiểu cơ bản:


Kiểu Ví dụ Giải thích
String "Xin Chào" Văn bản được bao trong dấu nháy kép
Integer 123 Số nguyên
Single 55.12 Số có dấu thập phân.
Boolean True Chỉ chấp nhận hai giá trị là: True, False

Gợi ý
Hầu hết các học viên gặp khó khăn với khái niệm một số, như số nguyên 1 không giống
như chữ số “1”. Dạng số nhị phân của số nguyên 1 là 00000001. Dạng nhị phân của chữ
số 1 là 00110001. Rõ ràng là khác nhau.

Visual Basic không cho biết điều đó và cố gắng chuyển sang dạng cần thiết. Ví dụ:
Dim A as Integer = 1
Dim B as String = “1”
If (A = B) Then

Đoạn mã lệnh trên trả về một giá trị đúng mặc dù thực tế rằng việc mô tả bên trong là
khác nhau.

Vì vậy không trực tiếp sử dụng số trong thuộc tính Text của một hộp văn bản.

44
Hãy xem ví dụ các lệnh gán giá trị cho các thuộc tính với các kiểu khác nhau:

TextBox1.Text = "Nụ cười"


TextBox1.Visible = True
TextBox1.Width = 1000

4. Biến là gì?
Biến được sử dụng bởi mã lệnh, để lưu trữ thông tin, nhằm mục đích cho việc sử dụng sau
này. Biến trong mã lệnh cũng giống như biến trong toán học. Chúng được gán một giá trị và
có thể được sử dụng để thay thế cho chính giá trị đó. Biến có thể được gán một giá trị mới tại
bất cứ thời điểm nào.

Trong mã lệnh, biến được chương trình sử dụng để “nhớ” thông tin. Nếu mã lệnh của bạn
không sử dụng biến thì mỗi lần cần thông tin, chương trình sẽ phải dừng và yêu cầu người
dùng nhập thông tin. Tưởng tượng là chương trình của bạn yêu cầu tuổi của người dùng ba
lần khác nhau! Điều này sẽ rất khó chịu nếu chương trình phải dừng lại và yêu cầu người
dùng vào lại tuổi ba lần.

Nhập tuổi của bạn vào:

Nhập tuổi của bạn vào:

Nhập tuổi của bạn vào:

Với việc sử dụng biến, chương trình sẽ chỉ cần duy nhất một lần để nhắc người dùng nhập
tuổi của họ vào. Tuổi sẽ được lưu trong biến, nó sẽ được đem ra sử dụng mỗi khi chương
trình cần tuổi của người dùng.

5. Tại sao sử dụng biến?


Như bạn đã thấy, biến giúp người dùng tiết kiệm thời gian. Chúng giảm bớt lượng thông
tin mà người dùng phải nhập vào. Chúng cũng giúp làm giảm bớt số lỗi mà chương trình có
thể mắc phải. Nếu bạn phải nhập một số gồm nhiều chữ số lặp đi lặp lại nhiều lần thì khả
năng mắc lỗi là rất cao.

Bên cạnh mục đích làm giảm lượng thông tin mà người dùng phải nhập vào, biến còn
được sử dụng để lưu giữ kết quả tính toán. Biến được sử dụng để so sánh trong việc quyết
định thứ tự thực hiện các mã lệnh. Chúng được sử dụng để đếm, chẳng hạn như là một phép
tính đã được thực hiện bao nhiêu lần.

45
6. Khai báo biến
Trước khi chương trình sử dụng biến thì bạn phải khai báo nó. Để khai báo biến, bạn viết
một dòng mã lệnh bao gồm tên biến và gán cho nó một kiểu cụ thể. Trong Visual Basic.NET
bạn phải khai báo tất cả các biến được sử dụng trong chương trình. Khai báo biến làm tăng
tốc độ biên dịch và làm cho chương trình thực hiện hiệu quả hơn. Nó cũng ngăn ngừa lỗi sai
chính tả khi nhập tên biến.

Để khai báo biến trong mã Visual Basic.NET, bạn sử dụng lệnh "Dim".

Lệnh Dim có cú pháp như sau

Dim Tên_Biến As Kiểu_Biến

Dưới đây là một vài ví dụ khai báo biến với các kiểu khác nhau

Dim Ten As String


Dim CanNang As Integer
Dim NoBrainer As Boolean
Dim GiaDVD As Single

Biến đầu tiên, Ten, được khai báo là biến kiểu


chuỗi. Điều này nghĩa là biến Ten chỉ có được gán
bằng một chuỗi ký tự. Biến thứ hai, CanNang, được
khai báo là một biến kiểu nguyên. Nó chỉ có thể
được gán bằng một số nguyên. Biến NoBrainer chỉ
có thể được gán bằng giá trị có kiểu lô gic và biến
GiaDVD chỉ có thể được gán bằng giá trị có kiểu số
thập phân.

7. Khai báo biến ở đâu?


Bạn có thể khai báo bao nhiêu biến mà bạn cần trong các đoạn mã của Visual Basic.NET.
Các biến có thể được khai báo là bất cứ kiểu gì mà NET Framework cho phép. Nên tuân theo
qui tắc chung, khai báo tất cả các biến tại nơi bắt đầu của đoạn mã. Cách này giúp bạn biết
chỗ để tìm chúng khi cần và xem kiểu của chúng là gì. Việc ấy cũng làm cho mã lệnh gọn
gàng và có tổ chức. Nếu cần tạo một biến khác trong khi viết mã lệnh, bạn nên quay trở lại
nơi bắt đầu của đoạn mã và khai báo. Không nên khai báo biến ở giữa đoạn mã.

Bạn có thể khai báo biến toàn cục hoặc biến cục bộ. Cho đến bây giờ, tất cả đoạn mã
chúng ta đã viết đều là ở trong thủ tục xử lý sự kiện của điều khiển – ví dụ như thủ tục xử lý
sự kiện nhấn nút. Biến mà chúng ta khai báo trong thủ tục xử lý sự kiện là biến cục bộ. Biến
cục bộ chỉ có thể được đọc hoặc thay đổi bởi mã lệnh của thủ tục xử lý sự kiện đã khai báo
nó. Chúng không thể truy cập được bởi các thủ tục xử lý kiện sự khác hoặc đoạn mã khác
trong Form. Giá trị của biến cục bộ chỉ được lưu giữ trong khoảng thời gian mà đoạn mã của

46
thủ tục xử lý sự kiện hoạt động. Sau khi thủ tục xử lý sự kiện kết thúc, giá trị của biến cục bộ
mất. Một ví dụ của biến cục bộ là một biến được khai báo trong sự kiện nhấn nút lệnh.

Để khai báo biến cục bộ, đặt lệnh Dim vào trong mã xử lý sự kiện. Biến sử dụng trong mã
được khai báo trước, trước khi bạn viết bất cứ mã lệnh xử lý sự kiện nào khác. Đây là một ví
dụ:

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As


System.EventArgs) Handles Button1.Click
Dim TenToi As String
TenToi = "Hoa"
TextBox1.Text = TenToi Gợi ý
End Sub TenToi được khai báo bên trong một
thủ tục (chương trình con). Ngay khi
đoạn lệnh End Sub được thực hiện
TenToi bị xóa bỏ

Biến toàn cục có thể được đọc hoặc gán giá trị bởi tất cả mã lệnh khác trong form. Biến
toàn cục có thể được truy cập bởi tất cả các thủ tục xử lý sự kiện và tất cả các mã lệnh trong
form. Chừng nào form còn được mở thì giá trị của biến toàn cục còn được lưu giữ. Một ví dụ
của biến toàn cục là bộ đếm dùng để đếm số lần mà nút lệnh trên form được nhấn.

Muốn khai báo biến toàn cục, để có thể được sử dụng bởi tất cả các mã lệnh trong form,
bạn phải đặt lệnh Dim trong thân của Form. Vị trí tốt nhất để khai báo biến toàn cục trong mã
lệnh của form là vị trí ngay sau dòng:

Windows Form Designer generated code

Dòng lệnh này được chứa trong một hộp hình chữ nhật và có một dấu cộng ở bên trái hộp
này. Khai báo biến ngay sau dòng lệnh này. Xem ví dụ này:

Windows Form Designer generated code


Dim TongSoLanNhanNut As Single

Biến TongSoLanNhanNut là biến toàn cục. TongSoLanNhanNut có thể được đọc hoặc
gán bằng mã lệnh khác trong Form chẳng hạn như mã lệnh ở trong các thủ tục xử lý sự kiện.

Nếu bạn khai báo tất cả các biến ở đây trong thân của Form thì tất cả chúng sẽ là biến toàn
cục. Giá trị của chúng có thể được đọc hoặc gán bởi tất cả các mã lệnh trong form và các thủ
tục xử lý sự kiện.

8. Khởi tạo biến

Một khi biến đã được khai báo, bạn có thể sử dụng nó trong mã lệnh. Một trong những
việc đầu tiên phải làm là gán giá trị khởi đầu cho biến. Bạn có thể gán cho biến bất cứ giá trị
nào miễn là nó có kiểu được chấp nhận. Bạn chỉ có thể gán cho biến giá trị bởi một giá trị có

47
cùng kiều. Khi bạn gán cho biến một giá trị là bạn đang sử dụng lệnh gán. Hãy xem ví dụ
sau:

Dim TenToi As String


TenToi = "Nga"

Dim CanNang As Integer


CanNang = 49

Dim KhoangCachDiXe As Single


KhoangCachDiXe = 12.8

Biến TenToi được khai báo là kiểu chuỗi và được gán chuỗi "Nga". Biến CanNang được
khai báo là kiểu số nguyên và được gán giá trị 49, một số nguyên. Biến KhoangCachDiXe
được khai báo là kiểu số thập phân và được gán giá trị 12.8, một số thập phân.

Đây có một cách làm tắt bạn có thể sử dụng để khai báo biến và gán giá trị khởi tạo cho
nó bằng cách sử dụng một dòng lệnh đơn. Điều này đảm bảo rằng biến bắt đầu với một giá trị
đúng. Sử dụng một biến chưa được khởi tạo có thể làm cho chương trình của bạn có lỗi.

Dim Tuoi As Integer = 100

9. Sử dụng biến
Bây giờ bạn đã khai báo biến và khởi tạo giá trị cho nó, bạn có thể sử dụng nó ở trong mã
lệnh. Bạn có thể sử dụng biến ở bất cứ chỗ nào mà bạn cần sử dụng giá trị của nó.

Dim TenToi As String


TenToi = "Trần Lâm"
MessageBox.Show(TenToi)

Chữ Trần Lâm sẽ được hiển thị trong hộp thông báo.

Dim TenToi As String


TenToi = "Lê, Thương và Hùng"
TextBox1.Text = TenToi

Bạn có thể thay giá trị của biến bằng cách sử dụng câu lệnh gán bổ sung. Cái gì sẽ được
hiển thị trong hộp văn bản TextBox1 sau đây?

Dim TenToi As String


TenToi = "Lan"
TenToi = "Huệ"
TenToi = "Hồng"
TextBox1.Text = TenToi

48
Tên ai sẽ được hiển thị trong hộp văn bản TextBox1? Nếu bạn nói là, "Hồng", bạn đã
đúng! Biến TenToi được gán giá trị Lan, tiếp đó là Huệ và cuối cùng là Hồng. Vì cuối cùng
TenToi được gán giá trị Hồng nên Hồng là giá trị được hiển thị trong hộp văn bản TextBox1.

Thậm chí bạn có thể gán giá trị của một biến cho một biến khác.

Dim TenToi As String


Dim TenBan As String
TenToi = "Ngọc Hà"
TenBan = TenToi
MessageBox.Show(TenBan)

Ngọc Hà được hiển thị trong hộp thông báo.

Đây là một ví dụ có lỗi bởi vì chúng ta đã gán một biến có kiểu khác với biến được gán, vì
thế khi biên dịch mã lệnh này trình biên dịch sẽ báo lỗi.

Dim TenToi As String


Dim GiaDVD As Single
TenToi = "Ngọc"
GiaDVD = TenToi

Nhớ rằng, biến được khai báo có kiểu là một kiểu cụ thể. Biến chỉ có thể được gán bằng một
giá trị có cùng kiểu với nó.

10. Tăng tốc sử dụng biến


Tạo ứng dụng Window mới trong Visual Studio.NET tên là XACTLY. Mở cửa sổ hộp
công cụ, thêm một nút lệnh và hai hộp văn bản vào Form1. Xoá thuộc tính Text của
TextBox1 và TextBox2. Đặt thuộc tính Text của Button1 là "Hiển thị XY". Đặt thuộc tính
ReadOnly của TextBox1 và TextBox2 là True. Nháy đúp vào nút Button1 để soạn thảo mã
lệnh cho sự kiện nhấn nút. Nhập vào các dòng mã lệnh sau:

Dim XName As String


Dim YName As String Gợi ý cho giáo viên
XName = "X là tên tôi" Bài này sẽ dễ hiểu hơn nếu bạn làm theo
YName = "Y là tên tôi" hướng dẫn, gõ mã đúng theo mẫu vào
TextBox1.Text = XName chương trình Visual Studio của bạn.
TextBox2.Text = YName

Dịch và chạy chương trình. Nhấn nút "Hiển thị XY". Mã lệnh của bạn khai báo hai biến
kiểu chuỗi, XName và YName. Biến XName và YName được gán giá trị là chuỗi văn bản
(được bao trong cặp dấu nháy kép). Thuộc tính Text của TextBox1 được gán bởi giá trị của
biến XName. Thuộc tính Text của TextBox2 được gán bởi giá trị của biến YName. Thử thay
đổi giá trị của XName và YName trong mã lệnh của bạn và chạy lại chương trình.

Bây giờ hãy sửa chương trình này. Thêm hộp văn bản thứ ba. Xoá giá trị của thuộc tính
Text của TextBox3. Đặt thuộc tính ReadOnly của Textbox3 là False.

49
Nhấp đúp vào nút Button1 để soạn thảo mã lệnh cho sự kiện nhấn nút. Sửa đổi mã lệnh
như dưới đây:

Dim XName As String


Dim YName As String
Dim ZName As String
ZName = TextBox3.Text
XName = ZName
YName = XName
TextBox1.Text = XName
TextBox2.Text = YName

Dịch và chạy chương trình. Nhập văn bản vào hộp văn bản TextBox3. Nhấn nút "Hiển thị
XY". Điều gì xảy ra? Mã lệnh của bạn khai báo ba biến kiểu chuỗi. Biến ZName được gán
giá trị là giá trị của thuộc tính Text của TextBox3. Biến XName được gán giá trị của ZName
(biến trước đó vừa được gán giá trị là giá trị của thuộc tính Text của TextBox3). Biến Yname
được gán giá trị của XName. Mã lệnh tiếp theo Gán giá trị của XName cho thuộc tính Text
của TextBox1 và giá trị của YName cho thuộc tính Text của TextBox2. Đoạn mã này chỉ ra
cách gán giá trị được lưu trong biến cho một biến khác.

Tạo một ứng dụng Window mới tên là TongSoLanNhanNut. Thêm ba nút lệnh vào
Form1. Trong cửa sổ mã lệnh hãy tìm dòng:

Windows Form Designer generated code

Ngay sau dòng mã lệnh này, thêm mã lệnh sau:

Dim TongSoLanNhanNut As Integer

Nhấp đúp vào Button1 và thêm mã lệnh sau vào thủ tục xử lý sự kiện nhấn Nút Lệnh.

TongSoLanNhanNut = TongSoLanNhanNut + 1
MessageBox.Show(TongSoLanNhanNut)

Thêm đoạn mã tương tự vào các thủ tục xử lý sự kiện của Button2 và Button3.

Dịch và chạy chương trình. Nhấn vào tất cả các nút theo thứ tự bất kỳ. Cứ mỗi lần nhấn
nút thì hộp thông báo lại hiển thị tổng số lần đã nhấn nút. Mã lệnh này làm việc bởi vì chúng
ta khai báo một biến toàn cục TongSoLanNhanNut trong mã lệnh của Form. Biến toàn cục để
lưu trữ tổng số lần đã nhấn phím. Mỗi khi người dùng nhấn nút thì giá trị của biến
TongSoLanNhanNut được tăng lên 1. Giá trị của biến toàn cục chỉ bị mất đi khi Form chứa
nó bị đóng.

50
11.Các kiểu biến khác
Trong Visual Basic.NET bạn có thể khai báo thêm rất nhiều kiểu biến khác ngoài các kiểu
cơ bản (chuỗi, số nguyên, Logic, số thập phân, v.v.). Những kiểu khác này được xây dựng
sẵn trong NET Framework và có thể được sử dụng bởi tất cả các ngôn ngữ NET. Rất nhiều
kiểu là thuộc tính của "System classes" (“lớp hệ thống”). Lớp hệ thống chứa các mã lệnh
cung cấp các chức năng cơ bản cho ngôn ngữ .NET. Một trong những phần quan trọng nhất
trong việc học lập trình ngôn ngữ .NET là hiểu lớp hệ thống và các chức năng của nó.
Từng bước bạn sẽ tiếp cận vấn đề này.

Mở ứng dụng ShowXY và thêm nút lệnh thứ hai vào Form1. Đổi thuộc tính Text của
Button2 thành "Màu sắc". Nhấp đúp nút Button2 để soạn thảo mã lệnh cho thủ tục xử lý sự
kiện nhấn nút lệnh.

Thêm dòng mã lệnh sau:

Dim MauNen As System.Drawing.Color


MauNen = System.Drawing.Color.Blue
Form1.ActiveForm.BackColor = Maunen

Dịch và chạy chương trình. Nhấn nút Button2.

Trong mã lệnh khai báo biến MauNen, ta thấy biến này có kiểu System.Drawing.Color.
Biến MauNen được gán giá trị là System.Drawing.Color.Blue, một giá trị của
System.Drawing.Color. Cuối cùng, thuộc tính màu nền của Form1 được gán giá trị của biến
MauNen. Để ý rằng thuộc tính màu nền phải được gán một giá trị có kiểu
System.Drawing.Color.

Bạn có thể tự mình khám phá lớp hệ thống (System classes). Cách tốt nhất là gõ System.
(dấu chấm) trong cửa sổ mã lệnh. IntelliSense sẽ hiển thị danh sách tất cả các thuộc tính và
phương thức sẵn có của lớp hệ thống. Chọn một thuộc tính hoặc một phương thức khác và gõ
dấu chấm khác để xem thuộc tính hoặc phương thức này có chứa các thuộc tính và phương
thức của nó không.

51
12.Bài kiểm tra

52
BÀI 7. TOÁN TỬ

1. Toán tử
Một vài ví dụ về toán tử là cộng, trừ, nhân, chia. Bạn đã sử dụng toán tử kể từ khi ở cấp 1.
Chỉ có điều là bạn không gọi chúng như thế. Trong lập trình có các toán tử khác để thực hiện
các tính toán phức tạp và ghép các chuỗi ký tự vào nhau.

Toán tử thường tác động lên hai giá trị, mặc dầu có một vài toán tử chỉ tác động lên một
giá trị. Giá trị được gọi là toán hạng. Đây là cú pháp cơ bản của việc sử dụng toán tử:

Toán_hạng_1 Toán_tử Toán_hạng_2

Ví dụ: 3 + 4

Trong biểu thức 3 + 4 có hai toán hạng (3 và 4) nối với nhau bởi toán tử (+). Toán tử thực
hiện (trong trường hợp này là cộng) trên hai toán hạng (3 và 4).

Bạn có thể xây dựng các biểu thức phức tạp bằng cách sử dụng toán tử. Hãy bắt đầu xem
các toán tử toán học – cộng, trừ, nhân và chia. Sau đó bạn tìm hiểu cách ghép nối các chuỗi
lại với nhau và chúng ta sẽ xem xét một toán tử đặc biệt đó là toán tử NOT.

2. Toán tử số học
Chương trình máy tính giải các bài toán rất tốt. Chúng không tạo thêm lỗi và không mệt
mỏi khi phải làm đi làm lại một bài toán nhiều lần. Nhưng nó không thể tự giải bài toán được
mà với tư cách là lập trình viên thì bạn phải chỉ ra cho chương trình cách giải bài toán.

Đó là lý do tại sao việc hiểu cách sử dụng toán tử toán học trong mã lệnh lại quan trọng.
Đó là cách bạn nói với chương trình của bạn bài toán mà bạn muốn nó giải. Vì máy tính giải
toán rất tốt nên tất cả các ngôn ngữ lập trình đều có các toán tử toán học chuẩn. Kí hiệu dùng
để biểu diễn toán tử trong mã lệnh hầu như giống nhau đối với tất cả các ngôn ngữ lập trình.

Đây là danh sách các toán tử toán học thông dụng nhất và các kí hiệu được sử dụng trong
cuộc sống hàng ngày đối chiếu với kí hiệu sử dụng trong mã lệnh. Để ý rằng chỉ có duy nhất
một sự khác nhau đó là phép nhân. Trong mã lệnh chúng ta dùng * thay vì x để trình bày toán
tử nhân.

Toán tử Kí hiệu trong đời sống Kí hiệu trong mã lệnh


Cộng + +
Trừ - -
Nhân X *
Chia / /

53
Hãy xem các ví dụ toán tử toán học trong Visual Basic. NET.

3+4

18 - 2

33 * 3

66 / 6

3. Toán tử chuỗi
Đôi khi chương trình của bạn chỉ cần làm việc
với các chuỗi văn bản. Trong Visual Basic.NET
và các ngôn ngữ lập trình khác bạn có thể “Cộng”
văn bản. Thực sự, nó không giống như phép cộng
thông thường của các số. “Cộng” văn bản được
gọi là "ghép chuỗi", nó chỉ là một cái tên để chỉ
việc nối hai chuỗi văn bản lại với nhau. Trong
Visual Basic.NET toán tử ghép chuỗi có kí hiệu là
&. Bạn sử dụng nó giống như việc sử dụng toán tử
cộng nhưng với toán hạng là các chuỗi văn bản.

Ví dụ:

"Lan" & "Hương”


"1" & "2"

4. Toán tử Not
Toán tử Not là một toán tử đặc biệt, nó chỉ thực hiện trên một toán hạng. Ngoài ra, nó
phải định giá một giá trị là đúng hoặc sai (True hoặc False). Nó thay đổi giá trị đúng thành
sai và ngược lại. Xem các ví dụ sau.

Not (True)
Not (Not (True))

5. Trong các đoạn lệnh gán


Hầu hết thời gian bạn sử dụng câu lệnh gán. Nhớ là, một câu lệnh gán trông như một biểu
thức cùng với một dấu bằng. Các toán tử và toán hạng được đặt ở bên phải dấu bằng. Giá trị
của biểu thức ở bên phải dấu bằng được tính trước, sau đó giá trị này được gán cho biểu thức
ở phía bên trái dấu bằng. Giá trị của biểu thức ở bên phải của dấu bằng phải cùng một kiểu
như biểu thức ở bên trái nếu không sẽ không biên dịch được - tức là biểu thức ở bên phải dấu

54
và bên trái dấu bằng phải cùng kiểu. Đây là các ví dụ sử dụng toán tử số học và toán tử ghép
chuỗi trong câu lệnh gán.

Dim FormWidth as Integer


FormWidth = 200 + 300

Dim FormHeight as Integer


FormHeight = 1000 / 2

Dim Ten as String


Ten = "Nguyễn" & "Tâm"

6. Hoạt động của Toán tử


Trên thực tế, bạn sẽ thường xuyên cần sử dụng các công thức hoặc thực hiện các tính
toán, gồm rất nhiều toán tử và toán hạng. Tuy vậy, đối với hầu hết các ngôn ngữ lập trình có
thể thêm rất nhiều toán tử và toán hạng khi cần để ghép nối chuỗi văn bản, chuyển công thức
thành mã lệnh.Thêm nữa bạn có thể sử dụng biến như là toán hạng. Toán tử cũng làm việc
được với biến – miễn là biến có kiểu đúng như toán hạng yêu cầu. Thậm chí bạn có thể gán
giá trị của biểu thức có chứa biến cho chính biến đó. Hãy xem một vài ví dụ phức tạp một
chút. Ví dụ thứ nhất tính chu vi lốp của xe Ô tô.

Dim ChuviLop As Single


Dim DuongkinhLop As Integer
Dim SoPi As Single
SoPi = 3.14159
DuongkinhLop = 18
ChuviLop = DuongkinhLop *
SoPi

Ví dụ này tính chi phí xăng trung bình


trong tháng ba và tháng tư. Để ý rằng tôi sử
dụng dấu ngoặc đơn để đảm bảo rằng các
chi phí được cộng lại, và số ga lông xăng
được cộng lại trước khi đem chia cho nhau.

Dim ChiphiThang3 As Single = 123.66


Dim ChiphiThang4 As Single = 231.45
Dim SoGalongThang3 As Single =
87.4
Dim SoGalongThang4 As Single =
157.2
Dim ChiphiTrenGalong As Single
ChiphiTrenGalong = (ChiphiThang3
+ ChiphiThang4) /
(SoGalongThang3+ SoGalongThang4)

55
7. Toán tử so sánh
Hãy xem ví dụ sau:

Dim SoDamDaDi as Integer


SoDamDaDi = 100
SoDamDaDi = SoDamDaDi + 200
SoDamDaDi = SoDamDaDi + 400
MessageBox.Show (SoDamDaDi)

Hộp thông báo sẽ hiển thị giá trị là 700, đó là giá trị của SoDamDaDi khi hàm
MessageBox được gọi. Đây là cách nó làm việc. Hai dòng lệnh đầu khai báo biến
SoDamDaDi và khởi tạo giá trị cho nó là 100. Dòng lệnh thứ ba đem giá trị hiện tại của
SoDamDaDi (100) cộng với 200 thành 300 và đem giá trị 300 này gán trở lại vào biến. Nhớ
rằng, bên phải của dấu bằng luôn luôn được định giá trước. Sau đó bên trái của biểu thức
(SoDamDaDi) được gán giá trị của biểu thức ở bên phải dấu bằng (300). Dòng mã lệnh thứ
tư đem giá trị hiện tại của biến SoDamDaDi (bây giờ 300) cộng với 400 thành 700. Tiếp đó
lại gán giá trị 700 này cho biến SoDamDaDi, và đây cũng là kết quả được hiển thị trong hộp
thông báo. Phần bên trái của dấu bằng không quan tâm đến kết quả của phần bên phải được
tính như thế nào, miễn là nó có cùng kiểu là được. Đến lúc xem xét phần bên trái của dấu
bằng, biến SoDamDaDi ở phần bên phải đã là biến khác.

Việc gán cho một biến một biểu thức chứa chính biến đó, là cách mã hoá phổ biến được
hỗ trợ bởi tất cả các ngôn ngữ NET. Nó tránh được rắc rối trong việc phải tạo một biến tạm
thời để lưu giá trị trung gian. Như ví dụ tôi đã chỉ ra, kỹ thuật này là tốt nhất trong việc đếm
và cộng một dãy giá trị. Bạn có biết rằng dòng mã lệnh phổ biến nhất có thể là biến=biến +1,
nó được dùng để đếm cái gì đó không? Thông thường nó được dùng để đếm số lần vòng lặp
được thực hiện.

8. Hoạt động của toán tử Not và toán tử ghép chuỗi


Hình như liên quan đến toán học hơi nhiều. Bây giờ tôi sẽ chỉ cho bạn một ví dụ về hoạt
động của toán tử ghép chuỗi và một trong các toán tử Not. Đây là một ví dụ ghép các biến
chuỗi và hiển thị kết quả trong hộp thông báo.

Dim HoDem As String


Dim Ten As String
HoDem = "Trần"
Ten = "Lâm"
TextBox1.Text = HoDem & " " & Ten

Phải thêm một khoảng trắng giữa HoDem và Ten, vì toán tử ghép chuỗi không tự động
thêm khoảng trắng vào.

56
Ví dụ cuối cùng chỉ cho bạn cách sử dụng toán tử Not để làm ẩn một hộp văn bản bất cứ
khi nào một hộp khác được hiển thị. Nhớ rằng, toán tử Not được sử dụng với kiểu Boolean
(lô gíc).

TextBox1.Visible = True
TextBox2.Visible = Not (TextBox1.Visible)

9. Tìm lỗi
Khi dự án của bạn không dịch được, tức là chương trình còn có lỗi, thế thì lúc này nhiệm
vụ của bạn là phải tìm ra những lỗi và sửa chữa những lỗi đó. Sửa chữa các lỗi trong mã lệnh
được gọi là gỡ lỗi. Gỡ lỗi là bước cần thiết để tạo một chương trình không có lỗi, chạy được
và đưa ra kết quả đúng. Trước tiên, bạn sẽ học cách gỡ lỗi trong Visual Studio.

1. Tạo một ứng dụng Window gọi là DebugView. Thêm một nút lệnh và hai hộp văn bản
vào Form1. Nhấp đúp vào nút lệnh Button1 và thêm dòng mã lệnh sau.

MyName = "Bill"
TextBox1.Text = MyName

2. Để ý rằng thậm chí trước khi bạn dịch,


Visual Studio.NET đặt một đường răng cưa để
gạch chân MyName trong dòng mã lệnh thứ
nhất và thứ hai, ý nghĩa điều này là gì? Visual
Studio.NET có cơ chế thông minh để nhận ra
rằng bạn chưa khai báo biến MyName. Nó
cảnh báo lỗi cho bạn trước khi bạn dịch.

3. Dịch và chạy chương trình. Cửa sổ Output


Window chỉ ra rằng việc dịch thất bại. Cửa sổ
Task List chỉ cho bạn biết tại sao việc dịch thất
bại. Bạn thấy hai dòng trong danh sách tác vụ
thông báo cho bạn rằng tên 'MyName' chưa
được khai báo.

4. Nhấp đúp vào "Name 'MyName' is not


declared” trong cửa sổ tác vụ (Task List). Bạn
di chuyển đến dòng mã có lỗi.

5. Để ý biến MyName được làm sáng lên –


đây là lỗi cần được sửa chữa. Thêm dòng mã
lệnh sau vào thủ tục xử lý sự kiện nhấn nút
Button1 để sửa lỗi.

Dim MyName As String

57
Đường răng cưa màu xanh da trời biến mất.

6. Dịch và chạy chương trình. Dịch không còn lỗi. Bạn đã thành công trong việc gỡ lỗi
chương trình.

10.Chạy từng dòng mã lệnh


Đôi khi các lỗi trong mã lệnh không phải là lỗi mà Visual Studio.NET có thể phát hiện và
thông báo cho bạn. Chương trình của bạn được dịch thành công, nhưng kết quả hoặc đầu ra
không chính xác như mong đợi. Trong trường hợp này, lỗi có thể là lỗi lô gíc, hoặc lỗi luồng
chương trình chứ không phải là lỗi cú pháp. Đây là những lỗi trong phần thiết kế chương
trình, Visual Studio.NET không xem chúng là lỗi vì cú pháp hoàn toàn đúng.

Trong trường hợp như thế này, bạn nên sử dụng kỹ thuật “Dò vết theo mã lệnh” để xem
cách thực hiện của từng dòng lệnh và luồng thực hiện của chương trình nhằm tìm xem lỗi
xảy ra ở đâu. Thường thì, bạn đặt một "break point" (điểm dừng) trong mã lệnh, sau đó chạy
từng mã lệnh để xem chương trình thực hiện từng dòng mã lệnh như thế nào. Điểm dừng
hoạt động như là dấu hiệu dừng–sự thực hiện dừng tại dòng mã lệnh mà bạn đánh dấu bằng
điểm dừng. Sau đó nhấn phím F11 để thực hiện lần lượt từng
dòng mã lệnh.

1. Tìm dòng lệnh sau trong thủ tục xử lý sự kiện nhấn nút của
Button1:

MyName = "Bill"

Đặt con trỏ vào dòng lệnh. Nhấn chuột phải và chọn "Insert
Breakpoint" từ thực đơn.

2. Để ý rằng dòng mã lệnh được


làm sáng lên bằng màu nâu và hình
tròn màu nâu xuất hiện bên mép
trái của dòng mã lệnh này. Dịch và
chạy chương trình. Khi Form xuất
hiện thì nhấn vào nút lệnh.

3. Mã lệnh thực hiện và chạy đến


dòng lệnh bạn muốn (MyName =
"Bill"). Hiện tại dòng mã lệnh
này vẫn chưa được thực hiện.
Dòng mã lệnh này được làm sáng
lên bằng màu vàng và bây giờ
hình tròn màu nâu bên cạnh nó
có một mũi tên màu vàng ở bên
trong nó.

58
4. Trong cửa sổ mã lệnh di chuyển con trỏ trên biến MyName. Một thông báo xuất hiện cho
bạn biết giá trị của biến MyName.

Hiện tại MyName = Nothing (tức là chưa được gán giá trị) bởi vì biến đã được khai báo
nhưng chưa được gán giá trị.

5. Trong cửa sổ mã lệnh di


chuyển con trỏ trên thuộc tính
Text của TextBox1. Một thông
báo xuất hiện cho bạn biết giá
trị của thuộc tính Text. Hiện tại
Text = TextBox1. Nhấn phím
F11. Bước này nhảy vào mã
lệnh thực hiện dòng lệnh hiện tại (MyName = "Bill") và làm sáng dòng mã lệnh kế tiếp bằng
màu vàng.

6. Trong cửa sổ mã lệnh di


chuyển con trỏ trên biến
MyName. Thông báo cho biết
MyName = Bill bởi vì chúng ta
vừa mới gán giá trị cho biến
này.

7. Trong cửa sổ mã lệnh di


chuyển con trỏ trên thuộc tính
Text của TextBox1. Thông báo
hiển thị Text = TextBox1. Giá
trị này không thay đổi.

Nhấn tiếp phím F11. Bước này


sẽ nhảy vào mã lệnh đang thực
hiện dòng lệnh hiện tại (TextBox1.Text = MyName) và làm sáng dòng lệnh tiếp theo bằng
màu vàng.

8. Trong cửa sổ mã lệnh di chuyển


con trỏ trên biến MyName. Thông
báo hiển thị MyName = Bill bởi vì
giá trị của biến này vẫn chưa thay
đổi.

9. Trong cửa sổ mã lệnh di chuyển


con trỏ trên thuộc tính Text của
TextBox1. Thông báo hiển thị Text
= "Bill" bởi vì chúng ta vừa mới
gán giá trị của biến MyName cho
thuộc tính này.

Nhấn tiếp phím F11. Form xuất hiện trở lại vì chương trình đã kết thúc việc thực hiện mã
lệnh trong sự kiện nhấn nút. Nhấn vào nút X trên góc trên bên phải của form để đóng form.

59
60
10. Trong cửa sổ mã lệnh trỏ vào nơi bắt đầu của dòng mã lệnh
được đánh dấu bằng điểm dừng. Nhấn tiếp chuột phải và chọn
“Remove Breakpoint” (gỡ bỏ điểm dừng) từ thực đơn.

Việc chạy từng dòng mã lệnh một, từ dòng này đến dòng
khác rất là hữu ích, nó giúp bạn có thể lần theo vết chương
trình đã chạy khi nó thực hiện mã lệnh. Đôi khi bạn có thể phát
hiện ra rằng bạn đã ra lệnh cho chương trình thực hiện mã lệnh
không đúng thứ tự hoặc sử dụng sai biến ở trong câu lệnh gán.
Việc chạy từng dòng mã lệnh giúp cho bạn tìm ra nơi chương
trình chạy không đúng. Trong chế độ này, bạn có thể giám sát
giá trị của thuộc tính và biến bằng cách di chuyển con trỏ trên
chúng trong cửa sổ mã lệnh. Các giá trị của biến và thuộc tính sẽ được cập nhật sau khi mỗi
dòng lệnh được thực hiện.

Những kỹ thuật gỡ lỗi này càng trở nên quan trọng khi mã lệnh của bạn càng phức tạp.
Mã lệnh phức tạp thì rất khó gỡ lỗi. Bạn sẽ học cách điều khiển thứ tự thực hiện mã lệnh
bằng cách sử dụng lệnh “điều khiển” và lệnh “lặp”. Các công cụ gỡ lỗi cực kì có giá trị trong
việc theo dõi chương trình thực hiện những lệnh kiểu này.

11.Bài kiểm tra

61
BÀI 8. CÂU LỆNH IF ĐƠN GIẢN

1. Ra Quyết định
Khi chúng ta ra một quyết định, chúng ta thường có rất nhiều lựa chọn. Giống như mua
loại kem có mùi vị gì, nghe nhạc gì, chơi với ai. Máy tính không quá may mắn như thế chúng
phải ra quyết định dựa trên cái gì đó là đúng hoặc sai. Đúng vậy, câu lệnh này đúng hoặc sai?

Ví dụ:

Bạn có muốn uống gì không? Có.


Bạn có muốn uống cà phê không? Không.
Bạn có muốn uống trà không? Không.
Bạn có muốn uống sô đa không? Có.
Bạn có muốn uống Cô la không? Không.
Bạn có muốn uống đồ uống không cồn không? Có!

Cách đặt câu hỏi và trả lời như thế này cũng giống như chương trình máy tính ra quyết
định –có hoặc không. Loại “suy nghĩ” hoặc lô gíc này được gọi là Boolean, lô gíc (đúng/sai).

2. Lô gíc Boolean
Chương trình máy tính rất giỏi trong việc giải các bài toán toán học. Chúng cũng giỏi
trong việc giải các bài toán lô gíc Boolean. Trong bài toán lô gíc Boolean, câu trả lời luôn
luôn hoặc là True (đúng) hoặc là False (sai). Dưới đây là một vài ví dụ lô gíc Boolean.

4=4
4=4 đúng không? có, điều này đúng.
3=1+3
3=1+3 đúng không? không, điều này sai.
3=(6+12)/(1+5)
3=(6+12)/(1+5) đúng không? có, điều này đúng.

Bạn có thể thấy rằng trong mỗi vấn đề lô gíc ở trên câu trả lời luôn luôn hoặc là đúng
hoặc là sai. Câu trả lời không phải là số, màu sắc, hoặc các từ. Đây là cách chương trình máy
tính ra quyết định. Nếu câu trả lời là True (đúng), chương trình thực hiện cái gì đó. Nếu câu
trả lời là False (sai) chương trình máy tính không thực hiện gì cả.

3. Toán tử Lô gíc
Như toán học phổ thông, Lô gíc cũng có các toán tử của nó, nhưng chúng không làm việc
trên các số, chúng chỉ làm việc trên các toán hạng lô gíc – Đúng và Sai. Chúng cho phép bạn
“thêm” các lệnh đúng và sai cùng với nhau theo cách riêng. Chúng có thể được sử dụng để
nối các lệnh lô gíc để tạo ra các biểu thức lô gíc phức tạp hơn.

Có ba toán tử lô gíc: AND, OR, và NOT. Toán tử AND và OR là toán tử hai ngôi (tác
động lên hai toán hạng). Toán tử NOT là toán tử một ngôi (tác động lên một toán hạng). Cả

62
ba toán tử đều cho kết quả là giá trị lô gíc. Mỗi toán tử có “quy tắc” riêng của nó. Hãy xem
một vài ví dụ toán tử lô gic.

3=1+2 AND 2=1+1 Biểu thức này đúng

Ở đây chúng ta có hai biểu thức lô gíc riêng biệt nối với nhau bằng toán tử AND. Đầu tiên
chúng ta định giá trị cho biểu thức 3=1+2, biểu thức này đúng. Tiếp đó chúng ta định giá trị
cho 2=1+1, biểu thức này cũng đúng. Sau đó chúng ta định giá trị cho biểu thức True AND
True (đúng AND đúng). Cả hai vế của toán tử AND là đúng nên câu trả lời cuối cùng là
đúng.

3=1+2 AND 5=2+2 Biểu thức này sai.

Chúng ta cũng có hai biểu thức nối với nhau bằng toán tử AND (Và). Đầu tiên chúng ta
định giá trị của biểu thức ở vế bên trái 3=1+2, biểu thức này đúng. Tiếp theo chúng ta định
giá trị của biểu thức ở vế bên phải 5=2+2, biểu thức này sai. Sau cùng chúng ta định giá trị
biểu thức True AND False (đúng AND sai), biểu thức này sai bởi vì nếu có ít nhất một vế
của toán tử AND là sai thì biểu thức AND sai.

Một ví dụ khác:

3=1+2 OR 5=2+2 Biểu thức này đúng.

Đầu tiên, chúng ta định giá trị 3=1+2, biểu thức này đúng. Tiếp đến định giá trị 5=2+2,
biểu thức này sai. Và bài toán trở thành True OR False (đúng OR sai), biểu thức này đúng.
Bởi vì nếu có ít nhất một biểu thức đúng thì biểu thức OR đúng.

Chúng ta sẽ luyện, chúng ta sẽ quen sau một thời gian sử dụng các toán tử logíc Chúng ta
có một bảng đơn giản liệt kê các khả năng xảy ra của toán tử AND. Bạn không cần ghi nhớ,
chỉ cần quay lại xem khi cần.

Vế trái Vế phải Vế trái AND Vế phải


(kết quả)
True True True
True False False
False True False
False False False

Các khả năng xảy ra của toán tử OR (hoặc).

Vế trái Vế phải Vế trái OR Vế phải (kết quả)


True True True
True False True
False True True
False False False

Toán tử Not không nối biểu thức lại với nhau. Nó chỉ đơn giản chuyển False(sai) thành True
(đúng) và ngược lại..

63
Vế phải NOT Vế phải (kết quả)
True False
False True

Dưới đây là một vài ví dụ của toán tử Not.

Not(3=1+2) cho kết quả là False.


3=1+2 là True. Not True là False.

Not(5=2+2) cho kết quả là True.


5=2+2 là False. Not False là True.

4. Toán tử so sánh
Khi mã lệnh được thực hiện, chương trình giải bài toán. Câu trả lời là đúng hoặc sai.
Chương trình ra quyết định phụ thuộc vào câu trả lời của bài toán là đúng hay sai.

Dấu bằng không những được sử dụng làm toán tử gán mà nó còn được sử dụng làm toán
tử so sánh. Trong ví dụ trên, dấu bằng là hỏi câu hỏi, "Vế trái có bằng vế phải không? Đúng
hoặc sai?" Có các toán tử so sánh khác dùng để so sánh vế trái có nhỏ hơn hoặc vế trái có lớn
hơn vế phải không. Trong từng trường hợp, câu trả lời sẽ là đúng hoặc sai.

3<4 Câu hỏi là: 3 có nhỏ hơn 4 không? Có, điều này đúng.

2>5 Câu hỏi là: 2 có lớn hơn 5 không? Không, điều này sai.

Bảng các toán tử so sánh thông dụng:

Toán tử so sánh Ý nghĩa Câu hỏi


= Bằng Biểu thức bên phải có bằng biểu thức bên
trái không?
> Lớn hơn Biểu thức bên trái có lớn hơn biểu thức
bên phải không?
< Nhỏ hơn Biểu thức bên trái có nhỏ hơn biểu thức
bên phải không?
>= Lớn hơn hoặc bằng Biểu thức bên trái có lớn hơn hoặc bằng
biểu thức bên phải không?
<= Nhỏ hơn hoặc bằng Biểu thức bên trái có nhỏ hơn hoặc bằng
biểu thức bên phải không?
<> Khác nhau Biểu thức bên trái có khác biểu thức bên
phải không?

64
Bạn có thể chưa quen với các toán tử >=, <= và<>. Chúng là hai toán tử gộp làm một.
Chúng chứa hai lệnh lô gíc được nối bởi toán tử một OR. Chỉ cần một lệnh lô gíc đúng thì
toàn bộ lệnh đúng. Ví dụ, >= nghĩa là: vế trái có lớn hơn vế phải không? OR vế trái có bằng
vế phải không? Hai câu hỏi riêng biệt được nối với nhau bởi toán tử OR. Toán tử <> nghĩa
là: vế trái có nhỏ hơn vế phải? OR vế trái có lớn hơn vế phải không? Thực ra toán tử <> hỏi:
hai vế không bằng nhau phải không?

Hãy xem một số ví dụ sau, sử dụng toán tử so sánh để xây dựng biểu thức lô gíc. Bạn có
thể phải xem lại các bảng.

3<=3
3<3 là sai. 3=3 là đúng. sai OR đúng =đúng
đúng, 3 nhỏ hơn hoặc bằng 3.

2>=3
2>3 là đúng. 2=3 là sai. sai OR sai = sai
sai, 2 không lớn hơn hoặc bằng 3.

3<>4
3<4 là đúng. 3>4 là sai. đúng OR sai = đúng
đúng, 3 không bằng 4.

3<>3
3<3 là sai. 3>3 là sai. sai OR sai = sai
sai, 3 không bằng 3. vì thế 3 bằng 3.

Các ví dụ đã đưa ra so sánh giữa các số. Bạn cũng


có thể sử dụng toán tử so sánh các chuỗi văn bản, các Gợi ý
giá trị lô gic khác. Xem các ví dụ sau: Việc so sánh giữa các chuỗi văn
bản thực hiện từ trái qua phải. Ký
"ABC" = "DEF" tự đầu tiên của toán tử 1 so sánh
"ABC" = "DEF"? Không, điều này sai. với ký tự đầu tiên của toán tử 2, sau
đó ký tự thứ 2 so sánh với ký tự thứ
True=True 2, .... Khi so sánh chữ hoa và chữ
True=True đúng không? Có, điều này đúng. thường là khác nhau.
True=False
True=False đúng không? Không, điều này sai.

5. Mã lệnh điều kiện


Bây giờ bạn để cho chương trình hỏi một câu hỏi đúng hoặc sai bằng cách sử dụng toán tử
so sánh và toán tử lô gíc. Nhưng chương trình máy tính làm gì với câu trả lời? Nó ra một
quyết định! Dựa trên câu trả lời cho câu hỏi lo gíc là đúng hoặc sai, nó có thể chọn thực hiện
việc này hoặc việc khác. Thực tế, nó không có sự lựa chọn. Nếu câu trả lời là đúng thì thực
hiện một việc gì đấy, nếu sai thì không làm gì cả.

65
Đây là một vài ví dụ trong cuộc sống thực tế:

Nếu rửa xe của mẹ trước khi bố về nhà thì bố sẽ cho mình $5.

Bố đã về nhà. Tôi đã rửa xe? đúng. Bố cho tôi $5.

Bố đã về nhà. Tôi đã rửa xe? sai. Bố không cho tôi $5.

Nếu Pauline nghĩ tôi tử tế thì cô ấy sẽ rủ tôi đi chơi.


Pauline nghĩ tôi là người tử tế? đúng. Cô rủ tôi đi chơi.
Pauline nghĩ tôi là người tử tế? sai. Cô không rủ tôi đi chơi.

Đây là một vài ví dụ về cách mà chương trình có thể ra quyết định:


Nếu Ô đánh dấu “ngoại cỡ” được đánh dấu thì hiển thị ảnh lớn.
Ô đánh dấu “ngoại cỡ” được đánh dấu? đúng. Hiển thị ảnh lớn.
Ô đánh dấu “ngoại cỡ” được đánh dấu? sai. Không hiển thị ảnh lớn.

Nếu biến SoGallon (tổng số galông) lớn hơn 0 thì tính chi phí xăng.
Biến SoGallon > 0? đúng. Tính chi phí xăng.
Biến SoGallon > 0? sai. Không tính chi phí xăng.

Bạn có thể thấy thực tế và chương trình của tôi có một vài thứ gì đó chung. Chúng sử
dụng toán tử lô gíc để hỏi một câu hỏi đúng hoặc sai. Câu hỏi đúng hoặc sai, sử dụng toán tử
so sánh như là bằng và nhỏ hơn hoặc bằng. Câu trả lời của câu hỏi thì hoặc là đúng hoặc là
sai. Nếu câu trả lời là đúng thì làm một điều gì đó. Nếu câu trả lời là sai thì không có gì xảy
ra.

6. Lệnh If...Then
Bạn có để ý rằng có ví dụ đã sử dụng từ "If" và "Then"? Nếu một điều kiện nào đó là
đúng thì làm cái gì đó. Nếu điều kiện sai thì không có gì xảy ra cả. Khi bạn muốn chương
trình ra một quyết định, bạn viết một lệnh "If...Then". Cú pháp của lệnh “If…Then” trong
Visual Basic.NET như sau:

If điều kiện Then


Lệnh
End If

Ví dụ trong Visual Basic.NET:

If Tuoi = 3 Then
MessageBox.Show("Tôi 3 tuổi.")
End If

Chú ý từ "If". Nó là một từ khoá của Visual Basic.NET nên nó có màu xanh da trời. Điều
kiện ở ngay sau từ "If". Điều kiện thực hiện một phép so sánh và hỏi một câu hỏi đúng hoặc

66
sai. Biến myAge = 3? Nếu đúng thì làm việc gì đó. Chú ý từ "Then" theo ngay sau điều kiện.
Nó cũng là từ khoá của Visual Basic.NET, vì thế nó có màu xanh da trời. Sau "Then" đến
lệnh được thực hiện. Chúng ta làm thụt đầu dòng này cho dễ đọc mã lệnh. Nếu điều kiện là
đúng thì chương trình hiển thị một hộp thông báo với dòng chữ " Tôi 3 tuổi". Để ý rằng từ
"End If" theo sau lệnh điều kiện cũng là từ khoá. Từ "End If" hoàn thành lệnh "If" (tức là báo
hiệu kết thúc lệnh If).

Bây giờ bạn thử câu lệnh If.. Then! Tạo một ứng dụng Window tên là IfThen. Thêm một
hộp văn bản vào Form1. Đặt một nút lệnh vào Form1. Nhấp đúp nút lệnh để mở cửa sổ soạn
thảo lệnh cho thủ tục xử lý sự kiện nhấn nút. Thêm các dòng lệnh sau vào thủ tục này.

Dim Tuoi As Integer


Tuoi = 3
If Tuoi = 3 Then
TextBox1.Text = "Tôi 3 tuổi."
End If

Dịch và chạy chương trình. Nhấn nút lệnh. Cái gì đang xảy ra ở đây. Mã lệnh khai báo
một biến tên là Tuoi và gán cho nó bằng 3. Lệnh "If" hỏi một câu hỏi đúng hoặc sai: Tuoi=3?
Câu trả lời là đúng bởi vì bạn vừa mới đặt Tuoi=3. Vì câu trả lời là đúng nên câu lệnh sau
"Then" được thực hiện. Hộp văn bản hiển thị nội dung "Tôi 3 tuổi"

Bây giờ hãy thay đổi mã lệnh như dưới đây:

Tuoi = 2

Dịch và chạy chương trình. Nhấn vào nút lệnh. Và theo dõi điều gì xảy ra. Tuoi được gán
bằng 2. Lệnh "If " hỏi một câu hỏi Tuoi=3? Lần này câu trả lời là sai, vì thế câu lệnh sau
"Then" không được thực hiện. Không có gì xảy ra. Nội dung của hộp văn bản không thay đổi
bởi vì điều kiện là sai. Chương trình thực hiện chính xác như đã định.

Hãy xem một ví dụ khác, trên Form1 thêm


vào một Ô đánh dấu. Viết mã lệnh cho sự kiện
nhấn nút lệnh. Thay thế mã lệnh trong thủ tục
xử lý sự kiện này bằng các mã lệnh sau:

If CheckBox1.Checked = True Then


TextBox1.Text="Tôi được đánh
dấu."
End If

Dịch và chạy chương trình. Đánh dấu vào


Ô đánh dấu sau đó nhấn vào nút. Điều kiện là
đúng (bạn đã đánh dấu vào Ô đánh dấu), vì thế
nội dung của hộp văn bản là "Tôi được đánh
dấu."

67
Dịch và chạy lại chương trình. Lần này, bỏ đánh dấu ở ô đánh dấu đi, sau đó nhấn vào nút
lệnh. Điều gì xảy ra? Không có gì xảy ra cả. Lần này điều kiện là sai (bạn không đánh dấu
vào Ô đánh dấu), vì thế nội dung của TextBox1.Text không thay đổi. Chương trình của bạn
đã ra quyết định (gán giá trị cho thuộc tính Text) dựa trên một điều kiện (Ô đánh dấu có được
đánh dấu hay không).

7. Sử dụng nhiều Lệnh If


Có thể bạn muốn chương trình của bạn ra một số quyết định trong khi chạy. Chương trình
có thể cần kiểm tra trạng thái của Ô đánh dấu, sau đó kiểm tra trạng thái của nút lựa chọn,
tiếp đến so sánh hai số, và cuối cùng là xác định xem người dùng có bỏ sót trường nào trống
không. Chà! Đòi hỏi chương trình nhiều quá. Tất cả các điều này đều có thể thực hiện được?
Câu trả lời là “có”. Bạn cần bao nhiêu lệnh "If...Then" thì bạn thêm vào chương trình từng
ấy. Giống như các lệnh khác, chúng được thực hiện theo thứ tự mà chúng xuất hiện. Hãy viết
một ứng dụng trình diễn cách sử dụng nhiều lệnh "If...Then".

Chương trình của chúng ta có một Ô đánh dấu "Hiển thị tất cả các báo động". Nếu ô đánh
dấu này được đánh dấu thì chương trình thay đổi màu nền (BackColor) của form thành màu
đỏ, thay đổi nội dung trong hộp văn bản thành "Báo động đỏ ", và hiển thị hộp thông báo
hiển thị nội dung "Nguy hiểm! Nguy hiểm!". Để làm được điều này bạn có thể sử dụng ba
lệnh "If...Then". Trong mỗi lệnh, điều kiện sẽ kiểm tra xem ô đánh dấu "Hiển thị tất cả các
báo động" có được đánh dấu hay không. Nếu điều kiện là đúng, câu lệnh điều kiện được thực
hiện.

Sau đây tạo một ứng dụng Window gọi là FireAlarm (báo cháy). Thêm một ô đánh dấu,
một hộp văn bản, và một nút lệnh vào Form1. Thay đổi tiêu đề của Button1 thành "Ba lệnh
If". Nháy đúp vào Button1 để viết lệnh cho sự kiện nhấn nút. Nội dung mã lệnh như sau.

If CheckBox1.Checked = True Then


Form.ActiveForm.BackColor = System.Drawing.Color.Red
End If
If CheckBox1.Checked = True Then
TextBox1.Text = "Báo động đỏ"
End If
If CheckBox1.Checked = True Then
MessageBox.Show("Nguy hiểm! Nguy hiểm!")
End If

Dịch và chạy chương trình. Đánh dấu vào ô đánh dấu "Hiển thị tất cả các báo động" sau
đó nhấn nút lệnh "Ba lệnh If “. Mỗi một lệnh "If...Then" thực hiện lần lượt và ba lệnh điều
kiện được thực hiện. Lệnh "If...Then" đầu tiên thay đổi màu nền của form thành màu đỏ.
Lệnh thứ hai thay đổi nội dung của hộp văn bản thành "Báo động đỏ". Lệnh thứ ba làm xuất
hiện một hộp thông báo hiển thị nội dung thông báo "Nguy hiểm! Nguy hiểm!"

8. Sử dụng nhiều điều kiện

Bạn có để ý là tất cả các lệnh "If...Then" trong ví dụ FireAlarm đều có điều kiện giống
nhau không? Tất cả chúng đều sử dụng cùng một điều kiện sau:

68
If CheckBox1.Checked = True Then

Visual Basic.NET và hầu hết các ngôn ngữ lập trình hiện đại đều cho phép nhiều lệnh
điều kiện chung cùng một điều kiện. Cú pháp như sau:

If Điều kiện Then


lệnh điều kiện 1
lệnh điều kiện 2
...
lệnh điều kiện n
End If

Hiểu được điều này, chúng ta có thể viết lại mã lệnh trong ứng dụng FireAlarm, đơn giản
hơn, loại bỏ các điều kiện lặp lại, và dễ hiểu hơn. Mở ứng dụng FireAlarm. Thêm nút lệnh
thứ hai vào Form1. Thay đổi tiêu đề của Button2 thành "Một lệnh If". Nhấp đúp vào nút
Button2 để sửa mã lệnh cho thủ tục xử lý sự kiện nhấn chuột như sau:

If CheckBox1.Checked = True Then


Form.ActiveForm.BackColor = System.Drawing.Color.Red
TextBox1.Text = "Báo động đỏ"
MessageBox.Show("Nguy hiểm! Nguy hiểm!")
End If

Dịch và chạy chương trình. Đánh dấu vào ô đánh dấu và nhấn vào nút "Một lệnh If". Một
điều kiện đơn được định giá là đúng, vì thế tất cả các lệnh điều kiện dưới nó được thực hiện
một cách tuần tự. Chương trình làm việc hệt như trước. Tuy nhiên, lần này ba dòng lệnh cùng
chia sẻ một điều kiện! Việc sử dụng một điều kiện với nhiều câu lệnh dưới nó cần ít mã lệnh
hơn và cũng dễ hiểu hơn.

9. Nhiều lựa chọn


Bạn có thể xây dựng các câu hỏi có nhiều lựa chọn trong mã lệnh bằng cách sử dụng một
loạt các lệnh "If...Then". Xem ví dụ sau:

Viết một ứng dụng Window gọi là ChooseAColor (chọn một màu). Thêm ba nút lựa chọn
và một nút lệnh vào Form1. Sử dụng cửa sổ thuộc tính để đặt các thuộc tính. Thay đổi tiêu đề
(thuộc tính Text) của nút lựa RadioButton1 thành "Đỏ". Thay đổi tiêu đề RadioButton2 thành
"Vàng". Thay đổi tiêu đề RadioButton3 thành "Xanh lá cây". Thay đổi tiêu đề của Button1
thành "Tô màu". Cài đặt thuộc tính Checked (đánh dấu) của RadioButton1 thành True. Nhấp
đúp vào Button1 để viết mã lệnh cho thủ tục xử lý sự kiện nhấn nút lệnh. Thêm thủ tục các
dòng mã lệnh sau:

Dim myColor As System.Drawing.Color


If RadioButton1.Checked = True Then
myColor = System.Drawing.Color.Red
End If
If RadioButton2.Checked = True Then
myColor = System.Drawing.Color.Yellow

69
End If
If RadioButton3.Checked = True Then
myColor = System.Drawing.Color.Green
End If

Form.ActiveForm.BackColor = myColor

Dịch và chạy chương trình. Để ý rằng nút lựa chọn "Đỏ" được chọn. Nhấn vào nút lệnh
"Tô màu ". Form và các nút được tô thành màu đỏ. Chọn một nút lựa chọn khác và nhấn nút
"Tô màu". Form và các nút được tô bằng màu khác! Nhìn vào mã lệnh. Một loạt các lệnh
"If...Then" được sử dụng để trả lời câu hỏi nhiều lựa chọn: "Nút lựa chọn nào được chọn?"
Vì mã lệnh thực hiện theo thứ tự, chương trình xác định nút nào trong số ba nút lựa chọn
được. Sau đó chương trình thực hiện lệnh thích hợp để tô màu cho Form.

10. Sử dụng toán tử lô gíc trong mã lệnh


Chúng ta đã nói về cách chúng ta sử dụng toán tử Lô gíc để nối các biểu thức lại với nhau
nhằm giải bài toán lô gíc phức tạp. Hãy xem một ví dụ sử dụng toán tử AND để tạo một biểu
thức phức tạp.

Chúng ta sửa ứng dụng ChooseAColor (chọn màu) bằng cách thêm một ô đánh dấu nhằm
mục đích cho phép hoặc không cho phép thực hiện chức năng thay đổi màu. Chúng ta sẽ sử
dụng toán tử AND để tạo một biểu thức điều kiện phức tạp hơn, yêu cầu ô đánh dấu được
đánh dấu hoặc không được thay đổi màu.

Mở ứng dụng ChooseAColor. Thêm tiếp một ô đánh dấu vào Form1. Thay đổi thuộc tính
Text thành "Cho phép đổi màu ". Sửa mã lệnh trong thủ tục xử lý sự kiện nhấn nút lệnh
Button1 bằng các mã lệnh dưới đây :

Dim myColor As System.Drawing.Color


If RadioButton1.Checked = True And CheckBox1.Checked Then
myColor = System.Drawing.Color.Red
End If
If RadioButton2.Checked = True And CheckBox1.Checked Then
myColor = System.Drawing.Color.Yellow
End If
If RadioButton3.Checked = True And CheckBox1.Checked Then
myColor = System.Drawing.Color.Green
End If
Form.ActiveForm.BackColor = myColor

Dịch và chạy chương trình. Nhấn nút "Tô màu ". Không có gì xảy ra! Màu không thay
đổi. Bây giờ đánh dấu "Cho phép đổi màu" và nhấn vào nút "Tô màu". Form và các điều
khiển được tô màu đỏ. Ở đây cái gì xảy ra? Chúng ta thêm mã lệnh sau vào điều kiện của
từng lệnh If...Then:

And CheckBox1.Checked

70
Nó thêm một điều kiện bổ sung. Bây giờ hai
điều kiện phải đúng thì màu của Form và điều
khiển mới thay đổi. Ví dụ,

RadioButton2.Checked = True And


CheckBox1.Checked

Cả hai điều kiện này phải đúng. Nhớ rằng,


True AND True=True. Nếu một trong hai vế của
toán tử AND là False thì biểu thức AND sẽ là
False và màu không thay đổi.

11. Bài kiểm tra

71
BÀI 9. CÂU LỆNH IF PHỨC TẠP

1. Lệnh If…Then mở rộng


Bạn đã biết cách xây dựng lệnh If…Then trong Visual Basic.NET. Với lệnh này bạn cũng
có thể làm được nhiều thứ với chỉ một câu lệnh. Bằng cách sử dụng nhiều câu lệnh If…Then,
chương trình có thể tạo một số các quyết định. Thậm chí bằng cách sử dụng nhiều lệnh
If…Then bạn có thể trả lời câu hỏi nhiều lựa chọn! Bạn cũng đã thấy nhiều câu lệnh dùng
chung một điều kiện. Nếu điều kiện là đúng thì tất cả các câu lệnh dưới nó được thực hiện lần
lượt theo thứ tự. Điều này làm cho mã lệnh của bạn đơn giản, dễ đọc và dễ gỡ lỗi.

Bằng cách sử dụng các lệnh If…Then đơn giản, bạn có thể viết mã lệnh cho chương trình
để ra bất cứ kiểu quyết định nào, không cần quan tâm đến độ phức tạp. Tuy nhiên, viết mã
lệnh này có thể khá phức tạp và thậm chí là hơi khó hiểu, đấy là không kể đến việc lặp đi lặp
lại. Vì thế bạn nên học một ít thủ thuật. Các thủ thuật này sẽ làm đơn giản hoá cuộc sống của
bạn và thêm một số chức năng hữu ích vào một lệnh If…Then. Đầu tiên, bạn học cách lồng
các lệnh If…Then. Tiếp đó, bạn học viết mã lệnh If…Then…Else.

2. Lệnh If…Then lồng nhau


Trong một lệnh If…Then, có thể có lệnh If…Then khác như là một câu lệnh bình thường!
Lệnh If…Then thứ hai chỉ được thực hiện nếu điều kiện của lệnh thứ nhất đúng. Lệnh thứ
nhất chứa lệnh thứ hai. Điều này gọi là “lồng nhau” bởi vì một lệnh If…Then lồng, hoặc nằm
gọn trong lệnh khác.

Đầu tiên hãy xem một ví dụ trong đời sống thực tế.

Nếu tôi có 200 đô la và nếu cửa hàng bách hóa mở Gợi ý


cửa thì tôi sẽ mua một máy nghe nhạc MP3.
Việc để các dòng lệnh thụt vào là
rất quan trọng để tránh lỗi khi viết
Viết dưới dạng giả mã nó có dạng như sau:
các câu lệnh If “lồng nhau”.

If I have $200 Then


If the store is open Then
I will buy an MP3 player
End If
End If

If Tôi có 200 đô la Then


If Cửa hàng bách hoá mở cửa Then
Tôi sẽ mua một máy nghe nhạc MP3
End If
End If

Nó giống như hai lệnh If...Then trong một! Lệnh If...Then thứ nhất bọc xung quanh lệnh
thứ hai. Lệnh thứ nhất có một điều kiện (nếu tôi có 200 đô la) và một lệnh khi điều kiện được

72
đáp ứng (nếu cửa hàng bách hoá mở cửa thì tôi sẽ mua một máy nghe nhạc MP3) đó là một
lệnh If…Then khác. Lệnh If...Then thứ hai cũng có điều kiện riêng của nó (nếu cửa hàng
bách hoá mở cửa) và lệnh điều kiện riêng của nó (tôi sẽ
mua một máy nghe nhạc MP3).
Gợi ý
Như bạn có thể thấy, tôi phải có 200 đô la và cửa
Bạn sẽ nhận xét rằng trong trường
hàng bách hoá phải mở cửa, hoặc không có máy nghe hợp này chỉ cần 1 câu lệnh If là đủ:
nhạc MP3. Cả hai điều kiện phải đúng. Nếu tôi không If tôi có $200 And cửa hàng mở.
có 200 đô la, điều kiện của lệnh If...Then thứ nhất sai Việc lồng các lệnh If cần thiết khi có
và không cần quan tâm đến cửa hàng bách hóa có mở nhiều câu lệnh If và các đoạn mã
hay không - không có máy nghe nhạc MP3! được để thụt vào tương ứng, hoặc
sau này khi giới thiệu tiếp phần Else
của câu lệnh If.

Bây giờ hãy xem thêm một vài ví dụ. Tạo một ứng
dụng tên là Nesting (lồng nhau). Thêm hai ô đánh dấu và một nút lệnh vào Form1. Thay đổi
thuộc tính Text của Button1 thành "Ai được đánh dấu?" Nhấp đúp vào Button1 để mở cửa sổ
soạn thảo lệnh. Thêm các dòng lệnh sau đây vào thủ tục xử lý sự kiện nhấn nút:

If CheckBox1.Checked = True Then


If CheckBox2.Checked = True Then
MessageBox.Show("Tất cả được đánh dấu.")
End If
End If

Dịch và chạy chương trình. Đánh dấu ô đánh dấu thứ nhất sau đó nhấn nút "Ai được đánh
dấu?". Điều gì xảy ra? Ồ, không có gì xảy ra. Bây giờ đánh dấu ô thứ hai và nhấn nút Ai
được đánh dấu? Lần nữa. Lần này hộp thông báo hiển thị thông báo "Tất cả được đánh dấu.".
Như bạn có thể thấy, dòng lệnh thứ nhất là điều kiện:

If CheckBox1.Checked = True Then

Điều kiện này có một lệnh điều kiện. Lệnh điều kiện này là một lệnh If...Then lồng trong
lệnh thứ nhất. Lệnh If...Then lồng lại có điều kiện riêng của nó:

If CheckBox2.Checked = True Then

Nó cũng có lệnh điều kiện riêng của nó:

MessageBox.Show("Tất cả được đánh dấu.")

Vì thế cái gì xảy ra? nếu điều kiện thứ nhất đúng (CheckBox1 được đánh dấu) thì lệnh
điều kiện được thực hiện. Lệnh điều kiện xuất hiện là lệnh If...Then thứ hai. Nếu điều kiện
thứ hai đúng (ô đánh dấu CheckBox2 được đánh dấu) thì lệnh điều kiện thứ hai được thực
hiện, nó sẽ hiển thị hộp thông báo. Cả hai điều kiện phải đúng để cho hộp thông báo hiển thị.
Nghĩa là, cả hai ô đánh dấu Checkbox1 và Checkbox2 phải được đánh dấu hoặc hộp thông
báo sẽ không hiển thị.

73
Lưu ý rằng trong đoạn mã trên câu lệnh
If…Then thứ hai nằm trong câu lệnh If…Then thứ
nhất. End If của If…Then thứ nhất nằm sau End If
của If…Then thứ hai. Có thể lồng nhiều câu lệnh
If…Then vào nhau để đoạn mã cần thiết chỉ chạy
khi tất cả các điều kiện được đáp ứng.

3. Điều kiện ngược lại


Một khả năng có thể là viết một lệnh If...Then khác với điều kiện ngược lại và lệnh điều
kiện riêng của nó để thực hiện.

Tạo một ứng dụng Window gọi là IfThenOtherwise (nếu thì ngược lại thì). Thêm một nút
lệnh và hai ô đánh dấu vào Form1. Thay đổi thuộc tính Text của Button1 thành "IfThen". Đặt
mã lệnh sau vào thủ tục xử lý sự kiện nhấn nut của Button 1 :

If CheckBox1.Checked = True Then


Form.ActiveForm.BackColor = System.Drawing.Color.Red
End If

If CheckBox1.Checked = False Then


Form.ActiveForm.BackColor = System.Drawing.Color.Blue
End If

Dịch và chạy ứng dụng. Nhấn nút "If Then". Form chuyển thành màu xanh da trời. Đánh
dấu ô đánh dấu CheckBox1 và nhấn lại nút
"IfThen". Form chuyển thành màu đỏ.

Mã lệnh này làm việc như thế nào? Trong lệnh


If...Then đầu tiên, điều kiện kiểm tra xem có đánh
dấu ô đánh dấu CheckBox1
(CheckBox1.Checked=True) không. Nếu đã đánh
dấu thì màu nền (BackColor) của form được cài
đặt là màu đỏ. Trong lệnh If...Then thứ hai điều
kiện kiểm tra xem nếu CheckBox1.Checked=False
(điều kiện ngược lại) thì màu nền của form được
đặt thành màu xanh da trời. Hơi lặp lại một chút,
nhưng nó làm việc được! Một vấn đề với mã lệnh
này là bạn phải viết khối mã lệnh gần như nhau
cho điều kiện ngược lại. Điều này có thể tốn nhiều

74
thời gian và có thể xảy ra lỗi.

4. If…Then…Else
Visual Basic.NET đề nghị một cách giải quyết loại trừ các dòng mã lệnh lặp lại và làm
cho mã lệnh rõ ràng hơn, dễ đọc hơn. Lựa chọn này là lệnh If...Then…Else. Lệnh
If...Then…Else chỉ yêu cầu một điều kiện nhưng cung cấp các mã lệnh cho cả hai kết quả
(True và False). Lệnh If...Then…Else được sử dụng thay vì việc viết hai lệnh If...Then tương
tự nhau có các điều kiện đối nghịch nhau. Đây là cú pháp:

If condition Then
conditional statement 1
Else
conditional statement 2
End If

If điều kiện Then


lệnh điều kiện 1
Else
lệnh điều kiện 2
End If

Mã lệnh này làm việc như thế nào? Đầu tiên điều kiện được tính. Nếu điều kiện là đúng
(True) thì lệnh điều kiện 1 được thực hiện. Ngược lại (else) lệnh điều kiện 2 được thực hiện.

Bây giờ sửa ứng dụng IfThenOtherwise để sử dụng lệnh If...Then…Else và chứng minh
rằng nó làm việc giống như hai lệnh If...Then độc lập nhưng điều kiện đối nghịch nhau.
Thêm nút lệnh thứ hai vào Form1. Thay đổi thuộc tính Text của Button2 thành "IfThenElse".
Thêm các mã lệnh sau vào thủ tục xử lý sự kiện nhấn nút của Button2:

If CheckBox1.Checked = True Then


Form.ActiveForm.BackColor = System.Drawing.Color.Red
Else
Form.ActiveForm.BackColor = System.Drawing.Color.Blue
End If

Dịch và chạy ứng dụng. Nhấn nút "IfThenElse". Form chuyển thành màu xanh da trời.
Đánh dấu ô đánh dấu CheckBox1 sau đó nhấn nút "IfThenElse". Form chuyển sang màu đỏ.
Chương trình sử dụng một lệnh IfThenElse thực hiện giống như khi nó thực hiện hai lệnh
IfThen! Mã lệnh thực hiện được bởi vì điều kiện kiểm tra nếu CheckBox1.Checked=True.
Nếu nó là True thì lệnh điều kiện đầu tiên được thực hiện và form chuyển thành màu đỏ.
Ngược lại (else), lệnh điều kiện thứ hai (lệnh ngay sau Else) được thực hiện và form chuyển
sang màu xanh da trời.

Hãy xem ví dụ If...Then…Else khác. Chúng ta sẽ sửa ứng dụng IfThenOtherwise để chứa
nhiều dòng mã lệnh trong cùng một điều kiện. Một lệnh If...Then…Else có thể có nhiều dòng
mã lệnh cho các lệnh điều kiện của nó sau mệnh đề If...Then và Else. Mở ứng dụng

75
IfThenOtherwise. Thay thế mã lệnh trong thủ tục xử lý sự kiện nhấn nút của Button2 bằng
các dòng mã lệnh sau:

If CheckBox1.Checked = True Then


Form.ActiveForm.BackColor = System.Drawing.Color.Red
MessageBox.Show("Tôi màu đỏ.")
TextBox1.Text = "Tôi màu đỏ."
Else
Form.ActiveForm.BackColor =
System.Drawing.Color.Blue
MessageBox.Show("Tôi màu xanh da
trời.")
TextBox1.Text = "Tôi màu xanh da
trời."
End If

Dịch và chạy chương trình. Nhấn vào nút


"IfThenElse". Ba sự kiện xảy ra. Bây giờ đánh dấu
vào ô đánh dấu CheckBox1 và nhấn vào nút
"IfThenElse". Ba sự kiện khác xảy ra.

5. Chế độ chạy từng lệnh trong lệnh If


Bây giờ hãy sử dụng khả năng gỡ lỗi của Visual Studio.NET để chạy từng lệnh trong lệnh
If...Then…Else. Đó là cách mà bạn có thể xem mã lệnh làm việc từ bên trong.

Tạo một ứng dụng Window gọi là StepInIf (chạy từng lệnh trong lệnh if). Thêm một nút
lệnh vào Form1. Đặt thuộc tính Checked của CheckBox1 thành True. Khi ứng dụng khởi
động, ô kiểm tra sẽ được đánh dấu.

Nhấp đúp vào nút lệnh để mở cửa sổ soạn thảo mã lệnh. Thêm các mã lệnh sau vào thủ
tục xử lý sự kiện nhấn nút :

Dim MyValue As Integer


MyValue = 1
If
CheckBox1.Checked
= True Then
MyValue = 2
Else
MyValue = 3
End If

1. Đặt điểm dừng trên dòng


lệnh đầu tiên (MyValue = 1)
bằng cách nhấp đúp vào vùng

76
xám bên trái của dòng lệnh, hoặc bằng cách nhấp chuột phải và chọn “Insert Breakpoint”.

2. Dịch và chạy chương trình.


Khi form xuất hiện, nhấn nút
lệnh. Mã lệnh thực hiện đến
dòng có điểm dừng.

3. Nhấn phím F11 để thực hiện


dòng mã lệnh hiện tại
(MyValue=1). Dòng mã lệnh
tiếp theo được làm sáng lên.

4. Nhấn phím F11 để thực hiện


dòng mã lệnh hiện tại (If
CheckBox1.Checked = True
Then). Vì CheckBox1 được
đánh dấu. Dòng mã lệnh tiếp
theo được làm sáng lên là
MyValue=2.

5. Nhấn phím F11để thực hiện


dòng mã lệnh hiện tại
(MyValue=2). Dòng mã lệnh
tiếp theo sáng lên.

6. Nhấn phím F11để thực hiện


dòng mã lệnh hiện tại (End If).
Dòng mã lệnh tiếp theo sáng
lên.

77
7. Nhấn phím F11 để thực hiện dòng mã lệnh
hiện tại (End Sub). Form xuất hiện lại.

8. Gỡ bỏ đánh dấu của ô đánh


dấu CheckBox1 và nhấn vào
nút lệnh. Lặp lại quá trình
từng bước bằng cách nhấn
phím F11 lặp đi lặp lại nhiều
lần và xem dòng lệnh nào
sáng lên khi mã lệnh thực
hiện. Lần này, mệnh đề Else
được thực hiện, được theo
sau bởi dòng MyValue=3.

6. Bài kiểm tra

78
BÀI 10. VÒNG LẶP XÁC ĐỊNH

1. Vòng Lặp
Đôi khi bạn cần chương trình làm cái gì đó lặp đi lặp lại cho đến khi nó thực hiện được
một số lần xác định. Đó là tại sao tất cả các ngôn ngữ lập trình đều có lệnh lặp. Mã lệnh trong
lệnh lặp được thực hiện lặp đi lặp lại nhiều lần. Vòng lặp rất có ích. Chúng giảm số mã lệnh
bạn phải viết. Bằng cách đặt mã lệnh trong vòng lặp, bạn chỉ phải viết nó một lần. Điều này
giúp làm giảm số lỗi chương trình có thể mắc phải.

Đây là ví dụ về tính có ích của vòng lặp trong chương trình. Tưởng tượng là bạn muốn
cộng tất cả các số từ 1 đến 100. Bạn có thể làm điều này bằng cách viết một biểu thức dài. Ví
dụ,

Dim TotalCount As Integer


TotalCount = 0
TotalCount = 1 + 2 + 3 + 4 'etc.

Cách khác:

Dim TotalCount As Integer


TotalCount = 0
TotalCount = TotalCount + 1
TotalCount = TotalCount + 1
TotalCount = TotalCount + 1
TotalCount = TotalCount + 1
'v.v...

Vẫn còn nhiều mã lệnh lặp lại. Bạn sẽ phải lặp lại việc viết 100 dòng lệnh giống nhau!

Nếu bạn muốn cộng tất cả các số từ 1 đến 1000! Các bạn sẽ giải quyết vấn đề này như thế
nào?

2. For…Next
Như đã đề cập trước đó, tất cả các ngôn ngữ lập trình đều có vòng lặp, nó cho phép mã
lệnh được thực hiện lặp đi lặp lại. Thường thì bạn biết số lần bạn muốn mã lệnh lặp lại.
Trong ví dụ cộng tất cả các số từ 1 đến 1000, chúng ta muốn mã lệnh thực hiện việc cộng các
số phải thực hiện 1000. Khi bạn biết được số lần bạn muốn mã lệnh thực hiện, bạn sử dụng
“lặp xác định” (definite loop). Nó được gọi là “lặp xác định”, bởi vì nó thực hiện một số lần
lặp lại được xác định trước. Bạn sử dụng vòng lặp để nói với mã lệnh thực hiện đúng số lần
bạn muốn nó thực hiện.

Trong Visual Basic.NET, vòng lặp xác định được xây dựng bằng cách sử dụng lệnh
For...Next. Mã lệnh mà bạn muốn thực hiện với số lần xác định được chứa trong For...Next.

79
Dim SoLanLap As Integer
For SoLanLap = CanDuoi To CanTren
Lenh 1
Lenh 2
Lenh n
Next

Các từ "For", "Next", và "To" là từ khoá. Chúng có chữ đầu tiên là chữ hoa và có màu
xanh da trời. Bạn khai báo biến SolanLap là biến kiểu nguyên (integer). SolanLap phải được
khai báo trước khi sử dụng nó trong lệnh lặp For...Next. Biến SolanLap giám sát số lần vòng
lặp đã thực hiện. Bạn có thể truy cập giá trị của biến SolanLap ở trong vòng lặp. Cả CanDuoi
và CanTren phải nguyên, biến có kiểu nguyên, hoặc biểu thức rút gọn được thành số nguyên,
ví dụ như (3 + 1 hoặc X + 1). CanDuoi là giá trị khởi tạo của SolanLap. CanTren là giá trị
cuối cùng của SolanLap. Mỗi lần vòng lặp thực hiện, biến SolanLap được tăng lên 1. Khi giá
trị của biến SolanLap lớn hơn CanTren thì vòng lặp dừng lại.

Hãy viết một vài mã lệnh sử dụng “lặp xác định” sử dụng lệnh For...Next. Trước hết,
chúng ta sẽ tạo một vòng lặp thực hiện 2 lần và hiển thị giá trị biến đếm lặp cho mỗi lần lặp.
Tạo một ứng dụng Window tên là ForNextTwo. Thêm một nút lệnh vào Form1. Nhấp đúp
vào Button1 để mở cửa sổ mã lệnh. Thêm mã lệnh sau vào thủ tục xử lý sự kiện nhấn nút của
nút lệnh Button1:

Dim LoopCounter As Integer


For LoopCounter = 1 To 2
MessageBox.Show(LoopCounter)
Next

Dịch và chạy chương trình. Nhấn vào nút lệnh. Một hộp thông báo hiển thị "1", giá trị
hiện tại của LoopCounter. Nhấn OK. Hộp hội thoại hiển thị "2", giá trị hiện tại của
LoopCounter. Nhấn OK. Vòng lặp kết thúc thực hiện, vì thế không còn thông báo nào được
hiển thị thêm nữa.

Trong mã lệnh, bạn khai báo biến LoopCounter có kiểu nguyên (integer). Trong lệnh For,
bạn khởi tạo LoopCounter bằng 1 và đặt giá trị cận trên của
LoopCounter bằng 2. Lệnh được thực hiện được đặt giữa Gợi ý
lệnh For và lệnh Next. Mỗi lần vòng lặp thực hiện,
LoopCounter được tăng lên 1. Hộp thông báo hiển thị giá trị Khi vòng lặp For kết thúc,
biến lắp bao giờ cũng lớn
hiện tại của LoopCounter(1, 2). Khi giá trị của LoopCounter hơn 1 so với cận trên.
bằng 3, vòng lặp thoát ra và hộp thông báo không còn được
hiển thị nữa và vòng lặp kết thúc.

3. Chạy từng lệnh một trong lệnh For…Next


Hãy khảo sát mã lệnh For...Next mà bạn vừa mới viết, bằng cách sử dụng công cụ gỡ lỗi
của Visual Studio.NET. Chúng ta sẽ chạy từng dòng mã lệnh một và xem cách thực hiện của
nó. Dưới đây là các bước hướng dẫn thực hiện:

1. Đặt điểm dừng trên dòng lệnh chứa lệnh For. Sau đó dịch và chạy ứng dụng.

80
2. Form mở ra. Nhấn vào nút
Button1. Mã lệnh chạy đến điểm
dừng. Dòng mã lệnh chứa điểm
dừng được làm sáng lên bằng màu
vàng.

3. Nhấn phím F11 dòng mã lệnh


sáng được thực hiện.

For LoopCounter = 1 To 2

Di chuyển con trỏ trên biến


LoopCounter. Giá trị của
LoopCounter là 1.

4. Nhấn phím F11 dòng lệnh sáng được thực hiện.

MessageBox.Show(LoopCounter)

Hộp thông báo hiển thị 1. Nhấn OK để đóng hộp thông báo.

5. Nhấn phím F11 dòng lệnh sáng được thực hiện.

Next

6. Và For loop được thực hiện.

For LoopCounter = 1 To 2

Di chuyển con trỏ trên biến LoopCounter trong lệnh For. Giá trị của LoopCounter là 2.

7. Nhấn phím F11. dòng lệnh sáng được thực hiện.

MessageBox.Show(LoopCounter)

Hộp thông báo hiển thị 2. Nhấn OK để đóng hộp thông báo.

8. Nhấn phím F11. dòng lệnh sáng được


thực hiện.

Next

9. Và For loop được thực hiện.

81
For LoopCounter = 1 To 2

Di chuyển con trỏ trên biến LoopCounter trong lệnh For. Giá trị của LoopCounter là 3.

10. Nhấn phím F11, dòng lệnh sáng được thực hiện.

End Sub

Form xuất hiện trở lại.

Bạn vừa mới sử dụng công cụ gỡ lỗi để chạy từng dòng mã lệnh trong lệnh For...Next.
Theo cách này, bạn thực sự xem được cách mã lệnh thực hiện trong chương trình.

4. Bài toán cộng 1000


Bây giờ hãy viết mã lệnh để cộng các số từ 1 đến 1000. Với việc sử dụng vòng lặp
For...Next thì việc này trở nên quá dễ ràng. Tạo một ứng dụng Window tên là AddUp (cộng
dồn). Thêm một nút lệnh vào Form1. Thay đổi thuộc tính Text của Button1 thành "Cộng".
Nhấp đúp vào Button1 để gõ đoạn mã cho sự kiện nhấn nút. Thêm mã lệnh sau đây vào:

Dim LoopCounter As Integer


Dim TotalCount As Integer = 0

For LoopCounter = 1 To 1000


TotalCount = TotalCount + LoopCounter
Next

Dịch và chạy chương trình. Nhấn nút "Cộng". Hộp thông báo hiển thị giá trị tổng của các
số từ 1 đến 1000. Có nhanh không? Bạn viết mã và chương trình tính còn nhanh hơn cả nếu
dùng máy tính tay!

Đoạn mã này làm việc như thế nào?

Đầu tiên chúng ta khai báo hai biến nguyên LoopCounter và TotalCount. LoopCounter
giám sát số lần vòng lặp đã thực hiện. Biến TotalCount giữ kết quả của phép cộng. Trong
lệnh For, giá trị khởi tạo của biến LoopCounter bằng 1 và giá trị cuối cùng là 1000. Bởi vì
chúng ta muốn vòng lặp thực hiện 1000 lần, cộng tất cả các số từ 1 đến 1000. Lệnh lặp thực
hiện việc cộng giá trị hiện tại của biến TotalCount và giá trị hiện tại của biến LoopCounter và
lưu trở lại biến TotalCount. Mỗi lần vòng lặp thực hiện, giá trị của biến LoopCounter được
cộng vào biến TotalCount (0+1=1, 1+2=3, 3+3=6, 6+4=10,…,1000). Sau khi LoopCounter
bằng 1000, thì vòng lặp không được thực hiện nữa(chương trình thoát ra khỏi vòng lặp) và
dòng mã lệnh tiếp theo sau lệnh Next đượcthực hiện.

Trong trường hợp này hộp thông báo hiển thị giá trị của biến TotalCount (tức là hiển thị
giá trị của việc cộng các số từ 1 đến 1000).

82
5. Đổ rác.
Bây giờ hãy xem một vài ví dụ của lệnh lặp xác định. Các ví dụ này thực hiện công việc
bên ngoài lĩnh vực toán học. Nhớ rằng, bạn có thể đặt bất kỳ mã lệnh bạn muốn vào trong
vòng lặp For...Next. Bạn có thể xây dựng chuỗi ký tự một cách tự động, hiển thị thông báo
quấy rầy lặp đi lặp lại, hoặc thay đổi thuộc tính dựa trên giá trị của biến đếm lặp. Thử các ví
dụ cho một vài cách sử dụng khác của lệnh lặp.

Tạo một ứng dụng Window tên là GarbageOut (Đổ rác). Thêm một nút lệnh vào Form1.
Thay đổi thuộc tính Text của Button1 thành "Mẹ nhắc". Nhấp đúp vào nút lệnh Button1 để
soạn thảo mã lệnh cho sự kiện nhấn nút lệnh Button1 như dưới đây :

Dim MomMessage As String


Dim i As Integer = 0
MomMessage = "Đổ rác đi"
For i = 1 To 5
MessageBox.Show(MomMessage)
MomMessage = MomMessage & vbNewLine & MomMessage
Next

Dịch và chạy ứng dụng. Nhấn vào nút "Mẹ nhắc". Lời mẹ nhắc được hiển thị. Nhấn tiếp
vào nút “Mẹ nhắc”. Để ý lời nhắc của mẹ ngày càng dài ra như thế nào. Tôi nghĩ tôi đã nghe
thấy lời mẹ nhắc! Sử dụng lệnh lặp là một cách mà bạn có thể sử dụng để ghép nối các chuỗi
ký tự lại với nhau.

Đây là một ví dụ khác. Thêm một nút lệnh vào Form1. Thay đổi thuộc tính Text của
Button2 thành “Tô màu lại ” ("Color Again"). Nhấp đúp vào Button2 để soạn thảo mã lệnh
cho sự kiện nhấn nút lệnh Button2 như dưới đây:

Dim i As Integer = 0
For i = 2 To 6
If i < 3 Or i > 5 Then
MessageBox.Show(i)
Form1.ActiveForm.BackColor =
System.Drawing.Color.Red
Else
MessageBox.Show(i)
Form1.ActiveForm.BackColor =
System.Drawing.Color.Blue
End If
Next

Dịch và chạy chương trình. Nhấn nút "Tô màu


lại ". Một hộp thông báo hiển thị giá trị hiện tại của
biến đếm lặp. Để ý rằng lần này có cận dưới là 2 và
cận trên là 6. Một lệnh If...Then...Else bên trong

83
lệnh For...Next quyết định cách tô màu Form dựa vào giá trị của biến đếm lặp. Do đặt một
hộp thông báo nên bạn có thể nhìn thấy giá trị của biến đếm lặp và sự thay đổi màu nền của
Form.

6. Vòng lặp trong vòng lặp


Bạn có biết là bạn có thể đặt một lệnh lặp For...Next bên trong một lệnh lặp khác không?
Lệnh For...Next bên trong là mã lệnh thực hiện lặp đi lặp lại bởi lệnh lặp For...Next ngoài. Vì
thế, mã lệnh ở trong Lệnh For...Next bên trong được thực hiện bao nhiêu lần? Hãy nhìn mã
lệnh ví dụ sau, để xác định câu trả lời cho câu hỏi này.

Tạo một ứng dụng Window gọi là LoopTheLoop. Thêm một nút lệnh vào Form1. Nhấp
đúp vào Button1 để soạn thảo mã lệnh cho sự kiện nhấn nút lệnh Button1 như dưới đây:

Dim OuterLimit As Integer = 3


Dim InnerLimit As Integer = 4
Dim OuterCounter As Integer
Dim OnnerCounter As Integer
Dim Total As As Integer = 0

For OuterCounter = 1 To OuterLimit


For InnerCounter = 1 To InnerLimit
Total = Total + 1
Next
Next
MessageBox.Show("Tổng bằng = " & Total)

Dịch và chạy ứng dụng. Nhấn nút lệnh Button1. Hộp thông báo hiển thị "Tổng bằng =
12". Đây là tổng số lần vòng lặp bên trong đã được thực hiện. Bạn có để ý là 12 bằng 3 (số
lần vòng lặp ngoài thực hiện) nhân 4 (số lần vòng lặp trong thực hiện)? Đúng vậy! Mỗi lần
vòng lặp ngoài thực hiện thì vòng lặp trong thực hiện 4 lần. Vì vòng lặp ngoài thực hiên 3 lần
nên vòng lặp trong sẽ thực hiện tổng số là 4 x 3=12 lần.

Để ý rằng trong ví dụ này chúng ta sử dụng hai biến, OuterLimit và InnerLimit, tương ứng
là cận trên của vòng lặp ngoài và vòng lặp trong. Cận trên và cận dưới không nhất thiết phải
là số nguyên. Chỉ cần chúng là biến hoặc biểu thức có thể định giá được về kiểu nguyên. Để
ý cách vòng lặp trong được để thụt vào.

7. Thoát khỏi vòng lặp - biển Exit


Đôi khi bạn cần dừng vòng lặp trước khi biến đếm lặp đạt đến giá trị cận trên. Bạn có thể
thực hiện điều này bằng cách sử dụng lệnh "Exit For". Lệnh Exit For được đặt trong một lệnh
If...Then trong thân của lệnh lặp. Điều kiện của lệnh If...Then nói cho mã lệnh biết khi nào
thì thoát ra khỏi vòng lặp. Hãy viết mã lệnh minh hoạ lệnh Exit For.

Tạo một ứng dụng Window gọi là ExitSign(biển báo thoát). Thêm một nút lệnh vào
Form1. Thay đổi thuộc tính Text của Button1 thành "Thoát Ngay". Nhấp đúp vào nút lệnh
Button1để soạn thảo mã lệnh cho sự kiện nhấn nút Button1 như dưới đây:

84
Dim i As Integer = 0
For i = 1 To 5
MessageBox.Show("i bên trong= " & i)
If i = 3 Then
Exit For
End If
Next
MessageBox.Show("i bên ngoài= " & i)

Dịch và chạy chương trình. Lặp lại việc nhấn nút lệnh "Thoát Ngay". Một hộp thông báo
hiển thị giá trị của biến đếm lặp. Khi biến đếm lặp bằng 3, điều kiện của lệnh If...Then đúng
và lệnh Exit For thực hiện. Mã lệnh thoát ra khỏi vòng
lặp mà không cần kết thúc nốt phần còn lại của vòng Gợi ý
lặp. Để ý rằng hộp thông báo không bao giờ hiển thị i Câu lệnh Exit dùng trong các
bên trong = 4. Khi vòng lặp thoát thì mã lệnh sau lệnh trường hợp: Exit For, Exit Do,
Next được thực hiện. Trong trường hợp này hộp thông Exit Sub
báo hiển thị i bên ngoài = 3.

Đây là ví dụ khác của lệnh Exit For. Chúng ta sẽ thêm nhiều chức năng vào ứng dụng Exit
Sign. Thêm một Ô đánh dấu vào Form1. Thêm nút lệnh khác vào Form1, thay đổi thuộc tính
Text của nó thành "ChexIt". Nhấp đúp vào Button2 để soạn thảo mã lệnh cho sự kiện nhấn
nút của nó như dưới đây:

Dim LoopIndex As Integer


For LoopIndex = 1 To 5
If LoopIndex = 4 Then
CheckBox1.Checked = True
End If
If CheckBox1.Checked = True Then
MessageBox.Show("Exit on: " & LoopIndex)
Exit For
End If
Next

Dịch và chạy chương trình. Nhấn vào nút "ChexIt". Lệnh For...Next chạy cho đến khi
LoopIndex = 4, thuộc tính Checked của CheckBox1 được đặt là True. Vì bây giờ Checkbox1
được đánh dấu, một thông báo hiển thị giá trị LoopIndex và chạy đến lệnh Exit For. Thoát ra
khỏi vòng lặp.

Nhấn lại nút "ChexIt" với ô đánh dấu CheckBox1 vẫn được đánh dấu. Lần này thì điều gì
xảy ra? Chay lệnh Exit For khi LoopIndex = 1.

85
8. Bài kiểm tra

86
BÀI 11. CÁC VÒNG LẶP KHÔNG XÁC ĐỊNH

1. Vòng lặp không xác định


Có nhiều thứ chúng ta phải làm đi làm lại cho đến khi có một điều gì đó khác xảy ra.
"Điều gì đó khác" này hoạt động như điều kiện thoát khỏi vòng lặp. Lặp không xác định cứ
thực hiện cho đến khi một điều kiện nào đó trở thành đúng hoặc sai thì dừng lại.

Mã lệnh cũng giống như thế. Đôi khi bạn cần thực hiện mã lệnh một cách lặp lặp lại,
trong khi hoặc đến khi một điều kiện xác định là đúng (True). Ví dụ, Mã lệnh có thể yêu cầu
người dùng nhập mật khẩu cho đến khi họ nhập đúng. Hoặc khi trong khi tính toán, chương
trình chơi một bản nhạc điện tử.

Sự phân biệt giữa vòng lặp không xác định và vòng lặp xác định là vòng lặp xác định thực
hiện một số lần đã xác định. Ngược lại vòng lặp không xác định thực hiện trong khi hoặc đến
khi một điều kiện nào đó xảy ra. Có hai kiểu vòng lặp không xác định: Vòng lặp "do while"
và "do until". Vòng lặp Do while thực hiện trong khi điều kiện vẫn còn đúng. Do until thực
hiện cho đến khi điều kiện trở thành đúng (True). Điểm mấu chốt của việc sử dụng vòng lặp
không xác định là việc chọn sử dụng vòng lặp do while loop hoặc vòng lặp do until loop.

2. Vòng lặp Do While…Loop


Vòng lặp "Do While...Loop" thực hiện một khối các lệnh lặp đi lặp lại trong khi một điều
kiện xác định vẫn đúng. Ngay khi điều kiện trở thành sai vòng lặp kết thúc và khối lệnh
không còn được thực hiện nữa. Phần của Do While...Loop, là điều kiện được sử dụng để điều
khiển nó. Đây là cú pháp của lệnh Do While...Loop trong Visual Basic.NET:

Do While (DieuKien)
MaLenh 1
MaLenh 2
MaLenh n
Loop

Các từ "Do", "While" và "Loop" là từ khoá. Chúng được hiển thị với màu xanh da trời.
Điều kiện được bao trong cặp dấu ngoặc đơn. Điều kiện có thể là bất cứ biểu thức lô gíc nào
mà giá trị của nó hoặc là đúng hoặc là sai. Ví dụ X < 4. Mã lệnh mà bạn muốn thực hiện lặp
đi lặp lại được đặt giữa lệnh Do While và Loop. Tại mỗi lần lặp, điều kiện lại được xem xét.
Nếu điều kiện còn đúng (True), mã lệnh tiếp tục được thực hiện. Nếu điều kiện sai thi vòng
lặp kết thúc.

Tạo một ứng dụng Window tên là DoWhileLoop. Thêm nút lệnh vào Form1. Nhấp đúp
vào Button1 để soạn thảo mã lệnh cho sự kiện nhấn nút lệnh của nó như sau:

87
Dim WhileValue As Integer
WhileValue = 0
Do While (WhileValue < 2)
MessageBox.Show(WhileValue)
WhileValue = WhileValue + 1
Loop

Dịch và chạy chương trình. Nhấn nút Button1. Một hộp thông báo hiển thị 0. Nhấn OK.
Một hộp thông báo hiển thị 1. Nhấn OK. Quay trở
lại Form.

Đoạn mã này làm việc như thế nào? Chúng ta


khai báo biến WhileValue và khởi tạo cho nó bằng
0. Sau mỗi lần lặp giá trị của WhileValue được
tăng lên 1. Tại đầu vòng lặp lệnh Do While kiểm
tra điều kiện WhileValue < 2. Nếu điều kiện đúng
thì hộp thông báo được hiển thị và WhileValue
được tăng lên 1. Ngược lại thì vòng lặp kết thúc.
Vòng lặp thực hiện hai lần trước khi điều kiện trở
thành sai. Lần đầu thông báo hiển thị 0. Lần thứ
hai thông báo hiển thị 1. lần thứ ba, WhileValue =
2. Biểu thức lô gíc 2 < 2 là sai. Vòng lặp kết thúc
và Hộp thông báo không hiển thị nữa.

3. Chạy lệnh Do While…Loop trong chế độ gỡ lỗi


Sử dụng công cụ gỡ lỗi của Visual Studio.NET để dừng lại ở cửa sổ mã lệnh và xem ứng
dụng DoWhileLoop chạy từng dòng lệnh.

1. Trong cửa sổ lệnh đặt điểm dừng lệnh


trên lệnh Do While.

2. Chạy chương trình. Mã lệnh chạy đến


điểm dừng thì dừng lại và làm sáng dòng
lệnh chứa điểm dừng.

88
3. Nhấn phím F11 để chạy dòng lệnh đang được làm sáng

Do While (WhileValue < 2)

Di chuyển con trỏ trên WhileValue. Ta thấy giá trị của nó là 0.

4. Nhấn phím F11 để chạy dòng lệnh đang được làm sáng.

MessageBox.Show(WhileValue)

Một thông báo hiển thị giá trị 0. Nhấn


OK.

5. Nhấn phím F11 để chạy dòng lệnh


đang được làm sáng.

WhileValue = WhileValue + 1

Giá trị của WhileValue được tăng lên 1.

6. Nhấn phím F11 để chạy dòng lệnh


đang được làm sáng

Loop

Lệnh loop được thực hiện lần nữa.

7. Nhấn phím F11 để chạy dòng lệnh


đang được làm sáng

Do While (WhileValue < 2)

Di chuyển con trỏ trên WhileValue. Ta


thấy giá trị của nó là 1.

8. Nhấn phím F11 để chạy dòng đang


lệnh đang được làm sáng

MessageBox.Show(WhileValue)

Hộp thông báo hiển thị 1. Nhấn OK.

9. Nhấn phím F11 để chạy dòng lệnh


đang được làm sáng

WhileValue = WhileValue + 1

89
Biến WhileValue được tăng lên 2.

10. Nhấn phím F11 để chạy dòng lệnh


đang được làm sáng.

Loop

Lệnh loop lại được thực hiện.

11. Nhấn phím F11 để chạy dòng lệnh


đang được làm sáng.

Do While (WhileValue < 2)

Di chuyển con trỏ trên WhileValue. Ta


thấy giá trị của nó là 2. Điều kiện
WhileValue < 2 trở thành sai. Vì thế
vòng lặp kết thúc. Hộp thông báo không
hiển thị nữa và giá trị của WhileValue
không tăng lên nữa.

12. Nhấn phím F11 để chạy dòng lệnh


đang được làm sáng.

End Sub

Sự kiện nhấn nút kết thúc. Form được hiển thị trở lại.

Trên đây bạn đã xem cách lệnh Do While...Loop làm việc. Bây giờ hãy xem tiếp lệnh Do
Until...Loop.

4. Vòng lặp Do Until…Loop


Lệnh Do Until...Loop thực hiện đoạn lệnh lặp đi lặp lại cho đến khi điều kiện trở thành
đúng. Điều kiện có thể là bất kỳ biểu thức lô gíc nào mà biểu thức này có giá trị hoặc là đúng
hoặc sai. Đây là cú pháp của lệnh Do Until...Loop trong Visual Basic.NET:

Do Until (DieuKien)
MaLenh 1
MaLenh 2
. ..
MaLenh n
Loop

Các từ "Do", "Until" và "Loop" là từ khoá. Chúng có màu xanh da trời. Điều kiện được
kiểm tra ở ngay đầu vòng lặp. Nếu điều kiện vẫn còn sai thì lệnh vẵn tiếp tục được thực hiện.
Khi điều kiện trong lệnh Do Until trở thành đúng thì vòng lặp kết thúc.

90
Làm một ví dụ Do Until...Loop trong Visual Basic.NET. Tạo một ứng dụng Window tên
là DoUntilLoop. Thêm một nút lệnh vào Form1. Nhấp đúp vào nút Button1 để soạn thảo mã
lệnh cho sự kiện nhấn nút nhấn nút như sau:

Dim UntilValue As Integer


UntilValue = 0
Do Until (UntilValue > 1)
MessageBox.Show(UntilValue)
UntilValue = UntilValue + 1
Loop

Dịch và chạy chương trình. Nhấn nút lệnh Button1. Hộp thông báo hiển thị 0. Nhấn OK.
Hộp thông báo hiển thị 1. Nhấn nút OK. Vòng lặp kết thúc, Form được hiển thị trở lại.

Mã lệnh Do Until...Loop làm việc như thế nào? Đầu tiên, chúng ta khai báo biến
UntilValue và khởi tạo giá trị ban đầu cho nó bằng 0. Biến UntilValue được sử dụng trong
lệnh so sánh (biểu thức điều kiện) dùng để quyết định xem có tiếp tục thực hiện vòng lặp nữa
không hay dừng lại. Mỗi lần vòng lặp thực hiện thì giá trị của UntilValue được tăng lên 1.
Lệnh Do Until chứa lệnh so sánh, lệnh này được dùng để kiểm tra xem giá trị của UntilValue
có lớn hơn 1 không. Ở lần lặp đầu tiên giá trị của UntilValue là 0. Biểu thức điều kiện có giá
trị sai vì thế vòng lặp tiếp tục được thực hiện. Hộp thông báo xuất hiện và giá trị của
UntilValue được tăng lên. Ở lần lặp thứ hai, giá trị của UntilValue là 1. Biểu thức lô gíc điều
kiện vẫn sai, mã lệnh trong vòng lặp vẫn tiếp tục được thực hiện. Ở lần lặp thứ ba, giá trị của
UntilValue là 2. Biểu thức lô gíc điều kiện 2>1 trở thành đúng, vòng lặp được kết thúc.

5. Hoạt động của lệnh lặp


Bây giờ hãy xem các ví dụ Do While...Loop và Do Until...Loop. Chúng sử dụng biểu thức
lô gíc điều kiện. Các biểu thức này không phụ thuộc trực tiếp biến đếm lặp. Ví dụ Do
While...Loop thứ nhất với biểu thức lô gíc điều kiện được dùng để kiểm tra xem giá trị của
biến có còn lớn hơn hoặc bằng 0 không. Khi giá trị của biến nhỏ hơn không thì vòng lặp kết
thúc.

Tạo một ứng dụng Window tên là LoopsInAction. Thêm một nút lệnh vào Form1. Thay
đổi thuộc tính Text của Button1 thành "Đếm Lùi". Nhấp đúp vào Button1 để soạn thảo mã
lệnh cho sự kiện nhấn nút của nó như sau:

Dim LoopIndex As Integer = 0


Dim WhileController As Integer = 167
Do While (WhileController >= 0)
LoopIndex = LoopIndex + 1
WhileController = WhileController - (23 * LoopIndex)
Loop
MessageBox.Show(WhileController)

Dịch và chạy chương trình LoopsInAction. Nhấn vào nút "Đếm Lùi". Hộp thông báo xuất
hiện và hiển thị -63. Mã lệnh này làm việc như thế nào? Chúng ta khai báo hai biến nguyên,
LoopIndex và WhileController, và khởi tạo các giá trị ban đầu cho chúng. Sau mỗi lần vòng

91
lặp được thực hiện Biến LoopIndex được tăng lên 1, một giá trị mới của biến
WhileController được tính toán bằng cách sử dụng một biểu thức phức tạp một chút. Giá trị
mới của WhileController được tính bằng cách lấy giá trị cũ của WhileController trừ đi giá trị
của LoopIndex nhân với 23. Vì thế sau mỗi lần lặp giá trị của WhileController càng ngày
càng nhỏ đi. Sẽ rất là khó mà đoán được vòng lặp sẽ thực hiện bao nhiêu lần trước khi giá trị
của biến WhileController nhỏ hơn 0 và vòng lặp kết thúc. Nhưng điều này thực sự không cần
thiết, Vì biểu thức lô gíc điều kiện điều khiển vòng lặp chỉ quan tâm đến giá trị của biến
WhileController và không quan tâm đến giá trị của LoopIndex.

Ví dụ Do While...Loop thứ hai với biểu thức lô gíc phụ thuộc vào việc nút lựa chọn
RadioButton3 có được chọn hay không. Mỗi lần lặp là một nút lựa chọn được kiểm tra.

Trong ứng dụng LoopsInAction, thêm một nút lệnh thứ hai vào Form1. Thay đổi thuộc
tính Text của Button2 thành "While". Thêm ba nút lựa chọn vào Form1. Nhấp đúp vào
Button2 để soạn thảo mã lệnh cho sự kiện nhấn nút của nó như sau:

Dim LoopIndex As Integer = 0


RadioButton1.Checked = True
Do While (RadioButton3.Checked = False)
LoopIndex = LoopIndex + 1
If LoopIndex = 1 Then
RadioButton1.Checked = True
ElseIf LoopIndex = 2 Then
RadioButton2.Checked = True
ElseIf LoopIndex = 3 Then
RadioButton3.Checked = True
End If
Loop
MessageBox.Show(LoopIndex)

Dịch và chạy chương trình. Để ý rằng RadioButton1 được chọn. Nhấn nút "While".
RadioButton3 được chọn bằng mã lệnh và hộp thông báo hiển thị chỉ số vòng lặp. Nếu mắt
bạn đủ nhanh, hoặc bạn sử dụng một máy tính thực sự chậm, bạn có thể nhìn thấy
RadioButton2 được chọn trong giây lát khi vòng lặp thực hiện.

Cái gì đang xảy ra ở đây. Chúng ta khai báo biến LoopIndex để giám sát số lần lặp được
thực hiện. Tuy nhiên, chúng ta không sử dụng biến LoopIndex trong biểu thức lô gíc điều
kiện (biểu thức điều khiển lệnh Do While...Loop). Mà chúng ta sử dụng biến LoopIndex làm
điều kiện để chọn nút lựa chọn trong mỗi lần lặp. Biểu thức điều kiện của lệnh Do
While...Loop kiểm tra xem nút lựa chọn RadioButton3 đã được chọn chưa. Vòng lặp kết thúc
ngay sau khi nút RadioButton3 được chọn (RadioButton3.Checked=True).

Ví dụ Do Until...Loop thứ ba. Biểu thức lô gíc điều kiện so sánh thuộc tính Text của
Textbox với biến chuỗi, giá trị của biến này thay đổi theo từng lần lặp. Thêm hộp văn bản
vào Form1 của ứng dụng ActionLoops. Giữ nguyên giá trị của thuộc tính Text của TextBox1
là "TextBox1". Thêm nút lệnh thứ ba vào Form1 và thay đổi thuộc tính Text của nó thành
"TextMatch". Nhấp đúp vào Button3 để soạn thảo mã lệnh cho sự kiện nhấn nút của nó:

92
Dim MatchText As String = ""
Dim LoopIndex As Integer = 0
Do Until (MatchText = TextBox1.Text)
LoopIndex = LoopIndex + 1
If LoopIndex = 2 Then
MatchText = "Text"
End If
If LoopIndex = 3 Then
MatchText = "Box1"
End If Gợi ý
If LoopIndex = 4 Then
Tên biến LoopIndex ở đây là tùy
MatchText = "TextBox1"
chọn. Nó có thể là LoopCounter,
End If LoopVariable, X, hoặc là cái gì đó
Loop khác.
MessageBox.Show("Sau " & LoopIndex & " lần lặp
đã khớp.")

Dịch và chạy chương trình. Nhấn nút "Text Match". Hộp thông báo xuất hiện và hiển thị
giá trị LoopIndex khi chuỗi văn bản so khớp với nhau.

Trong lệnh Do Until...Loop này. Biến LoopIndex chỉ được dùng để xác định giá trị của
biến MatchText. Biểu thức điều kiện so sánh giá trị của MatchText với thuộc tính Text của
TextBox1. Ở lần lặp thứ tư giá trị của biến LoopIndex là 4 và MatchText="TextBox1". Biểu
thức lô gíc điều kiện trở thành đúng (vì "TextBox1"="TextBox1"), vòng lặp kết thúc.

Điều gì sẽ xảy ra nếu thuộc tính Text của TextBox1 được đặt thành một chuỗi ký tự khác.
Bạn có thể thêm lệnh "If..Then" khác để cho mã lệnh vẫn tiếp tục được thực hiện không?

6. Dạng khác của lệnh lặp

Lệnh Do While...Loop và Do Until...Loop có thể được viết theo dạng khác tức là điều
kiện được đặt ở cuối của vòng lặp. Trong trường hợp này biểu thức điều kiện được viết ngay
sau mã lệnh. Mã lệnh luôn luôn được thực hiện ít nhất là một lần sau đó điều kiện mới được
kiểm tra. Những dạng này gồm các lệnh Do...Loop While và Do...Loop Until . Đây là ví dụ
về lệnh Do…Loop While:

Dim WhileValue As Integer


WhileValue = 0
Do
Gợi ý
MessageBox.Show(WhileValue)
WhileValue = WhileValue + 1 Để điều kiện ở cuối lệnh lặp đảm
Loop While (WhileValue < 2) bảo đoạn mã trong vòng lặp thực
hiện ít nhất một lần.
Đây là ví dụ của lệnh Do...LoopUntil:

Dim UntilValue As Integer


UntilValue = 0
Do

93
MessageBox.Show(UntilValue)
UntilValue = UntilValue + 1
Loop Until (UntilValue > 1)

Để ý rằng trong cả hai trường hợp, biểu thức điều kiện bây giờ là một bộ phận của lệnh
Loop hơn là bộ phận của lệnh Do. Các lệnh sau Do và trước Loop được thực hiện ít nhất một
lần. Sau đó biểu thức điều kiện được kiểm tra để xác định xem vòng lặp có tiếp tục nữa
không. Trong ví dụ trên, nếu UntilValue được khởi tạo là 5 thì hộp thông báo sẽ hiển thị 5
trước khi thực hiện kiểm tra biểu thức điều kiện.

7. Lệnh Exit Do
Bạn có nhớ Cliff dậy cách thoát khỏi vòng lặp For...Next bằng cách sử dụng lệnh Exit
For. Bạn cũng có thể thoát ra khỏi các lệnh lặp Do While...Loop, Do Until...Loop, Do...Loop
While và Do...Loop Until theo cách tương tự như thế bằng cách sử dụng lệnh "Exit Do". Bạn
sử dụng lệnh If...Then để cung cấp một biểu thức lô gíc nhằm điều khiển sự thực hiện của
lệnh Exit Do. Nếu biểu thức lô gíc có giá trị đúng thì lệnh Exit Do được thực hiện và vòng
lặp kết thúc. Sử dụng Exit Do khi bạn muốn thoát khỏi vòng lặp trước khi biểu thức lô gíc
của lệnh lặp thoả mãn điều kiện thoát khỏi vòng lặp.

Hãy viết mã lệnh để thoát khỏi vòng lặp Do Until...Loop. Tạo một ứng dụng Window tên
là ExitDo. Thêm một nút lệnh vào Form1. Nhấp đúp vào nút Button1 để soạn thảo mã lệnh
cho sự kiện nhấn nút của nó như dưới đây (các mã lệnh này cũng giống như mã lệnh của ứng
dụng DoLoopUntil):

Dim UntilValue As Integer


UntilValue = 0
Do Until (UntilValue > 10)
MessageBox.Show(UntilValue)
UntilValue = UntilValue + 1
If UntilValue = 5 Then
Exit Do
End If
Loop
MessageBox.Show("Giá trị thoát= " & UntilValue)

Dịch và chạy chương trình. Nhấn nút Button1. Trong mỗi lần lặp, giá trị của UntilValue
sẽ tăng lên 1 và hộp thông báo sẽ hiển thị đếm lặp (0,1,2,3 and 4). Bạn phải nhấn nút OK
trong từng lần lặp. Khi giá trị của UntilValue bằng 5, biểu thức so sánh của lệnh If...Then có
giá trị đúng. Lệnh Exit Do được thực hiện. Vòng lặp kết thúc và mã lệnh ở dòng đầu tiên
ngay sau lệnh Loop Until được thực hiện, nó hiển thị lại giá trị của UntilValue tại thời điểm
vòng lặp kết thúc. Mã lệnh hiển thị hộp thông báo với nội dung là "Giá trị thoát = 5". Nhấn
nút OK để trở về.

Bạn có thể sử dụng chính lệnh Exit Do này trong mã lệnh Do While...Loop để kết thúc
vòng lặp trước khi biểu thức điều kiện của nó trở thành sai.

94
8. Bài kiểm tra

95
BÀI 12. HÀM

1. Thủ tục là gì?


Thủ tục con (gọi là thủ tục cho tiện) giống như là một chương trình nhỏ (mini-program).
Bạn viết chúng để thực hiện các tác vụ cụ thể trong ứng dụng. Khi bạn viết một ứng dụng,
hãy chia nhỏ nó thành chức năng nhỏ hơn và viết thủ tục thực hiện từng chức năng nhỏ này.
Ứng dụng có thể chứa số thủ tục bằng số thủ tục mà bạn cần. Nhưng cố gắng viết các thủ tục
sao cho các thủ tục này chứa một chức năng cụ thể của ứng dụng.

Tại sao lại sử dụng thủ tục? Thủ tục giúp bạn viết lệnh và gỡ lỗi chương trình dễ ràng hơn
vì chúng chúng chia các chức năng của ứng dụng thành các chức năng nhỏ hơn. Viết và gỡ
lỗi vài thủ tục con ngắn thì dễ ràng hơn viết và gỡ lỗi toàn bộ ứng dụng rất nhiều. Một khi
bạn đã gỡ lỗi thủ tục thì nó đã sẵn sàng cho bạn sử dụng. Nó sẽ làm việc vào bất cứ khi nào
bạn cần sử dụng nó.

Dùng thủ tục là một cách giúp bạn tiết kiệm rất nhiều thời gian, khi bạn có nhiều mã lệnh
phức tạp mà bạn muốn truy nhập chúng từ các phần khác nhau của ứng dụng. Chúng có thể
được sử dụng một cách lặp đi lặp lại. Một khi bạn viết một thủ tục, nó có thể được sử dụng
tại bất cứ nơi đâu trong ứng dụng. Thậm chí thủ tục có thể sử dụng các thủ tục khác. Các bạn
thử tưởng tượng xem!

Thủ tục cũng là cách dùng để chia công việc lập trình trong các ứng dụng lớn. Mỗi lập
trình viên thường được phân công viết các thủ tục của ứng dụng. Họ chịu trách nhiệm viết và
gỡ lỗi các thủ tục do họ viết và đảm bảo rằng chúng làm việc được với các phần khác của
chương trình.

Một vài sử dụng phổ biến của thủ tục là để thực hiện tính toán, định dạng và hiển thị
thông tin, tuỳ biến giao diện người dùng, nhắc nhở người dùng nhập dữ liệu, cung cấp đầu
vào và đầu ra cho chương trình.

2. Viết thủ tục của bạn


Bây giờ các bạn sẽ viết thủ tục con sau đó sẽ học cách sử dụng nó trong ứng dụng. Chúng
ta sẽ bắt đầu bằng việc học cú pháp của cách viết thủ tục. Đây là cú pháp của thủ tục.

Private Sub TenThuTuc()


Lenh 1
lenh 2
...
Lenh n
End Sub

Để ý là các từ "Private", "Sub", "End Sub" là từ khoá. Trong cửa sổ mã lệnh, chúng có
màu xanh da trời. Từ khoá Private nghĩa là thủ tục này chỉ có thể được truy cập bởi mã lệnh
khác trong cùng một Form hoặc cùng một Class (lớp). TenThuTuc là tên của thủ tục.

96
Bạn có thể sử dụng bất cứ tên nào bạn muốn để đặt
tên cho thủ tục nhưng tốt nhất là bạn nên chọn tên có
khả năng gợi ý (liên tưởng) tới chức năng của thủ tục,
sao cho thông qua tên thủ tục bạn cũng có thể biết
chức năng của thủ tục dùng để làm gì.

Để ý cặp dấu ngoặc đơn đi sau tên thủ tục. Khi


thông tin được chuyển cho thủ tục, các biến lưu giữ
thông tin được đặt trong cặp dấu ngoặc đơn. Bạn đã
nhìn thấy tất cả các điều này trong tất cả các thủ tục
xử lý sự kiện mà bạn đã sử dụng trong các bài trước.
Các lệnh của thủ tục là các dòng mã lệnh nằm giữa các
dòng Sub và End Sub. Các lệnh này được thực hiện
theo thứ tự từ trên xuống dưới. Bạn hầu như có thể sử
dụng bất cứ lệnh nào bạn muốn trong thủ tục.

Bây gờ bạn viết thủ tục và gọi thủ tục này từ mã lệnh.

Tạo một ứng dụng Window tên là SimpleSub. Mở cửa sổ mã lệnh. Tìm đến dòng lệnh
"Windows Forms Designer generated code". Trên dòng tiếp theo của dòng lệnh này, nhập
vào mã lệnh sau:

Private Sub ThongBao()


MessageBox.Show("Đây là thông báo từ thủ tục ThongBao")
End Sub

Như bạn thấy, khi mã lệnh trong thủ tục ThongBao được thực hiện, hộp thông báo sẽ hiển
thị nội dung: " Đây là thông báo từ thủ tục ThongBao".

3. Gọi thủ tục của bạn


Để mã lệnh trong thủ tục thực hiện, bạn cần viết lệnh để gọi nó. Khi thủ tục được gọi thì
mã lệnh được chứa trong thân thủ tục được thực hiện. Cú pháp gọi thủ tục rất đơn giản. Bạn
sử dụng tên thủ tục và theo sau nó là cặp dấu ngoặc đơn. Đây là cú pháp gọi thủ tục:

TenThuTuc()

Bây giờ, hãy gọi thủ tục mà bạn vừa mới viết.

Trong dự án SimpleSub (thủ tục đơn giản), thêm một nút lệnh vào Form1. Thay đổi thuộc
tính Text của Button1 thành "Thông báo". Nhấp đúp vào Button1 để soạn thảo mã lệnh cho
sự kiện nhấn nút của nó như sau:

ThongBao()

Dịch và chạy chương trình. Nhấn nút " Thông báo". Hộp thông báo hiển thị thông báo
"Đây là thông báo từ thủ tục ThongBao ". Thông báo này đã đến từ đâu? Đây là dòng mã

97
lệnh được chứa trong thủ tục ThongBao. Khi thủ tục được gọi từ sự kiện nhấn nút thì dòng
mã lệnh này được thực hiện.

Bây giờ bạn sẽ thêm một thủ tục khác vào dự án SimpleSub. Nó sẽ hiển thị thông báo
khác. Mở cửa sổ mã lệnh và thêm mã lệnh sau đây vào sau lệnh End Sub của thủ tục
ThongBao:

Private Sub ThongBao1()


MessageBox.Show("Đây là thông báo từ thủ tục ThongBao1"
End Sub

Lần này, hãy gọi thủ tục ThongBao1 từ thủ tục ThongBao thay vì từ sự kiện nhấn nút. Sửa
lại mã lệnh của thủ tục ThongBao như sau:

Private Sub ThongBao ()


MessageBox.Show("Đây là thông báo từ thủ tục ThongBao")
ThongBao1()
End Sub

Chúng ta thêm lệnh gọi thủ tục ThongBao1 vào trong thủ tục ThongBao. Dịch và chạy
chương trình SimpleSub. Nhấn nút "Thông báo". Hai thông báo được hiển thị. Thông báo thứ
nhất hiển thị nội dung " Đây là thông báo từ thủ tục ThongBao". Thông báo thứ hai hiển thị "
Đây là thông báo từ thủ tục ThongBao1". Mã lệnh này làm việc như thế nào? Thủ tục xử lý
sự kiện nhấn nút gọi thủ tục ThongBao. Khi thủ tục này được gọi thì mã lệnh nó chứa, được
thực hiện. Thủ tục ThongBao chứa hai dòng mã lệnh. Dòng đầu tiên đưa ra hộp thông báo
với nội dung " Đây là thông báo từ thủ tục ThongBao". Dòng thứ hai gọi thủ tục ThongBao1,
đưa ra hộp thông báo với nội dung " Đây là thông báo từ thủ tục ThongBao1".

Bạn đã tạo hai thủ tục và gọi thủ tục thứ nhất từ sự kiện nhấn nút của nút lệnh còn thủ tục
thứ hai thì được gọi từ thủ tục thứ nhất!

4. Viết và gọi thủ tục có tham số


Một trong những tiện lợi của Visual Basic.NET, và hầu hết các ngôn ngữ lập trình hiện
đại khác đó là bạn có thể truyền thông tin cho thủ tục. Điều này rất là hữu ích, vì bạn có thể
viết một thủ tục tạo ra các kết quả hoặc các hành động khác nhau tuỳ thuộc vào thông tin
được chuyển cho nó. Những thông tin mà bạn truyền cho thủ tục được gọi là “đối số” của thủ
tục. Khi bạn viết một thủ tục có các tham số bạn phải chỉ rõ số lượng tham số và kiểu của
chúng.

Đây là cú pháp viết thủ tục có tham số:

Private Sub TenThuTuc (ByVal TenThamSo1 As KieuThamSo1, ByVal


TenThamSo2 As KieuThamSo2, ByVal TenThamSoN As KieuThamSoN)
Lenh1
Lenh 2

...

98
Lenh N
End Sub

Ở đây cặp dấu ngoặc đơn không trống. Chúng chứa danh sách tham số và kiểu của tham
số của thủ tục. Để ý từ "ByVal" là từ khoá. Nên trong cửa sổ mã lệnh nó có màu xanh. Kiểu
của tham số là các kiểu phổ biến như số nguyên
(Integer), chuỗi (String), v.v. Các tham số được phân Gợi ý
cách với nhau bằng dấu phẩy.
Tham số sau từ khóa ByVal có
nghĩa là giá trị của tham số tuy
Một ví dụ thực tế sẽ làm cho điều này trở nên rõ được chuyền cho thủ tục nhưng
ràng hơn nhiều. Mở cửa sổ mã lệnh trong dự án giá trị ban đầu của tham số vẫn
SimpleSub. Ngay tại dòng tiếp theo của dòng chứa lệnh không thay đôi.
End Sub của thủ tục ThongBao, nhập vào mã lệnh sau :

Private Sub ThongBaoChung(ByVal noidung


As String)
MessageBox.Show(noidung)
End Sub

Thủ tục này yêu cầu phải truyền một đối số có kiểu chuỗi (String) cho nó. Khi thủ tục
được gọi, nó sẽ đưa ra hộp thông báo hiển thị nội dung của đối số chuỗi mà nó nhận được.

Bây giờ hãy gọi thủ tục ThongBaoChung và truyền đối số chuỗi cho nó. Thêm một nút
lệnh thứ hai vào Form1 của dự án SimpleSub. Thay đổi thuộc tính Text của Button2 thành
"Thông báo bất kỳ". Nhấp đúp vào Button2 để soạn thảo mã lệnh cho sự kiện nhấn nút của
nó như sau:

ThongBaoChung("Bất kì thông báo nào")


ThongBaoChung("Một vài thông báo còn lại")
ThongBaoChung("Một thông báo khác")

Dịch và chạy ứng dụng. Nhấn nút " Thông báo bất kỳ". Ba thông báo được hiển thị. Điều
này có thể xảy ra như thế nào? Mã lệnh của thủ tục xử lý kiện nhấn nút gọi thủ tục
ThongBaoChung ba lần. Mỗi một lần nó truyền cho thủ tục đối số là một chuỗi văn bản khác
nhau. Lần thứ nhất, thủ tục được gọi với đối số " Bất kì thông báo nào ". Lần thứ hai, thủ tục
được gọi với đối số " Một vài thông báo còn lại". Lần thứ ba, thủ tục được gọi với đối số "
Một thông báo khác ". Khi mã lệnh trong thủ tục được thực hiện, đối số truyền cho thủ tục
được sử dụng bởi lệnh MessageBox.Show.

Hãy xem một ví dụ nữa. Lần này tôi sẽ viết thủ tục với hai tham số có kiểu số nguyên, thủ
tục sẽ cộng giá trị của hai tham số nguyên này lại, và sau đó hiển thị kết quả trong hộp thông
báo.

Thêm một thủ tục tên là Cong vào dự án SimpleSub. Thủ tục Cong như sau:

Private Sub Cong(ByVal ThamSo1 As Integer, ByVal ThamSo2 As Integer)


Dim Tong As Integer
Tong = ThamSo1 + ThamSo2

99
MessageBox.Show(Tong)
End Sub

Để ý là khi thủ tục bị gọi nó sẽ yêu cầu hai đối số nguyên. Bây giờ thêm nút lệnh thứ ba
vào Form1 của dự án SimpleSub. Thay đổi thuộc tính Text của Button3 thành ”Cộng”. Nhấp
đúp vào Button3 để soạn thảo mã lệnh cho sự kiện nhấn nút của nó như sau:

Cong(34, 57)

Dịch và chạy chương trình. Nhấn nút "Cộng". Hộp thông báo hiển thị 91. Mã lệnh của
thủ tục xử lý sự kiện nhấn nút lệnh gọi thủ tục Cong và truyền các đối số, 34 và 57 cho thủ
tục Cong. Thủ tục Cong thực hiện ba dòng lệnh. Dòng lệnh đầu khai báo biến Tong. Sau đó
biến Tong được gán giá trị tổng của ThamSo1 (34) và ThamSo2 (57). Đối số ThamSo1 và
ThamSo2 lưu giữ giá trị truyền cho thủ tục khi thủ tục được gọi. Cuối cùng, thủ tục hiển thị
giá trị của Tong (91)

Bây giờ bạn có thể tự viết thủ tục và truyền thông tin cho nó. Tiếp bạn sẽ học cách viết
các hàm. Bạn có thể truyền thông tin cho hàm bằng cách sử dụng các đối số, cũng như khi
bạn làm việc với thủ tục. Nhưng khác với thủ tục là bạn có thể nhận thông tin trả về từ một
hàm.

5. Viết hàm của bạn


Sự khác nhau chính giữa thủ tục và hàm là bạn có thể lấy thông tin trả về từ hàm. Thông
tin này được gọi là giá trị trả về. Hàm có một giá trị trả về, giá trị này có kiểu là một kiểu xác
định. Khi bạn viết một hàm bạn phải xác định kiểu của giá trị trả về. Hãy để tôi chỉ cho bạn
cú pháp viết một hàm có các đối số và một giá trị trả về:

Private Function TenHam(ByVal TenThamso1 As KieuThamso1, ByVal


TenThamso2 As KieuThamso2, ByVal TenThamsoN As KieuThamsoN) As
KieuTrave
MaLenh1
MaLenh2

...
MaLenhN
TenHam =GiaTriTreVe
End Function

Chú ý các từ "Private", "Function", và "End Function" là từ khoá. Chúng có màu xanh.
Tên hàm có thể là một tên bất kỳ không trùng với các từ khoá của Visual Basic .NET. Tên
hàm nên thể hiện được chức năng của hàm. Danh sách tham số và kiểu tham số được chứa
trong cặp dấu ngoặc đơn ngay sau tên của hàm. Các tham số được phân cách với nhau bởi
dấu phẩy. Bạn có thể dùng số tham số không hạn chế, nhưng chỉ có duy nhất một giá trị trả
về. Bạn phải xác định kiểu của giá trị trả về (ví dụ, As Integer hoặc As String). Dòng cuối
cùng để đặt giá trị trả về. Chú ý là dòng lệnh này gán cho tên của hàm giá trị mà hàm sẽ trả
về.

100
Một ví dụ thực tế sẽ giúp giải thích cú pháp của hàm. Các bạn tạo một ứng dụng Windows
gọi là FunctionJunction . Mở cửa sổ mã lệnh và tìm dòng mã lệnh: "Windows Forms
Designer generated code". Tại dòng tiếp theo của dòng này hãy thêm dòng lệnh sau đây vào:

Private Function NhanHaiSo (ByVal Thuaso1 As Integer, ByVal Thuaso2 As Integer)


As Integer
NhanHaiSo = Thuaso1 * Thuaso2
End Function

Hàm này gọi là NhanHaiSo có hai tham số có kiểu là số nguyên Thuaso1 và Thuaso2.
Kiểu trả về là xác định ngay sau danh sách tham số, trong trường hợp này, nó được xác định
là một số nguyên (As Integer). Trong thân hàm chứa dòng lệnh:

NhanHaiSo = Thuaso1 * Thuaso2

Dòng mã lệnh này nhân hai đối số và gán kết quả cho giá trị trả về. Tên hàm là
NhanHaiSo phải được sử dụng như là tên của giá trị trả về nếu không sẽ có lỗi.

Bây giờ, hãy gọi hàm này và sử dụng giá trị của nó trong chương trình.

6. Gọi Hàm
Một cách để gọi hàm cùng với giá trị trả về là đặt một biến bằng mã lệnh gọi hàm. Biến
này phải có cùng kiểu như là kiểu của giá trị trả về của hàm.

BienCuaKieuTrave = TenHam (ThamSo1, ThamSo2,.., DoiSoN)

Hãy gọi tên hàm NhanHaiSo mà bạn vừa tạo và sử dụng giá trị trả về của nó trong mã
lệnh. Thêm một nút lệnh vào Form1 của ứng dụng FunctionJunction. Thay đổi thuộc tính
Text của Button1 thành "Nhân". Thêm mã lệnh sau vào sự kiện nhấn nút của nút lệnh
Button1:

Dim Tich As Integer


Tich = NhanHaiSo(34, 57)
MessageBox.Show(Tich)

Dịch và chạy chương trình. Nhấn vào nút "Nhân". Hộp thông báo hiển thị tích của 34x57,
đó là 1938. Mã lệnh này làm việc như thế nào? Trong thủ tục xử lý sự kiện nhấn nút lệnh,
khai báo biến nguyên Tich. Mã lệnh gọi hàm NhanHaiSo và truyền cho hàm các đối số 34 và
57. Hàm NhanHaiSo nhân Thuaso1 (34) và Thuaso2 (57) với nhau, sau đó gán giá trị của tích
Thuaso1 * Thuaso2 cho giá trị trả về của hàm (NhanHaiSo). Giá trị trả về có kiểu số nguyên.
Trong thủ tục xử lý sự kiện nhấn nút, biến nguyên Tich được gán giá trị trả về của hàm
NhanHaiSo và sau đó giá trị này được hiển thị trong hộp thông báo.

Bây giờ chúng ta đã có hàm NhanHaiSo. Thêm một nút lệnh thứ hai vào Form1 của ứng
dụng FunctionJunction. Thay đổi thuộc tính Text của Button2 thành "Nhân tiếp". Thêm dòng
mã lệnh sau đây vào sự kiện nhấn nút của nút Button2:

101
Dim Tich As Integer
Tich = NhanHaiSo(NhanHaiSo(2, 3), NhanHaiSo(5, 7))
MessageBox.Show(Tich)

Dịch và chạy chương trình. Nhấn vào nút "Nhân


tiếp". Số 210 được hiển thị. Ở đây chúng ta đã gọi
hàm NhanHaiSo ba lần. Lần đầu tiênchúng ta gọi hàm
NhanHaiSo với các đối số là 2 và 3. Giá trị trả về (6)
được sử dụng như là đối số thứ nhất khi chúng ta gọi
hàm NhanHaiSo lần thứ ba. Lần thứ hai chúng ta gọi
NhanHaiSo với đối số là 5 và 7. Giá trị trả về (35)
được sử dụng như là đối số thứ hai khi chúng ta gọi
hàm NhanHaiSo lần thứ ba. Lần thứ ba chúng ta gọi
hàm NhanHaiSo với các đối số 6 (giá trị trả về của lần
gọi hàm NhanHaiSo thứ nhất) và 35 (giá trị trả về của
lần gọi hàm NhanHaiSo thứ hai).

Bạn có thể gọi một hàm (thậm chí gọi chính nó) từ
trong một hàm.

7. Các thủ tục và hàm có sẵn


Khung ứng dụng NET bao gồm rất nhiều thủ tục và hàm được xây dựng sẵn để quản lý
các tác vụ phổ biến. Những hàm này đã được gỡ lỗi, kiểm thử kỹ lưỡng, và có mặt ở trong tất
cả các ngôn ngữ NET. Bất cứ khi nào có thể, bạn nên sử dụng các thủ tục và hàm xây dựng
sẵn thay vì tự viết lấy. Nó không chỉ tiết kiệm về mặt thời gian mà còn chuẩn hoá mã lệnh
của bạn, làm cho mã lệnh của bạn trở lên dễ hiểu. Ngoài ra, có một số thủ tục và hàm xây
dựng sẵn mà tự bạn không thể viết được. Rất nhiều hàm trong chúng truy nhập các lớp khung
ứng dụng NET và các hàm Window API (giao diện lập trình ứng dụng- dùng để giao tiếp với
hệ điều hành) bên dưới.

Bạn sẽ biết thêm một số thủ tục và hàm phổ biến nhất được xây dựng sẵn trong khung ứng
dụng NET mà bạn có thể truy nhập bằng Visual Basic.NET . Bạn sẽ thấy rằng một vài thủ
tục và hàm rất quen thuộc bởi vì chúng được sử dụng trong các ví dụ hoặc bài tập ở trong các
bài trước.

8. Một số hàm xử lý chuỗi


The .NET Framework has a lot of built-in functions that are used to Khung ứng dụng NET
có nhiều hàm xây dựng sẵn để thao tác với kiểu chuỗi. Các hàm này cho phép bạn cắt bỏ các
kí tự không cần thiết, trích các chuỗi con từ một chuỗi lớn hơn, chuyển đổi chuỗi sang chữ
hoa hoặc chữ thường. Hầu hết chúng được minh họa một cách dễ hiểu bằng các ví dụ.

Trong tất cả các hàm xử lý chuỗi bạn sẽ thảo luận, cú pháp là tương tự nhau. Hàm có thể
được gọi bởi bất kỳ chuỗi nào. Một số hàm yêu cầu đối số, một số thì không. Hầu hết các
hàm này đều trả về một chuỗi, ngoại trừ hàm Length() trả về một số nguyên. Dưới đây là cú
pháp chung được sử dụng để gọi các hàm xử lý chuỗi được xây dựng sẵn trong Visual
Basic.NET, với GiaTriTraVe và ChuoiBatKy là biến:

102
GiaTriTrave = ChuoiBatKy.TenHamXulyChuoi(ThamSo1, ThamSo2, DoisoN)

Một hàm rất hữu ích và dễ sử dụng là hàm Length. Nó trả về một số nguyên là độ dài của
một chuỗi. Ví dụ:

MyText = "TextBox1"
myLength = MyText.Length 'trả về 8, độ dài của "TextBox1"

Các hàm ToLower và ToUpperđược sử dụng để chuyển nội dung của chuỗi sang chữ
thường hoặc chữ hoa. Hãy xem các ví dụ sau:

MyText = "TextBox1"
MyCaps = MyText.ToUpper 'trả về "TEXTBOX1"

MyText = "TextBox1"
mySmalls = MyText.ToLower 'trả về "textbox1"

Đôi khi bạn muốn chắc chắn rằng chuỗi văn bản không chứa các khoảng trắng ở đầu hoặc
cuối. Nghĩa là, bạn muốn gỡ bỏ mọi khoảng trắng ở đầu và cuối chuỗi văn bản. Sử dụng hàm
Trim để làm việc này như chỉ ra dưới đây:

MyText = " TextBox1"


myClean = MyText.Trim 'trả về "TextBox1"

MyText = " TextBox1 "


MyCleaner = MyText.Trim 'trả về "TextBox1"

Một hàm hữu ích và dễ sử dụng khác là hàm Substring. Hàm Substring trả về một phần
của chuỗi từ chuỗi lớn hơn. Khi bạn gọi hàm Substring, bạn cần truyền cho nó hai đối số
nguyên. Đối số thứ nhất là vị trí bắt đầu và đối số thứ hai là độ dài của chuỗi con. Chú ý là kí
tự đầu tiên trong xâu có vị trí là 0. kí tự thứ hai có vị trí là 1, kí tự thứ ba có vị trí là 2…kí tự
thứ N có vị trí là N-1

MyText = "TextBox1"
MySub = MyText.Substring(0, 4) 'trả về "Text", bắt đầu tại vị trí 0 với độ dài =4

MyText = "TextBox1"
MySub = MyText.Substring(1, 2) 'trả về "ex", bắt đầu tại vị trí 1 với độ dài =2

Hàm Substring yêu cầu hai đối số số nguyên và trả về một giá trị kiểu chuỗi. Đối số thứ
nhất là vị trí bắt đầu tìm kiếm, đối số thứ hai là dộ dài của xâu được trả về. Nhớ rằng, kí tự
đầu tiên có vị trí là 0 (chứ không phải 1), kí tự thứ hai có vị trí là 1 (chứ không phải 2). Tôi
biết bạn không thể đợi xem các hàm xử lý chuỗi này hoạt động được nữa, vì thế hãy tạo một
ứng dụng để minh họa cách làm việc của chúng!

Hãy tạo một ứng dụng Window mới tên là BuiltIn để trình diễn các hàm xử lý chuỗi.
Thêm hai hộp văn bản vào Form1. Xoá nội dung của thuộc tính Text của TextBox2. Cài đặt
thuộc tính Multiline (văn bản hiển thị trong hộp văn bản theo chế độ nhiều dòng)của

103
TextBox2 thành "Yes". Cài đặt thuộc tính Scrollbars của TextBox2 thành "Vertical" (hộp văn
bản có thanh cuộn đứng). Kéo hộp văn bản TextBox2 sao cho chiều cao của nó hầu như cao
bằng Form1. Thêm một nút lệnh vào Form1. Thêm các mã lệnh sau vào thủ tục xử lý sự kiện
nhấn nút của nút Button1:

Dim MyText As String


Dim TempText As String = ""
MyText = TextBox1.Text
TempText = TempText & MyText
TempText = TempText & vbNewLine & MyText.ToLower
TempText = TempText & vbNewLine & MyText.ToUpper
TempText = TempText & vbNewLine & MyText.Trim
TempText = TempText & vbNewLine & MyText.Substring(0, 4)
TempText = TempText & vbNewLine & MyText.Substring(1, 2)
TempText = TempText & vbNewLine & MyText.Length
TextBox2.Text = TempText

Dịch và chạy chương trình. Nhấn nút Button1. TextBox2 hiển thị kết quả thu được từ các
hàm của xử lý chuỗi, bằng cách sử dụng thuộc tính Text của TextBox1 như là một chuỗi văn
bản. Bây giờ, thay đổi nội dung của TextBox1 và lại nhấn nút Button1.

9. Bộ sinh số ngẫu nhiên


Nhiều chương trình cần sinh ra số ngẫu nhiên, nhất là các chương trình trò chơi. Các
chương trình này chứa các sự kiện xuất hiện một cách ngẫu nhiên như là tung đồng xu, hoặc
tung hạt xúc sắc. Khung ứng dụng NET (NET Framework) có lớp System.Random lớp này
chứa các hàm dùng để sinh ra các số ngẫu nhiên. Bây giờ tôi sẽ viết mã lệnh mô phỏng việc
tung hạt xúc sắc sáu mặt. Trên Form1 của dự án BuiltIn, thêm nút lệnh thứ hai. Thay đổi
thuộc tính Text của Button2 thành "Sinh số". Thêm mã lệnh sau vào sự kiện nhấn nút của
Button2:

Dim BoSinhSoNgauNhien As System.Random


Dim SoNgauNhien As Integer
BoSinhSoNgauNhien = New System.Random
SoNgauNhien = BoSinhSoNgauNhien.Next(1, 7)
MessageBox.Show(SoNgauNhien)

Dịch và chạy chương trình. Nhấn nút " Sinh số". Hộp thông báo hiển thị một số ngẫu
nhiên trong khoảng từ 1 đến 6. Nhấn nút " Sinh số" lần nữa. Một số ngẫu nhiên khác trong
khoảng từ 1 đến 6 được hiển thị.

Mã lệnh này làm việc như thế nào? Đầu tiên, chúng ta khai báo biến BoSinhSoNgauNhien
kiểu System.Random. Sau đó chúng ta khai báo biến SoNgauNhien kiểu số nguyên. Biến
BoSinhSoNgauNhien được tham trỏ đến đối tượng System.Random bằng việc sử dụng từ
khoá New. Để sinh số ngẫu nhiên trong khoảng từ 1 đến 6, chúng ta gọi hàm Next() của biến
BoSinhSoNgauNhien. Khi chúng ta gọi hàm Next(), chúng ta truyền các đối số 1 và 6 cho
nó (đây là các giá trị cận dưới và cận trên của dãy số ngẫu nhiên mà chúng ta muốn sinh ra).

104
Hàm Next() trả về một số nguyên ngẫu nhiên giữa 1 và 6, số nguyên này được gán cho biến
SoNgauNhien. Dòng mã lệnh cuối cùng hiển thị số ngẫu nhiên trong hộp thông báo.

10.Các hàm chuyển đổi kiểu


Visual Basic.NET có hai hàm chuyển đổi, chúng rất có ích khi bạn làm việc với kiểu số.
Đó là hàm Val và hàm Int. Hãy xem hàm Val trước. Hàm Val được sử dụng để chuyển đổi
một giá trị có kiểu chuỗi sang một giá trị có kiểu số. Nếu chuỗi chứa một dấu chấm thập
phân thì hàm Val trả về một số có kiểu Double (số thập phân chính xác kép). Nếu chuỗi
không chứa dấu chấm thập phân thì hàm Val trả về một số có kiểu Integer(kiểu số nguyên).
Hàm Val thường được sử dụng để chuyển đổi thuộc tính Text của một hộp văn bản thành
một giá trị số để sử dụng trong việc tính toán. Ví dụ:

Dim SoNguyen As Integer


SoNguyen = Val("123") + 123 'trả về giá trị 246

Dim SoThuc As Double


SoThuc = Val("123.22") + 123 'trả về giá trị 246.22

Hàm Int trả về phần nguyên của một số, nghĩa là, phần bên trái của dấu thập phân. Ví dụ:

Dim SoNguyen As Integer


SoNguyen = Int(123) 'trả về giá trị 123
SoNguyen = Int(123.45) 'trả về giá trị 123

105
11.Bài kiểm tra

106

You might also like