ในการใช้โปรแกรมต่างๆ บนระบบปฏิบัติการวินโดว์ เราจะสังเกตได้ว่าแต่ละโปรแกรมจะต้องมีเมนูเพื่อให้ผู้ใช้เลือกใช้โปรแกรมต่างๆ ได้สะดวก เมนูจะแสดงคำสั่งต่างๆ ที่โปรแกรมนั้นทำงาน โดยจะแสดงชื่อคำสั่งที่สั้นได้ใจความ และเข้าใจง่าย นอกจากนี้การสร้างและการออกแบบเมนูจะจัดกลุ่มและแสดงจุดประสงค์ของแต่ละกลุ่มเพื่อให้ผู้ใช้ค้นหาได้สะดวก เรียกใช้งานได้ถูกต้องบางเมนูอาจจะเห็นบ่อยๆ ในทุกๆโปรแกรม เช่น เมนู Edit > Cut, Copy และ Paste เพื่อใช้ในการคัดลอกออบเจ็กต์ต่างๆ เป็นต้น

จากบทที่ผ่านมาเราได้สร้างโปรแกรมประยุกต์ที่ทำงานบนวินโดว์ โดยแสดงผลเป็นฟอร์มมาแล้ว สำหรับโปรแกรมขนาดใหญ่ที่มีฟังก์ชันการทำงานจำนวนมาก มักจะมีการสร้างเมนูไว้ในโปรแกรมเพื่อรวบรวมคำสั่งต่างๆ ให้เป็นหมวดหมู่ ทำให้ง่ายต่อการใช้งานโปรแกรมที่สร้างขึ้น ในโปรแกรม Visual Basic มีคอมโพเนนต์สำหรับสร้างเมนูให้ใช้งานทำให้สร้างเมนูแบบ PullDown Menu และ PopUp Menu ได้ง่ายมาก ในบทนี้จะกล่าวถึงการสร้างเมนูและการใช้งานคุณสมบัติพื้นฐานของคอมโพเนนซ์ที่นำมาสร้างเมนู

เมนูเป็นเอกลักษณ์อย่างหนึ่งของโปรแกรมบนวินโดวส์ เพราะเป็นที่เก็บคำสั่งต่างๆ ที่โปรแกรมมีไว้ให้ผู้ใช้เรียกใช้ ส่วนประกอบต่างๆ ของเมนูแสดง

สำหรับการออกแบบเมนูที่ดีเราจำเป็นต้องจัดกลุ่มคำสั่งต่างๆ เป็นหมวดหมูและนำมาไว้ในแต่ละเมนูโดยอาจจะแบ่งคำสั่งบางชุดออกจากกันด้วยเส้นแบ่ง ดังที่เห็นในรูป

เมนูที่ใช้กันในโปรแกรมประยุกต์นั้นส่วนใหญ่แบ่งได้สองประเภทคือ PullDown Menu และ PopUp Menu เมนูแบบ PullDown เป็นเมนูที่มีตำแหน่งอยู่บนโปรแกรมแน่นอน เมื่อผู้ใช้งานเลือกเมนูนี้ก็อาจมีคำสั่งหรือเมนูย่อยๆ ให้เลือกใช้งานอีก ส่วนเมนูแบบ PopUp เป็นเมนูที่ไม่มีตำแหน่งที่แน่นอนในโปรแกรม ผู้ใช้อาจต้องคลิกที่ตำแหน่งใดตำแหน่งหนึ่งในโปรแกรมจึงจะแสดงเมนูออกมา สำหรับในหัวข้อนี้จะแสดงการสร้างเมนูแบบ PullDown
ในการสร้างเมนูบนฟอร์มสามารถทำได้โดยนำคอมโพเนนต์   MenuStrip มาใช้ได้คอมโพเนนต์ตัวนี้สามารถจัดการในเรื่องต่างๆ เกี่ยวกับเมนู เช่น การเพิ่ม ลบ และแก้ไขรายการที่ปรากฏในเมนู การกำหนดคีย์ลัด (ShortCuts) สำหรับเรียกใช้คำสั่ง เป็นต้น โดยเมนูที่สร้างขึ้นจะมีลักษณะเหมือนคอนโทรลทั่วไป ที่สามารถกำหนดคุณสมบัติของเมนูทางหน้าต่างคุณสมบัติได้ และตอบสนองต่ออีเวนต์ของเมนูได้ด้วย สำหรับตัวอย่างต่อไปเป็นการสร้างเมนูแบบ PullDown ให้กับโปรแกรมประยุกต์ทำได้โดยการนำคอมโพเนนต์ MenuStrip มาวางบนฟอร์ม คอมโพเนเนต์ตัวนี้จะอยู่ในกลุ่ม Menus & Toolbars การสร้างเมนูทำได้ขั้นตอนต่อไปนี้
1. สร้างโปรเจ็กต์ใหม่แล้วเลือกคอมโพเนนต์ MenuStrip มาวางบนฟอร์ม

2. สัญลักษณ์ของคอมโพเนนต์ MenuStrip จะแสดงบริเวณด้านล่างของ Form Designer ส่วนบนฟอร์มจะแสดงเมนูว่างเปล่าออกมา และปรากฏช่อง "Type Here" สำหรับพิมพ์รายการต่างๆของเมนูย่อยดังรูป

3. ทดลองสร้างเมนูย่อย โดยกำหนดให้เป็นเมนู File และมีคีย์ลัดคือคีย์ F โดยพิมพ์ &File ลงไปในช่อง Type Here เมื่อพิมพ์ข้อความลงไป โปรแกรมจะแสดงช่องสำหรับสร้างรายการย่อยต่อไปอีก และแสดงหน้าต่างคุณสมบัติของเมนู File ออกมาด้วย ดังรูป ในเมนูที่สร้างขึ้นหัวข้อหลักจะเรียกว่า เมนูบาร์ (Menu Bar) รายการแต่ละเมนูเรียกว่า เมนูไอเท็ม (Menu Item) ส่วนรายการย่อยของเมนูไอเท็มเรียกว่า เมนูย่อยหรือซับเมนู (Sub Menu)

4. ให้ทดลองสร้างเมนูที่สองเป็นเมนู "Edit" เมนูที่ต้องการให้เมนูย่อยทำได้โดยคลิกเมนูย่อยทางขวามือของรายการนั้นๆ ให้ทดลองเพิ่มรายการลงไปในเมนูดังรูป

5. เมื่อต้องการออกจากเมนูย่อยเพื่อกลับไปเมนูหลัก  ก็สามารถใช้เมาส์คลิกที่เมนูหลักได้ทันที  ตัวอย่างเช่น  ใช้เมาส์คลิกที่เมนู  File  จะเป็นการเพิ่มเติมเมนูย่อยให้กับเมนู  File

