Visual Basic .NET

מתוך ויקיפדיה, האנציקלופדיה החופשית

Visual Basic .NET
צילום מסך של VB Net 2005 בגרסה 8.0 (2005) כחלק מחבילת הסטודיו
פיתוח	מיקרוסופט
גרסה אחרונה	8.0, ב-אוגוסט 2005
מערכת הפעלה	חלונות
רשיון	קנייני
קטגוריה	סביבת פיתוח
דף בית	http://msdn.microsoft.com/vstudio/

גרסה זו של ויז'ואל בייסיק שהוכרזה לראשונה בפברואר 2002, שוכתבה מהיסוד ועברה מקצה שיפורים גדול, כדי שתתאים לסביבת הדוט נט. אף שהיא ממשיכתה של VB6 הויזואלית, ניתן לראות שהיא עברה מהפכה של ממש וששולבו בה אלמנטים רבים משפות אחרות בכדי להתאימה לסביבה הטכנולוגית החדשה, ולהעצים את מעמדה בעולם התכנותי.

בערך זה נסקרת בעיקר יכולת הפיתוח בשפה בסביבת חלונות -WinForms. ניתן להשתמש בשפה גם עבור פיתוח בסביבת ASP.NET לאתרי אינטרנט וכן בסביבת Console - מסך שחור הדומה לסביבת DOS.

• ASP.NET

[עריכה] מהות השפה

מחולל תפריטים ב-VB 2005. ניתן לראות שהתכנות הויזואלי, הגרפיקה, הגמישות והמורכבות של התפריטים חוזקה בגרסה זו באמצעות תפריטי הStrip.

עבודה עם בסיסי נתונים. ניתן לסייר בבסיסי נתונים, ליצור להם יצוגים ויזואלים שונים, ליצור שאילתות ולהריץ אותם, ואף ליצור טפסי קלט ודוחות, באמצעות תכנות ויזואלי המשולב בתכנות רגיל, ותוך שימוש מינימלי בקוד.

Visual Basic .NET היא שפת תכנות מונחת עצמים שבדומה לשפת C++‎ מאפשרת פיתוח מעורב של אובייקטים עם מודולים פרוצדורלים. בגרסה זו הושלמה יכולת תכנות מונחה עצמים במלואה, עם אפשרות של ירושה, העמסת פרמטרים, דריסת פונקציות והצללתן. כמו כן, הוספה גמישות לתוכנה למשל ביצירת הליכי-משנה. (Treading). התחביר שונה ונעשה ישור קו לכיוון השפות העיליות החזקות, בכדי להגדיל את התאימות לתפיסות המקובלות. נוספו אובייקטים וספריות רבות שמקלות על עבודת התיכנות. החל מסביבה זו קובצי ה-RUN TIME של התוכנה הינם בעצם קבצים משותפים לכל שפות הדוט נט, ואינם יחודיים לשפת VB כמו שהיה עד גרסה 6, ולכן אף שמדובר בקובץ גדול יותר פי כמה וכמה, סביר להניח שהוא כבר יהיה מותקן, בשל התפוצה הגדולה של ישומי הדוט נט.

[עריכה] גרסה 2002

השפה החדשה מתבססת על סביבת NET Framework. של מיקרוסופט, שהוסיפה יכולות נרחבות שכלל לא היו קיימות בגרסאות קודמות, ככתיבת ישומי ושירותי רשת וטפסי Web, וחיזוק העבודה עם בסיסי נתונים באמצעות טכנולוגיות ה-ADO.NET והASP.NET, אפשרות פיתוח לפלטפורמות שונות, כמו גם הוספת פקדים מגוונים שמאפשרים פעילויות רבות, כמו גישה קלה יותר לשירותי מערכת בתחום חיפוש הקבצים וההדפסה, כמו PrintDocument להדפסה, PrintPreviewControl לתצוגה מקדימה להדפסה, NotifyIcon, - לתצוגת אייקון במגש מערכת, Splitter, RichTextBox, FileSystemWatcher.

התוכנה הפכה להיות רב פלטפורמית, ואפשר לפתח בה ישומים להתקנים ניידים, למחשב האישי וישומי אינטרנט. הוספה לה יכולת תקשורת עם שפות תכנות אחרות הכלולות בדוט נט, באופן שמאפשר התייחסות לקטעי קוד משפה לשפה (ניתן בפתרון אחד לשלב שני פרויקטים בשפות שונות), ללא צורך של כתיבה מחדש. התחביר הדומה לשפת C# גם מאפשר, לתרגם בקלות קטעי קוד משפה לשפה, תוך השגת פונקציונאליות דומה.

