Lesson 36 · Conclusion & Next Steps

Conclusion & Next Steps

You have completed all 35 lessons of VB.NET 2026. Here is a full recap, a best-practices checklist, recommended projects, the essential NuGet ecosystem, and a VB→C# comparison for when you're ready to cross over.

« Lesson 35: Web API & HttpClient Back to Home

🎓

You've completed VB.NET 2026!

35 lessons, 100+ code examples, 70+ interactive simulations, and a complete curriculum from "Hello World" to async REST APIs — all in Visual Basic 2026 on .NET 10. Now it's time to build something real.

36.1 Curriculum Recap — All 35 Lessons

Introduction

IDE, project types

Designing the UI

Forms, controls layout

Enhancing the UI

Colour, fonts, styles

Writing the Code

Events, first logic

Working with Controls

TextBox, Button, Label

ListBox & ComboBox

Selection, items

PictureBox

Images, SizeMode

Data Types

Integer, String, Boolean…

Variables & Constants

Scope, Dim, Const

Arrays

1D, 2D, ReDim

Math Operations

Operators, Math class

String Manipulation

Substring, Split, Format

If…Then…Else

Branching, ElseIf

Select Case

Multi-branch, ranges

Looping

For, While, Do Loop

Sub Procedures

Parameters, ByRef/ByVal

Functions

Return values, overloads

Math Functions

Sqrt, Round, Abs, Log

Trigonometric

Sin, Cos, Tan, Atan2

Format Function

Currency, date, numeric

CheckBox

Checked, ThreeState

Radio Button

GroupBox, mutual exclusion

Web Browser

WebView2, navigation

Error Handling

Try/Catch, Finally

OOP

Class, Property, Inheritance

Graphics & GDI+

DrawLine, DrawString

Using Timer

Interval, Tick event

Animation

Movement, collision, GDI+

Database Intro

ADO.NET, SQLite, CRUD

Connecting DB

BindingSource, DataGridView

Editing Data

Validation, transactions, undo

LINQ & Collections

List, Dictionary, GroupBy

File I/O & JSON

StreamReader/Writer, JsonSerializer

Async Programming

Async/Await, IProgress, Cancel

Web API & HttpClient

REST, JSON deserialise

36.2 Best Practices Checklist

These are the patterns that separate maintainable professional code from working-but-fragile code. Tick them off on every project.

🏗 Code Structure

One class per file, named identically to the file.
Business logic in classes, not in form event handlers.
Constants at module top with descriptive names (MAX_RETRIES not 3).
Methods < 20 lines; if longer, extract helpers.

⚠️ Error Handling

Every database call and file I/O in Try/Catch.
Catch specific exceptions (SqliteException) before general (Exception).
Always use Finally to release resources (or Using blocks).
Log errors to a file — don't show stack traces to users.

🗃 Database

Always use parameterised queries — never string-concatenate SQL.
Wrap multi-row writes in a transaction.
Call Using on connections — never leave them open.
Validate all user input before writing to the database.

⚡ Async / UI

Every slow operation is Async Sub with Await.
Disable the triggering button; re-enable in Finally.
Use IProgress(Of Integer) — never update UI from a background thread.
One static HttpClient — never instantiate per request.

🧹 Collections & LINQ

Prefer List(Of T) over arrays for mutable sequences.
Call .ToList() to materialise a LINQ query you'll enumerate more than once.
Use FirstOrDefault not First — never let LINQ throw on empty sequences.
Build a Dictionary for O(1) lookup rather than .Where().First() in a loop.

📁 File & Settings

All data files under LocalUserAppDataPath — never write to Program Files.
Always check File.Exists before reading.
Wrap JSON Deserialize in Try/Catch — files can be hand-edited.
Use Path.Combine, never & or + for path strings.

The 5 Most Common Beginner Mistakes

SQL injection: "SELECT * FROM Students WHERE Name='" & txtName.Text & "'" — always use @Name parameters.
Blocking the UI thread: Thread.Sleep() or synchronous file reads inside a button click — always Async/Await.
Creating HttpClient per request: port exhaustion at scale — use one shared instance.
Forgetting Using: database connections and file handles left open — always use Using … End Using.
Unhandled exceptions in Async Sub: exceptions silently crash the app — always wrap Async Sub bodies in Try/Catch.

36.3 Project Ideas

The best way to solidify your skills is to build something end-to-end. Each project below has a difficulty rating and lists the exact lessons it exercises.

📚 Student Management System Beginner

Full CRUD for students, classes, and grades. Login form, DataGridView, CSV export, charts.

Lessons: 5–15, 24–25, 29–33

🛒 Inventory Tracker Beginner

Products, categories, stock levels, low-stock alerts. SQLite backend, LINQ analytics, JSON settings.

Lessons: 13–17, 29–33

🌦 Weather Dashboard Intermediate

Search any city, display current conditions and 7-day forecast. Uses Open-Meteo (free, no key).

Lessons: 26, 34–35

💱 Currency Converter Intermediate