6. ให้ทดลองเพิ่มรายการเข้าไปในเมนู  File  ดังรูปต่อไปนี้  ในการเพิ่มรายการนั้นถ้าหากต้องการให้เป็นเมนูในลักษณะใด  เช่น  ให้เป็นเท็กซ์บ็อกซ์  (TextBox)  หรือคอมโบบ็อกซ์  (ComboBox)  หรือมีการแทรกรายการใหม่ให้คลิกเมาส์ขวาแล้วเลือก  Insert  ดังรูป

7. ทดลองเพิ่มเมนูรายการต่างๆลงไปดังรูป  ถ้าหากต้องการให้เมนูไอเท็มหรือรายการใดแสดงเครื่องหมายเช็ค  (Checked)  ด้านหน้าเมนู เพื่อแสดงว่าได้เลือกรายการนั้นอยู่สามารถกำหนดได้ในหน้าต่างคุณสมบัติ  เลือก  คุณสมบัติ  Checked  ให้เป็น  True  ก็จะแสดงเครื่องหมายเช็คออกมา  ดังรูป

8. ในการสร้างเมนูนั้นถ้าหากป้อนรายการไอเท็มผิดพลาด  หรือต้องการแก้ไขลำดับเมนูเพื่อเรียงลำดับก่อนหลังใหม่  สามารถทำได้โดยการคลิกเมาส์ค้างไว้ที่ไอเท็ม แล้วลากไปยังตำแหน่งที่ต้องการ หรือถ้าต้องการให้มีเส้นคั่นระหว่างไอเท็ม สามารถทำได้โดยการพิมพ์เครื่องหมาย – ไปที่รายการนั้นดังรูป

หลังจากที่ได้สร้างรายการต่างๆ ให้กับเมนูแล้ว รายการแต่ละรายการถือว่าเป็นคอนโทรลตัวหนึ่งถ้าหากต้องการให้โปรแกรมประมวลอย่างไรเมื่อมีการคลิกเลือกรายการนั้นจะต้องมีการสร้าง อีเวนต์ให้กับรายการนั้นๆ เมธอดที่แสดงการทำงานของอีเวนต์แต่ละรายการจะเริ่มต้นด้วยชื่อไอเท็มแล้วตามด้วยคำว่า ToolStripMenuItems ตัวอย่างเช่นถ้าหากเมื่อเลือกรายการ Exit ในเมนู File แล้วให้ออกจากโปรแกรม เมธอดของอีเวนต์ให้กับไอเท็ม Exit สามารถทำได้ดังขั้นตอนต่อไปนี้
1. คลิกเมาส์ที่รายการ Exit
2. เปิดหน้าต่างคุณสมบัติของรายการ Exit แล้วคลิกที่ไอคอน Events
3. ดับเบิลคลิกที่อีเวนต์ Click

4. โปรแกรมจะสร้างอีเวนต์ของรายการ Exit ออกมา ให้เขียนโค้ดสำหรับการจบโปรแกรมดังต่อไปนี้

5. สำหรับไอเท็ม Summary ในเมนู Display นั้นจะมีเครื่องหมายเช็คอยู่หน้าไอเท็มดังนั้นรายการนี้จะเป็นได้สองกรณีคือ เลือกและไม่เลือก เราสามารถกำหนดค่าเริ่มต้นให้กับการเช็ครายการนี้ได้โดยกำหนดในหน้าต่างคุณสมบัติ

6. เมื่อนำเมาส์คลิกที่ไอเท็ม  Summary  แล้วต้องการเลือกรายการเปลี่ยนกลับไปมาทำได้โดยการสร้างอีเวนต์ให้กับไอเท็มนี้  แล้วเขียนโค้ดเพื่อกำหนดคุณสมบัติให้กับไอเท็ม  Summary  เพื่อให้เลือกหรือไม่เลือกได้ดังต่อไปนี้

Private Sub SummaryToolStripMenuItem_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles SummaryToolStripMenuItem.Click

End Sub

7. เพิ่มอีเวนต์ให้กับเมนู  Help  โดยเขียนโปรแกรมให้แสดงกล่องข้อความออกมาเมื่อคลิกเมนู  Help  โดยเขียนดังตัวอย่างต่อไปนี้

ทดลองรันโปรแกรมแล้วให้คลิกเมนูต่างๆ  ที่ได้สร้างมา  ถ้าหากคลิกปุ่ม  Help  โปรแกรมจะแสดงกล่องข้อความออกมาดังนี้

ในการพัฒนาโปรแกรมที่มีรายการของเมนูเป็นจำนวนมาก  บางครั้งเราอาจต้องการจัดอันดับเมนูใหม่  หรือเพิ่มลงเมนู   เราสามารถใช้หน้าต่าง  Items  Collection  มาช่วยได้  โดยหน้าต่างนี้ถ้าเป็น  MenuStrip  จะเรียกหน้าต่างนี้ผ่านคุณสมบัติ  Items  ซึ่งเป็นคุณสมบัติแบบคอลเลคชัน  (Collection)  แต่ถ้าเป็นคอนโทรล  ToolStripMenuItem  จะเรียกหน้าต่างนี้ผ่านคุณสมบัติ  DropDownItems

หน้าต่าง  Items  Collection  Editor  จะช่วยให้การจัดการเมนูไอเท็มทำได้ง่ายขึ้น  เช่น  การเพิ่ม  การลบ  การจัดเรียงลำดับเมนูไอเท็ม  ส่วนทางฝั่งขวาจะแสดงคุณสมบัติของเมนูไอเท็มที่เราเลือก  ซึ่งสามารถแก้ไขได้ตามต้องการ  และถ้าเราต้องการเพิ่มเมนูไอเท็มที่เป็นลูกของลูกก็สามารถทำได้โดยการไปที่คุณสมบัติ  Items  หรือ  DropDownItems  ของไอเท็มลูกนั้น  เพื่อเรียกหน้าต่าง  Items  Collection  Editor  ตัวใหม่ที่ขึ้นมาซ้อนทับหน้าต่างเดิม

ไดอะล็อกเป็นฟอร์มประเภทหนึ่งที่นิยมใช้ในการติดต่อกับผู้ใช้  โดยจะแสดงออกมาเป็นหน้าต่างบนโปรแกรมที่กำลังใช้งานอยู่  เพื่อให้ผู้ใช้เลือกรายการต่างๆ  หรือป้อนค่าตามที่แสดงไว้ในไดอะล็อก  ตัวอย่างเช่นในโปรแกรมไมโครซอฟต์เวิร์ด  เมื่อเลือกเมนูบันทึกไฟล์ก็จะปรากฏไดอะล็อกออกมา
โปรแกรม  VB  มีคอนโทรลสำหรับสร้างไดอะล็อกไว้ให้ใช้งานโดยคอนโทรลตัวนี้จะอยู่ในหมวดหมู่  Dialogs  ในหน้าต่างทูลบ็อกซ์ดังรูปไดอะล็อกที่นิยมใช้กันมีดังนี้