שינוי התחביר של ה VB הפך את התכנות בה ליותר גמיש אך גם יותר מסובך, וחייב המרה של הגרסאות הקודמות, דבר שעורר תרעומת אצל חלק ממתכנתי הVB, שהעדיפו להשאר עם הגרסה הקודמת, עם זאת השינויים הרבים שהיא עברה, הפכו אותה למעשה משפת נישה שמיועדת לממשקים ובסיסי נתונים, למעמד של שפה מובילה בפלטפורמת NET Framework.

[עריכה] גרסה 2003

גרסה זו שוחררה עם גרסת 1.1 NET Framework. בין היכולות הוספה תמיכה בגרסה קומפקטית של הדוט נט פריימוורק שמיועדת להתקנים ניידים כמו מחשבי כף יד. שיפור באשף שדרוג מגרסאות קודמות. שיפור ניכר גם בביצועים ובמהיימנות של סביבת הפיתוח המשולבת.

[עריכה] גרסה 2005

בגרסה 2005 ששוחררה עם גרסת 2 NET Framework. , קיים ניסיון לחזור למוסכמות שהיו קיימות בVB6, כך למשל בטופס: חלון הקוד פושט וסולקו ממנו הגדרות מפורטות, הבנאי ועוד לחלון נפרד של עיצוב הטופס. הוסף האובייקט My, שמאפשר להתייחס בקלות לאובייקטים תכנותיים מגוונים לפי נושאים, חזרה השליטה על הגדרת תחומי מערך, והוסף תחביר להופעה מידית של טפסים כפי שהיה נהוג בעבר. קיימת מחלקה לטיפול מובנה בסביבת הפיתוח, בפרמטרים של התוכנה, הנשמרים והנקראים מקובץ XML. הוספה אפשרות מובנת לרכז את כל המשאבים של הפרויקט במקום אחד, מה שמונע כפילות שהייתה קיימת עד כה. הוספו תגיות חכמות לפקדים, וניתן לקשור בין אירועי פקד לבין שגרות קיימות מתוך רשימה קיימת באופן דומה למה שכבר יושם בעבר בתוכנת אקסס.

בגרסה זו הוספה לראשונה יכולת של העמסת אופרטורים והעמסת המרת סוג. הוגמש וחוזק השימוש במאפיינים ובאירועים. הוספו טיפוסי מספרים שלמים מסוג Unsigned, פקודת TryCast לבדיקת ביצוע המרה, פקודת Continue בלולאות, בלוק Using לשימוש מהיר באובייקט ושחרורו, הגדרה אגבית של מונה הלולאה בתחילת לולאות, תמיכה מובנת וחזותית בפרמטרים של הגדרות התוכנה באמצעות מחלקה יעודית (Settings), הערות מתכנת במבנה XML להסבר הקוד, ותמיכה גנרית באוספי רשומות. משמעות חלק מהשיפורים שהשפה נעשתה תואמת יותר לשפת C#.

כמו כן הוספו כחמישה עשר פקדים מובנים חדשים כמו SerialPort, MaskedTextBox, BackgroundWorker - גישה ליציאה הטורית של המחשב, TableLayoutPanel, WebBrowser - לקריאה של קובצי HTML ושירותי דפדפן, ו-FolderBrowserDialog - לדיפדוף בתיקיות דיסק, משפחת פקדי תפריטים חדשים (Strip) שמחליפים את פקדי התפריטים הישנים (Bar), ופקדי כריכה לנתונים של קובצי בסיסי נתונים, הכוללים תכנות ויזואלי שמאפשר בקלות לייצר טפסי נתונים באופנים שונים. פקדים אלו מהווים תוספת משמעותית להקלה על העבודה התכנותית בהרבה היבטים. גם הפקדים שכבר היו כלולים באופן כזה או אחר, בחבילת הפקדים השיתופיים של הויז'ואל ביסיק בגרסה 6, עברו מקצה שיפורים.

כמו בגרסאות הקודמות, ניתן לייצר קובץ התקנה והפצה כפרויקט בתוך פתרון. בגרסה זו הוספה יכולת להורדה של סביבת הדוט.נט מאתר מיקרוסופט, במקרה שהיא עדיין איננה קיימת במחשב.

