Visual Basic .NET

**Visual Basic .NET** היא גרסה של שפת התכנות ויז'ואל בייסיק, ששוכתבה מהיסוד ועברה מקצה שיפורים גדול, כדי שתתאים לסביבת NET. (שם מלא קודם .NET Core) (בעבר - סביבת .NET Framework) של חברת מיקרוסופט. גרסה זו הוכרזה לראשונה בפברואר 2002. אף שהיא ממשיכתה של VB6 הוויזואלית, ניתן לראות שהיא עברה מהפכה של ממש וששולבו בה אלמנטים רבים משפות אחרות כדי להתאימה לסביבה הטכנולוגית החדשה, ולהעצים את מעמדה בעולם התכנותי. בגרסת 2005 נשמטה סיומת ה-".NET" אך עדיין משתמשים בה כדי להבדיל אותה מוויז'ואל בייסיק הקלאסית.

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

## מהות השפה
שמאל|ממוזער|250px|מחולל תפריטים ב-VB 2005. ניתן לראות שהתכנות הוויזואלי, הגרפיקה, הגמישות והמורכבות של התפריטים חוזקה בגרסה זו באמצעות תפריטי הStrip.
שמאל|ממוזער|250px|עבודה עם בסיסי נתונים. ניתן לסייר בבסיסי נתונים, ליצור להם ייצוגים ויזואליים שונים, ליצור שאילתות ולהריץ אותם, ואף ליצור טופסי קלט ודוחות, באמצעות תכנות ויזואלי המשולב בתכנות רגיל, ותוך שימוש מינימלי בקוד.

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

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

בגרסה זו הושלמה יכולת תכנות מונחה עצמים במלואה, עם אפשרות של ירושה (Inherits), העמסת פרמטרים, העמסת אופרטורים (Operator), פונקציות המרה, מחלקות אבסטרקטיות (MustInherit), פונקציות אבסטרקטיות (MustOverride), פונקציות וירטואליות (Overridable), דריסת פונקציות/מאפיינים/אירועים (Overloads) והצללתן (Overrides או Shadows), יצירת ממשקים (Interface) וחשיפתם (Implements), הגדרת מאפייני רכיבי תכנות (Attribute), רפלקציה (Reflection) ועוד. 

כמו כן, הוספה יכולת לשפה לטפל בהיבטים תכנותיים שונים כמו יצירת תהליכי-משנה (Threading), הימשכות (Serialization), מקביליות (Concurrency) ופעילות אסינכרונית. שימוש במצביעים לפונקציות ושגרות (Delegate), סימון קטעים קריטיים (Critical section), עבודה עם תבניות גנריות (Generic), אריזת קטעי קוד במרחב שמות (Namespace), חלוקת קטעי קוד (Region) ועוד. הסביבה תומכת בשינוי קוד תוך כדי ריצה בזמן ניפוי שגיאות (Edit and Continue), באופן חופשי למדי (רק כאשר משנים כותרת של פונקציה, צריך להריץ מחדש). ישנה השלמה אוטומטית של פקודות וביטויים לאחר שהם מתחילים להיכתב. טקסט הקוד מאורגן אוטומטית: קיימת אינדנטציה אוטומטית של הקוד לפי תוכנו ומחיקה אוטומטית של רווחים.

אף שתפיסת הפיתוח של VB נשמרה, והשימוש בתכנות ויזואלי נשמר ואף הועצם, תחביר השפה שונה ונעשה יישור קו לכיוון תחביר מקובל בשפות העיליות החזקות, כדי להגדיל את התאימות לתפיסות המקובלות, וכדי להעצים את השפה. נוספו אובייקטים וספריות רבות שמקלות על עבודת התכנות בהיבטים רבים ומגוונים. בשפה זו קובצי ההרצה (RUN TIME) של התוכנה (ה-Framework) הם קבצים משותפים לכל שפות הדוט נט, ואינם ייחודיים לשפת VB כפי שהיה עד גרסה 6, ולכן אף שמדובר בקובץ ריצה גדול יותר פי כמה וכמה מקובץ ההרצה של VB6, סביר להניח שהוא כבר יהיה מותקן, בשל התפוצה הגדולה של יישומי הדוט נט.

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