ไดอะล็อกที่กล่าวมาทุกตัวจะมีเมธอด   ShoeDialog  สำหรับแสดงไดอะล็อกที่กำหนดจากนั้นผู้ใช้งานสามารถกระทำการต่างๆ  กับไดอะล็อกนั้นได้  การให้โปรแกรมแสดงไดอะล็อกทำได้โดยเขียนคำสั่งดังต่อไปนี้

ตัวอย่างเช่น

ColorDialog

• Color เป็นค่าสีที่ได้จากการเลือก หลังจากกดปุ่ม OK
FolderBrowserDialog
• RootFoloder เป็นโฟลเดอร์เริ่มต้นของไดอะล็อกนี้
• SelectedPath เป็นชื่อพาธที่ได้จากการเลือก หลังจากกดปุ่ม OK
FontDialog
• Font เป็นชื่อฟอนต์ที่ได้จาการเลือก หลังจากกดปุ่ม OK
OpenFileDialog และ SaveFileDialog
• FileName เป็นชื่อไฟล์ที่ได้จากการเลือก หลังจากกดปุ่ม Open/Save
• InitialDirectory เป็นโฟลเดอร์เริ่มต้นของไดอะล็อกนี้

ตัวอย่างการใช้งานไดอะล็อกจัดการฟอนต์
สำหรับการนำไดอะล็อกมาใช้ สามารถทำได้ดังขั้นตอนในตัวอย่างต่อไปนี้
1. เปิดโปรเจ็กต์ที่ผ่านมาแล้วเพิ่มข้อความคำว่า "Programmer: Your Name" ลงไปดังรูป และให้ชื่อว่า Label1
2. เพิ่มไอเท็มในเมนู Edit ลงไป โดยโปรแกรมที่ออกแบบขึ้นมาเมื่อเลือกไอเท็ม Font จะให้โปรแกรมเลือกฟอนต์ตัวอักษรที่แสดงบนฟอร์มได้
3. สร้างอีเวนต์ให้กับรายการ Font โดยเลือกเป็นอีเวนต์ Click
4. นำ FontDialog จากทูลบ็อกซ์ มาวางบนฟอร์ม โปรแกรมจะไม่แสดงผลคอนโทรลตัวนี้ แต่จะปรากฏอยู่ด้านล่างของ Form Designer และโปรแกรมจะกำหนดชื่อให้เป็น FontDialog1

5. เขียนโค้ดให้กับอีเวนต์  Click  โดยเมื่อคลิกที่ไอเท็ม  Font  จะต้องให้โปรแกรมแสดงไดอะล็อกของฟอนต์ขึ้นมา  แล้วให้ผู้ใช้เปลี่ยนฟอนต์ของตัวอักษรที่แสดงบนฟอนต์ได้  เขียนโค้ดได้ดังนี้

จากคำสั่งที่เขียนจะเป็นการสั่งให้  FontDidlog1 แสดงไดอะล็อกออกมา  เมื่อผู้ใช้เลือกฟอนต์ตัวใดค่าที่เลือกจะอยู่ใน  FontDialog1.Font  จากนั้นก็จะกำหนดค่านี้ให้เป็นฟอนต์ของข้อความที่อ้างโดย  Label1  เมื่อรันโปรแกรมแล้วเลือกไอเท็ม  Font  จะเป็นดังนี้

ตัวอย่างการใช้งานไดอะล็อกจัดการสี
การใช้งานไดอะล็อกจัดการเกี่ยวกับสีสามารถทำได้ดังตัวอย่างต่อไปนี้ ซึ่งจะให้ผู้ใช้นำโปรแกรมที่ผ่านมา นำมาพัฒนาต่อ เมื่อผู้ใช้เลือกสีจะทำให้ข้อความบนลาเบลแสดงเป็นสีตามที่กำหนด
1. เปิดโปรเจ็กต์ที่ผ่านมาแล้วเพิ่มไอเท็ม Color ลงไปดังรูป จากนั้นเลือกอีเวนต์ Click

2. นำ ColorDialog จากทูลบ็อกซ์มางวางบนฟอร์ม
3. สร้างอีเวนต์ให้กับไอเท็ม Color โดยให้โปรแกรมแสดงไดอะล็อกขึ้นมาเพื่อเลือกสี จากนั้นอ่านค่าสีจากที่เลือกในไดอะล็อกแล้วนำไปกำหนดให้กับตัวอักษรใน Label1 โดยเขียนโค้ดได้ดังนี้

เมื่อทดลองรันโปรแกรมแล้วเลือก Color โปรแกรมจะแสดงไดอะล็อกจัดการค่าสีออกมาดังรูป เมื่อใช้เมาส์คลิกเลือกสีแล้วกด OK โปรแกรมจะทำให้สีของตัวอักษรเปลี่ยนไปตามสีที่เลือก

เมนูแบบ PopUp เป็นเมนูที่จะแสดงขึ้นเมื่อใช้เมาส์คลิกขวาที่คอนโทรลตัวใดตัวหนึ่ง จากนั้นผุ้ใช้โปรแกรมสามารถเลือกรายการต่างๆ ที่อยู่ในเมนูได้ ในโปรแกรม Visual Basic สามารถสร้างเมนูแบบ Popup ได้โดยใช้คอมโพเนนต์ ContextMenuStrip โดยทำได้ดังตัวอย่างต่อไปนี้
1. เปิดโปรเจ็กต์ใหม่แล้วนำคอมโพเนนต์ ContextMenuStrip มาวางบนฟอร์มดังรูปโดยโปรแกรมจะกำหนดชื่อคอมโพเนนต์นี้เป็น contextMenuStrip1

2. ปรับไตเติลของฟอร์มตามต้องการ แล้วสร้างออบเจ็กต์สำหรับเป็นจุดที่ต้องการแสดงเมนูแบบ Popup โดยนำลาเบลมาวาง สร้างข้อความคำว่า "คลิกตรงนี้เลยครับ" และกำหนดชื่อออบเจ็กต์เป็น Label1
3. เปิดหน้าต่างคุณสมบัติของ Label1 แล้วเลือกรายการ ContextMenuStrip

4. จากนั้นคลิกที่สัญลักษณ์ contexMenuStrip1 ที่อยู่ในด้านล่างฟอร์ม โปรแกรมจะแสดง ContexMenuStrip ออกมา ให้ทดลองพิมพ์ลงไปสามรายการดังรูป คือ Color.., Font.., และ Exit..
5. สร้างอีเวนต์ให้กับรายการต่างๆ โดยเลือกรายการที่ต้องการเขียนโค้ด จากนั้นเปิดหน้าต่างคุณสมบัติของรายการนั้น แล้วเลือกอีเวนต์ Click เพื่อสร้างเมธอดให้กับอีเวนต์