בשפה זו כמו בכל חבילת השפות של הדוט.נט הוספה גרסת חינם לחובבים וסטודנטים, בשם Visual Basic 2005 Express. לגרסה זו שכוללת סביבת פיתוח חלקית, חסרים כמה וכמה היבטים המצויים בגרסה המלאה ובהם הידור ל-64 ביט ולהתקנים ניידים, ניוון מנגנון ההפצה, חוסר אפשרות להוסיף הרחבות ועוד.

[עריכה] מבנה השפה

[עריכה] מודול - Module

מודול הוא המתחם הגלובלי של VB. באזור זה שמתחיל במילה השמורה Module ומסתיים במילה השמורה, End Module ניתן לכתוב קטעי קוד שונים: הגדרות של טיפוסים ומבנים חדשים, הכרזות של משתנים, פונקציות ושגרות ובגרסת הדוט נט, אף מחלקות. כאשר ישנן פונקציות כלליות שאינן שייכות למחלקה מסוימת נהוג לכותבן באזורים אלו, כמו כן כאשר ישנם משתנים ואף מחלקות שרוצים שיהיו גלובליים ונגישים לכל התוכנית, זהו המקום להכריז עליהם. ישנה שגרה מיוחדת בשם Main() שתיכתב במודול ראשי, שתפקידה הוא להתחיל את הרצת התוכנה כולה. באם כותבים אותה עם פרמטר מערך, אפשר לקבל פרמטרים בהרצת קובץ הEXE של התוכנה ולהתייחס אליהם בשגרה.

[עריכה] מחלקה - Class

המחלקה או האובייקט הוא מושג מרכזי בשפה, והוא האזור השני שבו קוד יכול להתקיים. רבים מרכיבי הVB הינם מחלקות, וביניהם אפשר למנות את הטפסים, הפקדים ופקדי המשתמש. למעשה אף המשתנים הרגילים הינם טיפוסי אובייקטים.

כל אובייקט צריך להתחיל במילה השמורה Class ולהסתיים ב End Class. לאובייקט יכולים להיות שגרה בונה New()‎ ושגרה הורסת Finalize()‎, כדי שיהיה אפשר לשלוט על על הקוד ביצירתו של האובייקט ובסגירתו. לכל מחלקה אפשר להגדיר חמש רמות שונות של חשיפה, בין פומבי (Public) לבין פרטי (Private).

כל מחלקה יכולה להוריש את תכונותיה למחלקת בן. ירושת מחלקה ממחלקת בסיס נעשית באמצעות המילה השמורה Inherits. התייחסות לפונקציה/שגרה של המחלקת הנוכחית נעשית באמצעות המילה Me, והתייחסות למחלקת הבסיס באמצעות המילה MyBase. אפשר לבצע דריסה של שגרה או פונקציה במחלקה היורשת על גבי שגרה/פונקציה של מחלקת הבסיס. כדי ששגרה/פונקציה תוכל להיות דרוסה באמצעות שגרה של מחלקה יורשת היא צריכה להיות מוגדרת במילה Overridable, כאשר הפונקציה/השגרה הדורסת צריכה להיות מוגדרת Overrides. בVB אפשר גם ליצור מחלקה אבסטרקטית שהיא מחלקת בסיס שנועדת לירושה בלבד ולא ליצירת מופע ממשי.(MustInherits). במחלקה כזאת ניתן לכפות יצירה של שגרות ומאפינים במחלקות היורשות (MustOverride). מאידך ניתן גם ליצור מחלקה שאיננה נרשת, אלא משמשת רק למופע. (NotInheritable).

לשפה יש יכולת להעמסת פונקציות/שגרות. העמסה (OverLoding) היא היכולת להעמיס באותה מחלקה כמה שגרות/פונקציות באותו שם. הדבר יעיל במיוחד כאשר ישנם מספר אופנים של טיפול לדבר מסוים. כך ניתן לרכז מספר רב של פעולות דומות תחת קורת גג אחת. ההבדל בין השגרות/פונקציות יהיה בפרמטרים שלהם: במספרם, בטיפוסם ובסידורם, שחייב להיות שונה, שאילולי כן התוכנית לא תדע לאיזו פונקציה/שגרה להתייחס בזמן הקריאה. (החל מגרסת 2005 ישנה גם אפשרות להעמסת אופרטורים במחלקות).

בVB אפשר ליצור מחלקות מקוננות (מחלקה שמכילה מחלקה נוספת), אבל לא פונקציות.