## גרסאות

### גרסה 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, כך למשל בטופס: חלון הקוד פושט וסולקו ממנו בברירת המחדל הגדרות מפורטות של הפקדים, הבנאי ועוד לחלון נפרד של עיצוב הטופס (Just My Code). הוסף האובייקט My, שמאפשר להתייחס בקלות לאובייקטים תכנותיים מגוונים לפי נושאים, חזרה השליטה על הגדרת תחומי מערך, והוסף תחביר להצגה מידית של טפסים, כפי שהיה נהוג בעבר. קיימת מחלקה לטיפול מובנה בפרמטרים של התוכנה, הנשמרים והנקראים מקובץ XML. הוספה אפשרות מובנית לרכז את כל המשאבים של הפרויקט במקום אחד, מה שמונע כפילות שהייתה קיימת עד כה. הוספו תגיות חכמות לפקדים, וניתן לקשור בין אירועי פקד לבין שגרות קיימות, מתוך רשימה קיימת באופן דומה למה שכבר יושם בעבר בתוכנת אקסס.

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

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

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

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

### גרסה 2008
גרסה זו גם מכונה Visual Basic .NET 9.0 יצאה ביחד עם NET Framework 3.5. חידושים בגרסה זו: הוספה שפת LINQ שהיא הרחבה של שפת SQL לאובייקטים, מסדי נתונים ושפת XML, ופישוט התכנות של מבנים ועבודה עם רשומות בעקבות הכנסת חידוש זה. בעקבות זאת פקודות SQL הפכו לחלק מהתחביר של VB.NET. בגרסה זו נוסף פרויקט מסוג WPF שיועד על ידי מיקרוסופט להיות מערכת הדור הבא ליישומי לקוח. בפרויקט זה הופרד עיצוב הממשק מהקוד לשפה מבוססת XML, והושם דגש על הוויזואליות של הממשק, ועל שימוש קל בגרפיקה דו־ממדית ותלת־ממדית, אנימציה, מולטימדיה, טיפול במסמכי XPS ובדיו אלקטרוני ועוד. נוספה תמיכה במולטי טרגטינג שהיא האופציה לתחם את הפרויקט לגרסה מסוימת של .NET, ואף למקד את הפרויקט לגרסת מערכת הפעלה מסוימת. נוספו שיפורים לשפה כמו אפשרות להגדיר משתנים ריקים (שערכם Nothing), ולבצע קריאה לשגרת פקד קיימת ללא פרמטרים, תמיכה בתחשיב למדא, Type inference (זיהוי אוטומטי של סוג טיפוס ערך), Anonymous type -טיפוס אלמוני, שמייתר הגדרה מפורשת בתחשיב למדא, ו-Extension method - תכונה המאפשרת להרחיב יכולות של אובייקטים של המערכת ולהוסיף להם שיטות מותאמות של המתכנת. ה-IDE שופר בתחביר האינטליגנטי שמקפיץ חלונית צפה ובו המילים האפשריות לפי הקשר, וכן בסידור שורות המשך (בשימוש באופרטור _, קו תחתון). מנפה השגיאות שוכלל באופן שמאפשר לעקוב אחרי תהליכונים, ולדלג לתוך קוד המקור של ספריות הדוט נט עצמו. נוספה ארכיטקטורה חדשה של הרצת קוד מנוהל שמאפשר להריץ טוב יותר את הקוד. וכן, קוד מטריקס שמאפשר לאבחן את הסיבוכיות וקלות התחזוקה של קוד המקור של המתכנת לפי מתודות.