6. นำ ColorDialog และ FontDialog มาวางบนฟอร์ม
7. เขียนโค้ดสำหรับรายการ Color โดยให้แสดงไดอะล็อก เมื่อมีการเลือกสีใดในไดอะล็อกจัดการค่าสีให้นำสีนั้นมาเป็นสีให้กับตัวอักษร Label1
8. เขียนโค้ดสำหรับรายการ Font เพื่อใช้สำหรับเลือกฟอนต์ให้กับตัวอักษร
9. เขียนโค้ดสำหรับรายการ Exit เพื่อใช้สำหรับออกจากโปรแกรม
สำหรับโค้ดโปรแกรมแสดงได้ดังนี้

ทดลองรันโปรแกรม เมื่อนำเมาส์ไปวางบนตัวอักษรแล้วคลิกขวาโปรแกรมจะแสดงเมนูแบบ PopUp ออกมา ให้ทดลองเลือกรายการต่างๆแล้วสังเกตสิ่งที่เกิดขึ้นกับตัวอักษรที่แสดงผลอยู่

โปรแกรมที่ 1 ตัวอย่างนี้จะทดลองสร้างโปรแกรมแสดงรูปภาพ โดยสามารถเลือกภาพจากโฟลเดอร์ที่ต้องการได้ โดยนำคอมโพเนนต์ต่างๆ ที่ได้ศึกษามาแล้วมาใช้งาน โดยทำตามขั้นตอนต่อไปนี้
1. สร้างโปรเจ็กต์ใหม่ให้ชื่อว่า Show_pic
2. นำคอมโพเนนต์ MenuStrip, OpenFileDialog และ FolderBrowserDialog มาวางบนฟอร์ม แล้วกำหนดค่าให้ออบเจ็กต์ต่างๆ ดังนี้

3. สร้างเมนู  File  โดยมีไอเท็ม  Load  สำหรับเปิดภาพ  และไอเท็ม  Exit  สำหรับออกจากโปรแกรม

4. เขียนโค้ดให้กับโปรแกรม เมื่อเลือกไอเท็ม Load ในเมนู File โปรแกรมจะให้เลือกไปยังโฟลเดอร์ที่ใช้เก็บภาพตามที่ต้องการ เมื่อเลือกชื่อไฟล์ภาพที่ต้องการ โปรแกรมจะแสดงภาพนั้นทางพิกเจอร์บ็อกซ์ และแสดงชื่อไฟล์นั้นทางเท็กซ์บ็อกซ์ ดังนั้นโค้ดโปรแกรมสำหรับอีเวนต์ของ ไอเท็ม Load เขียนได้ดังนี้

จากโค้ดที่เขียนขึ้น เริ่มแรกจะแสดงไดอะล็อกค้นหาโฟลเดอร์ (1) เพื่อให้ผู้ใช้เลือกโฟลเดอร์ที่เก็บรูปภาพที่ต้องการแสดงผล จากนั้นจะเรียกใช้คุณสมบัติ SelectedPath (2) เพื่อนำพาธของโฟลเดอร์ที่ต้องการติดต่อมาเก็บไว้ใน dpath เพื่อใช้สำหรับเรียกรูปภาพขึ้นมาแสดงผล สำหรับการใช้ไดอะล็อกเปิดไฟล์นั้นจะต้องกำหนดพาธที่ต้องการแสดงไดอะล็อกเสียก่อน โดยนำค่าจาก dpath ไปกำหนดให้กับ InitialDirectory (3) ต่อมาแสดงไดอะล็อกเปิดไฟล์ (4) แล้วนำชื่อไฟล์ที่เลือกไปแสดงผลทางเท็กซ์บ็อกซ์ (5) จากนั้นนำชื่อไฟล์ไปกำหนดให้กับคุณสมบัติ ImageLocation เพื่อเสดงภาพทางพิกเจอร์บ็อกซ์ (6)
ดังนั้นเมื่อรันโปรแกรมแล้วเลือกไอเท็ม Load การทำงานต่างๆ จะเป็นดังนี้
1. แสดงไดอะล็อกค้นหาโฟลเดอร์ดังรูป

2. ให้ใช้เมาส์เลือกโฟลเดอร์ที่ต้องการเปิดภาพ ในที่นี้จะเลือกโฟลเดอร์ Picture แล้วคลิกปุ่ม OK จากนั้นโปรแกรมจะแสดงไดอะล็อกเปิดไฟล์ออกมาดังรูป

3. ให้ใช้เมาส์เลือกรูปภาพที่ต้องการแสดงผลจากนั้นคลิกปุ่ม  Open  โปรแกรมจะแสดงรูปที่เลือกออกมา

ในโปรแกรมนิยมนำคำสั่งหรือฟังก์ชันการทำงานที่ใช้บ่อยๆ มารวมไว้เป็นทูลบาร์ โดยแสดงเป็นปุ่มหรือตัวอักษรเล็กๆ เรียงกันอยู่ด้านบนของโปรแกรม ทำให้ผู้ใช้สามารถสั่งงานโปรแกรมได้รวดเร็ว การสร้างเมนูแบบทูลบาร์นี้ทำได้โดยใช้คอนโทรล ToolStrip ซึ่งมีการใช้งานคล้ายกับ MenuStrip เมื่อนำคอนโทรลตัวนี้มาวางบนฟอร์ม โปรแกรมจะแสดงตัวเลือกว่าจะใช้คอนโทรลตัวใดดังรูป

สำหรับปุ่มต่างๆ ที่แสดงผลบนทูลบาร์สามารถเลือกได้ดังนี้
• Button เป็นรูปแบบที่ใช้งานกันทั่วไปโดยจะแสดงเป็นปุ่มบนทูลบาร์
• Label เป็นแถบข้อความ
• Split Button เป็นปุ่มและสามารถคลิกเปิดเป็นเมนูอีกได้
• DropDownButton เป็นปุ่มสำหรับเปิดเมนูย่อย
• Sepatator เป็นตัวแยกหมวดหมู่คอนโทรลบนทูลบาร์
• ComboBox เป็นรายการให้เลือกและสามารถใส่ข้อมูลเข้าไปได้โดยตรง
• TextBox เป็นช่องรับข้อความ
• ProgressBar แสดงการทำงาน โดยทั่วไปแล้วไม่นิยมใช้บนทูลบาร์
เมื่อเลือกปุ่มแต่ละประเภทมาใช้งานแล้ว ปุ่มแต่ละปุ่มยังมีคุณสมบัติที่ต้องศึกษาเพิ่มเติมอีกด้วยการกำหนดค่าการทำงานต่างๆ สามารถกำหนดได้ที่หน้าต่างคุณสมบัติของปุ่มนั้นๆ สำหรับในหัวข้อนี้จะยกตัวอย่างการใช้งานปุ่ม Button และแบบ Label เท่านั้น โดยการสร้างทูลบาร์สามารถทำได้ดังนี้
1. สร้างโปรเจ็กต์ใหม่แล้วนำคอนโทรล ToolStrip มาวางบนฟอร์ม คลิกปุ่มลูกศรแล้วเลือกรูปแบบเป็น Button
2. โปรแกรมจะแสดงรูปปุ่มออกมาโดยปรากฏเป็นรูปภาพ และหน้าต่างคุณสมบัติของปุ่มนั้น