Imports Namespace.Class 
Public Class '''ClassName''' 
                  Inherits '''ClassBase'''

משתנים כלליים
 Dim|Private|Public Variable1 As Type, Variable2 As Type
    שגרה 
    
 Private|Public Sub SubName(ByVal|ByRef ParametName As Type) Handles Object.Event
   Dim LocalVariable As Type
   ...
 End Sub

 Private|public Function FunctionName(ByVal|ByRef ParametName As Type) As Type
   Dim LocalVariable As Type
   return LocalVariable 
 End Function

End Class

בכדי ליצור מופע של אובייקט יש להגדיר אותו באמצעות המילה השמורה New. ניתן לחשוף חברים במחלקה שיוכלו להיות חשופים החוצה ללא יצירת מופע חדש של המחלקה באמצעות המילה Shared בקידומת של מתודה או תכונה.

[עריכה] מאפיינים

לכל מחלקה יכולות להיות תכונות או מאפיינים. התכונות מהוות חלק מישום הכמיסות של המחלקה. לחסום אפשרות של עדכון משתנים של המחלקה מבחוץ ללא כל בקרה של המחלקה. באמצעות התכונות מאפשרים למשתמש במחלקה לעדכן או לקבל מידע ממנה, ועם זאת לבקר את פעולותיו, ולמנוע ממנו גישה חופשית לגמרי, שעלולה לפגום בנתונים.

המאפיין מהווה למעשה פילטר וחוצץ, בין המשתנה הפרטי ש"מוטמן" בעמקי המחלקה לבין לבין המשתמש. באמצעות התכונות ניתן גם לחסום את הקריאה (לכתיבה בלבד) או את הכתיבה (לקריאה בלבד) למאפיין, כאשר פשוט פקודת Get או פקודת Set לא קיימת והמאפיין מוכרז לקריאה בלבד, או לכתיבה בלבד. המאפיין הופך למעשה את המשתנה הפאסיבי, למשתנה אקטיבי שיש לו יכולת בקרה, שליטה ומניפולציה על התוכן שמושם בו או נלקח ממנו.

בVB פקודות המאפיינים היו נפרדים, מה שעשה את התוכנה לפחות קריאה. בדוט נט פונקציות ההשמה והקבלה מרוכזות במאפיין אחד. הן פקודת הקבלה Get שבאמצעותה ניתן לקבל ערך, והן פקודת Set שאמצעותה ניתן לבצע השמה לערך.

 Private LocalVariable As VariableType
 Public [ReadOnly|WriteOnly] Property MyProperty() As VariableType
    Get
       Return LocalVariable 
    End Get

    Set(ByVal value As VariableType)
       LocalVariable = value
    End Set

 End Property

למי שישתמש באובייקט, יהיה מאפיין בשם MyProperty, שבאמצעותו הוא יהיה נגיש למשתנה LocalVariable של המחלקה, לפקודות של השמה ושל קבלה. בדוגמה לא נעשה שימוש בבקרה או במניפולציה על המאפיין, אבל בהחלט ניתן ומומלץ לעשות כן. יש לשים לב שסוג הפרמטר של התכונה ושל הSET שלה, חייבים להיות זהים.

[עריכה] אירועים

שפת הVB הינה ביסודה גם שפה מונחת אירועים. זאת אומרת שלכל אובייקט, יש אירועים מובנים שונים שמתבצעים בתנאים שונים. האירועים הנפוצים ביותר קשורים לפעולת המשתמש כמו אירועי מקלדת ועכבר, אך יכולים להיות אירועי נוספים כמו אירועים הקשורים לפעילות התוכנה, כמו בעת פתיחת וסגירת טופס, או אירועי שעון מערכת. בVB.NET הורחבו האירועים של האובייקטים השונים למקרים רבים, כך שהם מכסים טווח נרחב יותר של אופציות, ומגבירים בכך את הגמישות התכנותית.

בVB6 כל אירוע היה קשור לאובייקט אחד בלבד באמצעות שמו, בVB.NET האירועים הורחבו באופן כזה שאירוע יכול להיות מוזנק על ידי מספר רב של אובייקטים אף מטיפוסים שונים באמצעות הHandles שבסיומה של השגרה, ולצורך כך אף הוסף פרמטר בשם Sender בשגרות אירוע שבאמצעותו ניתן לזהות את האובייקט שמזניק את האירוע. כמו כן, אובייקט יכול להזניק מספר רב של אירועים בו זמנית באירוע בודד. יחד עם זאת כל הפרמטרים של שגרת אירוע באשר היא הוכמסו באובייקט אחד בשם E, דבר המהווה הפשטה תכנותית.