Real-time exchange rates, conversion calculator, rate history chart drawn with GDI+, cached settings.

Lessons: 26–27, 33–35

📊 LINQ Analytics Board Intermediate

Import CSV data, apply Where/GroupBy/Aggregate queries interactively, export filtered results.

Lessons: 32–33, 26

🎮 Simple Arcade Game Advanced

GDI+ sprites, Timer-driven game loop, collision detection, high-score table persisted to SQLite.

Lessons: 15, 24–28, 29

📝 Notes App with Sync Advanced

Local SQLite + JSON export, async auto-save, tag-based LINQ filtering, optional REST sync endpoint.

Lessons: 29–35

📈 Stock Watcher Advanced

Poll a stock API every 60 seconds (Timer + HttpClient), draw price history with GDI+, alert on thresholds.

Lessons: 27, 33–35

36.4 Essential NuGet Packages

Beyond what's built into .NET 10, these packages are widely used in real VB.NET applications. Search for them in Tools → NuGet Package Manager → Browse in Visual Studio.

Microsoft.Data.Sqlite

Official SQLite driver for .NET

Local database without SQL Server. Used in Lessons 29–31.

Dapper

Micro-ORM — SQL → typed objects

conn.Query(Of Student)("SELECT…") — eliminates manual DataReader mapping.

Newtonsoft.Json

Popular JSON library (Json.NET)

More features than System.Text.Json: dynamic, LINQ to JSON, converters.

CsvHelper

Professional CSV reading/writing

Handles quoted fields, headers, type mapping. Replaces manual Split(",").

Serilog

Structured logging

Log to file, console, or cloud. Log.Information("Loaded {Count} rows", n).

LiveCharts2

Modern charting for WinForms

Line, bar, pie charts with animations. Replaces hand-drawn GDI+ charts.

FluentValidation

Validation rule builder

Replaces manual error lists. Define rules in a class; validate objects.

Polly

Resilience & retry library

Automatic HTTP retries, circuit breaker, timeout policies for HttpClient.

Package Manager Console — install commands

' In Visual Studio → Tools → NuGet Package Manager → Package Manager Console:
Install-Package Microsoft.Data.Sqlite
Install-Package Dapper
Install-Package Newtonsoft.Json
Install-Package CsvHelper
Install-Package Serilog
Install-Package LiveChartsCore.SkiaSharpView.WinForms
Install-Package FluentValidation
Install-Package Polly

36.5 VB.NET → C# Comparison

C# is the dominant .NET language in industry. The languages are functionally identical — same framework, same IL output, same NuGet packages. Syntax is the only difference. If you know VB, you can read C# within a week.

Concept	VB.NET 2026	C# (.NET 10)
Class definition	`Public Class Student … End Class`	`public class Student { … }`
Auto-property	`Public Property Name As String`	`public string Name { get; set; }`
Variable declaration	`Dim x As Integer = 5`	`int x = 5;` or `var x = 5;`
String interpolation	`$"Hello {name}"`	`$"Hello {name}"` — identical!
If statement	`If x > 0 Then … End If`	`if (x > 0) { … }`
For each loop	`For Each s In students … Next`	`foreach (var s in students) { … }`
LINQ (method)	`students.Where(Function(s) s.Grade > 80)`	`students.Where(s => s.Grade > 80)`
Async function	`Async Function LoadAsync() As Task(Of T)`	`async Task<T> LoadAsync()`
Null coalescing	`If(value, defaultVal)`	`value ?? defaultVal`
Null-conditional	`obj?.Property`	`obj?.Property` — identical!
And / Or	`AndAlso` / `OrElse`	`&&` / `\|\|`
Not equal	`<>`	`!=`
Using statement	`Using conn As New SqliteConnection(…) … End Using`	`using var conn = new SqliteConnection(…);`
Throw exception	`Throw New ArgumentException("msg")`	`throw new ArgumentException("msg");`
Comments	`' single line`	`// single line` or `/* block */`

Migration Tips

The free CodeConverter (also available as a Visual Studio extension) converts VB.NET ↔ C# with high accuracy. It's an excellent tool for learning C# syntax from your own working VB code.

36.6 Continued Learning

Where to go from here, in rough order of priority for a VB.NET Windows Forms developer:

📖 Official Docs

🎯 Next Topics to Learn

Entity Framework Core — ORM; auto-generates SQL from class models
WinForms MVVM — separate UI from logic using data binding
Unit Testing — xUnit / NUnit; test business logic without the UI
Git & GitHub — version control; essential for any project

🤝 Community

🚀 Now go build something!

Every great application starts as a simple form with a button. Pick one of the project ideas above, open Visual Studio 2026, and start writing. The best way to learn is always to ship.

📖 Back to Lesson Index ↩ Start from Lesson 1 🌐 VBTutor.net

Featured Books

Visual Basic 2022 Made Easy

by Dr. Liew Voon Kiong

The definitive companion to this tutorial series — all 35 lesson topics in print with exercises.

View on Amazon →

VB Programming With Code Examples