ถ้าหากเปิดหน้าต่างคุณสมบัติของปุ่มออกมา จะพบว่ามีคุณสมบัติอยู่หลายรายการ สำหรับรายการที่ใช้บ่อยๆ มีดังนี้
• Image รูปภาพที่แสดงบนปุ่ม ถ้าหากคลิกที่ปุ่มนี้สามารถเลือกรูปภาพได้
• ImageScaling การปรับขนนาดภาพ ถ้าเลือกเป็น SizeToFit จะปรับให้พอดีกับทูลบาร์
• DisplayStyle เลือกรูปแบบการแสดงผลให้แสดงเป็นข้อความหรือรูปภาพ
• Text ข้อความที่แสดงบนปุ่ม
• AutoSize ขนาดปุ่ม ถ้าเป็น True ขนาดปุ่มจะพอดีกับรูป ถ้าเป็น False จะกำหนดเอง
• Enabled การใช้ปุ่ม ถ้าเป็น True ปุ่มนี้จะใช้งานได้ ถ้าเป็น False ปุ่มจะกลายเป็นสีจาง
• TooltipText ข้อความทูลทิป เมื่อนำเมาส์มาวางบนปุ่ม

3. ถ้าหากคลิกเมาส์ขวาโปรแกรมจะแสดงเมนูออกมา ถ้าหากเลือก Set Image โปรแกรมจะแสดงหน้าต่างให้เลือกรูปภาพมาใช้กับปุ่ม

4. สร้างปุ่มต่อไปโดยเลือกเป็นแบบ Label แล้วพิมพ์ข้อความว่า "เปิดไฟล์" ในหน้าต่างคุณสมบัติ โปรแกรมจะแสดงคำว่าเปิดไฟล์บนปุ่ม

ปุ่มต่างๆที่สร้างขึ้นมาเป็นทูลบาร์  เมื่อเลือกที่ไอคอน  Events  จะทำให้เพิ่มการจัดการอีเวนต์ให้กับปุ่มต่างๆได้

โปรแกรมบางประเภทอาจต้องสร้างฟอร์มขึ้นมามากกว่าหนึ่งฟอร์ม โปรแกรม Visual Basic สามารถสร้างฟอร์มขึ้นมาใช้งานเพิ่มในโปรเจ็กต์ได้เช่นกัน โดยฟอร์มแต่ละฟอร์มจะมีชื่อโปรแกรมแยกออกจากกัน แต่สามารถเรียกมาใช้งานร่วมกันได้ การสร้างฟอร์มใหม่ศึกษาได้ดังตัวอย่างต่อไปนี้
นำโปรแกรม LuckySeven จากบทที่ 7 มาพัฒนาเพิ่มเติม ให้มีปุ่ม Help สำหรับแนะนำการเล่นโปรแกรม เมื่อผู้เล่นคลิกปุ่มนี้
โปรแกรมจะแสดงฟอร์มใหม่ออกมา โดยขั้นตอนการพัฒนาเป็นดังนี้
1. เปิดโปรเจกต์ LuckySeven แล้วเข้าสู่หน้าต่างการออกแบบโปรแกรม คลิกขวาที่ชื่อ โปรเจกต์ เลือก Add > Windows Form ดังรูป

2. โปรแกรมจะแสดงหน้าต่าง  Add  New  Item  ออกมา  ให้เลือก  Windows  Form  แล้วตั้งชื่อฟอร์มเป็น  HelpInfo.vb  จากนั้นคลิก  Add

3. ฟอร์มที่สองจะมีชื่อว่า  HelpInfo.vb  แล้วจะถูกเพิ่มเข้าไปในโปรเจ็กต์  ถ้าหากดูในหน้าต่าง  Solution  จะเห็นไฟล์ของฟอร์มนี้แสดงออกมา

4. สร้างโปรแกรมของฟอร์มที่สอง  โดยนำคอนโทรลลาเบล  เท็กบ็อกซ์  และปุ่มกด  มาวางบนฟอร์ม
5. ปรับคุณสมบัติของ  Multiline  ของเท็กบ็อกซ์ให้เป็น  True  เพื่อปรับขนาดได้ในแนวตั้งสำหรับคุณสมบัติอื่นๆ  ให้ปรับดังตารางต่อไปนี้

6. ปรับตำแหน่งของออบเจ็กต์ให้สวยงามดังรูป  สำหรับรายละเอียดในเท็กซ์บ็อกซ์สามารถพิมพ์ได้ตามต้องการ

7. เขียนโปรแกรมให้กับปุ่ม  OK  โดยใช้คำสั่ง  Close()  เพื่อใช้เปิดหน้าต่าง
8. ปรับปรุงฟอร์มหลัก  โดยนำปุ่มกดมาวางเพิ่ม  แล้วปรับคุณสมบัติให้แสดงคำว่า  “Help”   ดังรูป

9. เขียนโปรแกรมให้กับปุ่ม  Help  ดังต่อไปนี้

การเขียนลักษณะนี้ที่เริ่มต้นด้วยคำว่า  My  จะเป็นการบอกว่าในฟอร์มที่กำลังแอคทีฟอยู่นี้ให้เรียกไฟล์  HelpInfo  ขึ้นมาแสดงผล  โดยระหว่างการพิมพ์คำสั่ง  โปรแกรมของ  VB  จะหาไฟล์ของฟอร์มออกมาได้เองดังรูป

ให้ทดลองรันโปรแกรมและศึกษาสิ่งต่างๆที่เกิดขึ้น

จากที่ได้ศึกษามาทั้งหมดเราได้กล่าวถึงคอนโทรลและคอมโพเนนต์พื้นฐานที่ใช้งานกันทั่วๆไปมาแล้ว  ซึ่งจะพบว่าออบเจ็กต์ที่นำมาวางบนฟอร์มแล้วมีรูปร่างหน้าตาที่ติดต่อกับผู้ใช้ได้เราจะเรียกว่าคอนโทรล  ส่วนคอมโพเนนต์ก็คือคอนโทรลที่ไม่มีส่วนติดต่อกับผู้ใช้  ใน .NET  Framework  ยังมีคอนโทรลอื่นๆและคอมโพเนนต์อีกมากมาย  ในหัวข้อนี้จะยกตัวอย่างคอนโทรลและคอมโพเนนต์บางตัวที่น่าสนใจ