### גרסה 2010
גרסה זו שמספרה הוא 10.0 יצאה באמצע אפריל 2010, ביחד עם NET Framework 4.
בגרסה זו הורחבה התמיכה בפקודת Lambda. במקרים רבים בוטל הצורך בשימוש במקף החיבור (_) לפקודה שמשתרעת על פני מספר שורות. נוספה אפשרות ליישום אוטומטי (ומקוצר) של מאפיין מחלקה בשורה בודדת בדומה לקיים ב-C#. הוסף אתחול מקוצר של אובייקט אוסף, בדומה לאתחול של מערך. נוספו שיפור עבודה עם מערכים. תמיכה ב-Dynamic Language Runtime, כך שהשפה יכולה לתקשר ביתר קלות עם שפות דינמיות. שיפור בפרמטרים אופציונאליים. והוספת אפשרות להטמעת מעטפת Interop לרכיבי COM בקובץ ההרצה של היישום, במקום DLL עצמאי, כדי למנוע התנגשות בין גרסאות שונות. בטופס נוסף פקד chart - ליצירת גרפים. (לרשימת חידושים רשמית).

### גרסה 2012
לגרסה זו הוספו מספר תכונות חדשות:
* יכולת א-סינכרונית (Async feature) למשל באמצעות פונקציה אסינכרונית שבה מקטע מתבצע במשימה (Task) נפרדת מהתהליך שקורא לו.

```vbnet
Async Function AccessTheWebAsync() As Task(Of Integer)
    Dim client As HttpClient = New HttpClient()
    Dim getStringTask As Task(Of String) = client.GetStringAsync("http://site.org")
    DoIndependentWork()
    Dim urlContents As String = Await getStringTask
    Return urlContents.Length
End Function
```


* איטרטורים (Iterators) המשמשים לביצוע איטרציה מותאמת אישית על אוספים כגון רשימות או מערכים.
* היררכיית הקריאה (Call Hierarchy) מאפשרת לך לנווט את הקוד שלך על ידי הצגת כל הקריאות, דבר המאפשר להבין טוב יותר את זרימת הקוד.

### גרסת 2013 (VB 12.0)
גרסת Visual Basic 2013 שוחרר לצד .NET Framework 4.5.1 עם Visual Studio 2013. יכול גם לבנות יישומי .NET Framework 4.5.2 על ידי התקנת Developer Pack. 

### גרסת 2015 (VB 14.0)
גרסת Visual Basic 2015 (קוד בשם VB 
14.0) שוחרר עם Visual Studio 2015. תכונות השפה כוללות "?." אופרטור לביצוע בדיקות null מוטבעות, ותכונת אינטרפולציה חדשה של מחרוזת כלולה לעיצוב מחרוזות בשורה.