למעשה אפשר להגדיר אירוע ולהזניקו בכל הליך תכנותי. הדבר חיוני בתכנות מונחה עצמים, לתקשר עם החוץ, ולהוציא הודעות בסיטואציות מסוימות אל מחוץ למחלקה. בכדי ליצור אירוע יש 1. להכריז עליו והפרמטרים שהוא שולח באמצעות המילה Event, בדומה להגדרה של פונקציה. 2. ולהזניקו באמצעות המילה השמורה RaiseEvent תוך השמת ערכים לטיפוסי הפרמטרים שהוכרזו. בכדי ללכוד אירוע יש: 1. יש להצהיר במקום שבו מגדירים מופע של המחלקה שהאזור מהווה מקום ללכידת אירועי המחלקה, באמצעות הכרזת האובייקט עם המילה השמורה WithEvent. 2. ולאחר מכן בכדי ללכוד את האירוע, יש ליצור ידית (Handle) לאירוע בסופה של שגרה בעלת פרמטרים זהים לאירוע, ובכך לקשור בין האירוע לשגרה.

[עריכה] מבנה - Structure

מבנה (יורשו של ה-Type מה-VB6) בעוד שבVB6 יכל רק לאגד בתוכו משתנים תחת מרחב שם משותף, בדוט נט בהשראת שפת C++ הוא הורחב מאוד, והפך לסוג של טיפוס שיכול להכיל בתוכו משתנים, מתודות, מאפיינים ואף אירועים ושגרת בנאי. ולמעשה מתנהג כמו מחלקה שיכולותיה הוגבלו מעט וברירות המחדל שלה שונו. אמנם עיקר השימוש שבו נותר ליצור טיפוס משתמש, שמאגד משתנים מסוגים שונים שיש להם עניין משותף. כאשר מגדירים מערך של structure יוצרים למעשה UDT (User Defined Types)- שהוא למעשה טבלת משתמש בזכרון. השימוש במבנה מאפשר לנהל רשומות בזכרון, וגם לשמור ולקרוא אותם מקובץ באופן קל ופשוט. אפשר גם ליצור מבנים מורכבים יותר, שבו מבנה אחד יכלול מבנה אחר.

Private Structure BookType
    Dim Title As String
    Dim URL As String
    Dim Page As integer
End Structure

Private BookData() As BookType

BookData(0).URL = "http://he.wikipedia.org"

בדוגמה נוצר מערך בשם BookData של המבנה BookType. ומודגמת בו פעולות השמה של מחרוזת, למשתנה URL של האיבר הראשון במערך. ניתן לשמור ולקרוא מקובץ מבנה או מערך של מבנים, באמצעות פקודות השמירה והקריאה לקובץ של VB.NET.

[עריכה] פונקציה ושגרה

מבני הקוד הבסיסיים הם שגרות ופונקציות שמכילות למעשה את קטעי הקוד להוראה. הם יכולים להיות מוכלים במודלים או במחלקות. ההבדל בין שגרה (Sub) לבין פונקציה (Function), הוא בכך ששגרה מכילה קטע ביצוע מבלי להחזיר ערך, ואילו פונקציה מבצעת קטע ביצועי ומחזירה ערך, ולכן יכולה להיות מושמת למשתנה באמצעות אופרטור =, או להיות כלולה בתחביר תנאי לוגי. צורת החזרת הערך שנעשתה באמצעות השמה לשם הפונקציה ב-VB6, שונתה בשפה זו ונעשית באמצעות פקודת return כמקובל. יתרון השיטה הזו שבמקרה שמשנים את שם הפונקציה, אין מקומות נוספים שצריך לשנות, דבר מסורבל שבעבר גרם לשגיאות הרצה.

שני המבנים יכולים לקבל פרמטרים. הפרמטרים כבררת מחדל יהיו לפי ערך (ByVal). באם רוצים שהפרמטר יהיה מצביע יש להשתמש במילה השמורה (ByRef). אפשר להפוך פרמטר שיהיה אופציונאלי באמצעות המילה Optional לפני שם הפרמטר, אפשר לתת לפרמטר ערך בררת מחדל, ואפשר לתת בפרמטר מערך באמצעות המילה השמורה ParamArray.