คอนโทรล  NumericUpDown

คอนโทรลตัวนี้ใช้สำหรับปรับค่าตัวเลข  โดยจะเพิ่มหรือลดตัวเลขเป็นลำดับต่อเนื่องในช่วงที่กำหนด  ทำให้สามารถกำหนดขอบเขตของตัวเลขได้  การป้อนตัวเลขจะมีลูกศรคลิกเพิ่มค่าหรือลดค่าตามต้องการ  ในโปรแกรมนิยมนำคอนโทรลตัวนี้มาแทนการป้อนข้อมูลตัวเลขเข้าทางเท็กซ์บ็อกซ์ทำให้ข้อมูลที่ป้อนเป็นตัวเลขเสมอ  ไม่ต้องเขียนโปรแกรมดักจับข้อผิดพลาดว่าเป็นตัวเลขจริงหรือไม่

คุณสมบัติที่สำคัญของคอนโทรลตัวนี้ได้แก่
• Increment ค่าที่เพิ่มหรือลดในแต่ละครั้ง
• Minimum กำหนดเป็นค่าต่ำสุด
• Maximum กำหนดเป็นค่าสูงสุด
• Value ค่าของตัวเลข

โปรแกรมที่ 2 การสร้างโปรแกรมป้อนข้อมูลนักศึกษา โดยให้ป้อนชื่อ ชั้นปี และจำนวนวิชาที่เรียนลงไป โดยสร้างโปรเจ็กต์ใหม่ นำคอนโทรล NumericUpDown มาใช้ แล้วกำหนดชื่อให้ออบเจ็กต์ต่างๆ ดังนี้

โปรแกรมที่ออกแบบขึ้นจะใช้เท็กซ์บ็อกซ์ในการรับชื่อ – นามสกุล  ให้ผู้ใช้ป้อนชื่อและนามสกุลเข้าไป  และจะนำ  NumericUpDown  มาใช้สองจุด  คือใช้รับค่าชั้นปี  โดยกำหนดค่าต่ำสุดเป็น 1 และค่าสูงสุดเป็น 5  และใช้รับจำนวนวิชาที่เรียนโดยกำหนดค่าต่ำสุดเป็น 1 และค่าสูงสุดเป็น 10 โปรแกรมที่ออกแบบขึ้นต้องการให้คลิกปุ่ม “บันทึก” แล้วแสดงข้อมูลที่ป้อนออกมาทางกล่องข้อความดังนั้นจะต้องสร้างอีเวนต์ให้กับปุ่ม “บันทึก”  และเขียนโค้ดให้อ่านข้อมูลที่ป้อนเข้าไปมาแสดงผลโดยข้อมูลที่ป้อนเข้าไปทางเท็กซ์บ็อกซ์จะเป็นข้อความสตริง  แต่ข้อมูลที่เลือกจาก  NumericUpDown  จะเป็นตัวเลข  เราสามารถใช้คุณสมบัติ  Value  อ่านค่าออกมาได้  โค้ดที่เขียนขึ้นจะเป็นดังนี้

จากโปรแกรมจะพบว่าจะนำข้อมูลทั้งหมดมารวมกันเป็นสตริง  strShow   ดังนั้นจะต้องนำค่าที่ได้จาก  NumericUpDown  มาเปลี่ยนเป็นข้อความสตริงเสียก่อนโดยใช้เมธอด  ToString  สำหรับ  Environment.NewLine  จะเป็นรหัสควบคุมสำหรับขึ้นบรรทัดใหม่  เมื่อรันโปรแกรมผลลัพธ์จะเป็นดังนี้

คอนโทรล DateTimePicker
คอนโทรลตัวนี้เป็นเครื่องมือสำหรับป้อนวัน-เดือน-ปี และเวลา ทำให้ข้อมูลที่ได้จากการป้อนมีความถูกต้องมากยิ่งขึ้น การนำคอนโทรลตัวนี้มาใช้ทำให้โปรแกรมสามารถอ่านค่าวันและเวลาจากการป้อนเข้าไปมาใช้งานได้ สำหรับคุณสมบัติที่สำคัญของคอนโทรลตัวนี้ได้แก่
• MinDate ขอบเขตของวันเดือนปีต่ำสุดที่จะนำมาแสดงผล
• MaxDate ขอบเขตของวันเดือนปีสูงสุดที่จะนำมาแสดงผล
• ShowUpDown เลือกวิธีการแสดงผลว่าจะแสดงผลเป็นลูกศรหรือเป็นปฏิทิน
• Format กำหนดรูปแบบการแสดงผลวันเดือนปีและเวลา โดยมีรูปแบบดังนี้
- Long ให้แสดงเฉพาะวันเดือนปีแบบเต็มรูปแบบ
- Short ให้แสดงเฉพาะวันเดือนปีแบบสั้น
- Time ให้แสดงเฉพาะเวลา
- Custom กำหนดรูปแบบตามต้องการ
• Value ค่าวันเดือนปีและเวลาจากการเลือกจากคอนโทรล

โปรแกรมที่ 3 ตัวอย่างนี้จะนำโปรแกรมที่ 2 มาปรับ โดยให้กำหนดวันที่ในการลงทะเบียนได้ โดยเพิ่มคอนโทรล DataTimePicker เข้าไป และให้มีชื่อออบเจ็กต์ดังนี้

เมื่อกดปุ่ม "บันทึก"จะให้โปรแกรมแสดงผลลัพธ์ออกมาด้วยว่าลงทะเบียนเมื่อวันที่เท่าไหร่ดังนั้นจะต้องปรับโค้ดโปรแกรมของอีเวนต์ปุ่มบันทึกใหม่ ดังนี้

เมื่อรันโปรแกรมแล้วป้อนข้อมูลต่างๆ เข้าไปดังรูป  เมื่อคลิกป้อนวันลงทะเบียน  โปรแกรมจะแสดงเป็นปฏิทินให้เลือก  ถ้าเลือกแล้วให้คลิกปุ่ม  “บันทึก”  โปรแกรมจะแสดงผลลัพธ์ออกมา

คอนโทรล MonthCalendar
คอนโทรลตัวนี้ใช้สำหรับรับค่าวันเดือนปีโดยจะแสดงปฏิทินเป็นรายเดือนให้เลือกวันและสามารถใช้ลูกศรเลื่อนไปยังเดือนถัดไปได้ คุณสมบัติและเมธอดที่สำคัญของคอนโทรลตัวนี้มีดังนี้
• FirstDayOfWeek กำหนดวันแรกของสัปดาห์ในปฏิทิน
• MinDate กำหนดขอบเขตวันต่ำสุดให้ปฏิทิน
• MaxDate กำหนดขอบเขตวันสูงสุดให้ปฏิทิน
• SelectionStart กำหนดช่วงวันเริ่มต้น
• ShowToday แสดงไฮไลต์วันที่ปัจจุบัน
• ShowTodayCircle แสดงเส้นรอบวันปัจจุบัน
• TodayDate เก็บค่าของวันที่ปัจจุบัน
• SetDate(DateTime) เป็นเมธอดที่กำหนดวันที่ที่ต้องการให้แสดงในปฏิทินสำหรับอีเวนต์ของคอนโทรลตัวนี้มีดังนี้
• DateChanged เกิดเมื่อวันที่ทีเลือกมีค่าเปลี่ยนไป
• DateSelected เกิดเมื่อเลือกวันหรือช่วงวัน

