What you need

Before writing any code, you need three things from Meta:

1. Meta Business Account with a registered app at developers.facebook.com
2. Phone Number ID from the WhatsApp section in your app dashboard
3. Access Token (temporary for testing, permanent via System User for production)

Meta provides a free test phone number and five test recipient numbers. You can send real messages during development without any cost.

How the WhatsApp Cloud API works

The WhatsApp Cloud API is a REST API hosted by Meta. Your VB.NET application sends an HTTP POST request with a JSON body to Meta’s servers. Meta then delivers the message to the recipient’s WhatsApp app. The flow is:

1. Your app sends a POST request to https://graph.facebook.com/v20.0/{phone_number_id}/messages
2. Meta validates your token, phone number, and message format
3. Meta delivers the message via WhatsApp servers
4. You receive a JSON response with the message ID or an error

There is one important rule: you can only send template messages to users who have not messaged you in the last 24 hours. Free-form text messages are only allowed within a 24-hour conversation window. For most notification use cases (order confirmations, alerts, reminders), template messages are what you need.

Sending a text message

This is the simplest example. It sends a plain text message to a single recipient inside an active conversation window:

Imports System.Net.Http
Imports System.Text

Private Async Function SendWhatsAppMessage(recipientPhone As String, message As String) As Task(Of Boolean)
    Dim phoneNumberId As String = "YOUR_PHONE_NUMBER_ID"
    Dim accessToken As String = "YOUR_ACCESS_TOKEN"
    Dim url As String = $"https://graph.facebook.com/v20.0/{phoneNumberId}/messages"

    Dim json As String = "{" &
        """messaging_product"": ""whatsapp""," &
        """to"": """ & recipientPhone & """," &
        """type"": ""text""," &
        """text"": {""body"": """ & message & """}" &
        "}"

    Using client As New HttpClient()
        client.DefaultRequestHeaders.Add("Authorization", "Bearer " & accessToken)
        Dim content As New StringContent(json, Encoding.UTF8, "application/json")
        Dim response = Await client.PostAsync(url, content)
        Return response.IsSuccessStatusCode
    End Using
End Function

Call it from a button click or any event handler:

Private Async Sub btnSend_Click(sender As Object, e As EventArgs) Handles btnSend.Click
    Dim success = Await SendWhatsAppMessage("491234567890", "Your order has been shipped.")

    If success Then
        lblStatus.Text = "Message sent."
    Else
        lblStatus.Text = "Failed to send message."
    End If
End Sub

The phone number must include the country code without a plus sign or leading zeros. For a German number like +49 123 4567890, use 491234567890.

Sending a template message

Template messages are pre-approved message formats that you create in your Meta Business dashboard. They are required for sending the first message to a user or for messages outside the 24-hour window:

Private Async Function SendTemplateMessage(recipientPhone As String, templateName As String) As Task(Of Boolean)
    Dim phoneNumberId As String = "YOUR_PHONE_NUMBER_ID"
    Dim accessToken As String = "YOUR_ACCESS_TOKEN"
    Dim url As String = $"https://graph.facebook.com/v20.0/{phoneNumberId}/messages"

    Dim json As String = "{" &
        """messaging_product"": ""whatsapp""," &
        """to"": """ & recipientPhone & """," &
        """type"": ""template""," &
        """template"": {" &
            """name"": """ & templateName & """," &
            """language"": {""code"": ""en_US""}" &
        "}" &
        "}"

    Using client As New HttpClient()
        client.DefaultRequestHeaders.Add("Authorization", "Bearer " & accessToken)
        Dim content As New StringContent(json, Encoding.UTF8, "application/json")
        Dim response = Await client.PostAsync(url, content)
        Return response.IsSuccessStatusCode
    End Using
End Function

Meta provides a default template called hello_world for testing. Create your own templates in the WhatsApp Manager section of your Meta Business dashboard. Templates can include variables like {{1}} that you fill with dynamic content at send time.

Template message with variables

Most real templates include placeholders for customer names, order numbers, or dates. Here is how to send a template with variable parameters:

Private Async Function SendOrderConfirmation(phone As String, customerName As String, orderId As String) As Task(Of Boolean)
    Dim phoneNumberId As String = "YOUR_PHONE_NUMBER_ID"
    Dim accessToken As String = "YOUR_ACCESS_TOKEN"
    Dim url As String = $"https://graph.facebook.com/v20.0/{phoneNumberId}/messages"

    ' Template "order_confirmation" with two body parameters
    Dim json As String = "{" &
        """messaging_product"": ""whatsapp""," &
        """to"": """ & phone & """," &
        """type"": ""template""," &
        """template"": {" &
            """name"": ""order_confirmation""," &
            """language"": {""code"": ""en_US""}," &
            """components"": [{" &
                """type"": ""body""," &
                """parameters"": [" &
                    "{""type"": ""text"", ""text"": """ & customerName & """}," &
                    "{""type"": ""text"", ""text"": """ & orderId & """}" &
                "]" &
            "}]" &
        "}" &
        "}"

    Using client As New HttpClient()
        client.DefaultRequestHeaders.Add("Authorization", "Bearer " & accessToken)
        Dim content As New StringContent(json, Encoding.UTF8, "application/json")
        Dim response = Await client.PostAsync(url, content)
        Return response.IsSuccessStatusCode
    End Using
End Function

The parameters fill the {{1}}, {{2}} placeholders in your template in order. Make sure the number of parameters matches what the template expects.

Reading the API response

A successful response returns a JSON object with the message ID. An error returns a structured error object. Here is how to read both:

Private Async Function SendAndLog(recipientPhone As String, message As String) As Task
    Dim phoneNumberId As String = "YOUR_PHONE_NUMBER_ID"
    Dim accessToken As String = "YOUR_ACCESS_TOKEN"
    Dim url As String = $"https://graph.facebook.com/v20.0/{phoneNumberId}/messages"

    Dim json As String = "{" &
        """messaging_product"": ""whatsapp""," &
        """to"": """ & recipientPhone & """," &
        """type"": ""text""," &
        """text"": {""body"": """ & message & """}" &
        "}"

    Using client As New HttpClient()
        client.DefaultRequestHeaders.Add("Authorization", "Bearer " & accessToken)
        Dim content As New StringContent(json, Encoding.UTF8, "application/json")
        Dim response = Await client.PostAsync(url, content)
        Dim body = Await response.Content.ReadAsStringAsync()

        If response.IsSuccessStatusCode Then
            ' body contains: {"messaging_product":"whatsapp","contacts":[...],"messages":[{"id":"wamid.xxx"}]}
            Console.WriteLine("Sent. Response: " & body)
        Else
            ' body contains: {"error":{"message":"...","type":"...","code":100,...}}
            Console.WriteLine("Error " & response.StatusCode.ToString() & ": " & body)
        End If
    End Using
End Function

For production applications, log the response body to a file for debugging. See the VB.NET write text file guide for file logging patterns.

Sending to multiple recipients

The WhatsApp API accepts one recipient per request. To send to multiple numbers, loop through a VB.NET List of phone numbers:

Private Async Function SendToMultiple(phones As List(Of String), message As String) As Task
    Dim successCount As Integer = 0
    Dim failCount As Integer = 0

    For Each phone In phones
        Dim success = Await SendWhatsAppMessage(phone, message)

        If success Then
            successCount += 1
        Else
            failCount += 1
        End If

        ' Respect rate limits: max 80 messages per second for Business API
        Await Task.Delay(50)
    Next

    Console.WriteLine($"Sent: {successCount}, Failed: {failCount}")
End Function

The Task.Delay(50) adds a small pause between requests to stay within the API rate limit. For large batches (thousands of messages), consider queuing messages and processing them in the background.

Storing credentials safely

Never hardcode your access token in source code. For desktop applications, store credentials in an external config file or environment variables:

' Read from App.config or environment variable
Dim accessToken As String = Environment.GetEnvironmentVariable("WHATSAPP_TOKEN")
Dim phoneNumberId As String = Environment.GetEnvironmentVariable("WHATSAPP_PHONE_ID")

If String.IsNullOrEmpty(accessToken) OrElse String.IsNullOrEmpty(phoneNumberId) Then
    MessageBox.Show("WhatsApp credentials not configured.", "Configuration Error",
        MessageBoxButtons.OK, MessageBoxIcon.Error)
    Return
End If

Set environment variables on the machine running your app, or use My.Settings with user-scoped settings for per-user configuration.

Using Twilio as an alternative

If you prefer a simpler SDK over raw HTTP requests, Twilio offers a WhatsApp integration with a .NET NuGet package. Install Twilio via NuGet, then:

Imports Twilio
Imports Twilio.Rest.Api.V2010.Account

' Initialize once at app startup
TwilioClient.Init("YOUR_ACCOUNT_SID", "YOUR_AUTH_TOKEN")

' Send a message
Dim msg = MessageResource.Create(
    body:="Your order has been shipped.",
    from:=New Twilio.Types.PhoneNumber("whatsapp:+14155238886"),
    [to]:=New Twilio.Types.PhoneNumber("whatsapp:+491234567890")
)

Console.WriteLine("Message SID: " & msg.Sid)

Twilio costs money per message but handles rate limiting, retries, and delivery tracking for you. The direct Meta API is free (you only pay for conversations after the free tier), but you handle everything yourself.

Common mistakes

Sending free-form text outside the 24-hour window

The API returns error code 131047 if you try to send a text message to someone who has not messaged you in the last 24 hours. Use a template message instead. Template messages work anytime and are the standard approach for notifications.

Wrong phone number format

The API expects the full international number without a plus sign, spaces, or dashes. 491234567890 is correct. +49 123 456 7890, 01234567890, or 0049-123-4567890 will fail. Strip all formatting before sending:

Dim cleanPhone = phone.Replace("+", "").Replace(" ", "").Replace("-", "")

Hardcoding the access token

Temporary tokens expire after 24 hours. If you hardcode one and forget to update it, your app silently stops sending. Use a permanent System User token for production and store it in environment variables or a secure config file, never in source code.

FAQ

Wrapping up

Sending WhatsApp messages from VB.NET comes down to a single HttpClient.PostAsync call to Meta’s Cloud API. Use template messages for notifications, store your token securely, and clean phone numbers before sending. For simpler integration at higher cost, Twilio wraps the same functionality in a NuGet package. For logging API responses to a file, see the VB.NET write text file guide.

Der Beitrag VB.NET Send WhatsApp Message via Cloud API (2026) erschien zuerst auf Robert Skibbe.

MsgBox vs. MessageBox.Show

VB.NET offers two ways to display a message box. Both open the same Windows dialog, but they differ in origin and API style:

' VB.NET-style (from Microsoft.VisualBasic namespace)
MsgBox("File saved.", MsgBoxStyle.Information, "Success")

' .NET Framework-style (from System.Windows.Forms)
MessageBox.Show("File saved.", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information)

MsgBox is a VB.NET convenience wrapper around the Win32 MessageBox API. MessageBox.Show is the .NET Framework class that works across all .NET languages. Both produce the exact same dialog window. If your project is purely VB.NET, either works fine. If you share code with C# developers or follow .NET conventions, MessageBox.Show is the better choice.

MsgBox syntax

Dim result As MsgBoxResult = MsgBox(
    Prompt,          ' The message text (required)
    Buttons Or Icon, ' MsgBoxStyle flags (optional)
    Title            ' Window title (optional)
)

The first parameter is the message. The second combines button and icon styles with Or. The third sets the window title. Only the first parameter is required.

Simple message

The simplest MsgBox with just a message and the default OK button:

MsgBox("The file has been saved.")

With a title and information icon:

MsgBox("The file has been saved.", MsgBoxStyle.Information, "Success")

Yes/No confirmation

Ask the user a yes/no question and react to their choice:

Dim result = MsgBox(
    "Do you want to delete this record?",
    MsgBoxStyle.YesNo Or MsgBoxStyle.Question,
    "Confirm deletion")

If result = MsgBoxResult.Yes Then
    DeleteRecord()
End If

Combine button style and icon style with Or. The return value tells you which button was clicked.

Yes/No/Cancel

For unsaved changes, offer three options:

Dim result = MsgBox(
    "You have unsaved changes. Save before closing?",
    MsgBoxStyle.YesNoCancel Or MsgBoxStyle.Exclamation,
    "Unsaved changes")

Select Case result
    Case MsgBoxResult.Yes
        SaveDocument()
        Me.Close()
    Case MsgBoxResult.No
        Me.Close()
    Case MsgBoxResult.Cancel
        ' Do nothing, stay on the form
End Select

All button styles

All icon styles

Setting the default button

By default, the first button is focused. You can change this to prevent accidental clicks on a destructive action:

' Focus "No" by default so the user doesn't accidentally delete
Dim result = MsgBox(
    "Delete all records permanently?",
    MsgBoxStyle.YesNo Or MsgBoxStyle.Critical Or MsgBoxStyle.DefaultButton2,
    "Warning")

If result = MsgBoxResult.Yes Then
    DeleteAllRecords()
End If

DefaultButton2 focuses the second button (No). Use DefaultButton3 for the third button in three-button dialogs.

The same examples with MessageBox.Show

Here are the same patterns using the .NET MessageBox.Show equivalent, so you can compare:

' Simple message
MessageBox.Show("The file has been saved.", "Success",
    MessageBoxButtons.OK, MessageBoxIcon.Information)

' Yes/No confirmation
Dim result As DialogResult = MessageBox.Show(
    "Do you want to delete this record?", "Confirm deletion",
    MessageBoxButtons.YesNo, MessageBoxIcon.Question)

If result = DialogResult.Yes Then
    DeleteRecord()
End If

' Yes/No/Cancel with default button
Dim result2 As DialogResult = MessageBox.Show(
    "Save before closing?", "Unsaved changes",
    MessageBoxButtons.YesNoCancel, MessageBoxIcon.Warning,
    MessageBoxDefaultButton.Button2)

Select Case result2
    Case DialogResult.Yes
        SaveDocument()
        Me.Close()
    Case DialogResult.No
        Me.Close()
    Case DialogResult.Cancel
        ' Stay on the form
End Select

The functionality is identical. MessageBox.Show uses separate enums (MessageBoxButtons, MessageBoxIcon, MessageBoxDefaultButton) instead of combining flags with Or. The return type is DialogResult instead of MsgBoxResult.

When to use which

Use MsgBox when:

• Your project is VB.NET only and you prefer shorter syntax
• You are prototyping quickly and want minimal code

Use MessageBox.Show when:

• Your codebase is shared with C# developers
• You want to follow .NET conventions
• You need the owner window parameter (to keep the dialog on top of a specific form)
• You want your code to be portable to .NET 5+ / .NET 8+ projects

Complete example: save-before-close pattern

A realistic example that asks to save before closing a form. This pattern works in any text editor, data entry form, or settings window:

Private _hasChanges As Boolean = False

Private Sub TextBox1_TextChanged(sender As Object, e As EventArgs) Handles TextBox1.TextChanged
    _hasChanges = True
End Sub

Private Sub Form1_FormClosing(sender As Object, e As FormClosingEventArgs) Handles Me.FormClosing
    If Not _hasChanges Then Return

    Dim result = MsgBox(
        "You have unsaved changes. Save now?",
        MsgBoxStyle.YesNoCancel Or MsgBoxStyle.Exclamation Or MsgBoxStyle.DefaultButton1,
        "Unsaved changes")

    Select Case result
        Case MsgBoxResult.Yes
            SaveToFile()
        Case MsgBoxResult.Cancel
            e.Cancel = True  ' Prevent closing
    End Select
End Sub

Private Sub SaveToFile()
    File.WriteAllText("data.txt", TextBox1.Text, Encoding.UTF8)
    _hasChanges = False
End Sub

Setting e.Cancel = True in the FormClosing event prevents the form from closing. The user stays on the form and can continue editing. For more on writing files, see the VB.NET Write Text File guide.

Common mistakes

Ignoring the return value

' BAD - asks Yes/No but ignores the answer
MsgBox("Delete?", MsgBoxStyle.YesNo)
DeleteRecord()

' GOOD - check which button was clicked
If MsgBox("Delete?", MsgBoxStyle.YesNo) = MsgBoxResult.Yes Then
    DeleteRecord()
End If

Confusing MsgBox with VBScript MsgBox

The VB.NET MsgBox function lives in Microsoft.VisualBasic.Interaction and returns MsgBoxResult. The VBScript MsgBox returns integer values (1 for OK, 6 for Yes, etc.). They look similar but live in completely different environments. In VB.NET, always compare against the MsgBoxResult enum, never against magic numbers.

Using MsgBox in a background thread

Both MsgBox and MessageBox.Show must be called from the UI thread. If you call them from a background thread or Task, the dialog may appear behind other windows or cause cross-thread exceptions. Use Me.Invoke() to marshal the call to the UI thread if needed.

FAQ

Wrapping up

The MsgBox function gives you quick message dialogs with one line of code. Combine button styles and icon styles with Or, always check the return value for Yes/No prompts, and use DefaultButton2 before destructive actions. If you prefer .NET-standard code, use MessageBox.Show with separate enums for the same result. For handling button events dynamically, see the VB.NET AddHandler guide. For writing files after a save prompt, check the VB.NET Write Text File guide.

Der Beitrag VB.NET MsgBox and MessageBox.Show – Complete Guide (2026) erschien zuerst auf Robert Skibbe.

Handles vs. AddHandler

In WinForms there are two ways to connect an event to a method:

' Way 1: Handles clause (static, at design time)
Private Sub BtnSave_Click(sender As Object, e As EventArgs) Handles BtnSave.Click
    ' Automatically wired by the designer
End Sub

' Way 2: AddHandler (dynamic, at runtime)
AddHandler BtnSave.Click, AddressOf BtnSave_Click

Private Sub BtnSave_Click(sender As Object, e As EventArgs)
    ' No "Handles" needed
End Sub

The Handles clause only works with controls that exist at design time. AddHandler works anywhere, including controls you create through code. As soon as you generate controls dynamically, AddHandler is the only option.

AddHandler syntax

AddHandler Object.Event, AddressOf MethodName

• Object.Event is the event you want to subscribe to (e.g. Button1.Click)
• AddressOf returns a reference to the method that should be called
• The method signature must match the event (e.g. sender As Object, e As EventArgs)

Basic example

A button click using AddHandler instead of Handles:

Public Class Form1
    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        AddHandler BtnGreet.Click, AddressOf BtnGreet_Click
    End Sub

    Private Sub BtnGreet_Click(sender As Object, e As EventArgs)
        MessageBox.Show("Hello!")
    End Sub
End Class

Notice that BtnGreet_Click has no Handles clause at the end. The connection is made entirely through AddHandler in the Load event.

Creating dynamic controls

The most common use case for AddHandler: controls are created through code and need event handlers. Here is an example with dynamically created buttons:

Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    Dim categories = New List(Of String) From {
        "Personal", "Business", "Archive"
    }

    For Each category In categories
        Dim btn As New Button()
        btn.Text = category
        btn.Size = New Size(120, 40)
        btn.Margin = New Padding(5)
        AddHandler btn.Click, AddressOf CategoryButton_Click
        FlowLayoutPanel1.Controls.Add(btn)
    Next
End Sub

Private Sub CategoryButton_Click(sender As Object, e As EventArgs)
    Dim btn = DirectCast(sender, Button)
    MessageBox.Show($"Category: {btn.Text}")
End Sub

Every button gets the same click handler. Use DirectCast(sender, Button) to determine which button was clicked. This scales to any number of controls without needing a separate handler for each one.

Complete example: numpad keyboard

A realistic example that creates a virtual numpad keyboard at runtime. Each key button is connected to a shared handler via AddHandler:

Public Class Form1
    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        Dim keys = New List(Of String) From {
            "7", "8", "9",
            "4", "5", "6",
            "1", "2", "3",
            "0", "00", ","
        }

        For Each key In keys
            Dim btn As New Button()
            btn.Text = key
            btn.Size = New Size(50, 50)
            btn.FlatStyle = FlatStyle.Flat
            btn.FlatAppearance.BorderSize = 1
            btn.BackColor = Color.White
            btn.Font = New Font("Segoe UI", 12, FontStyle.Bold)
            AddHandler btn.Click, AddressOf NumpadButton_Click
            FlowLayoutPanel1.Controls.Add(btn)
        Next
    End Sub

    Private Sub NumpadButton_Click(sender As Object, e As EventArgs)
        Dim btn = DirectCast(sender, Button)
        TextBox1.Text &= btn.Text
    End Sub
End Class

You only need a FlowLayoutPanel (about 180 x 260 pixels) and a TextBox on the form. The buttons are created entirely through code, no designer work needed.

RemoveHandler: disconnecting events

Use RemoveHandler to disconnect the event binding. This is important to avoid memory leaks when removing controls at runtime:

' Assign handler
AddHandler btn.Click, AddressOf Button_Click

' Remove handler
RemoveHandler btn.Click, AddressOf Button_Click

Use RemoveHandler whenever you:

• Remove dynamic controls (e.g. when closing a tab)
• Want to swap a handler (remove first, then add)
• Want to prevent an event from firing multiple times

Multiple events, one handler

A single handler can process multiple events. This is especially useful for forms with many similar controls:

Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    AddHandler TxtName.TextChanged, AddressOf ValidateField
    AddHandler TxtEmail.TextChanged, AddressOf ValidateField
    AddHandler TxtPhone.TextChanged, AddressOf ValidateField
End Sub

Private Sub ValidateField(sender As Object, e As EventArgs)
    Dim txt = DirectCast(sender, TextBox)
    If String.IsNullOrWhiteSpace(txt.Text) Then
        txt.BackColor = Color.MistyRose
    Else
        txt.BackColor = Color.White
    End If
End Sub

All three text boxes share the ValidateField handler. The sender parameter identifies which text box changed.

Custom events with AddHandler

You can also define your own events and subscribe to them with AddHandler. This is useful for loosely coupled communication between classes:

Public Class FileWatcher
    Public Event FileChanged(filePath As String)

    Public Sub CheckForChanges()
        ' Check logic...
        RaiseEvent FileChanged("C:\data\config.xml")
    End Sub
End Class

' In the form:
Private WithEvents watcher As New FileWatcher()

Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    AddHandler watcher.FileChanged, AddressOf OnFileChanged
End Sub

Private Sub OnFileChanged(filePath As String)
    MessageBox.Show($"File changed: {filePath}")
End Sub

The class uses RaiseEvent to trigger the event. The subscriber reacts through AddHandler. This keeps the FileWatcher class independent from the form.

Common mistakes

Handler registered multiple times

' BAD - each click adds another handler
Private Sub BtnRefresh_Click(sender As Object, e As EventArgs) Handles BtnRefresh.Click
    AddHandler Timer1.Tick, AddressOf Timer1_Tick
End Sub

' GOOD - register handler once in Load
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    AddHandler Timer1.Tick, AddressOf Timer1_Tick
End Sub

Calling AddHandler multiple times for the same event and method causes the method to execute multiple times. Register handlers in Load or call RemoveHandler first. For more on timers, see the VB.NET Timer guide.

Wrong method signature

' BAD - parameters don't match the event
Private Sub Button_Click(text As String)
End Sub

' GOOD - signature matches the Click event
Private Sub Button_Click(sender As Object, e As EventArgs)
End Sub

The method must have exactly the parameter types the event expects. For Click, that is (sender As Object, e As EventArgs). The compiler will report an error if the signature does not match.

Forgetting RemoveHandler for dynamic controls

If you remove controls with Controls.Remove() but don’t disconnect the handler, the reference keeps the object in memory. Always call RemoveHandler before removing a dynamic control.

FAQ

Wrapping up

The AddHandler statement makes event handling in VB.NET flexible. Use it for dynamically created controls, when you need to assign or swap handlers at runtime, and for custom events in your classes. Remember to call RemoveHandler when removing controls, and register handlers only once to avoid multiple executions. For related topics, check out the VB.NET Timer guide and the VB.NET List guide.

Der Beitrag VB.NET AddHandler – Wire Events at Runtime (2026) erschien zuerst auf Robert Skibbe.

What is the FolderBrowserDialog?

The FolderBrowserDialog is a WinForms control from System.Windows.Forms. When you call ShowDialog(), it opens the Windows folder picker. The user navigates the folder tree, selects a folder, and clicks OK. Your code then reads the full folder path from the SelectedPath property.

Use it when:

• The user should choose an output folder for exports, backups, or reports
• Your application needs to batch-process all files inside a directory
• The user should pick an installation or working directory
• You want to let the user create a new folder on the fly

If the user should pick a single file instead, use the OpenFileDialog. To save a file to a specific location, use the SaveFileDialog.

Basic example

The simplest FolderBrowserDialog that displays the selected path:

Using dlg As New FolderBrowserDialog()
    dlg.Description = "Select a folder"

    If dlg.ShowDialog() = DialogResult.OK Then
        MessageBox.Show($"Selected: {dlg.SelectedPath}")
    End If
End Using

The Using block disposes the dialog after use. ShowDialog() returns DialogResult.OK when the user confirms, or DialogResult.Cancel when they close the dialog. Always check the result before using the path.

Setting the root folder

The RootFolder property restricts which top-level node the dialog shows. It accepts values from Environment.SpecialFolder:

Using dlg As New FolderBrowserDialog()
    ' Only show folders inside Desktop
    dlg.RootFolder = Environment.SpecialFolder.Desktop
    dlg.Description = "Select a project folder"

    If dlg.ShowDialog() = DialogResult.OK Then
        Dim folder As String = dlg.SelectedPath
    End If
End Using

Common values for RootFolder:

• Environment.SpecialFolder.Desktop (default) shows the full tree starting from Desktop
• Environment.SpecialFolder.MyComputer shows all drives
• Environment.SpecialFolder.MyDocuments limits browsing to the Documents folder

Pre-selecting a folder

Use SelectedPath to pre-select a folder when the dialog opens. This is useful when the user already chose a folder earlier and you want to remember it:

Using dlg As New FolderBrowserDialog()
    dlg.Description = "Select export folder"
    dlg.SelectedPath = "C:\Users\Public\Documents"

    If dlg.ShowDialog() = DialogResult.OK Then
        Dim exportFolder As String = dlg.SelectedPath
    End If
End Using

The dialog opens with that folder already highlighted. If the path does not exist, the dialog falls back to the root.

Hiding the New Folder button

By default, the dialog includes a „Make New Folder“ button. If the user should only pick an existing folder, disable it:

Using dlg As New FolderBrowserDialog()
    dlg.Description = "Select an existing folder"
    dlg.ShowNewFolderButton = False

    If dlg.ShowDialog() = DialogResult.OK Then
        Dim folder As String = dlg.SelectedPath
    End If
End Using

Set ShowNewFolderButton = False for read-only operations like importing files. Keep it True (the default) when the user might need to create a destination folder for exports.

Complete example: batch-processing files

A realistic example that lets the user pick a folder and then processes all text files inside it:

Imports System.IO
Imports System.Text

Private Sub BtnImport_Click(sender As Object, e As EventArgs) Handles BtnImport.Click
    Using dlg As New FolderBrowserDialog()
        dlg.Description = "Select folder with text files"
        dlg.ShowNewFolderButton = False

        If dlg.ShowDialog() = DialogResult.OK Then
            Dim files() As String = Directory.GetFiles(
                dlg.SelectedPath, "*.txt")

            For Each filePath In files
                Dim content As String = File.ReadAllText(
                    filePath, Encoding.UTF8)
                ' Process each file...
            Next

            MessageBox.Show($"{files.Length} files processed.")
        End If
    End Using
End Sub

Directory.GetFiles() returns all matching files in the selected folder. Use the second parameter for pattern matching, e.g. "*.csv" or "*.xml". For more on reading text files, see the VB.NET Read Text File guide.

Including subfolders

To process files recursively, add SearchOption.AllDirectories:

If dlg.ShowDialog() = DialogResult.OK Then
    Dim files() As String = Directory.GetFiles(
        dlg.SelectedPath, "*.txt", SearchOption.AllDirectories)

    For Each filePath In files
        Dim relativePath As String = filePath.Replace(
            dlg.SelectedPath & "\", "")
        ' Process file with relative path info...
    Next
End If

This searches the selected folder and all its subfolders. Be careful with large directory trees, as this can take a while if there are thousands of files.

Using Environment.SpecialFolder

You can combine the dialog with Environment.GetFolderPath() to pre-select common system folders. You can also use the application path as the starting point:

' Start in Documents
Using dlg As New FolderBrowserDialog()
    dlg.SelectedPath = Environment.GetFolderPath(
        Environment.SpecialFolder.MyDocuments)

    If dlg.ShowDialog() = DialogResult.OK Then
        ' Use dlg.SelectedPath...
    End If
End Using

' Start in the application directory
Using dlg As New FolderBrowserDialog()
    dlg.SelectedPath = Application.StartupPath

    If dlg.ShowDialog() = DialogResult.OK Then
        ' Use dlg.SelectedPath...
    End If
End Using

All important properties at a glance

The FolderBrowserDialog has fewer properties than the OpenFileDialog because it only deals with folders, not files. There is no Filter or Multiselect property.

Common mistakes

Using the path without checking DialogResult

' BAD - SelectedPath is empty if user cancels
dlg.ShowDialog()
Dim files = Directory.GetFiles(dlg.SelectedPath)

' GOOD - check the result first
If dlg.ShowDialog() = DialogResult.OK Then
    Dim files = Directory.GetFiles(dlg.SelectedPath)
End If

Confusing RootFolder and SelectedPath

RootFolder limits which folders the user can see. SelectedPath pre-selects a folder within the visible tree. If you set RootFolder = MyDocuments, the user cannot navigate outside of Documents. If you only want to suggest a starting point but allow full navigation, use SelectedPath instead.

Forgetting the Using block

Like all WinForms dialogs, the FolderBrowserDialog holds unmanaged resources. Without Using, those resources stay in memory until the garbage collector runs. Always wrap it in a Using block.

FAQ

Wrapping up

The FolderBrowserDialog gives your VB.NET application a native folder picker with minimal code. Set SelectedPath to suggest a starting folder, use RootFolder to restrict navigation, and hide the New Folder button with ShowNewFolderButton = False when the user should only select existing folders. After the dialog closes, combine SelectedPath with Directory.GetFiles() to process folder contents. For picking individual files, use the OpenFileDialog. To save files, see the SaveFileDialog.

Der Beitrag VB.NET FolderBrowserDialog – Pick Folders Easily (2026) erschien zuerst auf Robert Skibbe.

What is the OpenFileDialog?

The OpenFileDialog is a WinForms control from System.Windows.Forms. When you call ShowDialog(), it opens the standard Windows „Open“ dialog. The user navigates to a folder, picks a file, and clicks Open. Your code then receives the full file path through the FileName property.

Use it when:

• The user should choose which file to open (imports, config files, images)
• You need a file type filter (e.g. only .txt, .csv, or .png)
• You want built-in validation that the selected file actually exists
• You need to let the user select multiple files at once

If you need the user to pick a save destination instead, use the SaveFileDialog.

Basic example

The simplest OpenFileDialog that reads a text file:

Using dlg As New OpenFileDialog()
    dlg.Filter = "Text files (*.txt)|*.txt"
    dlg.Title = "Open text file"

    If dlg.ShowDialog() = DialogResult.OK Then
        Dim content As String = File.ReadAllText(dlg.FileName)
        TextBox1.Text = content
    End If
End Using

The Using block disposes the dialog after use. ShowDialog() returns DialogResult.OK when the user clicks Open, or DialogResult.Cancel when they close the dialog. Always check the result before reading.

Setting up file type filters

The Filter property controls which file types appear in the dropdown. The syntax is identical to the SaveFileDialog:

' Single filter
dlg.Filter = "Text files (*.txt)|*.txt"

' Multiple filters
dlg.Filter = "Text files (*.txt)|*.txt|CSV files (*.csv)|*.csv|All files (*.*)|*.*"

' Pre-select the second filter (1-based index)
dlg.FilterIndex = 2

' Allow multiple extensions in one filter
dlg.Filter = "Images (*.png;*.jpg;*.gif)|*.png;*.jpg;*.gif"

To combine multiple extensions in a single filter entry, separate them with semicolons inside the pattern part: *.png;*.jpg;*.gif. The user sees one „Images“ dropdown entry that matches all three types.

Setting the default folder

Using dlg As New OpenFileDialog()
    ' Start in the user's Documents folder
    dlg.InitialDirectory = Environment.GetFolderPath(
        Environment.SpecialFolder.MyDocuments)

    dlg.Filter = "CSV files (*.csv)|*.csv"

    If dlg.ShowDialog() = DialogResult.OK Then
        Dim content As String = File.ReadAllText(dlg.FileName)
    End If
End Using

Common choices for InitialDirectory:

• Environment.SpecialFolder.MyDocuments for user documents
• Environment.SpecialFolder.Desktop for the desktop
• The application path for files next to the executable

If you don’t set InitialDirectory, the dialog remembers the last folder the user navigated to during the current session.

Selecting multiple files

Set Multiselect = True to let the user select more than one file. The selected paths are available through FileNames (plural):

Using dlg As New OpenFileDialog()
    dlg.Filter = "Images (*.png;*.jpg)|*.png;*.jpg"
    dlg.Multiselect = True
    dlg.Title = "Select images to import"

    If dlg.ShowDialog() = DialogResult.OK Then
        For Each filePath In dlg.FileNames
            Dim img As Image = Image.FromFile(filePath)
            ' Process each image...
        Next

        MessageBox.Show($"{dlg.FileNames.Length} files selected.")
    End If
End Using

The user holds Ctrl to pick individual files, or Shift to select a range. FileName (singular) still returns the first selected file; FileNames returns all of them as a String() array.

Complete example: reading a text file

A realistic example that reads a text file with encoding support, using ReadAllText:

Imports System.IO
Imports System.Text

Private Sub BtnOpen_Click(sender As Object, e As EventArgs) Handles BtnOpen.Click
    Using dlg As New OpenFileDialog()
        dlg.Title = "Open report"
        dlg.Filter = "Text files (*.txt)|*.txt|CSV files (*.csv)|*.csv|All files (*.*)|*.*"
        dlg.InitialDirectory = Environment.GetFolderPath(
            Environment.SpecialFolder.MyDocuments)

        If dlg.ShowDialog() = DialogResult.OK Then
            Dim content As String = File.ReadAllText(dlg.FileName, Encoding.UTF8)
            TextBox1.Text = content
            Me.Text = $"Editor - {Path.GetFileName(dlg.FileName)}"
        End If
    End Using
End Sub

Specify Encoding.UTF8 when reading text files to correctly handle special characters. Path.GetFileName() extracts just the file name from the full path, which is useful for setting the window title.

Reading binary files (images, PDFs)

OpenFileDialog works the same way for binary content. Only the read method changes:

' Load an image into a PictureBox
Using dlg As New OpenFileDialog()
    dlg.Filter = "Images (*.png;*.jpg;*.bmp)|*.png;*.jpg;*.bmp"

    If dlg.ShowDialog() = DialogResult.OK Then
        PictureBox1.Image = Image.FromFile(dlg.FileName)
    End If
End Using

' Read a file as byte array
Using dlg As New OpenFileDialog()
    dlg.Filter = "All files (*.*)|*.*"

    If dlg.ShowDialog() = DialogResult.OK Then
        Dim bytes() As Byte = File.ReadAllBytes(dlg.FileName)
        ' Process bytes...
    End If
End Using

Reading large files with StreamReader

For large files or line-by-line processing, use a StreamReader with the path from the dialog:

Using dlg As New OpenFileDialog()
    dlg.Filter = "CSV files (*.csv)|*.csv"

    If dlg.ShowDialog() = DialogResult.OK Then
        Using reader As New StreamReader(dlg.FileName, Encoding.UTF8)
            Dim lineNumber As Integer = 0
            While Not reader.EndOfStream
                Dim line As String = reader.ReadLine()
                lineNumber += 1
                ' Process each line...
            End While
        End Using
    End If
End Using

The StreamReader approach is more memory-efficient for large files because it reads line by line instead of loading the entire file into memory. For more on reading text files, see the VB.NET Read Text File guide.

All important properties at a glance

Common mistakes

Reading without checking DialogResult

' BAD - FileName is empty if user cancels
dlg.ShowDialog()
Dim content = File.ReadAllText(dlg.FileName)

' GOOD - check the result first
If dlg.ShowDialog() = DialogResult.OK Then
    Dim content = File.ReadAllText(dlg.FileName)
End If

Using FileName instead of FileNames with Multiselect

' BAD - only gets the first file when Multiselect is True
dlg.Multiselect = True
If dlg.ShowDialog() = DialogResult.OK Then
    Dim content = File.ReadAllText(dlg.FileName)  ' only first file!
End If

' GOOD - iterate all selected files
If dlg.ShowDialog() = DialogResult.OK Then
    For Each path In dlg.FileNames
        Dim content = File.ReadAllText(path)
    Next
End If

Forgetting the Using block

The OpenFileDialog holds unmanaged resources (a Windows COM object). Without Using, those resources stay in memory until the garbage collector runs. Always wrap it in a Using block.

FAQ

Wrapping up

The OpenFileDialog gives your VB.NET application a native file-open experience with minimal code. Set a Filter for file types, enable Multiselect for batch operations, and always check DialogResult.OK before reading. For the actual file reading, use File.ReadAllText() for text or File.ReadAllBytes() for binary data. Need to save files instead? The SaveFileDialog follows the same pattern. For more on reading text files, see the VB.NET Read Text File guide.

Der Beitrag VB.NET OpenFileDialog – Open Files with Dialog (2026) erschien zuerst auf Robert Skibbe.

What is the SaveFileDialog?

The SaveFileDialog is a WinForms control from System.Windows.Forms. When you call ShowDialog(), it opens the standard Windows „Save As“ dialog. The user picks a folder, enters a file name, and clicks Save. Your code then receives the full file path through the FileName property.

Use it when:

• The user should choose where to save a file (exports, reports, downloads)
• You need a file type filter (e.g. only .txt, .csv, or .pdf)
• You want built-in overwrite confirmation without writing your own

Basic example

The simplest SaveFileDialog with a single file type:

Using dlg As New SaveFileDialog()
    dlg.Filter = "Text files (*.txt)|*.txt"
    dlg.Title = "Save text file"

    If dlg.ShowDialog() = DialogResult.OK Then
        File.WriteAllText(dlg.FileName, "Hello World")
    End If
End Using

The Using block disposes the dialog after use. ShowDialog() returns DialogResult.OK when the user clicks Save, or DialogResult.Cancel when they close the dialog. Always check the result before writing.

Setting up file type filters

The Filter property controls which file types appear in the dropdown. The syntax is Description|Pattern, separated by pipes for multiple types:

' Single filter
dlg.Filter = "Text files (*.txt)|*.txt"

' Multiple filters
dlg.Filter = "Text files (*.txt)|*.txt|CSV files (*.csv)|*.csv|All files (*.*)|*.*"

' Pre-select the second filter (1-based index)
dlg.FilterIndex = 2

Each filter entry consists of two parts: the display text (e.g. „Text files (*.txt)“) and the actual pattern (e.g. „*.txt“). FilterIndex is 1-based, so 2 selects the second entry.

Automatically adding the file extension

' Append extension if user doesn't type one (default: True)
dlg.AddExtension = True

' Set default extension (without the dot)
dlg.DefaultExt = "txt"

With AddExtension = True (the default), if the user types „report“ without an extension, the dialog appends „.txt“ based on the selected filter or the DefaultExt value.

Setting the default folder and file name

Using dlg As New SaveFileDialog()
    ' Start in the user's Documents folder
    dlg.InitialDirectory = Environment.GetFolderPath(
        Environment.SpecialFolder.MyDocuments)

    ' Pre-fill the file name
    dlg.FileName = "report-2026.csv"

    dlg.Filter = "CSV files (*.csv)|*.csv"

    If dlg.ShowDialog() = DialogResult.OK Then
        File.WriteAllText(dlg.FileName, csvContent)
    End If
End Using

InitialDirectory sets where the dialog opens. Common choices:

• Environment.SpecialFolder.MyDocuments for user documents
• Environment.SpecialFolder.Desktop for the desktop
• The application path for saving next to the executable

If you don’t set InitialDirectory, the dialog remembers the last folder the user navigated to during the current session.

Overwrite confirmation

' Show a warning when the file already exists (default: True)
dlg.OverwritePrompt = True

This is enabled by default. When the user selects an existing file, Windows shows a confirmation dialog asking if they want to replace it. You don’t need to code this yourself.

Complete example: saving a text file

A realistic example that saves a multi-line text file with encoding support, using WriteAllText:

Imports System.IO
Imports System.Text

Private Sub BtnSave_Click(sender As Object, e As EventArgs) Handles BtnSave.Click
    Using dlg As New SaveFileDialog()
        dlg.Title = "Save report"
        dlg.Filter = "Text files (*.txt)|*.txt|CSV files (*.csv)|*.csv"
        dlg.InitialDirectory = Environment.GetFolderPath(
            Environment.SpecialFolder.MyDocuments)
        dlg.FileName = $"report-{DateTime.Now:yyyy-MM-dd}"

        If dlg.ShowDialog() = DialogResult.OK Then
            Dim content As String = BuildReport()
            File.WriteAllText(dlg.FileName, content, Encoding.UTF8)
            MessageBox.Show($"Saved to {dlg.FileName}",
                "Success", MessageBoxButtons.OK, MessageBoxIcon.Information)
        End If
    End Using
End Sub

Always specify Encoding.UTF8 when writing text files. Without it, .NET uses the system default encoding, which can cause issues with special characters on other machines.

Saving binary files (images, PDFs)

SaveFileDialog works the same way for binary content. The only difference is the write method:

' Save an image
Using dlg As New SaveFileDialog()
    dlg.Filter = "PNG images (*.png)|*.png|JPEG images (*.jpg)|*.jpg"
    dlg.FileName = "screenshot"

    If dlg.ShowDialog() = DialogResult.OK Then
        PictureBox1.Image.Save(dlg.FileName)
    End If
End Using

' Save a byte array (e.g. downloaded PDF)
Using dlg As New SaveFileDialog()
    dlg.Filter = "PDF files (*.pdf)|*.pdf"

    If dlg.ShowDialog() = DialogResult.OK Then
        File.WriteAllBytes(dlg.FileName, pdfBytes)
    End If
End Using

Saving with a StreamWriter (large files)

For large files or line-by-line writing, use a StreamWriter with the path from the dialog:

Using dlg As New SaveFileDialog()
    dlg.Filter = "CSV files (*.csv)|*.csv"

    If dlg.ShowDialog() = DialogResult.OK Then
        Using writer As New StreamWriter(dlg.FileName, False, Encoding.UTF8)
            writer.WriteLine("Name,Email,Age")
            For Each contact In contacts
                writer.WriteLine($"{contact.Name},{contact.Email},{contact.Age}")
            Next
        End Using
    End If
End Using

The StreamWriter approach is more memory-efficient for large datasets because it writes line by line instead of building the entire string in memory first. For a deeper look at text file operations, see the VB.NET Write Text File guide.

All important properties at a glance

Common mistakes

Writing without checking DialogResult

' BAD - writes to empty path if user cancels
dlg.ShowDialog()
File.WriteAllText(dlg.FileName, content)

' GOOD - check the result first
If dlg.ShowDialog() = DialogResult.OK Then
    File.WriteAllText(dlg.FileName, content)
End If

Forgetting the Using block

The SaveFileDialog holds unmanaged resources (a Windows COM object). Without Using, those resources stay in memory until the garbage collector runs. Always wrap it in a Using block.

Broken filter syntax

' BAD - missing pattern after pipe
dlg.Filter = "Text files|"

' BAD - using comma instead of pipe
dlg.Filter = "Text files (*.txt), *.txt"

' GOOD - correct description|pattern syntax
dlg.Filter = "Text files (*.txt)|*.txt"

A broken Filter string throws an ArgumentException at runtime. The pattern is always Display text|*.extension, with a pipe separating each pair.

FAQ

Wrapping up

The SaveFileDialog gives your VB.NET application a native file-save experience with minimal code. Set a Filter for file types, use InitialDirectory for the starting folder, and always check DialogResult.OK before writing. For the actual file writing, use File.WriteAllText() for text or File.WriteAllBytes() for binary data. Need to read files instead? The OpenFileDialog follows the same pattern in reverse. For more on writing text files, see the VB.NET Write Text File guide.

Der Beitrag VB.NET SaveFileDialog – Save Files with Dialog (2026) erschien zuerst auf Robert Skibbe.

What is a DataTable and when to use it

A DataTable lives in the System.Data namespace and represents a single table of in-memory data. Think of it as a spreadsheet: it has columns with names and types, and rows that hold the actual values.

Use a DataTable when:

• You need to bind tabular data to a DataGridView or other WinForms controls
• You work with ADO.NET and want to fill a table from a database query
• You need built-in filtering and sorting without writing your own logic
• You process CSV or Excel imports where rows and columns map naturally

If you only need an ordered list of objects, a VB.NET List(Of T) is simpler and more type-safe. If you need key-value lookups, use a Dictionary. DataTable shines when you need a flexible, schema-based structure with filtering, sorting, and UI binding built in.

Creating a DataTable with columns

Every DataTable starts with a schema: the columns that define what data each row can hold.

Dim table As New DataTable("Contacts")

' Add columns with name and type
table.Columns.Add("Id", GetType(Integer))
table.Columns.Add("Name", GetType(String))
table.Columns.Add("Email", GetType(String))
table.Columns.Add("Age", GetType(Integer))

' Set a primary key
table.PrimaryKey = {table.Columns("Id")}

Every column has a DataType (Integer, String, DateTime, Decimal, Boolean, etc.) and an optional ColumnName. The primary key enables fast lookups with Rows.Find() and prevents duplicate entries.

Column properties

' Auto-increment column
Dim idCol = table.Columns("Id")
idCol.AutoIncrement = True
idCol.AutoIncrementSeed = 1
idCol.AutoIncrementStep = 1

' Default value
table.Columns("Age").DefaultValue = 0

' Disallow nulls
table.Columns("Name").AllowDBNull = False

Adding rows

' Method 1: NewRow + field assignment
Dim row As DataRow = table.NewRow()
row("Name") = "Alice"
row("Email") = "alice@example.com"
row("Age") = 30
table.Rows.Add(row)

' Method 2: Add values directly (column order)
table.Rows.Add(Nothing, "Bob", "bob@example.com", 25)

' Method 3: Add from an Object array
Dim values() As Object = {Nothing, "Clara", "clara@example.com", 35}
table.Rows.Add(values)

When using AutoIncrement on the Id column, pass Nothing for that field. The DataTable assigns the next value automatically.

Reading and accessing data

' Access a specific row by index
Dim firstRow As DataRow = table.Rows(0)
Dim name As String = CStr(firstRow("Name"))

' Iterate all rows
For Each row As DataRow In table.Rows
    Console.WriteLine($"{row("Id")}: {row("Name")} ({row("Email")})")
Next

' Find a row by primary key
Dim found As DataRow = table.Rows.Find(2)
If found IsNot Nothing Then
    Console.WriteLine($"Found: {found("Name")}")
End If

' Total row count
Dim count As Integer = table.Rows.Count

Fields return Object, so you need to cast them (CStr, CInt, CDec, etc.) or use the typed Field(Of T) extension method: row.Field(Of String)("Name"). The Field method also handles DBNull safely for nullable types.

Filtering with Select and DataView

DataTable has two ways to filter data: the Select() method for quick queries, and DataView for persistent, bindable filters.

DataTable.Select()

' Filter by condition
Dim olderThan25() As DataRow = table.Select("Age > 25")

' Filter + sort
Dim sorted() As DataRow = table.Select("Age > 25", "Name ASC")

' Multiple conditions
Dim specific() As DataRow = table.Select("Age > 20 AND Name LIKE 'A%'")

' Process results
For Each row In olderThan25
    Console.WriteLine(row("Name"))
Next

The filter expression uses a SQL-like syntax: =, <>, >, <, LIKE, AND, OR, IN, IS NULL. The sort expression takes a column name followed by ASC or DESC.

DataView for bindable filtering

A DataView wraps a DataTable and provides a filtered, sorted view that you can bind directly to UI controls:

Dim view As New DataView(table)
view.RowFilter = "Age >= 30"
view.Sort = "Name ASC"

' Bind to DataGridView
DataGridView1.DataSource = view

' Change the filter at runtime (UI updates automatically)
view.RowFilter = "Name LIKE 'B%'"

DataView is the better choice for DataGridView filter functionality because it updates the bound control automatically when you change RowFilter or Sort.

Sorting rows

DataTable itself has no Sort() method. You sort through Select() or DataView:

' Sort with Select (returns DataRow array)
Dim sortedRows() As DataRow = table.Select("", "Age DESC")

' Sort with DataView (bindable)
Dim view As New DataView(table)
view.Sort = "Name ASC, Age DESC"

' Sort with LINQ (returns new collection)
Dim linqSorted = From row In table.AsEnumerable()
                 Order By row.Field(Of String)("Name")
                 Select row

For DataGridView binding, use DataView. For processing rows in code, the Select() method or LINQ both work well.

Updating and deleting rows

' Update a field
table.Rows(0)("Email") = "alice.new@example.com"

' Update by primary key
Dim target As DataRow = table.Rows.Find(2)
If target IsNot Nothing Then
    target("Age") = 26
End If

' Delete a row (marks it for deletion)
table.Rows(0).Delete()

' Remove a row immediately
table.Rows.Remove(table.Rows(0))

' Accept all pending changes
table.AcceptChanges()

There is an important difference: Delete() marks the row with RowState = Deleted but keeps it in the table until AcceptChanges() is called. Remove() deletes the row immediately. Use Delete() when you need change tracking (e.g. syncing back to a database with a DataAdapter).

Binding a DataTable to a DataGridView

One of the most common uses of DataTable is displaying data in a DataGridView:

' Direct binding
DataGridView1.DataSource = table

' Binding via DataView (with filter + sort)
Dim view As New DataView(table)
view.RowFilter = "Age > 25"
view.Sort = "Name ASC"
DataGridView1.DataSource = view

The DataGridView auto-generates columns from the DataTable schema. Changes in the grid are written back to the DataTable automatically. If you want a read-only grid, set DataGridView1.ReadOnly = True.

Refreshing the grid after data changes

' Add a row programmatically
table.Rows.Add(Nothing, "David", "david@example.com", 28)

' Grid updates automatically when bound to the DataTable
' No manual refresh needed

' If you replace the entire DataTable, re-bind it
DataGridView1.DataSource = Nothing
DataGridView1.DataSource = newTable

Loading data from a database

DataTable works with any ADO.NET provider. Here is an example using SQLite:

Imports System.Data.SQLite

Dim table As New DataTable()

Using connection As New SQLiteConnection("Data Source=app.db")
    connection.Open()
    Using command As New SQLiteCommand("SELECT * FROM Contacts", connection)
        Using reader As SQLiteDataReader = command.ExecuteReader()
            table.Load(reader)
        End Using
    End Using
End Using

' table now contains all rows from the Contacts table
DataGridView1.DataSource = table

The Load() method reads all rows from a DataReader and creates the columns automatically based on the query result. This works with SQL Server, MySQL, PostgreSQL, or any other ADO.NET provider.

Alternative: using a DataAdapter

Dim table As New DataTable()

Using connection As New SQLiteConnection("Data Source=app.db")
    Using adapter As New SQLiteDataAdapter("SELECT * FROM Contacts", connection)
        adapter.Fill(table)
    End Using
End Using

The DataAdapter approach is shorter and also supports writing changes back to the database with adapter.Update(table). For simpler, strongly-typed database access without DataTable, consider Dapper as an alternative.

Converting between DataTable and List

Sometimes you need to switch between a DataTable and a typed List(Of T):

DataTable to List(Of T)

Public Class Contact
    Public Property Id As Integer
    Public Property Name As String
    Public Property Email As String
    Public Property Age As Integer
End Class

' Convert DataTable rows to a typed List
Dim contacts = table.AsEnumerable().Select(Function(row)
    Return New Contact With {
        .Id = row.Field(Of Integer)("Id"),
        .Name = row.Field(Of String)("Name"),
        .Email = row.Field(Of String)("Email"),
        .Age = row.Field(Of Integer)("Age")
    }
End Function).ToList()

List(Of T) to DataTable

Public Function ToDataTable(contacts As List(Of Contact)) As DataTable
    Dim table As New DataTable()
    table.Columns.Add("Id", GetType(Integer))
    table.Columns.Add("Name", GetType(String))
    table.Columns.Add("Email", GetType(String))
    table.Columns.Add("Age", GetType(Integer))

    For Each c In contacts
        table.Rows.Add(c.Id, c.Name, c.Email, c.Age)
    Next

    Return table
End Function

The LINQ approach with AsEnumerable() requires a reference to System.Data.DataSetExtensions. In modern .NET (5+), this is included by default.

Common pitfalls

Ignoring DBNull

DataTable fields can be DBNull.Value instead of Nothing. A direct cast will throw an InvalidCastException:

' BAD - throws InvalidCastException if Email is DBNull
Dim email As String = CStr(row("Email"))

' GOOD - check for DBNull first
Dim email As String = If(row.IsNull("Email"), "", CStr(row("Email")))

' BEST - use the typed Field extension
Dim email As String = row.Field(Of String)("Email")  ' returns Nothing for DBNull

Deleting rows in a For Each loop

Just like with a List, modifying a DataTable while iterating throws an exception. Use a backward For loop or collect rows first:

' BAD - modifying during iteration
For Each row As DataRow In table.Rows
    If CInt(row("Age")) < 18 Then
        row.Delete()
    End If
Next

' GOOD - iterate backwards
For i As Integer = table.Rows.Count - 1 To 0 Step -1
    If CInt(table.Rows(i)("Age")) < 18 Then
        table.Rows(i).Delete()
    End If
Next
table.AcceptChanges()

Forgetting AcceptChanges

When you call Delete() on a row, it is only marked as deleted. The row still shows up in table.Rows.Count and can cause unexpected behavior. Call AcceptChanges() after a batch of deletions, or use Remove() for immediate removal.

FAQ

Wrapping up

The DataTable is the right choice when you need schema-based, filterable tabular data with native DataGridView binding. Use Select() for quick queries, DataView for live-filtered UI binding, and Field(Of T) to avoid DBNull issues. For simpler use cases with typed objects, a List(Of T) is often the better fit. For database access without DataTable, take a look at Dapper.

Der Beitrag VB.NET DataTable – Create, Fill, Filter with Examples (2026) erschien zuerst auf Robert Skibbe.

What is a List(Of T) and when to use it

A List(Of T) is a generic collection from the System.Collections.Generic namespace. The T stands for the type of objects you want to store: List(Of String) holds strings, List(Of Integer) holds numbers, List(Of Customer) holds your own objects.

Use a List when:

• You need an ordered collection where items have a position (index)
• The number of items changes at runtime (unlike arrays, which have a fixed size)
• You want built-in methods for sorting, searching, and filtering
• You access items by position, not by a key

If you need key-value lookups instead (e.g. finding a customer by ID), use a VB.NET Dictionary. Lists search by iterating through every item, which gets slow with large datasets. Dictionaries find entries in constant time.

Creating a List

The most common ways to create a List(Of T):

' Empty list
Dim names As New List(Of String)

' List with initial values
Dim numbers As New List(Of Integer) From {3, 5, 7, 9}

' List of custom objects
Dim customers As New List(Of Customer) From {
    New Customer With {.Name = "Alice", .Email = "alice@example.com"},
    New Customer With {.Name = "Bob", .Email = "bob@example.com"}
}

The From keyword together with curly braces is a collection initializer. It calls Add() for each item behind the scenes.

Setting an initial capacity

If you know roughly how many items the list will hold, set the capacity upfront. This avoids repeated internal array resizing:

' Pre-allocate space for ~500 items
Dim largeList As New List(Of String)(500)

This doesn’t limit the list to 500 items. It just avoids unnecessary memory allocations until you exceed that number.

Adding items

Add and AddRange

Dim names As New List(Of String)

' Add single items
names.Add("Alice")
names.Add("Bob")

' Add multiple items at once
names.AddRange({"Clara", "David", "Eva"})

' Add items from another list
Dim moreNames As New List(Of String) From {"Frank", "Grace"}
names.AddRange(moreNames)

Insert at a specific position

' Insert "Zara" at position 0 (beginning)
names.Insert(0, "Zara")

' Insert at position 2
names.Insert(2, "Maria")

Be aware that Insert() shifts all subsequent items, which costs O(n). For frequent insertions at the beginning, consider a LinkedList(Of T) instead.

Accessing items

Items are accessed by their zero-based index:

Dim names As New List(Of String) From {"Alice", "Bob", "Clara"}

' Access by index
Dim first As String = names(0)    ' "Alice"
Dim last As String = names(names.Count - 1)  ' "Clara"

' Iterate with For Each
For Each name In names
    Console.WriteLine(name)
Next

' Iterate with index
For i As Integer = 0 To names.Count - 1
    Console.WriteLine($"[{i}] {names(i)}")
Next

Accessing an invalid index throws an ArgumentOutOfRangeException. Always check Count before using a specific index, or use methods like FirstOrDefault() from LINQ.

Removing items

Dim names As New List(Of String) From {"Alice", "Bob", "Clara", "David"}

' Remove by value (first occurrence)
names.Remove("Bob")   ' returns True if found

' Remove by index
names.RemoveAt(0)      ' removes "Alice"

' Remove last item
If names.Count > 0 Then
    names.RemoveAt(names.Count - 1)
End If

' Remove all items matching a condition
names.RemoveAll(Function(n) n.StartsWith("C"))

' Remove everything
names.Clear()

Remove() searches the list from the beginning and removes the first match. If the item doesn’t exist, it returns False without throwing an exception. RemoveAt() on an invalid index does throw.

Sorting a List

Simple sort

Dim names As New List(Of String) From {"Clara", "Alice", "Bob"}

' Sort alphabetically (in-place)
names.Sort()
' Result: Alice, Bob, Clara

' Reverse the order
names.Reverse()
' Result: Clara, Bob, Alice

Sort with custom comparison

For custom objects, pass a comparison lambda to Sort():

Public Class Contact
    Public Property Name As String
    Public Property Age As Integer
End Class

Dim contacts As New List(Of Contact) From {
    New Contact With {.Name = "Clara", .Age = 30},
    New Contact With {.Name = "Alice", .Age = 25},
    New Contact With {.Name = "Bob", .Age = 35}
}

' Sort by name
contacts.Sort(Function(a, b) String.Compare(a.Name, b.Name))

' Sort by age (descending)
contacts.Sort(Function(a, b) b.Age.CompareTo(a.Age))

Sorting with LINQ (non-destructive)

Sort() modifies the original list. If you want a new sorted list without changing the original, use LINQ:

' Original stays unchanged
Dim sorted = contacts.OrderBy(Function(c) c.Name).ToList()
Dim sortedDesc = contacts.OrderByDescending(Function(c) c.Age).ToList()

Searching and filtering with LINQ

LINQ is the most powerful way to query lists in VB.NET. Import System.Linq (usually imported by default) and you get a full set of query methods:

Find items

Dim contacts As New List(Of Contact) From {
    New Contact With {.Name = "Alice", .Age = 25},
    New Contact With {.Name = "Bob", .Age = 35},
    New Contact With {.Name = "Clara", .Age = 30}
}

' Find first match (returns Nothing if not found)
Dim alice = contacts.FirstOrDefault(Function(c) c.Name = "Alice")

' Check if any item matches
Dim hasOlderThan30 As Boolean = contacts.Any(Function(c) c.Age > 30)

' Check if all items match
Dim allAdults As Boolean = contacts.All(Function(c) c.Age >= 18)

Filter items

' Get all contacts older than 25
Dim olderContacts = contacts.Where(Function(c) c.Age > 25).ToList()

' Get just the names
Dim names = contacts.Select(Function(c) c.Name).ToList()

' Combine: filter + transform
Dim olderNames = contacts _
    .Where(Function(c) c.Age > 25) _
    .Select(Function(c) c.Name) _
    .ToList()

Aggregate queries

' Count, Min, Max, Average, Sum
Dim count As Integer = contacts.Count
Dim youngest As Integer = contacts.Min(Function(c) c.Age)
Dim oldest As Integer = contacts.Max(Function(c) c.Age)
Dim averageAge As Double = contacts.Average(Function(c) c.Age)

' Distinct values
Dim uniqueAges = contacts.Select(Function(c) c.Age).Distinct().ToList()

Converting lists

Lists can be converted to and from other collection types:

' List to Array
Dim namesArray As String() = names.ToArray()

' Array to List
Dim backToList As List(Of String) = namesArray.ToList()

' List to Dictionary (key must be unique)
Dim contactDict = contacts.ToDictionary(
    Function(c) c.Name,
    Function(c) c)

' String from List (join)
Dim csv As String = String.Join(", ", names)
' Result: "Alice, Bob, Clara"

The ToDictionary() conversion is especially useful when you later need fast lookups by key. Read more about that in the Dictionary guide.

List vs. Array vs. Dictionary

Choosing the right collection type matters for both readability and performance. Here’s a comparison of the most common choices:

A detailed performance comparison with real benchmarks is available in the C# List guide, which applies equally to VB.NET since both use the same .NET runtime.

Common pitfalls

Modifying a list during iteration

This is one of the most frequent beginner mistakes. Removing items inside a For Each loop throws an InvalidOperationException:

' BAD - throws InvalidOperationException!
For Each name In names
    If name.StartsWith("A") Then
        names.Remove(name)
    End If
Next

' GOOD - use RemoveAll instead
names.RemoveAll(Function(n) n.StartsWith("A"))

' ALSO GOOD - iterate backwards with For
For i As Integer = names.Count - 1 To 0 Step -1
    If names(i).StartsWith("A") Then
        names.RemoveAt(i)
    End If
Next

Using a List for lookups

If you frequently search for items by a unique property (name, ID, email), a List is the wrong choice. Every search iterates the entire list. A Dictionary finds the item instantly. This difference becomes massive with thousands of entries, as demonstrated in this benchmark comparison.

Forgetting to call ToList()

LINQ methods like Where() and Select() return lazy IEnumerable objects, not lists. Each time you iterate, the query runs again. Call .ToList() to materialize the result:

' Lazy - runs the filter twice!
Dim filtered = names.Where(Function(n) n.Length > 3)
Console.WriteLine(filtered.Count())   ' filter runs here
Console.WriteLine(filtered.Count())   ' filter runs again

' Better - materialize once
Dim filteredList = names.Where(Function(n) n.Length > 3).ToList()
Console.WriteLine(filteredList.Count)  ' just reads the count
Console.WriteLine(filteredList.Count)  ' same, no re-evaluation

FAQ

Wrapping up

The List(Of T) is the go-to collection for ordered, resizable data in VB.NET. Use Add() and RemoveAll() for basic operations, Sort() with a lambda for custom sorting, and LINQ for filtering and transforming. For key-based lookups, switch to a Dictionary. If you’re working with C# as well, the same concepts apply with slightly different syntax, as shown in the C# List guide.

Der Beitrag VB.NET List – Create, Sort, Filter with Examples (2026) erschien zuerst auf Robert Skibbe.

What is Dapper and why use it?

Dapper is a lightweight „micro ORM“ for .NET, originally built by the Stack Overflow team to solve their own performance problems. It sits on top of IDbConnection and extends it with convenience methods like Query(Of T) and Execute(). Here’s why it matters:

• No boilerplate – no more manual SqliteCommand, AddWithValue, ExecuteReader, and column-by-column mapping
• Strongly typed – query results map directly to your VB.NET classes by matching property names to column names
• Fast – Dapper is nearly as fast as raw ADO.NET, much faster than Entity Framework for simple queries
• No magic – you write real SQL, so you always know exactly what hits the database
• Works with any database – SQLite, SQL Server, PostgreSQL, MySQL, anything that has an IDbConnection

If you’ve followed the VB.NET SQLite article, you already know how to create a database and run queries with SqliteCommand. Dapper replaces that manual work while keeping full control over your SQL.

Installing Dapper via NuGet

Open the Package Manager Console in Visual Studio (Tools → NuGet Package Manager → Package Manager Console) and run:

Install-Package Dapper
Install-Package Microsoft.Data.Sqlite

You need both packages: Dapper provides the extension methods, and Microsoft.Data.Sqlite provides the database connection. If you already have Microsoft.Data.Sqlite installed from a previous project, just add Dapper.

Alternatively, right-click your project in Solution Explorer → Manage NuGet Packages → search for Dapper → Install. Then repeat for Microsoft.Data.Sqlite if you haven’t already.

Setting up the model class

Before writing any queries, define a class whose properties match the column names in your table. Dapper maps columns to properties by name, case-insensitive:

Public Class Contact
    Public Property Id As Long
    Public Property Name As String
    Public Property Email As String
    Public Property Phone As String
    Public Property CreatedAt As String
End Class

That’s all Dapper needs. No attributes, no base classes, no configuration files. If a column name doesn’t match a property name, you can use a SQL alias: SELECT first_name AS Name.

Connecting and creating tables

Dapper works on top of any IDbConnection. You still create the connection yourself. Use AppContext.BaseDirectory to build a reliable path, as explained in the Application Path article:

Imports Dapper
Imports Microsoft.Data.Sqlite

Dim dbPath As String = Path.Combine(AppContext.BaseDirectory, "myapp.db")
Dim connectionString As String = $"Data Source={dbPath}"

Using connection As New SqliteConnection(connectionString)
    connection.Open()

    connection.Execute("
        CREATE TABLE IF NOT EXISTS Contacts (
            Id INTEGER PRIMARY KEY AUTOINCREMENT,
            Name TEXT NOT NULL,
            Email TEXT,
            Phone TEXT,
            CreatedAt TEXT DEFAULT CURRENT_TIMESTAMP
        )")
End Using

Notice how connection.Execute() replaces the entire SqliteCommand / ExecuteNonQuery() pattern. Dapper opens the connection automatically if it’s closed, but I prefer opening explicitly for clarity.

Inserting data

With raw ADO.NET you’d create a command, add parameters one by one, and call ExecuteNonQuery(). With Dapper, you pass an anonymous object and it maps the properties to parameter names:

Using connection As New SqliteConnection(connectionString)
    connection.Open()

    connection.Execute(
        "INSERT INTO Contacts (Name, Email, Phone) VALUES (@Name, @Email, @Phone)",
        New With {
            .Name = "John Doe",
            .Email = "john@example.com",
            .Phone = "+49 123 456789"
        })
End Using

Dapper automatically creates parameterized queries from the anonymous object. There is no risk of SQL injection because the values are never concatenated into the SQL string.

Inserting multiple rows at once

Pass a list instead of a single object and Dapper will execute the statement once per item:

Dim contacts As New List(Of Contact) From {
    New Contact With {.Name = "Alice", .Email = "alice@example.com"},
    New Contact With {.Name = "Bob", .Email = "bob@example.com"},
    New Contact With {.Name = "Clara", .Email = "clara@example.com"}
}

Using connection As New SqliteConnection(connectionString)
    connection.Open()

    connection.Execute(
        "INSERT INTO Contacts (Name, Email) VALUES (@Name, @Email)",
        contacts)
End Using

For large datasets (hundreds or thousands of rows), wrap this in a transaction for significantly better performance. More on that in the transactions section below.

Querying data

This is where Dapper really shines. Instead of looping through a DataReader and mapping each column manually, you call Query(Of T) and get a typed collection back:

Using connection As New SqliteConnection(connectionString)
    connection.Open()

    Dim contacts = connection.Query(Of Contact)(
        "SELECT Id, Name, Email, Phone FROM Contacts ORDER BY Name")

    For Each contact In contacts
        Console.WriteLine($"[{contact.Id}] {contact.Name} - {contact.Email}")
    Next
End Using

The result is an IEnumerable(Of Contact) that you can iterate, filter with LINQ, or bind directly to a DataGridView.

Querying with parameters

Pass parameters as an anonymous object, just like with Execute():

Using connection As New SqliteConnection(connectionString)
    connection.Open()

    Dim results = connection.Query(Of Contact)(
        "SELECT Id, Name, Email FROM Contacts WHERE Name LIKE @Search",
        New With {.Search = $"%{searchTerm}%"})

    For Each contact In results
        Console.WriteLine($"[{contact.Id}] {contact.Name}")
    Next
End Using

Getting a single row

Use QueryFirstOrDefault(Of T) when you expect exactly one result (or nothing):

Using connection As New SqliteConnection(connectionString)
    connection.Open()

    Dim contact = connection.QueryFirstOrDefault(Of Contact)(
        "SELECT Id, Name, Email, Phone FROM Contacts WHERE Id = @Id",
        New With {.Id = 1})

    If contact IsNot Nothing Then
        Console.WriteLine($"{contact.Name} ({contact.Email})")
    End If
End Using

Other variants: QueryFirst (throws if no rows), QuerySingle (throws if not exactly one row), QuerySingleOrDefault (throws if more than one row).

Scalar queries

For queries that return a single value, use ExecuteScalar(Of T):

Using connection As New SqliteConnection(connectionString)
    connection.Open()

    Dim count = connection.ExecuteScalar(Of Long)(
        "SELECT COUNT(*) FROM Contacts")

    Console.WriteLine($"{count} contacts in database")
End Using

Updating and deleting data

Updates and deletes follow the same pattern as inserts. Execute() returns the number of affected rows:

UPDATE

Using connection As New SqliteConnection(connectionString)
    connection.Open()

    Dim rowsAffected = connection.Execute(
        "UPDATE Contacts SET Email = @Email WHERE Id = @Id",
        New With {.Email = "new-email@example.com", .Id = 1})

    Console.WriteLine($"{rowsAffected} row(s) updated.")
End Using

DELETE

Using connection As New SqliteConnection(connectionString)
    connection.Open()

    Dim rowsAffected = connection.Execute(
        "DELETE FROM Contacts WHERE Id = @Id",
        New With {.Id = 5})

    Console.WriteLine($"{rowsAffected} row(s) deleted.")
End Using

Complete example: ContactRepository with Dapper

Here’s a complete repository class that wraps all CRUD operations. Compare this to the manual ADO.NET version in the SQLite article to see much code Dapper saves:

Imports Dapper
Imports Microsoft.Data.Sqlite

Public Class ContactRepository

    Private ReadOnly _connectionString As String

    Public Sub New(connectionString As String)
        _connectionString = connectionString
    End Sub

    Public Sub InitializeDatabase()
        Using connection As New SqliteConnection(_connectionString)
            connection.Open()
            connection.Execute("
                CREATE TABLE IF NOT EXISTS Contacts (
                    Id INTEGER PRIMARY KEY AUTOINCREMENT,
                    Name TEXT NOT NULL,
                    Email TEXT,
                    Phone TEXT,
                    CreatedAt TEXT DEFAULT CURRENT_TIMESTAMP
                )")
        End Using
    End Sub

    Public Function AddContact(name As String, email As String, phone As String) As Long
        Using connection As New SqliteConnection(_connectionString)
            connection.Open()

            connection.Execute(
                "INSERT INTO Contacts (Name, Email, Phone) VALUES (@Name, @Email, @Phone)",
                New With {.Name = name, .Email = email, .Phone = phone})

            Return connection.ExecuteScalar(Of Long)("SELECT last_insert_rowid()")
        End Using
    End Function

    Public Function GetAllContacts() As List(Of Contact)
        Using connection As New SqliteConnection(_connectionString)
            connection.Open()
            Return connection.Query(Of Contact)(
                "SELECT Id, Name, Email, Phone FROM Contacts ORDER BY Name").AsList()
        End Using
    End Function

    Public Function GetContactById(id As Long) As Contact
        Using connection As New SqliteConnection(_connectionString)
            connection.Open()
            Return connection.QueryFirstOrDefault(Of Contact)(
                "SELECT Id, Name, Email, Phone FROM Contacts WHERE Id = @Id",
                New With {.Id = id})
        End Using
    End Function

    Public Function UpdateContact(id As Long, name As String, email As String, phone As String) As Boolean
        Using connection As New SqliteConnection(_connectionString)
            connection.Open()
            Dim rows = connection.Execute(
                "UPDATE Contacts SET Name = @Name, Email = @Email, Phone = @Phone WHERE Id = @Id",
                New With {.Name = name, .Email = email, .Phone = phone, .Id = id})
            Return rows > 0
        End Using
    End Function

    Public Function DeleteContact(id As Long) As Boolean
        Using connection As New SqliteConnection(_connectionString)
            connection.Open()
            Dim rows = connection.Execute(
                "DELETE FROM Contacts WHERE Id = @Id",
                New With {.Id = id})
            Return rows > 0
        End Using
    End Function
End Class

Usage is straightforward:

Dim repo As New ContactRepository($"Data Source={dbPath}")
repo.InitializeDatabase()

Dim newId = repo.AddContact("John Doe", "john@example.com", "+49 123 456789")
Console.WriteLine($"Created contact with ID {newId}")

Dim allContacts = repo.GetAllContacts()
For Each c In allContacts
    Console.WriteLine($"[{c.Id}] {c.Name} - {c.Email}")
Next

Transactions with Dapper

For bulk operations, wrap them in a transaction. Without a transaction, SQLite commits after every single statement, which is extremely slow for hundreds of inserts:

Using connection As New SqliteConnection(connectionString)
    connection.Open()

    Using transaction = connection.BeginTransaction()
        Dim contacts As New List(Of Object)
        For i As Integer = 1 To 1000
            contacts.Add(New With {
                .Name = $"Contact {i}",
                .Email = $"contact{i}@example.com"
            })
        Next

        connection.Execute(
            "INSERT INTO Contacts (Name, Email) VALUES (@Name, @Email)",
            contacts,
            transaction)

        transaction.Commit()
    End Using
End Using

The key difference to raw ADO.NET: you pass the transaction object as a parameter to Execute(). No need to set command.Transaction manually. And because Dapper loops through the list internally, you get transaction safety for all 1000 inserts with minimal code.

Async queries: keeping the UI responsive

Every Dapper method has an async counterpart. If you’re building a WinForms or WPF application, use them to keep the UI from freezing during database calls. For the fundamentals, check out the VB.NET Async/Await guide.

Private Async Function LoadContactsAsync() As Task(Of List(Of Contact))
    Using connection As New SqliteConnection(connectionString)
        Await connection.OpenAsync()

        Dim contacts = Await connection.QueryAsync(Of Contact)(
            "SELECT Id, Name, Email, Phone FROM Contacts ORDER BY Name")

        Return contacts.AsList()
    End Using
End Function

Available async methods: QueryAsync, QueryFirstOrDefaultAsync, ExecuteAsync, ExecuteScalarAsync. They work exactly like their synchronous counterparts, just with Await.

Dapper vs. raw ADO.NET: side-by-side comparison

Here’s the same „get all contacts“ operation written both ways. First, raw ADO.NET as shown in the SQLite article:

' Raw ADO.NET - 13 lines
Using connection As New SqliteConnection(connectionString)
    connection.Open()
    Using command As New SqliteCommand("SELECT Id, Name, Email, Phone FROM Contacts ORDER BY Name", connection)
        Using reader = command.ExecuteReader()
            While reader.Read()
                Dim contact As New Contact With {
                    .Id = reader.GetInt64(0),
                    .Name = reader.GetString(1),
                    .Email = If(reader.IsDBNull(2), "", reader.GetString(2)),
                    .Phone = If(reader.IsDBNull(3), "", reader.GetString(3))
                }
                contacts.Add(contact)
            End While
        End Using
    End Using
End Using

Now the same thing with Dapper:

' Dapper - 4 lines
Using connection As New SqliteConnection(connectionString)
    connection.Open()
    Dim contacts = connection.Query(Of Contact)(
        "SELECT Id, Name, Email, Phone FROM Contacts ORDER BY Name").AsList()
End Using

Same result, same SQL, same performance. Dapper handles the reader loop, the null checks, and the property mapping automatically. The more complex your model, the bigger the difference.

Common pitfalls and tips

Property names must match column names

Dapper maps by name, case-insensitive. If your table has first_name but your class has FirstName, use a SQL alias:

Dim contacts = connection.Query(Of Contact)(
    "SELECT first_name AS FirstName, last_name AS LastName FROM Contacts")

NULL handling

Dapper handles NULL columns automatically. If a column is NULL and the target property is a String, the property will be Nothing. If you want an empty string instead, initialize your properties with defaults:

Public Class Contact
    Public Property Id As Long
    Public Property Name As String = ""
    Public Property Email As String = ""
    Public Property Phone As String = ""
End Class

Don’t forget Using blocks

Dapper does not manage connection lifetimes. You still need Using blocks for every connection, exactly like with raw ADO.NET. An open connection locks the SQLite file.

Dapper and Dependency Injection

In larger applications, inject the connection string instead of hardcoding it. The ContactRepository class above already follows this pattern. If you’re using a DI container like Autofac, check the Dependency Injection guide.

FAQ

Wrapping up

Dapper eliminates the repetitive ADO.NET boilerplate while keeping you in full control of your SQL. Install the NuGet package, define a model class, and replace your manual SqliteCommand / DataReader code with Query(Of T) and Execute(). If you haven’t set up your database yet, start with the VB.NET SQLite guide first, then come back here to simplify your data access layer.

Der Beitrag VB.NET Dapper – Micro ORM for Clean Data Access (2026) erschien zuerst auf Robert Skibbe.

Why SQLite for your VB.NET application?

There are many database engines available, but SQLite stands out for local VB.NET applications. Here’s why:

• Zero setup – no server process, no installation, no admin rights needed
• Single file – the entire database lives in one .db file you can ship with your app
• Cross-platform – works on Windows, Linux, and macOS
• Lightweight – perfect for desktop apps, prototypes, embedded systems, and offline-first scenarios
• Reliable – used by Firefox, Chrome, Android, and millions of other applications

If you just need to persist settings or small amounts of data, you could also write a text file in VB.NET. But as soon as you need structured data, queries, or relationships, SQLite is the better choice.

Installing the NuGet package

There are two popular SQLite packages for .NET:

1. Microsoft.Data.Sqlite – Microsoft’s official, lightweight package (recommended for .NET 5+ / .NET Framework 4.6.1+)
2. System.Data.SQLite – the older, full-featured package from the SQLite team (supports even .NET Framework 4.0)

In this article I’ll use Microsoft.Data.Sqlite because it’s lighter and the recommended path going forward. The API is almost identical, so switching later is straightforward.

Install via Package Manager Console

Open the Package Manager Console in Visual Studio (Tools → NuGet Package Manager → Package Manager Console) and run:

Install-Package Microsoft.Data.Sqlite

Alternatively, right-click your project in Solution Explorer → Manage NuGet Packages → search for Microsoft.Data.Sqlite → Install.

Add the Imports statement

At the top of your code file, add the following import:

Imports Microsoft.Data.Sqlite

Creating a database and connecting

A big advantage of SQLite: you don’t need to „create“ a database manually. If the file doesn’t exist yet, SQLite creates it automatically when you open a connection.

The connection string

The SQLite connection string is minimal. All you need is the path to the database file:

Dim connectionString As String = "Data Source=myapp.db"

This creates the file myapp.db in the application’s working directory. If you want to place the database next to your executable, you can use the VB.NET Application Path to build a reliable path:

Dim dbPath As String = Path.Combine(AppContext.BaseDirectory, "myapp.db")
Dim connectionString As String = $"Data Source={dbPath}"

Opening a connection

Always wrap your connection in a Using block. This ensures the connection is properly closed and disposed, even if an exception occurs:

Using connection As New SqliteConnection("Data Source=myapp.db")
    connection.Open()

    ' Your database operations here...

End Using ' connection is automatically closed

This is the basic pattern you’ll use for every database operation. The Using block is essential to avoid file locks and „database is locked“ errors (more on that later).

Creating tables

Before you can store data, you need at least one table. Use CREATE TABLE IF NOT EXISTS to safely run the command every time your app starts, without errors if the table already exists:

Using connection As New SqliteConnection("Data Source=myapp.db")
    connection.Open()

    Using command As New SqliteCommand()
        command.Connection = connection
        command.CommandText = "
            CREATE TABLE IF NOT EXISTS Contacts (
                Id INTEGER PRIMARY KEY AUTOINCREMENT,
                Name TEXT NOT NULL,
                Email TEXT,
                Phone TEXT,
                CreatedAt TEXT DEFAULT CURRENT_TIMESTAMP
            )"
        command.ExecuteNonQuery()
    End Using
End Using

SQLite data types

SQLite uses a dynamic type system that’s different from SQL Server. The most common types are:

• INTEGER – whole numbers (equivalent to Integer / Long in VB.NET)
• TEXT – strings (equivalent to String)
• REAL – floating point numbers (equivalent to Double)
• BLOB – binary data (equivalent to Byte())
• NULL – no value

A tip: SQLite doesn’t have a native DATETIME type. Store dates as TEXT in ISO 8601 format (e.g. 2026-04-07T14:30:00) or as INTEGER (Unix timestamp).

Inserting data

Now let’s insert a record into our Contacts table. Always use parameterized queries instead of string concatenation. This protects your app from SQL injection and handles special characters correctly:

Using connection As New SqliteConnection("Data Source=myapp.db")
    connection.Open()

    Using command As New SqliteCommand()
        command.Connection = connection
        command.CommandText = "INSERT INTO Contacts (Name, Email, Phone) VALUES (@name, @email, @phone)"
        command.Parameters.AddWithValue("@name", "John Doe")
        command.Parameters.AddWithValue("@email", "john@example.com")
        command.Parameters.AddWithValue("@phone", "+49 123 456789")
        command.ExecuteNonQuery()
    End Using
End Using

Why parameterized queries matter

Never build SQL strings by concatenating user input directly. This is the #1 security mistake that leads to SQL injection:

' ❌ NEVER do this - SQL injection vulnerability!
command.CommandText = "INSERT INTO Contacts (Name) VALUES ('" & txtName.Text & "')"

' ✅ Always use parameters instead
command.CommandText = "INSERT INTO Contacts (Name) VALUES (@name)"
command.Parameters.AddWithValue("@name", txtName.Text)

Getting the last inserted ID

After inserting a row, you often want to know the auto-generated ID. Use last_insert_rowid() for that:

command.CommandText = "INSERT INTO Contacts (Name, Email) VALUES (@name, @email)"
command.Parameters.AddWithValue("@name", "Jane Doe")
command.Parameters.AddWithValue("@email", "jane@example.com")
command.ExecuteNonQuery()

command.CommandText = "SELECT last_insert_rowid()"
Dim newId As Long = CLng(command.ExecuteScalar())
Console.WriteLine($"New contact ID: {newId}")

Reading data (SELECT)

Use ExecuteReader() to query data and iterate over the results. Again, wrap everything in Using blocks:

Using connection As New SqliteConnection("Data Source=myapp.db")
    connection.Open()

    Using command As New SqliteCommand("SELECT Id, Name, Email FROM Contacts", connection)
        Using reader As SqliteDataReader = command.ExecuteReader()
            While reader.Read()
                Dim id As Long = reader.GetInt64(0)
                Dim name As String = reader.GetString(1)
                Dim email As String = If(reader.IsDBNull(2), "", reader.GetString(2))

                Console.WriteLine($"[{id}] {name} - {email}")
            End While
        End Using
    End Using
End Using

Filtering with WHERE

To search for specific records, use a parameterized WHERE clause:

Using command As New SqliteCommand(
    "SELECT Id, Name, Email FROM Contacts WHERE Name LIKE @search",
    connection)
    command.Parameters.AddWithValue("@search", $"%{searchTerm}%")

    Using reader As SqliteDataReader = command.ExecuteReader()
        While reader.Read()
            ' Process results...
        End While
    End Using
End Using

If you’re building a search-as-you-type feature, consider debouncing the input so you don’t fire a query on every keystroke.

Updating and deleting data

UPDATE

Using connection As New SqliteConnection("Data Source=myapp.db")
    connection.Open()

    Using command As New SqliteCommand()
        command.Connection = connection
        command.CommandText = "UPDATE Contacts SET Email = @email WHERE Id = @id"
        command.Parameters.AddWithValue("@email", "new-email@example.com")
        command.Parameters.AddWithValue("@id", 1)

        Dim rowsAffected As Integer = command.ExecuteNonQuery()
        Console.WriteLine($"{rowsAffected} row(s) updated.")
    End Using
End Using

DELETE

Using connection As New SqliteConnection("Data Source=myapp.db")
    connection.Open()

    Using command As New SqliteCommand("DELETE FROM Contacts WHERE Id = @id", connection)
        command.Parameters.AddWithValue("@id", 5)

        Dim rowsAffected As Integer = command.ExecuteNonQuery()
        Console.WriteLine($"{rowsAffected} row(s) deleted.")
    End Using
End Using

Complete example: Contact manager

Let’s tie it all together. Here’s a complete helper class that wraps all CRUD operations for a Contacts table. You can use this as a starting point for your own projects:

Imports Microsoft.Data.Sqlite

Public Class ContactRepository

    Private ReadOnly _connectionString As String

    Public Sub New(dbPath As String)
        _connectionString = $"Data Source={dbPath}"
    End Sub

    ''' Ensures the Contacts table exists.
    Public Sub InitializeDatabase()
        Using connection As New SqliteConnection(_connectionString)
            connection.Open()

            Using command As New SqliteCommand()
                command.Connection = connection
                command.CommandText = "
                    CREATE TABLE IF NOT EXISTS Contacts (
                        Id INTEGER PRIMARY KEY AUTOINCREMENT,
                        Name TEXT NOT NULL,
                        Email TEXT,
                        Phone TEXT,
                        CreatedAt TEXT DEFAULT CURRENT_TIMESTAMP
                    )"
                command.ExecuteNonQuery()
            End Using
        End Using
    End Sub

    ''' Adds a new contact and returns the generated Id.
    Public Function AddContact(name As String, email As String, phone As String) As Long
        Using connection As New SqliteConnection(_connectionString)
            connection.Open()

            Using command As New SqliteCommand()
                command.Connection = connection
                command.CommandText = "
                    INSERT INTO Contacts (Name, Email, Phone)
                    VALUES (@name, @email, @phone)"
                command.Parameters.AddWithValue("@name", name)
                command.Parameters.AddWithValue("@email", CObj(email) ?? DBNull.Value)
                command.Parameters.AddWithValue("@phone", CObj(phone) ?? DBNull.Value)
                command.ExecuteNonQuery()
            End Using

            Using command As New SqliteCommand("SELECT last_insert_rowid()", connection)
                Return CLng(command.ExecuteScalar())
            End Using
        End Using
    End Function

    ''' Returns all contacts as a list of dictionaries.
    Public Function GetAllContacts() As List(Of Dictionary(Of String, Object))
        Dim contacts As New List(Of Dictionary(Of String, Object))

        Using connection As New SqliteConnection(_connectionString)
            connection.Open()

            Using command As New SqliteCommand("SELECT Id, Name, Email, Phone FROM Contacts ORDER BY Name", connection)
                Using reader As SqliteDataReader = command.ExecuteReader()
                    While reader.Read()
                        Dim contact As New Dictionary(Of String, Object) From {
                            {"Id", reader.GetInt64(0)},
                            {"Name", reader.GetString(1)},
                            {"Email", If(reader.IsDBNull(2), "", reader.GetString(2))},
                            {"Phone", If(reader.IsDBNull(3), "", reader.GetString(3))}
                        }
                        contacts.Add(contact)
                    End While
                End Using
            End Using
        End Using

        Return contacts
    End Function

    ''' Updates a contact by Id.
    Public Function UpdateContact(id As Long, name As String, email As String, phone As String) As Boolean
        Using connection As New SqliteConnection(_connectionString)
            connection.Open()

            Using command As New SqliteCommand()
                command.Connection = connection
                command.CommandText = "UPDATE Contacts SET Name = @name, Email = @email, Phone = @phone WHERE Id = @id"
                command.Parameters.AddWithValue("@name", name)
                command.Parameters.AddWithValue("@email", CObj(email) ?? DBNull.Value)
                command.Parameters.AddWithValue("@phone", CObj(phone) ?? DBNull.Value)
                command.Parameters.AddWithValue("@id", id)

                Return command.ExecuteNonQuery() > 0
            End Using
        End Using
    End Function

    ''' Deletes a contact by Id.
    Public Function DeleteContact(id As Long) As Boolean
        Using connection As New SqliteConnection(_connectionString)
            connection.Open()

            Using command As New SqliteCommand("DELETE FROM Contacts WHERE Id = @id", connection)
                command.Parameters.AddWithValue("@id", id)

                Return command.ExecuteNonQuery() > 0
            End Using
        End Using
    End Function

End Class

Using the ContactRepository

Here’s how you’d use the class above, for example in a WinForms Form_Load event:

Dim dbPath As String = Path.Combine(AppContext.BaseDirectory, "contacts.db")
Dim repo As New ContactRepository(dbPath)

' Create the table (safe to call every time)
repo.InitializeDatabase()

' Add a contact
Dim newId As Long = repo.AddContact("Robert Skibbe", "mail@robbelroot.de", "+49 123 456")
Console.WriteLine($"Added contact with ID {newId}")

' Read all contacts
For Each contact In repo.GetAllContacts()
    Console.WriteLine($"[{contact("Id")}] {contact("Name")} - {contact("Email")}")
Next

' Update a contact
repo.UpdateContact(newId, "Robert S.", "new@robbelroot.de", "+49 999 999")

' Delete a contact
repo.DeleteContact(newId)

If you want to display the results in a grid, have a look at the VB.NET DataGridView with filter functionality. For storing results by key, the VB.NET Dictionary is a great data structure.

Using transactions

When you need to insert or update multiple rows at once, wrap them in a transaction. This is both faster and safer: either all operations succeed or none of them do.

Using connection As New SqliteConnection("Data Source=myapp.db")
    connection.Open()

    Using transaction = connection.BeginTransaction()
        Using command As New SqliteCommand()
            command.Connection = connection
            command.Transaction = transaction
            command.CommandText = "INSERT INTO Contacts (Name, Email) VALUES (@name, @email)"

            For i As Integer = 1 To 1000
                command.Parameters.Clear()
                command.Parameters.AddWithValue("@name", $"Contact {i}")
                command.Parameters.AddWithValue("@email", $"contact{i}@example.com")
                command.ExecuteNonQuery()
            Next
        End Using

        transaction.Commit()
    End Using
End Using

Without a transaction, inserting 1,000 rows can take several seconds because SQLite commits after each individual INSERT. With a transaction, the same operation finishes in milliseconds.

Async/Await: keeping the UI responsive

If a database query runs on the UI thread, the entire interface freezes until it completes. Using Async/Await moves the work to the background while the UI stays responsive. For a deeper dive, check out the article on asynchronous programming in VB.NET.

Public Async Function GetAllContactsAsync() As Task(Of List(Of Dictionary(Of String, Object)))
    Dim contacts As New List(Of Dictionary(Of String, Object))

    Using connection As New SqliteConnection(_connectionString)
        Await connection.OpenAsync()

        Using command As New SqliteCommand("SELECT Id, Name, Email FROM Contacts ORDER BY Name", connection)
            Using reader As SqliteDataReader = Await command.ExecuteReaderAsync()
                While Await reader.ReadAsync()
                    Dim contact As New Dictionary(Of String, Object) From {
                        {"Id", reader.GetInt64(0)},
                        {"Name", reader.GetString(1)},
                        {"Email", If(reader.IsDBNull(2), "", reader.GetString(2))}
                    }
                    contacts.Add(contact)
                End While
            End Using
        End Using
    End Using

    Return contacts
End Function

The pattern applies to all operations: OpenAsync() instead of Open(), ExecuteNonQueryAsync() instead of ExecuteNonQuery(), ReadAsync() instead of Read(). The calling method must be declared as Async Function.

Common pitfalls and solutions

„Database is locked“

This is the most common SQLite error. It occurs when multiple threads or connections try to write to the database simultaneously. Here’s how to avoid it:

• Always dispose connections – use Using blocks consistently. A forgotten open connection locks the file.
• Enable WAL mode – Write-Ahead Logging allows readers and one writer to work concurrently:

Using connection As New SqliteConnection("Data Source=myapp.db")
    connection.Open()

    Using walCommand As New SqliteCommand("PRAGMA journal_mode=WAL;", connection)
        walCommand.ExecuteNonQuery()
    End Using
End Using

• Set a busy timeout – instead of failing immediately, let SQLite retry for a few seconds:

Using walCommand As New SqliteCommand("PRAGMA busy_timeout=5000;", connection)
    walCommand.ExecuteNonQuery()
End Using

• Use transactions for bulk operations instead of opening/closing connections in a tight loop.
• Avoid long-running reads while writing. If you need complex background work, look into asynchronous programming in VB.NET.

File path issues

A relative path like Data Source=myapp.db resolves against the current working directory, which may differ depending on how your application was started (e.g. double-click vs. command line). Use an absolute path built from AppContext.BaseDirectory to be safe, as shown in the Application Path article.

NULL handling

When reading nullable columns, always check with reader.IsDBNull() before calling GetString() or GetInt64(). Otherwise you’ll get an InvalidCastException at runtime. When inserting NULL values, pass DBNull.Value instead of Nothing.

FAQ

Wrapping up

SQLite is the fastest way to add a local database to your VB.NET application. Install Microsoft.Data.Sqlite via NuGet, use Using blocks for every connection, and always write parameterized queries. For multi-threaded scenarios, enable WAL mode and set a busy timeout to avoid „database is locked“ errors.

Downloads

Der Beitrag VB.NET SQLite – Connect, Read & Write Data (2026) erschien zuerst auf Robert Skibbe.