צורת הכתיבה הבסיסית של שגרה:

 [modifiers] Sub SubName[(parameterlist)] 
 ...
 End Sub

צורת הכתיבה הבסיסית של פונקציה:

 [modifiers] Function FunctioName[(parameterlist)] As returntype 
 ...
 Return {value|variable}
 End Function

[עריכה] טופס

הטופס שמהווה רכיב מכולה ואוסף גם יחד, תפקידו המרכזי להכיל בתוכו פקדים. אף שהוא למעשה כיום מקרה פרטי של מחלקה, נותר אחד המחלקות הבסיסיות והחשובות של השפה. בVisual Basic .NET נשמרה והורחבה התפיסה שהתכנות מתחיל בשלב הויזואלי בשרטוט הפקדים על הטופס, הגדרת תכונותיהם בגיליון התכונות, וממשיך לכיוון הקוד. בנוסף לטופס של ישומי חלונות הוסף טופס של ישומי WEB, שמאפשר ליצור ישומי אינטרנט באופן דומה לישומי חלונות. (דבר שיושם באופן ממצה במחולל האתרים של הקוד הפתוח DotNetNuke). כמו כן הוסף טופס להתקנים ניידים.

הטופס הפך להיות גמיש יותר ומרובה תכונות, ופונקציונליות שהושגה לפני כן באמצעות קריאות לפונקציות מערכת, או באמצעות חישובים מדוקדקים, הוטמעה במחלקת הטופס, כך למשל מיקום דינמי של פקדי טופס נעשה קל ופשוט. הוספו מספר רב של פקדים נוספים בתחומים שונים והוספו מספר רב של תבניות טפסים. השילוב של הטופס עם תכנות מונחה עצמים, מרחיב את הגמישות של הפיתוח, ומאפשר ליצור טפסים על בסיס טופס משתמש, ולירוש ממנו את תכונותיו. באופן זה אפשר לשנות את הממשק של כל טפסי הישום, בשינוי טופס הבסיס בלבד.

החלוקה בין פקדי ממשק לפקדי פעולה שתפקידם לבצע פונקציה מסוימת מאחורי הקלעים, נעשתה ברורה יותר (הם מופיעים באזור מיוחד בתחתית המסך). בפקדים עצמם יכולות שהיו קיימות רק בתכנות, הוספו למבט עיצוב. הגמישות בטיפול בפקדים עצמה הוגדלה, ואפשר לטפל בפקדים כמו במשתנים, דבר שלא היה קיים בגרסת ה-VB6. כל הפקדים קיבלו שיטות גרפיות רבות, שלפני כן היו רק לפקד תמונה, וכעת אפשר לצייר אפילו על פקד Label שנחשב לפקד הבסיסי והנחות ביותר.

הקשר בין פקד לאירועיו חוזק, ושינוי שמו של פקד, כבר איננו מנתק את הקשר לאירועים שלו, דבר שהיווה בעייה לא קטנה בגרסת VB6. מאידך האפשרות ליצור אוסף פקדים, באופן שיהיה אפשר להתייחס לפקדים כמו למערך הוסרה מברירת המחדל, וממומשת רק כתוספת תואמת לגרסאות הקודמות, בצורת פקדים מיוחדים, שמסורבל כיום לתפעל אותם מבעבר.

[עריכה] פקודות בסיסיות

[עריכה] אופרטורים

בנוסף לאופרטורים האריתמטים הרגילים כמו -,/,+,-,*,^,\, וMOD

• הוספו אופרטורי השמה דבר המאפשר לבצע פעולות על משתנה באמצעות האופרטורים =+, =-, =*, =/, =^,=<<, =>>, =& - בכדי לשרשר מחרוזת למחרוזת, בלי תחביר מסורבל.
• הוספו האופרטורים << ו >> לתזוזה של ביטים במשתנה שמבוצעת בו פעולת השמה.
• באופרטורים השוואתיים הוספו על ה-Is האופרטורים IsNot ו-Like שנלקח משפת SQL ויכול לבצע השוואות מורכבות בין מחרוזות.
• בתחום האופרטורים הלוגיים בנוסף לAnd, Not , Or, Xor שכבר היו קיימים הוספו האופרטורים: AndAlso , OrElse , IsFalse , IsTrue
• באופרטורים הכללים הוספו על TypeOf שהיה קיים, AddressOf - שיוצר התייחסות לשגרה, וGetType - לשם קבלת סוגו של משתנה.