### גרסת 2017 (VB 15.x)
גרסת Visual Basic 2017 (קוד בשם VB "15.) שוחרר עם Visual Studio 2017. מרחיב את התמיכה בתכונות השפה החדשות של Visual Basic 15 עם גרסאות 2017, 15.3, 15.5, 15.8. מציגה רפקטורים חדשים המאפשרים ארגון קוד מקור בפעולה אחת.

### גרסת 2019 (VB 16.0)
גרסת Visual Basic 2019 (קוד בשם VB "16.0") שוחרר עם Visual Studio 2019. זוהי הגרסה הראשונה של Visual Basic המתמקדת ב-.NET Core. 

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

בשפת VB.NET הושם דגש על ידידותיות וקלות בפיתוח (אוטומציה גדולה יותר בחילול קוד. השלמה אוטומטית של כתיבת פקודות, הזחה אוטומטית של הקוד, ניווט קל בין אירועי פקד, הסתרה של Delegate וטיפול אוטומטי באירועים), על האינטואיטיביות והקריאות של הקוד (פקודות מפורשות ומובנות יותר), ושפה זו יותר גמישה תכנותית ו"סבלנית" כלפי המפתח (למשל המרה אוטומטית בין טיפוסי משתנים, הנגשת תכונות sender בפונקציית אירוע ללא המרה, משפט Case שאפשר לערב בו אותיות, מספרים ואף ביטויים, מאפיין עם פרמטר ועוד), ופעולות טכניות שונות הוסתרו מאחורי הקלעים. לעומת זאת בשפת C# הושם דגש על הדיוק הטכני וההקפדה התכנותית (למשל בהמרה בין סוגי משתנים, הקפדה על החזרת ערך בפונקציה), על הבנה ומעורבות עמוקה של המתכנת בתכנות, על חוזק תחבירי של הקוד (שמבוסס על קונבנציות של שפת C), ועל תאימות והתממשקות לשפת C++ (אפשרות לכתוב קטעי קוד מעורבים של C# ו-C++). 

בעוד ששפת VB.NET אמורה לשמש את מתכנתי ה-VB, שפת C# אמורה לשמש את מתכנתי ++C. ולכן בסופו של דבר יצא ששפת C# יותר פופולרית אצל מתכנתים, והיצע המשרות בה גדול באופן ניכר על פני המשרות בשפת VB.NET.

## מבנה השפה
שמאל|ממוזער|250px|פקדים שיתופיים של השפה

בדומה ל-#C לכל רכיב בשפה קיימות חמש רמות הרשאה לגישה. ההרשאה הפתוחה ביותר היא Public המאפשרת גישה מכל אובייקט, לאחריה הרשאת Protected המצמצמת גישה למחלקות יורשות, ולאחריה הרשאת Private שמצמצמת גישה רק לחברי המחלקה עצמה. בנוסף ישנה הרשאת Friend המאפשרת גישה כללית רק מתוך ה-Assembly של המחלקה, והרשאת Protected Friend המאפשרת גישה מתוך מחלקות יורשות גם אם הן ב-Assembly אחר.

ב-VB.NET קיימים שני תחומים שבהם ניתן לכתוב קוד:

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

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

כל מחלקה צריכה להתחיל במילה השמורה - **Class** ולהסתיים ב- **End Class**.
למחלקה יכולים להיות שגרה בונה New()&lrm; ושגרה הורסת Finalize()&lrm;, כדי שיהיה אפשר לשלוט על הקוד ביצירתו של האובייקט ובסגירתו. כל מחלקה יכולה להכיל טיפוסים, מבנים, קבועים, משתנים, שיטות, תכונות ואירועים.

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

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

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

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


```vbnet
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** למשתנה, למתודה או למאפיין). בשיטה זו ניתן ליצור פונקציות גלובליות ללא שימוש במודולים של VB.

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

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

ב-VB פקודות Get ו-Set של מאפיינים היו נפרדים, מה שעשה את התוכנה לפחות קריאה. ב-VB.NET פקודות ההשמה ('Set***)*** **והקבלה ''(***Get) מרוכזות במאפיין אחד.

<syntaxhighlight lang="vbnet">
Private LocalVariable As VariableType

Public Property MyProperty() As VariableType
   Get
      Return LocalVariable
   End Get
   Set(ByVal value As VariableType)
      LocalVariable = value
   End Set
End Property
</syntaxhighlight>

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

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

<syntaxhighlight lang="vbnet">
    Private _Bytes() As Byte

    Public Property Bytes(ByVal index As Integer) As Byte
        Get
            Return _Bytes(index)
        End Get
        Set(ByVal value As Byte)
            _Bytes(index) = value
        End Set
    End Property
</syntaxhighlight>

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

<syntaxhighlight lang="vbnet">
Public Property Name As String 
</syntaxhighlight>

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

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

בדוגמה, ארבעה כפתורים שקשורים לאותו אירוע, והתוצאה בלחיצה על אחד מהכפתורים הללו תהיה הודעה למסך עם שמו של הכפתור המזניק.
<syntaxhighlight lang="vbnet">
  Private Sub Button_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) _
     Handles Button1.Click, Button2.Click, Button3.Click, Button4.Click
        MessageBox.Show("Name: " & sender.Name)
  End Sub
</syntaxhighlight>

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

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

בדוגמה הבאה ניתן לראות שתי מחלקות. במחלקת People מוגדרת פונקציה CheckBirthDate, שבודקת אם חל היום יום ההולדת, ומזניקה את האירוע BirthDate במידה והתשובה חיובית, עם חישוב של הגיל. ובמחלקת Form1 ממומש אובייקט של People שלוכד את האירוע BirthDate בעת שהוא יוזנק במחלקת People. הדבר מאפשר לכמוס את הבדיקה במחלקת People, ולא להכביד על מחלקת Form1 בבדיקות מיותרות.
<syntaxhighlight lang="vbnet">
Public Class Form1
    Private WithEvents people1 As People = New People()

    Private Sub Form1_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load
        people1.Id = "068557588585"
        people1.Name = "John Doe"
        people1.DateOfBirth = #8/30/1999#
    End Sub

    Sub BirthDate(ByVal sender As Object, id As String, ByVal age As Integer) Handles people1.BirthDate
        Console.WriteLine(id.ToString() & " " & age.ToString())
    End Sub
End Class

Public Class People
    Public Property Id As String
    Public Property Name As String
    Public Property DateOfBirth As Date

    Public Event BirthDate(ByVal sender As Object, id As String, ByVal age As Integer)

    Private Sub CheckBirthDate() ' Operate by timer once a day
        If (DateOfBirth.Month = Date.Today.Month And DateOfBirth.Day = Date.Today.Day) Then
            RaiseEvent BirthDate(Me, Id, DateDiff(DateInterval.Year, DateOfBirth, Date.Today))
        End If
    End Sub
End Class

</syntaxhighlight>

===מבנה - Structure===
מבנה (יורשו של ה-Type מה-VB6) בעוד שב-VB6 יכל רק לאגד בתוכו משתנים תחת מרחב שם משותף, בדוט נט בהשראת שפת ++C הוא הורחב מאוד, והפך לסוג של טיפוס שיכול להכיל בתוכו משתנים, מתודות, מאפיינים ואף אירועים ושגרת בנאי. ולמעשה מתנהג כמו מחלקה שיכולותיה הוגבלו מעט וברירות המחדל שלה שונו. אמנם עיקר השימוש שבו נותר ליצור טיפוס משתמש, שמאגד משתנים מסוגים שונים שיש להם עניין משותף. 

<syntaxhighlight lang="vbnet">
Private Structure BookType
    Dim Title As String
    Dim URL As String
    Dim Page As integer
End Structure
</syntaxhighlight>

כאשר מגדירים משתנה מטיפוס זה (עם פקודת New) ניתן לאתחל אותו בהגדרה, כפי שניתן לעשות במחלקה. 
<syntaxhighlight lang="vbnet">
Private BookData As New BookType() With {.Title = "The Catcher in the Rye", .Page = 10}
</syntaxhighlight>

אחד השימושים הנפוצים הוא להגדיר מערך או ליסט של structure היוצרים למעשה [[UDT]] (User Defined Types)- שהוא למעשה טבלת משתמש בזיכרון. השימוש במבנה מאפשר לנהל רשומות בזיכרון, וגם לשמור ולקרוא אותם מקובץ באופן קל ופשוט. אפשר גם ליצור מבנים מורכבים יותר, שבו מבנה אחד יכלול מבנה אחר.
 
<syntaxhighlight lang="vbnet">

Private BookData(12) As BookType

BookData(0).Title = "The Catcher in the Rye"
BookData(0).URL = "http://en.wikipedia.org/wiki/The_Catcher_in_the_Rye"
</syntaxhighlight>

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

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

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

: **צורת הכתיבה הבסיסית של שגרה:**
<syntaxhighlight lang="vbnet">
[modifiers] Sub SubName[(parameterlist)]
...
End Sub
</syntaxhighlight>

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

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


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

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

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

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

בנוסף לטופס של יישומי חלונות (WinForm), הוסף טופס גרפי מתקדם Window ביישום של WPF, וכן קיים טופס של יישומי אינטרנט (WebForm), שמאפשר ליצור יישומי אינטרנט באופן דומה ליישומי חלונות. (דבר שיושם באופן ממצה במחולל האתרים של הקוד הפתוח DotNetNuke). כמו כן הוסף טופס להתקנים ניידים.

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

### משתנים

השפה כוללת את כל טיפוסי המשתנים הרגילים: בוליאני (Boolean), מספר שלם (Byte, Short, Integer, Long, Decimal), נקודה צפה (Single, Double), תו (Char), ומחרוזת (String = המסוגלת להכיל עד 2 מיליארד תווי יוניקוד). כמו כן ניתן להגדיר מספרים שלמים חיובים (UShort, UInteger, ULong). קיימים גם טיפוס תאריכי (Date), ואובייקט (Object) שהוא משתנה רב תכליתי, המסוגל להכיל מגוון רחב של טיפוסים. (משתנה זה מחליף את משתנה Variant של VB, וסוג הטיפוס שלו משתנה בהתאם לערך שהושם בו. כלומר: אם בשורה הראשונה יושם בו מספר שלם הוא יהיה מסוג integer ואם בשורה השנייה תושם בו מחרוזת הוא יהפוך לטיפוס String). 

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


```vbnet
Dim String1 As String = OpenFileDialog.FileName
```


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


```vbnet
Dim string1 As New String("*", 500)
```


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


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


#### מערכים
כמו ב-VB ניתן להגדיר מערך הן בגודל קבוע מראש (בהגדרת מספר האיברים שבו), והן בגודל משתנה במהלך הריצה (בהקצאה דינמית באמצעות פקודת ReDim) עם אופציה לשמירת הנתונים שכבר קיימים בו. (הגישה לאיברים תהיה באמצעות אינדקס בתוך סוגריים עגולים).
  
ניתן להגדיר בשפה מערך משונן (jagged array), שהוא למעשה מערך של מערכים, ונועד להכיל בתוכו מערכים בגדלים משתנים. 

```vbnet
Dim Array1() As Integer = {1, 2, 3, 4, 5}
    Dim Array2() As Integer = {4, 5}
    Dim JaggedArray()() As Integer = {Array1, Array2}
```


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

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

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


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


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


```vbnet
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

Dim Text As String = "Me"
Select Case Text
    Case "All" : Camera = 0
    Case "AllMe".Substring(3, 2)
      Camera = 1
    Case -999, -888
      Camera = 1
End Select
```


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

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


```vbnet
For VariableName [As Variable] = StartValue to StoptValue [Step Value]
  statements...
 [Continue For]
 [Exit For]
 Next [VariableName]
```


##### לולאת For Each
לולאה זו (שהייתה קיימת ב-VB), היא לולאה מתוחכמת שפועלת עם מערך/רשימה/אוסף, ורצה כפי מספר האיברים שבו. לולאה זו היא לולאה בטוחה, שלא תחרוג ממספר האיברים שבאובייקט. בכל מחזור ריצה היא מצביעה על האיבר הנוכחי באוסף, ואפשר לפנות דרכה לתכונותיו ולמתודות שלו. פעולה שימושית שלה הוא מעבר על כל הפקדים בטופס.


```vbnet
For Each VariableName [As Variable] In Array|List|Collection
      Statements...
      [Continue For]
      [Exit For]
   Next [ObjectItem]
```


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


```vbnet
Dim stringArray() As String = {"Mouse", "Cat", "Dog"}
   For Each valueItem As String In stringArray
      Console.WriteLine(valueItem)
   Next
```


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


```vbnet
Do {While | Until} condition
    statements...
   [Continue While]
   [Exit Do]
 Loop

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


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


```vbnet
#Region "heading"
  ...
 #End Region
```


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

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

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


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


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

### רכיבים נוספים בשפה
שפת ה-VB.NET מכילה תמיכה עשירה בשיטות תכנות שונות. ברכיבי ממשק התוכנה ניתן ליצור רכיבי COM לשימוש בתוכנות אחרות (שרת), ולעבודה עם רכיבי COM שנכתבו בשפות אחרות (לקוח). בממשק המשתמש ניתן ליצור בטפסים פקדי משתמש (UserControl), וכן רכיבים (CustomControl), שנועדו לייצר רכיבים חדשים או להרחיב יכולות של רכיבים קיימים תוך ריכוזם ביחידה עצמאית לשימוש חוזר. לשם עבודה בממשק משתמש ניתן ליצור ממשקים תוך שימוש ביחידת ה-WPF של דוט נט, ולשם יצירת תקשורת רשת בין תוכנות ניתן להשתמש ביחידת התקשורת WCF של הדוט נט. לעבודה עם אוספים ומערכים ובסיסי נתונים ניתן להשתמש בהרחבה של ה-LINQ. לשימוש בתכנות פונקציונלי ניתן להשתמש בתחשיב למדא ופונקציות אנונימיות. לשם עבודה עם בסיסי נתונים ניתן להשתמש ברכיבי ה-OLEDB או ברכיבי ה-ADODB.

## דברים עיקריים ששונו בשפה זו לעומת VB6
* תחביר פקודות השפה ומבני הבקרה הוגמש וחוזק.
* פרדיגמת תכנות מונחה-עצמים שהייתה חלקית ב-VB6 הושלמה בשפה זו.
* הוספו יכולות תכנותיות מובנות בשפה: תהליכי-משנה (Threading), סימון קטעים קריטיים (Critical section), עבודה עם תבניות גנריות (Generic).
* נעשו שינויים שונים במשתנים: משתנים מספרים הוכפלו בגודלם, משתנה מסוג Variant הומר ל-Object. טיפוס רשומה Type הומר ל-Structure. מחרוזת באורך קבוע fixed String הוסרה מהשפה, גודל מחרוזות נקבע אוטומטית. הגדרה כוללנית של משתנים באמצעות Def הוסרה, מעתה יש להגדיר כל משתנה בנפרד.
* הוספו פקדים רבים ומגוונים יותר. אוסף פקדים הוסר מברירת המחדל, והפך להיות מעט קשה יותר לביצוע.
* אירוע אחד ניתן להקשר למספר פקדים, ופקד אחד ניתן להקשר למספר אירועים, בניגוד ל-VB שם הקשר בין פקד לאירוע היה חד-חד-ערכי.
* הוספה מערכת משתנים לפי פרויקט שנשמרים בקובץ Settings, שניתן לקשור אותם למאפיינים של פקדים.
* למנגנון לכידת חריגים ON ERROR הוסף מנגנון נוסף בדומה למנגנון שקיים ב-++C.
* מנגנון ניהול הזיכרון הפך להיות אוטומטי. במסגרתו קיים מנגנון "איסוף זבל", שמנקה את הזיכרון ומשחרר אובייקטים שאינם בשימוש בתנאים שנקבעו לו.
* הוספת שפת LINQ לקיצור תהליכים תכנותיים בעבודה עם מערכים ורשימות בסגנון שפת SQL.
* הוספת תחשיב למדא למימוש של תכנות פונקציונלי.

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


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


או בתחביר מקוצר:


```vbnet
Public Class Form1
   Private Sub PlayAudio()
         My.Computer.Audio.Play("c:\test.wav")
   End Sub
 End Class
```


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


```vbnet
Public Class Form1
   Private Sub ShowSerialPortNames()
        MsgBox(My.Computer.Ports.SerialPortNames.Item(0).ToString)
   End Sub
 End Class
```


שגרה שמבצעת משלוח אימייל באמצעות שרת SMTP


```vbnet
Imports System.Net.Mail

Public Sub SendMailMessage(ByVal UserName As String, ByVal Password As String)
 Dim MySmtpClient As New SmtpClient("smtp.012.net.il", "25")
 MySmtpClient.Credentials = New Net.NetworkCredential(UserName, Password)
 MySmtpClient.UseDefaultCredentials=False
 MySmtpClient.Send(New MailMessage("bibinat@012.net.il", _
                      "alon123@gmail.com", "Hello", "What's new?"))
End Sub
```


## ראו גם
* ASP.NET
* DotNetNuke

## קישורים חיצוניים

* 
* האתר הרשמי של השפה בגרסה החדשה
* להורדת גרסה לימודית, חינמית ועדכנית של ויזואל בייסיק - מהדורה 2010, באתר מיקרוסופט
* שיעורי וידאו ללימוד השפה, אתר msdn
* השוואה בין שפות C# ו-VB.NET, באתר Harding University
* ממיר קוד בין שפות דוט נט ל-VB.NET, באתר Developer fusion
* Complete Comparison for VB.NET and C#, codeproject

## הערות שוליים

קטגוריה:שפות תכנות
קטגוריה:כלי פיתוח מבית מיקרוסופט
קטגוריה:.NET