โปรแกรมที่ 4  ตัวอย่างโปรแกรมลงทะเบียนเรียนของโรงเรียนกวดวิชา  โดยให้ผู้ใช้ป้อนชื่อเข้าไป  แล้วเลือกวิชาที่ต้องการเรียน  และวันที่เริ่มเรียน  โดยออกแบบโปรแกรมและกำหนดชื่อให้กับออบเจ็กต์ต่างๆดังนี้

โปรแกรมที่พัฒนาขึ้นจะให้ผู้ใช้ป้อนชื่อ  เลือกวิชาเรียน  เลือกวันเริ่มต้นที่จะเรียน  โดยในโปรแกรมจะนำลิสต์บ็อกซ์มาใช้โดยกำหนดวิชาลงไป 4 วิชาดังรูป  เมื่อรันโปรแกรมแล้วนำเมาส์ไปเลือกวิชาที่อยู่ในลิสต์ บ็อกซ์จะทำให้อ่านชื่อวิชาออกมาได้  เมื่อนำคอนโทรล  MonthCalendar  มาวางบนฟอร์ม  คอนโทรลจะแสดงเป็นรูปปฏิทินพร้อมกับแสดงวันที่ปัจจุบัน สำหรับค่าคุณสมบัติต่างๆ  จะใช้ตามที่กำหนดเป็นค่าเริ่มต้น  สำหรับอีเวนต์ของปุ่ม  “ตกลง”  จะเขียนได้ดังนี้

เมื่อรันโปรแกรมแล้วทดลองป้อนชื่อลงไปเลือกวิชาที่จะเรียน เลือกวันที่เริ่มเรียน  เมื่อคลิกปุ่ม  “ตกลง”  โปรแกรมจะแสดงผลลัพธ์ดังต่อไปนี้

คอนโทรล  TrackBar
คอนโทรลตัวนี้เป็นคอนโทรลที่ใช้รับข้อมูลจากผู้ใช้โดยออกแบบเป็นตัวเลื่อนสำหรับเพิ่มค่าและสดค่า คล้ายๆ กับปุ่มปรับสัญญาณต่างๆ ของเครื่องเสียง  ในการนำมาใช้งานสามารถกำหนดขอบเขตของตัวเลขที่ต้องการได้  เมื่อนำคอนโทรลมาวางบนฟอร์มจะเห็นเป็นแถบตัวเลื่อนและมีขีดเล็กๆแสดงการคลิกแต่ละครั้งเรียกว่า  Tick  การเลื่อนตัวเลื่อนนี้สามารถทำได้โดยการคลิกเมาส์หรือเขียนโค้ดคำสั่ง

คุณสมบัติที่สำคัญของคอนโทรลตัวนี้มีดังนี้
• Enabled กำหนดให้ใช้เมาส์เลื่อนได้หรือไม่ได้
• Maximum ค่ามากที่สุดเมื่อเลื่อนไปจุดสุดท้าย
• Minimum ค่าน้อยที่สุดเมื่อเลื่อนไปจุดเริ่มต้น
• Orientation รูปแบบการวางแนวตั้งหรือแนวนอน
• SmallChange ค่าที่เปลี่ยนไปทีละขั้น
• TickFequency ความถี่ของขีดตำแหน่งตัวเลื่อน ควรกำหนดให้เหมาะสมระหว่าง Maximum และ Minimum
• TickStyle รูปแบบของขีดตัวเลื่อน
• Value ค่าปัจจุบันที่ TrackBar กำหนดอยู่
สำหรับอีเวนต์ที่น่าสนใจมีดังนี้
• Scroll เป็นอีเวนต์เมื่อมีการเลื่อนตัวเลื่อน
• ValueChanged เป็นอีเวนต์เมื่อค่าของ TrackBar เปลี่ยนไป

โปรแกรมที่ 5  ตัวอย่างนี้จะพัฒนาโปรแกรมบวกเลขโดยนำคอนโทรล  TravkBar  มาใช้โดยโปรแกรมจะนำค่า  A  มาบวกกับค่า  B  โดยที่ค่าทั้งสองนี้จะได้จากการปรับตัวเลื่อนที่มีค่าตั้งแต่ 0 ไปจนถึง 10 ในการออกแบบโปรแกรมให้นำออบเจ็กต์ต่างๆมาวางบนฟอร์มแล้วตั้งชื่อออบเจ็กต์ต่างๆ ดังนี้

ชื่อของเท็กซ์บ็อกซ์ทั้งสามตัวเป็นดังนี้
1. Name = textBox1
2. Name = textBox2
3. Name = textBox3
ในการออกแบบโปรแกรมจะกำหนดให้คอนโทรล  TrackBar  ทั้งสองตัวมีค่าต่ำสุดเป็น 0 และมีค่าสูงสุดเป็น 10  เมื่อปรับค่าทั้งสองจะทำให้ตัวเลขที่แสดงทางเท็กซ์บ็อกซ์  “ตัวเลข A” และ “ตัวเลข B”  มีค่าเปลี่ยนไป ส่วน  textBox3  จะแสดงผลรวมของค่า A และ B
ในการเขียนโปรแกรมจะต้องประกาศตัวแปรออกมาสองตัว  ในที่นี้จะให้เป็น A และ  B เป็นตัวแปรเก็บเลขจำนวนเต็มและเป็นตัวแปรแบบทั่วไปเมื่อมีการปรับค่า  TrackBar   ก็จะทำให้ค่าตัวแปรทั้งสองเปลี่ยนไป  ดังนั้นจะต้องนำอีเวนต์ของ  TrackBar  มาใช้  ในโปรแกรมนี้จะใช้อีเวนต์  Scroll  เมื่อมีการปรับ  TrackBar  ก็ให้ตัวแปร  A  หรือ  B  อ่านค่าที่ได้จาก TrackBar  มาใช้งาน  โดยโปรแกรมที่เขียนขึ้นเป็นดังนี้

เมื่อรันโปรแกรมแล้วลองปรับค่า A และ B ผลลัพธ์จะเป็นดังนี้