[עריכה] משתנים

המשתנים הפכו למעשה להיות אובייקטים. ניתן כמובן להכריז ולהשתמש בהם בדרך הרגילה:

Dim String1 As String = OpenFileDialog.FileName

אבל ניתן לעשות הרבה יותר. ניתן להגדיר משתנה ולאתחל את ערכו כשם שעושים באובייקט. למשל אפשר ליצור משתנה מחרוזת שיהיו בו 500 כוכביות, באמצעות הביטוי הבא:

Dim string1 As New String("*", 500)‎

מכיוון שהם למעשה אובייקטים. למשתנים יש מתודות שמיוחדות לפי כל משתנה. שוב אין צורך לחפש את שם הפונקציה ולבדוק האם היא פועלת על טיפוס המשתנה שהוכרז או מחזירה שגיאה. לאחר כתיבת המשתנה מקלידים נקודה ומקבלים את כל הפונקציות הפועלות על המשתנה. דוגמה שממחישה את הדבר, היא הבדיקה האם התו השלישי במחרוזת הינו "A", ניתנת להעשות בדרך הבאה:

String1.Substring(3, 1).Equals("A") = True

בנוסף לכל המשתנים הרגילים ובנוסף לטיפוס מערך Array שכבר כולל אפשרויות של מיון וחיפוש שמובנים בו, הוספה מחלקת אוספים (Collections) שמטפלת במשתנים מורכבים: Hashtable, ArrayList, BitArray , CollectionBase, SortedList, DictionaryBase, אוספי מחסנית ועוד, ובגרסה 2 - גרסה גנרית של ArrayList בשם List. למבנים מורכבים אלו יכולות שונות ומשונות לטיפול חכם בנתונים, כמו טיפול במספר איברים בבת אחת, מיון, חיפוש בינארי ועוד, והם פועלים למעשה כמו רשימות מקושרות, כאשר כל הטיפול בזיכרון נעשה מאחורי הקלעים. תפיסה זו של אוספים שהייתה כבר קיימת בVB6 הורחבה ושוכללה לסביבת הדוט נט כולה.

[עריכה] מבני בקרה

השפה כוללת מבנה בקרה מסוגים שונים. מבנה הבקרה הם פקודות שמאפשרות שליטה על זרימת הקוד. באופן עקרוני מבנה הבקרה בגרת הדוט נט נותרו זהים לגרסאות הקודמת.

[עריכה] מבני תנאי

[עריכה] תנאי If

מבנה התנאי נשאר בתחביר זה לגרסה הקודמת. אפשר ליצור פקודות IF מקוננות אחת בתוך השניה.

 If condition Then
        statements 
 [ElseIf condition Then
        statements ]
 [Else
        statements ]
 End If

[עריכה] תנאי Select Case

מבנה זה מאפשר לכתוב מספר של פקודות תנאי שרק אחת יכולה להתקיים. במקרה שקייס מתקיים, מבוצעת הפקודה שלו, ולאחר מכן מתבצעת יציאה ממנו.

 Select [ Case ] testexpression
    [ Case expressionlist
        [ statements ] ]
    [ Case Else
        [ elsestatements ] ]
 End Select


 Select Case MyVariable 
        Case 5
                MenuItemToCheck = Value
        Case 7 To 9
                MenuItemToCheck = Value
        Case 3, 11, 13 
                MenuItemToCheck = Value
        Case Is > maxNumber 
                MenuItemToCheck = Value
        Case Else
                MsgBox("Message")
 End Select

[עריכה] לולאות

לולאות הם מבנים שמבצעים פעילות מחזורית שוב ושוב. מבנים אלו אחראים לחוזק של התכנות באופן כללי, מפני שהם מאפשרים לבצע שוב ושוב מספר רב של מחזורים. שגיאה תכנותית נפוצה קשורה ללואות במקרה שיש לולאות מתמשכות ללא יציאה מהן, נוצרת לולאה אינסופית, שנראת בעיני המשתמש כתקיעה של התוכנה שרצה.

[עריכה] לולאת For

לולאה זו היא לולאה רגילה, שנזקקת למשתנה כדי שימנה את המחזורים שלה. יש לקבוע את התחום התחתון והתחום העליון, מדרגת הקפיצה בכל מחזור הינו אופציונאלי וכברירת המחדל עומד על 1. (אפשר שהמדרגה תהיה מספר שלילי ולהתחיל ממספר גבוה לעבר מספר נמוך)

 Dim Variable As VariableType
 For Variable = StartValue to StoptValue  [Step Value]
        ...
 [ Exit For ]
 Next [Variable]

