Phat Trien Ung Dung Co Ban Voi Vb.net - Format

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. 2. 3. 4.

Nháy nút Start Chọn Programs Chọn thư mục Visual Studio.Net 2003 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 là 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. 2. 3. 4.

Chọn File từ menu chính Chọn Save All từ thanh menu kéo xuống Để thoát Visual Studio.NET, chọn File từ menu chính 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 ứ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 họ chạy chương trình. Form chính như là bảng điều khiển trung tâm. Từ form này người dùng có thể chuyển đến (thực hiện) bất kì phần nào của chương trình.

Gợi ý Form1.vb có thể đổi tên thành một 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 tạp

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 Gợi ý thông báo trong form hội thoại chung. Sau khi ngườ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ưng thường không thực hiện nhấn vào nút OK. Vì vậy, bạn sẽ tự mình thiết kế form - form “lốp xẹp hơi”. Sau đó bạn thêm một vài điều khiển vào form và cài đặt các thuộc tính cho chúng. Tôi sẽ chỉ cho bạn cách thức mà các điều khiển form đáp lại các sự kiện như là 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.

đúng như những gì mô tả trong tài liệu. Các học sinh đạt hiệu quả nhất nếu làm đúng những gì trong sách hướng dẫn. Cần kiểm tra để tin chắc học sinh hiểu giáo trình khóa học.

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 khiển trên form. Ngoài ra nó còn được sử dụng một cách phổ biến để đưa ra các hướng dẫn hoặc chỉ ra thứ tự cho việc nhập thông tin trên form. Mở cửa sổ công cụ và nhấp đúp vào điều khiển nhãn. Nhãn được thêm vào form. Kéo nó đến vị trí

Gợi ý Tất cả các điều khiển là các đối tượng nhưng không phải tất cả các đối tượng 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 hoặc độ rộng.

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 String Integer Single Boolean

Ví dụ "Xin Chào" 123 55.12 True

Giải thích Văn bản được bao trong dấu nháy kép Số nguyên Số có dấu thập phân. 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" Gợi ý TextBox1.Text = TenToi 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 XName = "X là tên tôi" YName = "Y là tên tôi" TextBox1.Text = XName TextBox2.Text = YName

Gợi ý cho giáo viên Bài này sẽ dễ hiểu hơn nếu bạn làm theo hướng dẫn, gõ mã đúng theo mẫu vào chương trình Visual Studio của bạn.

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ử Cộng Trừ Nhân Chia

Kí hiệu trong đời sống + X /

Kí hiệu trong mã lệnh + * /

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

True True False False

True False True False

Vế trái AND Vế phải (kết quả) True False False False

Các khả năng xảy ra của toán tử OR (hoặc). Vế trái True True False False

Vế phải True False True False

Vế trái OR Vế phải (kết quả) True True True 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 True False

NOT Vế phải (kết quả) 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: Ý nghĩa Toán tử so sánh = Bằng >

Lớn hơn

<

Nhỏ hơn

>=

Lớn hơn hoặc bằng

<=

Nhỏ hơn hoặc bằng

<>

Khác nhau

Câu hỏi Biểu thức bên phải có bằng biểu thức bên trái không? Biểu thức bên trái có lớn hơn biểu thức bên phải không? Biểu thức bên trái có nhỏ hơn biểu thức bên phải khô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? 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? 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 giá trị lô gic khác. Xem các ví dụ sau: "ABC" = "DEF" "ABC" = "DEF"? Không, điều này sai. True=True True=True đúng không? Có, điều này đúng. True=False True=False đúng không? Không, điều này sai.

Gợi ý 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ý tự đầu tiên của toán tử 1 so sánh 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ứ 2, .... Khi so sánh chữ hoa và chữ thường là khác nhau.

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ở cửa thì tôi sẽ mua một máy nghe nhạc MP3. Viết dưới dạng giả mã nó có dạng như sau:

Gợi ý 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 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ó nhiều câu lệnh If và các đoạn mã và không cần quan tâm đến cửa hàng bách hóa có mở được để thụt vào tương ứng, hoặc hay không - không có máy nghe nhạc MP3! 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, Khi vòng lặp For kết thúc, LoopCounter được tăng lên 1. Hộp thông báo hiển thị giá trị 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 Gợi ý lặp mà không cần kết thúc nốt phần còn lại của vòng 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 trường hợp: Exit For, Exit Do, bên trong = 4. Khi vòng lặp thoát thì mã lệnh sau lệnh Exit Sub Next được thực hiện. Trong trường hợp này hộp thông 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 If LoopIndex = 4 Then MatchText = "TextBox1" End If Loop MessageBox.Show("Sau " & LoopIndex & " lần lặp đã khớp.")

Gợi ý Tên biến LoopIndex ở đây là tùy chọn. Nó có thể là LoopCounter, LoopVariable, X, hoặc là cái gì đó khác.

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 MessageBox.Show(WhileValue) WhileValue = WhileValue + 1 Loop While (WhileValue < 2)

Gợi ý Để điều kiện ở cuối lệnh lặp đảm 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. Một ví dụ thực tế sẽ làm cho điều này trở nên rõ ràng hơn nhiều. Mở cửa sổ mã lệnh trong dự án SimpleSub. Ngay tại dòng tiếp theo của dòng chứa lệnh End Sub của thủ tục ThongBao, nhập vào mã lệnh sau :

Tham số sau từ khóa ByVal có nghĩa là giá trị của tham số tuy được chuyền cho thủ tục nhưng giá trị ban đầu của tham số vẫn không thay đôi.

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 Dim Tong As Integer Tong = ThamSo1 + ThamSo2

As Integer)

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 As Integer NhanHaiSo = Thuaso1 * Thuaso2 End Function

Thuaso2 As Integer)

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