คอนโทรล ProgressBar
เมื่อคอมพิวเตอร์กำลังประมวลผลงานหนึ่งอยู่ ถ้าหากต้องการให้ผู้ใช้โปรแกรมทราบว่าเครื่องยังทำงานอยู่หรือไม่ หรือทำไปกี่ปอร์เซ็นต์แล้ว สามารถนำคอนโทรล ProgressBar มาใช้ได้คอนโทรลตัวนี้จะทำงานในลักษณะแสดงแถบการทำงานให้ทราบว่าขณะนี้ทำงานไปเท่าไรแล้ว
คุณสมบัติที่สำคัญของคอนโทรลตัวนี้ได้แก่
• Minimum ขอบเขตค่าต่ำสุดของโปรเกรสบาร์
• Maximum ขอบเขตค่าสูงสุดของโปรเกรสบาร์
• Style กำหนดรูปแบบของการแสดงผล โดยแบ่งเป็น Blocks จะแสดงเป็นช่องเรียงต่อกัน, Continuous จะแสดงเป็นแถบสีเพิ่มขึ้น และ Marquee จะแสดงเป็นช่องวิ่งไปวิ่งมา
• Value อ่านหรือกำหนดค่าให้กับโปรเกรสบาร์

คอมโพเนนต์ Timer
ใช้สำหรับจับเวลา การนำคอนโพเนนต์นี้ขึ้นมาใช้ทำให้สามารถกำหนดช่วงเวลาของการทำงานต่างๆได้ คอมโพเนนต์ตัวนี้สามารถนำไปประยุกต์ร่วมกับคอนโทรลอื่นๆ ได้อีกด้วย เมื่อนำคอมโพเนนต์นี้มาวางบนฟอร์มจะปรากฏเป็นรูปไอคอนอยู่ด้านล่างฟอร์ม คุณสมบัติ และเมธอดที่สำคัญของคอมโพเนนต์นี้ได้แก่
• Enabled ถ้าเป็น True จะให้ไทเมอร์ทำงาน ถ้าเป็น False จะให้ไทเมอร์หยุดทำงาน
• Interval กำหนดค่าการจับเวลา มีหน่วยเป็นมิลลิวินาที
• Start() เป็นเมธอดสั่งให้ไทเมอร์เริ่มจับเวลา
• Stop() เป็นเมธอดสั่งให้ไทเมอร์หยุดจับเวลา
เมื่อสั่งให้ไทเมอร์ทำงาน เมื่อเวลาเดินมาถึงค่าที่กำหนดใน Interval โปรแกรมจะทำอีเวนต์ Tick ซึ่งเป็นอีเวนต์เดียวของไทเมอร์

โปรแกรมที่ 6  ตัวอย่างการใช้คอนโทรลโปรเกรสบาร์และไทเมอร์  โดยให้กดปุ่มแล้วไทเมอร์เริ่มทำงานเป็นจำนวน 100 ครั้ง   แล้วแสดงการทำงานทางโปรเกรสบาร์
ให้สร้างโปรเจ็กต์ใหม่แล้วนำโปรเกรสบาร์และไทเมอร์มาวางโดยกำหนดชื่อของออบเจ็กต์ดังนี้

ถ้าให้ไทเมอร์ทำงานเมื่อเวลาเดินมาถึงค่าที่กำหนดใน  Interval  โปรแกรมสามารถไปทำ         อีเวนต์  Tick  ได้  ดังนั้นจะต้องสร้างการจัดการอีเวนต์ให้กับคอมโพเนนต์  Timer  ด้วย
โปรแกรมที่ออกแบบขึ้นจะประการตัวแปรสำหรับนับครั้ง  โดยให้ชื่อว่า  count  แล้วกำหนดค่าเริ่มต้นให้เป็นศูนย์  การทำงานของโปรแกรมออกแบบให้เมื่อมีการคลิกปุ่ม “ทำงาน”  จะให้โปรแกรมไปเรียกให้ไทเมอร์จับเวลา  โดยกำหนดค่าเวลาเป็น 100 มิลลิวินาที  เมื่อครบทุกๆ 100 มิลลิวินาทีจะทำอีเวนต์  Tick  และทุกการทำอีเวนต์  Tick  จะเพิ่มค่าให้กับตัวแปร count  หนึ่งค่าแล้วนำค่านี้ไปกำหนดให้กับโรเกรสบาร์  และเมื่อตัวแปร count ครบ 100  ครั้ง  ก็จะสั่งให้ไทเมอร์หยุดจับเวลาโปรแกรมที่เขียนขึ้นเป็นดังนี้

เมื่อรันโปรแกรมแล้วคลิกปุ่ม “ทำงาน”  จะเห็นแถบเสดงการทำงานดังรูป

โปรแกรมที่ 7 ตัวอย่างนี้จะแสดงการสร้างโปรแกรมสำหรับดูข้อมูลเกี่ยวกับเวลา ผู้ใช้สามารถเลือกดูวันที่ หรือเวลาได้ การพัฒนาโปรแกรมทำได้ดังขั้นตอนต่อไปนี้
1. ให้สร้างโปรเจ็กต์ใหม่ นำคอนโทรล MenuStrip มาวางบนฟอร์ม แล้วสร้างเมนูดังรูปแบบต่อไปนี้

2. นำลาเบลสำหรับแสดงข้อมูลมาวางกึ่งกลางฟอร์ม จากนั้นปรับคุณสมบัติของ Label1 ดังนี้

จากนั้นปรับหน้าต่างของโปรแกรมให้มีลักษณะดังนี้

3. ดับเบิลคลิกที่เมนู Date เพื่อเขียนคำสั่งให้แสดงวันที่  จากนั้นพิมพ์คำสั่งต่อไปนี้

4. ดับเบิลคลิกที่เมนู Time เพื่อเขียนคำสั่งให้แสดงเวลา จากนั้นพิมพ์คำสั่งต่อไปนี้

โปรแกรมที่เขียนทั้งหมดจะเป็นดังนี้

เมื่อทดลองรันโปรแกรมแล้วเลือกเมนูต่างๆ จะได้ผลลัพธ์ดังนี้

การสร้างคีย์ลัด
การใช้งานโปรแกรมที่มีเมนูให้เลือกนั้นเพื่อสะดวกในการใช้งานโปรแกรมมักจะมีคีย์ลัดอยู่ด้วย  โปรแกรม  VB  สามารถสร้างคีย์ลัดได้เช่นกัน  โดยปรับที่หน้าต่างคุณสมบัติของเมนูที่ต้องการสร้างคีย์ลัด  ตัวอย่างเช่นจากโปรแกรมที่ผ่านมาถ้าหากต้องการให้เมนู  Date  มีคีย์ลัดเป็น  <Ctrl+T> ให้คลิกเมาส์ที่เมนู แล้วปรับคุณสมบัติ  ShortcutKeys  ดังรูป

เมื่อเลือกคีย์ลัดแล้ว คีย์ที่เลือกจะแสดงบนเมนูด้วย