[עריכה] לולאת For Each

לולאה זו היא לולאה מתוחכמת שפועלת עם אוסף, ורצה כפי מספר האיברים שבו. לולאה זו היא לולאה בטוחה שלא תחרוג ממספר האיברים שבו. בכל מחזור ריצה היא מצביעה על האיבר הנוכחי באוסף, ואפשר לפנות דרכה לתכונותיו ולמתודות שלו. פעולה שימושית שלה הוא מעבר על כל הפקדים בטופס.

 Dim ObjectItem As ObjectType
 For Each ObjectItem In Object
        statements 
 [ Exit For ]
 Next [ObjectItem]

[עריכה] לולאת Do Loop

לולאה זו היא לולאה שמתבצעת לפי תנאי, בתחילתה או בסופה. היא נכתבת כאשר לא ברורים מראש מספר המחזורים, כמו למשל בקריאת קובץ או בחיפוש איבר במערך.

 Do { While | Until } condition
    statements 
   [ Exit Do ]
 Loop

 Do
   statements 
  [ Exit Do ]
 Loop { While | Until } condition

[עריכה] אזור - Region

ניתן לתחום אזור באמצעות הפקודה Region לשם ניווט קל בקוד. אזור כזה יפעל כמו תבנית:מסגרת ניווט בוויקיפדיה, ויהיו לו שני מצבים. פתוח וסגור. לאחר המילה השמורה Region, יש לכתוב מחרוזת זיהוי.

 #Region "heading"
        ...
 #End Region

[עריכה] מרחבי-שם

ניתן לכנוס מספר מחלקות, מודולים או פונקציות תחת שם משותף באמצעות המילה השמורה NameSpace. בכדי להשתמש בו יש למקף את האזור באמצעות התחלה וסיום של ה-NameSpace.

[עריכה] טיפול בשגיאות

ב-Visual Basic 6 יכולות הטיפול בשגיאות היו מוגבלות, ונשענו על מבנים תכנותיים מיושנים (קפיצות בקוד בעזרת goto), שהיא ירשה מ-QuickBasic.

ב-Visual Basic .NET קיים מנגנון טיפול בחריגים, הדומה לזה שקיים ב-C++‎ ובג'אווה.

 Try
    ... קטע שמנסה להתבצע 
 Catch exp As Exception
   ... קטע שיתבצע רק במקרה של חריגה 
 Finally
   ... קטע שיתבצע בכל מקרה
 End Try

המפתח עצמו יכול להזניק חריגים, שילכדו באמצעות מנגנון לכידת החריגים באמצעות הביטוי Throw New IvalidcaseException

[עריכה] תוכניות לדוגמה

תוכנית שכתובה בגרסה 2005, מנגנת קובץ קול בפורמט WAV, בזמן טעינת טופס, לללא כל שימוש בAPI או קובץ Dll חיצוני בשתי פעולות. דבר המדגים את הפשטות והאלגנטיות של סביבת ה.NET. הפונקציונליות של ניגון קובץ קול מתבצעת ב-
1. בהגדרת אובייקט SoundPlayer תוך ביצוע השמת תוכן של קובץ קול לתוכו.
2. הפעלת מתודה של נגינת האובייקט (Play).

 Public Class Form1
   Dim MySound As New System.Media.SoundPlayer("C:\My Music\test.wav")
   Private Sub Form1_Load(ByVal sender As Object, _
               ByVal e As System.EventArgs) Handles Me.Load
         MySound.Play()
   End Sub
 End Class

תוכנית שמציגה את שם היציאה הטורית הראשונה שבמחשב

 Public Class Form1
   Private Sub Form1_Load(ByVal sender As Object, _
               ByVal e As System.EventArgs) Handles Me.Load
        MsgBox(My.Computer.Ports.SerialPortNames.Item(0).ToString))
   End Sub
 End Class

[עריכה] קישורים חיצוניים

מיזמי קרן ויקימדיה
ספר לימוד בוויקיספר: NET

• מדריך ללימוד VB ודוט נט
• האתר הרשמי של השפה בגרסה החדשה
• להורדת גרסה לימודית, חינמית ועדכנית של ויזואל בייסיק, באתר מיקרוסופט
• חידושי השפה, באתר MSDN
• ממיר קוד של C# לקוד VB.NET