Was du brauchst

Bevor du Code schreibst, brauchst du drei Dinge von Meta:

1. Meta Business Account mit einer registrierten App auf developers.facebook.com
2. Phone Number ID aus dem WhatsApp-Bereich in deinem App-Dashboard
3. Access Token (temporär zum Testen, permanent über System User für Produktion)

Meta stellt eine kostenlose Test-Rufnummer und fünf Test-Empfänger bereit. Du kannst während der Entwicklung echte Nachrichten ohne Kosten senden.

So funktioniert die WhatsApp Cloud API

Die WhatsApp Cloud API ist eine REST API, die von Meta gehostet wird. Deine VB.NET-Anwendung sendet einen HTTP-POST-Request mit JSON-Body an Metas Server. Meta liefert die Nachricht dann an die WhatsApp-App des Empfängers. Der Ablauf:

1. Deine App sendet einen POST-Request an https://graph.facebook.com/v20.0/{phone_number_id}/messages
2. Meta prüft deinen Token, die Rufnummer und das Nachrichtenformat
3. Meta stellt die Nachricht über WhatsApp-Server zu
4. Du erhältst eine JSON-Antwort mit der Nachrichten-ID oder einem Fehler

Eine wichtige Regel: Du kannst nur Template-Nachrichten an Nutzer senden, die dir in den letzten 24 Stunden nicht geschrieben haben. Freitext-Nachrichten sind nur innerhalb eines 24-Stunden-Gesprächsfensters erlaubt. Für die meisten Benachrichtigungs-Szenarien (Bestellbestätigungen, Alerts, Erinnerungen) sind Template-Nachrichten der richtige Weg.

Textnachricht senden

Das einfachste Beispiel. Es sendet eine Klartext-Nachricht an einen einzelnen Empfänger innerhalb eines aktiven Gesprächsfensters:

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

Aufruf per Button-Klick oder beliebigem Event-Handler:

Private Async Sub btnSend_Click(sender As Object, e As EventArgs) Handles btnSend.Click
    Dim success = Await SendWhatsAppMessage("491234567890", "Deine Bestellung wurde versendet.")

    If success Then
        lblStatus.Text = "Nachricht gesendet."
    Else
        lblStatus.Text = "Nachricht konnte nicht gesendet werden."
    End If
End Sub

Die Rufnummer muss die Landesvorwahl ohne Pluszeichen oder führende Nullen enthalten. Für eine deutsche Nummer wie +49 123 4567890 verwendest du 491234567890.

Template-Nachricht senden

Template-Nachrichten sind vorab genehmigte Nachrichtenformate, die du in deinem Meta Business Dashboard erstellst. Sie sind erforderlich, wenn du die erste Nachricht an einen Nutzer sendest oder außerhalb des 24-Stunden-Fensters kommunizierst:

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"": ""de""}" &
        "}" &
        "}"

    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 stellt ein Standard-Template namens hello_world zum Testen bereit. Eigene Templates erstellst du im WhatsApp-Manager-Bereich deines Meta Business Dashboards. Templates können Variablen wie {{1}} enthalten, die du beim Senden mit dynamischen Inhalten füllst.

Template-Nachricht mit Variablen

Die meisten echten Templates enthalten Platzhalter für Kundennamen, Bestellnummern oder Termine. So sendest du ein Template mit variablen Parametern:

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 "bestellbestaetigung" mit zwei Body-Parametern
    Dim json As String = "{" &
        """messaging_product"": ""whatsapp""," &
        """to"": """ & phone & """," &
        """type"": ""template""," &
        """template"": {" &
            """name"": ""bestellbestaetigung""," &
            """language"": {""code"": ""de""}," &
            """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

Die Parameter füllen die {{1}}-, {{2}}-Platzhalter in deinem Template der Reihe nach. Stelle sicher, dass die Anzahl der Parameter mit den Erwartungen des Templates übereinstimmt.

API-Antwort auswerten

Eine erfolgreiche Antwort enthält ein JSON-Objekt mit der Nachrichten-ID. Ein Fehler gibt ein strukturiertes Fehlerobjekt zurück. So liest du beides aus:

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 enthält: {"messaging_product":"whatsapp","contacts":[...],"messages":[{"id":"wamid.xxx"}]}
            Console.WriteLine("Gesendet. Antwort: " & body)
        Else
            ' body enthält: {"error":{"message":"...","type":"...","code":100,...}}
            Console.WriteLine("Fehler " & response.StatusCode.ToString() & ": " & body)
        End If
    End Using
End Function

Für Produktionsanwendungen speichere die Antwort in einer Log-Datei zum Debuggen. Siehe den VB.NET Textdatei schreiben Guide für Logging-Muster.

An mehrere Empfänger senden

Die WhatsApp API akzeptiert einen Empfänger pro Request. Um an mehrere Nummern zu senden, iterierst du über eine VB.NET List von Rufnummern:

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

        ' Rate-Limit einhalten: max 80 Nachrichten pro Sekunde
        Await Task.Delay(50)
    Next

    Console.WriteLine($"Gesendet: {successCount}, Fehlgeschlagen: {failCount}")
End Function

Das Task.Delay(50) fügt eine kleine Pause zwischen den Requests ein, um innerhalb des API-Rate-Limits zu bleiben. Bei großen Batches (Tausende von Nachrichten) solltest du die Nachrichten in eine Queue stellen und im Hintergrund verarbeiten.

Zugangsdaten sicher speichern

Schreibe deinen Access Token nie fest in den Quellcode. Für Desktop-Anwendungen speicherst du Zugangsdaten in einer externen Config-Datei oder Umgebungsvariablen:

' Aus App.config oder Umgebungsvariable lesen
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-Zugangsdaten nicht konfiguriert.", "Konfigurationsfehler",
        MessageBoxButtons.OK, MessageBoxIcon.Error)
    Return
End If

Setze Umgebungsvariablen auf der Maschine, auf der deine App läuft, oder verwende My.Settings mit benutzerbezogenen Einstellungen für Einzelbenutzer-Konfiguration.

Twilio als Alternative

Wenn du ein einfacheres SDK gegenüber rohen HTTP-Requests bevorzugst, bietet Twilio eine WhatsApp-Integration mit einem .NET-NuGet-Paket. Installiere Twilio via NuGet:

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

' Einmalig beim App-Start initialisieren
TwilioClient.Init("YOUR_ACCOUNT_SID", "YOUR_AUTH_TOKEN")

' Nachricht senden
Dim msg = MessageResource.Create(
    body:="Deine Bestellung wurde versendet.",
    from:=New Twilio.Types.PhoneNumber("whatsapp:+14155238886"),
    [to]:=New Twilio.Types.PhoneNumber("whatsapp:+491234567890")
)

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

Twilio kostet Geld pro Nachricht, übernimmt aber Rate-Limiting, Retries und Zustellverfolgung für dich. Die direkte Meta API ist kostenlos (du zahlst nur für Conversations über das Freitier hinaus), aber du machst alles selbst.

Häufige Fehler

Freitext außerhalb des 24-Stunden-Fensters senden

Die API gibt Fehlercode 131047 zurück, wenn du eine Textnachricht an jemanden sendest, der dir in den letzten 24 Stunden nicht geschrieben hat. Verwende stattdessen eine Template-Nachricht. Template-Nachrichten funktionieren jederzeit und sind der Standard-Ansatz für Benachrichtigungen.

Falsches Rufnummernformat

Die API erwartet die vollständige internationale Nummer ohne Pluszeichen, Leerzeichen oder Bindestriche. 491234567890 ist korrekt. +49 123 456 7890, 01234567890 oder 0049-123-4567890 schlagen fehl. Bereinige alle Formatierung vor dem Senden:

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

Access Token fest im Code

Temporäre Tokens laufen nach 24 Stunden ab. Wenn du einen fest einträgst und vergisst ihn zu aktualisieren, hört deine App leise auf zu senden. Verwende für Produktion einen permanenten System-User-Token und speichere ihn in Umgebungsvariablen oder einer sicheren Config-Datei, nie im Quellcode.

FAQ

Fazit

WhatsApp-Nachrichten aus VB.NET senden läuft über einen einzigen HttpClient.PostAsync-Aufruf an Metas Cloud API. Verwende Template-Nachrichten für Benachrichtigungen, speichere deinen Token sicher und bereinige Rufnummern vor dem Senden. Für einfachere Integration zu höheren Kosten gibt es Twilio als NuGet-Paket. Zum Loggen von API-Antworten in eine Datei, siehe den VB.NET Textdatei schreiben Guide.

Der Beitrag VB.NET WhatsApp Nachricht senden per Cloud API (2026) erschien zuerst auf Robert Skibbe.

MsgBox vs. MessageBox.Show

VB.NET bietet zwei Wege, eine Meldung anzuzeigen. Beide öffnen denselben Windows-Dialog, unterscheiden sich aber in Herkunft und API-Stil:

' VB.NET-Stil (aus Microsoft.VisualBasic Namespace)
MsgBox("Datei gespeichert.", MsgBoxStyle.Information, "Erfolg")

' .NET Framework-Stil (aus System.Windows.Forms)
MessageBox.Show("Datei gespeichert.", "Erfolg", MessageBoxButtons.OK, MessageBoxIcon.Information)

MsgBox ist ein VB.NET-Wrapper um die Win32-MessageBox-API. MessageBox.Show ist die .NET-Framework-Klasse, die in allen .NET-Sprachen funktioniert. Beide erzeugen exakt dasselbe Dialog-Fenster. Wenn dein Projekt rein VB.NET ist, funktioniert beides. Wenn du Code mit C#-Entwicklern teilst oder .NET-Konventionen folgst, ist MessageBox.Show die bessere Wahl.

MsgBox Syntax

Dim result As MsgBoxResult = MsgBox(
    Prompt,            ' Der Nachrichtentext (erforderlich)
    Buttons Or Icon,   ' MsgBoxStyle-Flags (optional)
    Title              ' Fenstertitel (optional)
)

Der erste Parameter ist die Nachricht. Der zweite kombiniert Button- und Icon-Stile mit Or. Der dritte setzt den Fenstertitel. Nur der erste Parameter ist erforderlich.

Einfache Meldung

Die einfachste MsgBox mit nur einer Nachricht und dem Standard-OK-Button:

MsgBox("Die Datei wurde gespeichert.")

Mit Titel und Informations-Icon:

MsgBox("Die Datei wurde gespeichert.", MsgBoxStyle.Information, "Erfolg")

Ja/Nein-Bestätigung

Dem Benutzer eine Ja/Nein-Frage stellen und auf die Antwort reagieren:

Dim result = MsgBox(
    "Möchtest du diesen Datensatz löschen?",
    MsgBoxStyle.YesNo Or MsgBoxStyle.Question,
    "Löschen bestätigen")

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

Kombiniere Button-Stil und Icon-Stil mit Or. Der Rückgabewert sagt dir, welcher Button geklickt wurde.

Ja/Nein/Abbrechen

Für ungespeicherte Änderungen drei Optionen anbieten:

Dim result = MsgBox(
    "Du hast ungespeicherte Änderungen. Vor dem Schließen speichern?",
    MsgBoxStyle.YesNoCancel Or MsgBoxStyle.Exclamation,
    "Ungespeicherte Änderungen")

Select Case result
    Case MsgBoxResult.Yes
        SaveDocument()
        Me.Close()
    Case MsgBoxResult.No
        Me.Close()
    Case MsgBoxResult.Cancel
        ' Nichts tun, auf dem Form bleiben
End Select

Alle Button-Stile

Alle Icon-Stile

Standard-Button ändern

Standardmäßig ist der erste Button fokussiert. Du kannst das ändern, um versehentliche Klicks auf destruktive Aktionen zu vermeiden:

' "Nein" standardmäßig fokussieren, damit nicht versehentlich gelöscht wird
Dim result = MsgBox(
    "Alle Datensätze endgültig löschen?",
    MsgBoxStyle.YesNo Or MsgBoxStyle.Critical Or MsgBoxStyle.DefaultButton2,
    "Warnung")

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

DefaultButton2 fokussiert den zweiten Button (Nein). Verwende DefaultButton3 für den dritten Button bei Drei-Button-Dialogen.

Dieselben Beispiele mit MessageBox.Show

Hier die gleichen Muster mit der .NET-Variante MessageBox.Show zum Vergleichen:

' Einfache Meldung
MessageBox.Show("Die Datei wurde gespeichert.", "Erfolg",
    MessageBoxButtons.OK, MessageBoxIcon.Information)

' Ja/Nein-Bestätigung
Dim result As DialogResult = MessageBox.Show(
    "Möchtest du diesen Datensatz löschen?", "Löschen bestätigen",
    MessageBoxButtons.YesNo, MessageBoxIcon.Question)

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

' Ja/Nein/Abbrechen mit Standard-Button
Dim result2 As DialogResult = MessageBox.Show(
    "Vor dem Schließen speichern?", "Ungespeicherte Änderungen",
    MessageBoxButtons.YesNoCancel, MessageBoxIcon.Warning,
    MessageBoxDefaultButton.Button2)

Select Case result2
    Case DialogResult.Yes
        SaveDocument()
        Me.Close()
    Case DialogResult.No
        Me.Close()
    Case DialogResult.Cancel
        ' Auf dem Form bleiben
End Select

Die Funktion ist identisch. MessageBox.Show verwendet getrennte Enums (MessageBoxButtons, MessageBoxIcon, MessageBoxDefaultButton) statt Flags mit Or zu kombinieren. Der Rückgabetyp ist DialogResult statt MsgBoxResult.

Wann was verwenden

Verwende MsgBox, wenn:

• Dein Projekt rein VB.NET ist und du kürzere Syntax bevorzugst
• Du schnell prototypen willst und minimalen Code brauchst

Verwende MessageBox.Show, wenn:

• Deine Codebasis mit C#-Entwicklern geteilt wird
• Du .NET-Konventionen folgen willst
• Du den Owner-Window-Parameter brauchst (um den Dialog über einem bestimmten Form zu halten)
• Dein Code portierbar zu .NET 5+ / .NET 8+ Projekten sein soll

Komplettes Beispiel: Speichern-vor-Schließen-Muster

Ein realistisches Beispiel, das vor dem Schließen eines Forms zum Speichern auffordert. Dieses Muster funktioniert in jedem Texteditor, Dateneingabe-Form oder Einstellungsfenster:

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(
        "Du hast ungespeicherte Änderungen. Jetzt speichern?",
        MsgBoxStyle.YesNoCancel Or MsgBoxStyle.Exclamation Or MsgBoxStyle.DefaultButton1,
        "Ungespeicherte Änderungen")

    Select Case result
        Case MsgBoxResult.Yes
            SaveToFile()
        Case MsgBoxResult.Cancel
            e.Cancel = True  ' Schließen verhindern
    End Select
End Sub

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

Mit e.Cancel = True im FormClosing-Event wird das Schließen des Forms verhindert. Der Benutzer bleibt auf dem Form und kann weiter arbeiten. Mehr zum Schreiben von Dateien findest du im VB.NET Textdatei schreiben Guide.

Häufige Fehler

Rückgabewert ignorieren

' SCHLECHT - fragt Ja/Nein, ignoriert aber die Antwort
MsgBox("Löschen?", MsgBoxStyle.YesNo)
DeleteRecord()

' GUT - prüfen, welcher Button geklickt wurde
If MsgBox("Löschen?", MsgBoxStyle.YesNo) = MsgBoxResult.Yes Then
    DeleteRecord()
End If

MsgBox mit VBScript-MsgBox verwechseln

Die VB.NET-MsgBox-Funktion lebt in Microsoft.VisualBasic.Interaction und gibt MsgBoxResult zurück. Die VBScript-MsgBox gibt ganzzahlige Werte zurück (1 für OK, 6 für Ja, usw.). Sie sehen ähnlich aus, laufen aber in komplett unterschiedlichen Umgebungen. In VB.NET immer gegen das MsgBoxResult-Enum vergleichen, nie gegen Magic Numbers.

MsgBox in einem Hintergrund-Thread verwenden

Sowohl MsgBox als auch MessageBox.Show müssen vom UI-Thread aus aufgerufen werden. Wenn du sie aus einem Hintergrund-Thread oder Task aufrufst, kann der Dialog hinter anderen Fenstern erscheinen oder Cross-Thread-Exceptions auslösen. Verwende Me.Invoke(), um den Aufruf auf den UI-Thread zu marshallen.

FAQ

Fazit

Die MsgBox-Funktion gibt dir schnelle Meldungsdialoge mit einer Zeile Code. Kombiniere Button- und Icon-Stile mit Or, prüfe immer den Rückgabewert bei Ja/Nein-Abfragen und verwende DefaultButton2 vor destruktiven Aktionen. Wenn du .NET-Standardcode bevorzugst, nutze MessageBox.Show mit getrennten Enums für dasselbe Ergebnis. Für dynamisches Event-Handling schau dir den VB.NET AddHandler Guide an. Zum Schreiben von Dateien nach einem Speichern-Dialog siehe den VB.NET Textdatei schreiben Guide.

Der Beitrag VB.NET MsgBox – Meldungsdialoge einfach erklärt (2026) erschien zuerst auf Robert Skibbe.

Was ist der FolderBrowserDialog?

Der FolderBrowserDialog ist ein WinForms-Control aus System.Windows.Forms. Beim Aufruf von ShowDialog() öffnet sich der Windows-Ordnerdialog. Der Benutzer navigiert durch den Ordnerbaum, wählt einen Ordner aus und klickt OK. Dein Code erhält dann den vollständigen Ordnerpfad über die Eigenschaft SelectedPath.

Verwende ihn, wenn:

• Der Benutzer einen Ausgabeordner für Exporte, Backups oder Berichte wählen soll
• Deine Anwendung alle Dateien eines Verzeichnisses verarbeiten muss
• Der Benutzer ein Installations- oder Arbeitsverzeichnis auswählen soll
• Der Benutzer einen neuen Ordner anlegen können soll

Falls der Benutzer stattdessen eine einzelne Datei auswählen soll, verwende den OpenFileDialog. Zum Speichern einer Datei an einem bestimmten Ort verwende den SaveFileDialog.

Einfaches Beispiel

Der einfachste FolderBrowserDialog, der den gewählten Pfad anzeigt:

Using dlg As New FolderBrowserDialog()
    dlg.Description = "Ordner auswählen"

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

Der Using-Block gibt den Dialog nach der Verwendung frei. ShowDialog() gibt DialogResult.OK zurück, wenn der Benutzer bestätigt, oder DialogResult.Cancel, wenn er den Dialog schließt. Prüfe immer das Ergebnis, bevor du den Pfad verwendest.

Stammordner einschränken

Die RootFolder-Eigenschaft legt fest, welcher Knotenpunkt als oberste Ebene im Dialog angezeigt wird. Sie akzeptiert Werte aus Environment.SpecialFolder:

Using dlg As New FolderBrowserDialog()
    ' Nur Ordner innerhalb des Desktops anzeigen
    dlg.RootFolder = Environment.SpecialFolder.Desktop
    dlg.Description = "Projektordner auswählen"

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

Gängige Werte für RootFolder:

• Environment.SpecialFolder.Desktop (Standard) zeigt den kompletten Baum ab dem Desktop
• Environment.SpecialFolder.MyComputer zeigt alle Laufwerke
• Environment.SpecialFolder.MyDocuments beschränkt das Browsen auf den Dokumente-Ordner

Ordner vorauswählen

Verwende SelectedPath, um beim Öffnen des Dialogs einen Ordner vorzuwählen. Das ist nützlich, wenn der Benutzer zuvor bereits einen Ordner gewählt hat und du dir den merken willst:

Using dlg As New FolderBrowserDialog()
    dlg.Description = "Exportordner auswählen"
    dlg.SelectedPath = "C:\Users\Public\Documents"

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

Der Dialog öffnet sich mit diesem Ordner bereits markiert. Falls der Pfad nicht existiert, springt der Dialog zum Stammordner zurück.

Neuer-Ordner-Button ausblenden

Standardmäßig enthält der Dialog einen „Neuen Ordner erstellen“-Button. Wenn der Benutzer nur einen existierenden Ordner auswählen soll, deaktiviere ihn:

Using dlg As New FolderBrowserDialog()
    dlg.Description = "Vorhandenen Ordner auswählen"
    dlg.ShowNewFolderButton = False

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

Setze ShowNewFolderButton = False für reine Leseoperationen wie den Import von Dateien. Lass ihn auf True (Standard), wenn der Benutzer eventuell einen Zielordner für Exporte anlegen muss.

Komplettes Beispiel: Dateien im Batch verarbeiten

Ein realistisches Beispiel, das den Benutzer einen Ordner auswählen lässt und dann alle Textdateien darin verarbeitet:

Imports System.IO
Imports System.Text

Private Sub BtnImportieren_Click(sender As Object, e As EventArgs) Handles BtnImportieren.Click
    Using dlg As New FolderBrowserDialog()
        dlg.Description = "Ordner mit Textdateien auswählen"
        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)
                ' Jede Datei verarbeiten...
            Next

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

Directory.GetFiles() gibt alle passenden Dateien im gewählten Ordner zurück. Verwende den zweiten Parameter für Muster, z.B. "*.csv" oder "*.xml". Mehr zum Lesen von Textdateien findest du im VB.NET Textdatei einlesen Guide.

Unterordner einbeziehen

Um Dateien rekursiv zu verarbeiten, füge SearchOption.AllDirectories hinzu:

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 & "\", "")
        ' Datei mit relativem Pfad verarbeiten...
    Next
End If

Das durchsucht den gewählten Ordner und alle seine Unterordner. Sei vorsichtig bei großen Verzeichnisbäumen, da dies bei Tausenden von Dateien eine Weile dauern kann.

Environment.SpecialFolder verwenden

Du kannst den Dialog mit Environment.GetFolderPath() kombinieren, um gängige Systemordner vorzuwählen. Du kannst auch den Anwendungspfad als Startpunkt verwenden:

' In Dokumente starten
Using dlg As New FolderBrowserDialog()
    dlg.SelectedPath = Environment.GetFolderPath(
        Environment.SpecialFolder.MyDocuments)

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

' Im Anwendungsverzeichnis starten
Using dlg As New FolderBrowserDialog()
    dlg.SelectedPath = Application.StartupPath

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

Alle wichtigen Eigenschaften im Überblick

Der FolderBrowserDialog hat weniger Eigenschaften als der OpenFileDialog, weil er nur Ordner und keine Dateien behandelt. Es gibt keine Filter– oder Multiselect-Eigenschaft.

Häufige Fehler

Pfad verwenden ohne DialogResult zu prüfen

' SCHLECHT - SelectedPath ist leer, wenn der Benutzer abbricht
dlg.ShowDialog()
Dim files = Directory.GetFiles(dlg.SelectedPath)

' GUT - Ergebnis zuerst prüfen
If dlg.ShowDialog() = DialogResult.OK Then
    Dim files = Directory.GetFiles(dlg.SelectedPath)
End If

RootFolder und SelectedPath verwechseln

RootFolder schränkt ein, welche Ordner der Benutzer sehen kann. SelectedPath wählt einen Ordner innerhalb des sichtbaren Baums vor. Wenn du RootFolder = MyDocuments setzt, kann der Benutzer nicht aus den Dokumenten herausnavigieren. Wenn du nur einen Startpunkt vorschlagen, aber volle Navigation erlauben willst, verwende stattdessen SelectedPath.

Using-Block vergessen

Wie alle WinForms-Dialoge hält der FolderBrowserDialog unverwaltete Ressourcen. Ohne Using bleiben diese Ressourcen im Speicher, bis der Garbage Collector läuft. Wickle ihn immer in einen Using-Block ein.

FAQ

Fazit

Der FolderBrowserDialog gibt deiner VB.NET-Anwendung einen nativen Ordnerdialog mit minimalem Code. Setze SelectedPath um einen Startordner vorzuschlagen, verwende RootFolder um die Navigation einzuschränken, und blende den Neuer-Ordner-Button mit ShowNewFolderButton = False aus, wenn der Benutzer nur existierende Ordner wählen soll. Nach dem Dialog kombiniere SelectedPath mit Directory.GetFiles() um den Ordnerinhalt zu verarbeiten. Für die Auswahl einzelner Dateien verwende den OpenFileDialog. Zum Speichern von Dateien siehe den SaveFileDialog.

Der Beitrag VB.NET FolderBrowserDialog – Ordner auswählen (2026) erschien zuerst auf Robert Skibbe.

Was ist der OpenFileDialog?

Der OpenFileDialog ist ein WinForms-Control aus System.Windows.Forms. Beim Aufruf von ShowDialog() öffnet sich der Standard-Windows-Dialog „Öffnen“. Der Benutzer navigiert zu einem Ordner, wählt eine Datei aus und klickt Öffnen. Dein Code erhält dann den vollständigen Dateipfad über die Eigenschaft FileName.

Verwende ihn, wenn:

• Der Benutzer wählen soll, welche Datei geöffnet wird (Importe, Konfigdateien, Bilder)
• Du einen Dateitypfilter brauchst (z.B. nur .txt, .csv oder .png)
• Du eine eingebaute Prüfung willst, ob die gewählte Datei tatsächlich existiert
• Der Benutzer mehrere Dateien gleichzeitig auswählen können soll

Falls der Benutzer stattdessen ein Speicherziel wählen soll, verwende den SaveFileDialog.

Einfaches Beispiel

Der einfachste OpenFileDialog, der eine Textdatei einliest:

Using dlg As New OpenFileDialog()
    dlg.Filter = "Textdateien (*.txt)|*.txt"
    dlg.Title = "Textdatei öffnen"

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

Der Using-Block gibt den Dialog nach der Verwendung frei. ShowDialog() gibt DialogResult.OK zurück, wenn der Benutzer auf Öffnen klickt, oder DialogResult.Cancel, wenn er den Dialog schließt. Prüfe immer das Ergebnis, bevor du die Datei liest.

Dateitypfilter einrichten

Die Filter-Eigenschaft steuert, welche Dateitypen im Dropdown erscheinen. Die Syntax ist identisch zum SaveFileDialog:

' Einzelner Filter
dlg.Filter = "Textdateien (*.txt)|*.txt"

' Mehrere Filter
dlg.Filter = "Textdateien (*.txt)|*.txt|CSV-Dateien (*.csv)|*.csv|Alle Dateien (*.*)|*.*"

' Zweiten Filter vorauswählen (1-basierter Index)
dlg.FilterIndex = 2

' Mehrere Endungen in einem Filter
dlg.Filter = "Bilder (*.png;*.jpg;*.gif)|*.png;*.jpg;*.gif"

Um mehrere Endungen in einem Filtereintrag zu kombinieren, trenne sie mit Semikolons im Muster-Teil: *.png;*.jpg;*.gif. Der Benutzer sieht einen einzelnen „Bilder“-Eintrag, der alle drei Typen akzeptiert.

Standardordner setzen

Using dlg As New OpenFileDialog()
    ' Im Dokumente-Ordner des Benutzers starten
    dlg.InitialDirectory = Environment.GetFolderPath(
        Environment.SpecialFolder.MyDocuments)

    dlg.Filter = "CSV-Dateien (*.csv)|*.csv"

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

Gängige Optionen für InitialDirectory:

• Environment.SpecialFolder.MyDocuments für Benutzerdokumente
• Environment.SpecialFolder.Desktop für den Desktop
• Den Application Path für Dateien neben der Anwendung

Wenn du InitialDirectory nicht setzt, merkt sich der Dialog den zuletzt besuchten Ordner während der aktuellen Sitzung.

Mehrere Dateien auswählen

Setze Multiselect = True, damit der Benutzer mehrere Dateien auswählen kann. Die gewählten Pfade sind über FileNames (Plural) verfügbar:

Using dlg As New OpenFileDialog()
    dlg.Filter = "Bilder (*.png;*.jpg)|*.png;*.jpg"
    dlg.Multiselect = True
    dlg.Title = "Bilder zum Importieren auswählen"

    If dlg.ShowDialog() = DialogResult.OK Then
        For Each filePath In dlg.FileNames
            Dim img As Image = Image.FromFile(filePath)
            ' Jedes Bild verarbeiten...
        Next

        MessageBox.Show($"{dlg.FileNames.Length} Dateien ausgewählt.")
    End If
End Using

Der Benutzer hält Strg gedrückt, um einzelne Dateien auszuwählen, oder Shift für einen Bereich. FileName (Singular) gibt weiterhin die erste gewählte Datei zurück; FileNames liefert alle als String()-Array.

Komplettes Beispiel: Textdatei einlesen

Ein realistisches Beispiel, das eine Textdatei mit Encoding-Unterstützung einliest, unter Verwendung von ReadAllText:

Imports System.IO
Imports System.Text

Private Sub BtnOeffnen_Click(sender As Object, e As EventArgs) Handles BtnOeffnen.Click
    Using dlg As New OpenFileDialog()
        dlg.Title = "Bericht öffnen"
        dlg.Filter = "Textdateien (*.txt)|*.txt|CSV-Dateien (*.csv)|*.csv|Alle Dateien (*.*)|*.*"
        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

Gib beim Lesen von Textdateien immer Encoding.UTF8 an, um Sonderzeichen korrekt zu verarbeiten. Path.GetFileName() extrahiert nur den Dateinamen aus dem vollen Pfad, was z.B. für den Fenstertitel nützlich ist.

Binärdateien lesen (Bilder, PDFs)

Der OpenFileDialog funktioniert für binäre Inhalte genauso. Nur die Lesemethode ändert sich:

' Bild in eine PictureBox laden
Using dlg As New OpenFileDialog()
    dlg.Filter = "Bilder (*.png;*.jpg;*.bmp)|*.png;*.jpg;*.bmp"

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

' Datei als Byte-Array einlesen
Using dlg As New OpenFileDialog()
    dlg.Filter = "Alle Dateien (*.*)|*.*"

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

Große Dateien mit StreamReader lesen

Für große Dateien oder zeilenweise Verarbeitung verwende einen StreamReader mit dem Pfad aus dem Dialog:

Using dlg As New OpenFileDialog()
    dlg.Filter = "CSV-Dateien (*.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
                ' Jede Zeile verarbeiten...
            End While
        End Using
    End If
End Using

Der StreamReader-Ansatz ist speichereffizienter für große Dateien, weil er Zeile für Zeile liest, statt die gesamte Datei in den Speicher zu laden. Mehr zum Lesen von Textdateien findest du im VB.NET Textdatei einlesen Guide.

Alle wichtigen Eigenschaften im Überblick

Häufige Fehler

Lesen ohne DialogResult zu prüfen

' SCHLECHT - FileName ist leer, wenn der Benutzer abbricht
dlg.ShowDialog()
Dim content = File.ReadAllText(dlg.FileName)

' GUT - Ergebnis zuerst prüfen
If dlg.ShowDialog() = DialogResult.OK Then
    Dim content = File.ReadAllText(dlg.FileName)
End If

FileName statt FileNames bei Multiselect

' SCHLECHT - bekommt nur die erste Datei bei Multiselect
dlg.Multiselect = True
If dlg.ShowDialog() = DialogResult.OK Then
    Dim content = File.ReadAllText(dlg.FileName)  ' nur erste Datei!
End If

' GUT - alle gewählten Dateien durchlaufen
If dlg.ShowDialog() = DialogResult.OK Then
    For Each path In dlg.FileNames
        Dim content = File.ReadAllText(path)
    Next
End If

Using-Block vergessen

Der OpenFileDialog hält unverwaltete Ressourcen (ein Windows-COM-Objekt). Ohne Using bleiben diese Ressourcen im Speicher, bis der Garbage Collector läuft. Wickle ihn immer in einen Using-Block ein.

FAQ

Fazit

Der OpenFileDialog gibt deiner VB.NET-Anwendung ein natives Datei-Öffnen-Erlebnis mit minimalem Code. Setze einen Filter für Dateitypen, aktiviere Multiselect für Batch-Operationen und prüfe immer DialogResult.OK bevor du liest. Für den eigentlichen Lesevorgang verwende File.ReadAllText() für Text oder File.ReadAllBytes() für Binärdaten. Musst du stattdessen Dateien speichern? Der SaveFileDialog funktioniert nach dem gleichen Muster. Mehr zum Lesen von Textdateien findest du im VB.NET Textdatei einlesen Guide.

Der Beitrag VB.NET OpenFileDialog – Datei öffnen mit Dialog (2026) erschien zuerst auf Robert Skibbe.

Was ist der SaveFileDialog?

Der SaveFileDialog ist ein WinForms-Control aus System.Windows.Forms. Beim Aufruf von ShowDialog() öffnet sich der Standard-Windows-Dialog „Speichern unter“. Der Benutzer wählt einen Ordner, gibt einen Dateinamen ein und klickt Speichern. Dein Code erhält dann den vollständigen Dateipfad über die Eigenschaft FileName.

Verwende ihn, wenn:

• Der Benutzer wählen soll, wo eine Datei gespeichert wird (Exporte, Berichte, Downloads)
• Du einen Dateitypfilter brauchst (z.B. nur .txt, .csv oder .pdf)
• Du eine eingebaute Überschreib-Bestätigung willst, ohne sie selbst zu programmieren

Einfaches Beispiel

Der einfachste SaveFileDialog mit einem einzelnen Dateityp:

Using dlg As New SaveFileDialog()
    dlg.Filter = "Textdateien (*.txt)|*.txt"
    dlg.Title = "Textdatei speichern"

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

Der Using-Block gibt den Dialog nach der Verwendung frei. ShowDialog() gibt DialogResult.OK zurück, wenn der Benutzer auf Speichern klickt, oder DialogResult.Cancel, wenn er den Dialog schließt. Prüfe immer das Ergebnis, bevor du schreibst.

Dateitypfilter einrichten

Die Filter-Eigenschaft steuert, welche Dateitypen im Dropdown erscheinen. Die Syntax ist Beschreibung|Muster, getrennt durch Pipes für mehrere Typen:

' Einzelner Filter
dlg.Filter = "Textdateien (*.txt)|*.txt"

' Mehrere Filter
dlg.Filter = "Textdateien (*.txt)|*.txt|CSV-Dateien (*.csv)|*.csv|Alle Dateien (*.*)|*.*"

' Zweiten Filter vorauswählen (1-basierter Index)
dlg.FilterIndex = 2

Jeder Filtereintrag besteht aus zwei Teilen: dem Anzeigetext (z.B. „Textdateien (*.txt)“) und dem eigentlichen Muster (z.B. „*.txt“). FilterIndex ist 1-basiert, also wählt 2 den zweiten Eintrag aus.

Dateiendung automatisch anhängen

' Endung anhängen, wenn der Benutzer keine eingibt (Standard: True)
dlg.AddExtension = True

' Standard-Endung setzen (ohne den Punkt)
dlg.DefaultExt = "txt"

Mit AddExtension = True (Standard) hängt der Dialog „.txt“ an, wenn der Benutzer nur „bericht“ ohne Endung eingibt. Die Endung kommt aus dem ausgewählten Filter oder dem DefaultExt-Wert.

Standardordner und Dateiname setzen

Using dlg As New SaveFileDialog()
    ' Im Dokumente-Ordner des Benutzers starten
    dlg.InitialDirectory = Environment.GetFolderPath(
        Environment.SpecialFolder.MyDocuments)

    ' Dateiname vorausfüllen
    dlg.FileName = "bericht-2026.csv"

    dlg.Filter = "CSV-Dateien (*.csv)|*.csv"

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

InitialDirectory legt fest, wo der Dialog öffnet. Gängige Optionen:

• Environment.SpecialFolder.MyDocuments für Benutzerdokumente
• Environment.SpecialFolder.Desktop für den Desktop
• Den Application Path zum Speichern neben der Anwendung

Wenn du InitialDirectory nicht setzt, merkt sich der Dialog den zuletzt besuchten Ordner während der aktuellen Sitzung.

Überschreib-Bestätigung

' Warnung anzeigen, wenn die Datei bereits existiert (Standard: True)
dlg.OverwritePrompt = True

Diese Option ist standardmäßig aktiviert. Wenn der Benutzer eine bestehende Datei auswählt, zeigt Windows einen Bestätigungsdialog. Das musst du nicht selbst programmieren.

Komplettes Beispiel: Textdatei speichern

Ein realistisches Beispiel, das eine mehrzeilige Textdatei mit Encoding-Unterstützung speichert, unter Verwendung von WriteAllText:

Imports System.IO
Imports System.Text

Private Sub BtnSpeichern_Click(sender As Object, e As EventArgs) Handles BtnSpeichern.Click
    Using dlg As New SaveFileDialog()
        dlg.Title = "Bericht speichern"
        dlg.Filter = "Textdateien (*.txt)|*.txt|CSV-Dateien (*.csv)|*.csv"
        dlg.InitialDirectory = Environment.GetFolderPath(
            Environment.SpecialFolder.MyDocuments)
        dlg.FileName = $"bericht-{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($"Gespeichert unter {dlg.FileName}",
                "Erfolg", MessageBoxButtons.OK, MessageBoxIcon.Information)
        End If
    End Using
End Sub

Gib beim Schreiben von Textdateien immer Encoding.UTF8 an. Ohne diese Angabe verwendet .NET das System-Standard-Encoding, was auf anderen Rechnern zu Problemen mit Sonderzeichen führen kann.

Binärdateien speichern (Bilder, PDFs)

Der SaveFileDialog funktioniert für binäre Inhalte genauso. Der einzige Unterschied ist die Schreibmethode:

' Bild speichern
Using dlg As New SaveFileDialog()
    dlg.Filter = "PNG-Bilder (*.png)|*.png|JPEG-Bilder (*.jpg)|*.jpg"
    dlg.FileName = "screenshot"

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

' Byte-Array speichern (z.B. heruntergeladenes PDF)
Using dlg As New SaveFileDialog()
    dlg.Filter = "PDF-Dateien (*.pdf)|*.pdf"

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

Mit StreamWriter speichern (große Dateien)

Für große Dateien oder zeilenweises Schreiben verwende einen StreamWriter mit dem Pfad aus dem Dialog:

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

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

Der StreamWriter-Ansatz ist speichereffizienter für große Datenmengen, weil er Zeile für Zeile schreibt, statt den gesamten String im Speicher aufzubauen. Für einen tieferen Einblick in Dateioperationen siehe den VB.NET Textdatei schreiben Guide.

Alle wichtigen Eigenschaften im Überblick

Häufige Fehler

Schreiben ohne DialogResult zu prüfen

' SCHLECHT - schreibt in leeren Pfad, wenn der Benutzer abbricht
dlg.ShowDialog()
File.WriteAllText(dlg.FileName, content)

' GUT - Ergebnis zuerst prüfen
If dlg.ShowDialog() = DialogResult.OK Then
    File.WriteAllText(dlg.FileName, content)
End If

Using-Block vergessen

Der SaveFileDialog hält unverwaltete Ressourcen (ein Windows-COM-Objekt). Ohne Using bleiben diese Ressourcen im Speicher, bis der Garbage Collector läuft. Wickle ihn immer in einen Using-Block ein.

Fehlerhafte Filter-Syntax

' SCHLECHT - fehlendes Muster nach dem Pipe
dlg.Filter = "Textdateien|"

' SCHLECHT - Komma statt Pipe
dlg.Filter = "Textdateien (*.txt), *.txt"

' GUT - korrekte Beschreibung|Muster-Syntax
dlg.Filter = "Textdateien (*.txt)|*.txt"

Ein fehlerhafter Filter-String wirft zur Laufzeit eine ArgumentException. Das Muster ist immer Anzeigetext|*.endung, mit einem Pipe-Zeichen als Trenner.

FAQ

Fazit

Der SaveFileDialog gibt deiner VB.NET-Anwendung ein natives Datei-Speichern-Erlebnis mit minimalem Code. Setze einen Filter für Dateitypen, nutze InitialDirectory für den Startordner und prüfe immer DialogResult.OK bevor du schreibst. Für den eigentlichen Schreibvorgang verwende File.WriteAllText() für Text oder File.WriteAllBytes() für Binärdaten. Musst du stattdessen Dateien einlesen? Der OpenFileDialog funktioniert nach dem gleichen Muster in umgekehrter Richtung. Mehr zum Schreiben von Textdateien findest du im VB.NET Textdatei schreiben Guide.

Der Beitrag VB.NET SaveFileDialog – Datei speichern mit Dialog (2026) erschien zuerst auf Robert Skibbe.

Was ist eine DataTable und wann setzt man sie ein?

Eine DataTable liegt im System.Data-Namespace und stellt eine einzelne Tabelle im Arbeitsspeicher dar. Vergleichbar mit einer Tabellenkalkulation: sie hat Spalten mit Namen und Typen, und Zeilen, die die eigentlichen Werte enthalten.

Verwende eine DataTable, wenn:

• Du tabellarische Daten an ein DataGridView oder andere WinForms-Controls binden willst
• Du mit ADO.NET arbeitest und eine Tabelle aus einer Datenbankabfrage füllen willst
• Du eingebautes Filtern und Sortieren brauchst, ohne eigene Logik schreiben zu müssen
• Du CSV- oder Excel-Importe verarbeitest, bei denen Zeilen und Spalten natürlich abbildbar sind

Falls du nur eine geordnete Liste von Objekten brauchst, ist eine VB.NET List(Of T) einfacher und typsicherer. Für Key-Value-Lookups verwende ein Dictionary. Die DataTable spielt ihre Stärken aus, wenn du eine flexible, schemabasierte Struktur mit Filtern, Sortieren und UI-Binding brauchst.

Eine DataTable mit Spalten erstellen

Jede DataTable beginnt mit einem Schema: den Spalten, die festlegen, welche Daten jede Zeile aufnehmen kann.

Dim table As New DataTable("Contacts")

' Spalten mit Name und Typ hinzufügen
table.Columns.Add("Id", GetType(Integer))
table.Columns.Add("Name", GetType(String))
table.Columns.Add("Email", GetType(String))
table.Columns.Add("Age", GetType(Integer))

' Primärschlüssel setzen
table.PrimaryKey = {table.Columns("Id")}

Jede Spalte hat einen DataType (Integer, String, DateTime, Decimal, Boolean, etc.) und einen optionalen ColumnName. Der Primärschlüssel ermöglicht schnelle Lookups mit Rows.Find() und verhindert doppelte Einträge.

Spalteneigenschaften

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

' Standardwert
table.Columns("Age").DefaultValue = 0

' Nullwerte verbieten
table.Columns("Name").AllowDBNull = False

Zeilen hinzufügen

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

' Methode 2: Werte direkt übergeben (Spaltenreihenfolge)
table.Rows.Add(Nothing, "Bob", "bob@example.com", 25)

' Methode 3: Aus einem Object-Array
Dim values() As Object = {Nothing, "Clara", "clara@example.com", 35}
table.Rows.Add(values)

Bei einer AutoIncrement-Id-Spalte übergibst du Nothing für das Feld. Die DataTable vergibt den nächsten Wert automatisch.

Daten lesen und zugreifen

' Auf eine bestimmte Zeile per Index zugreifen
Dim firstRow As DataRow = table.Rows(0)
Dim name As String = CStr(firstRow("Name"))

' Alle Zeilen durchlaufen
For Each row As DataRow In table.Rows
    Console.WriteLine($"{row("Id")}: {row("Name")} ({row("Email")})")
Next

' Zeile per Primärschlüssel finden
Dim found As DataRow = table.Rows.Find(2)
If found IsNot Nothing Then
    Console.WriteLine($"Gefunden: {found("Name")}")
End If

' Gesamtanzahl der Zeilen
Dim count As Integer = table.Rows.Count

Felder geben Object zurück, daher musst du sie casten (CStr, CInt, CDec, etc.) oder die typisierte Field(Of T)-Erweiterungsmethode verwenden: row.Field(Of String)("Name"). Die Field-Methode behandelt DBNull bei Nullable-Typen automatisch sicher.

Filtern mit Select und DataView

DataTable bietet zwei Wege zum Filtern: die Select()-Methode für schnelle Abfragen und DataView für persistente, bindbare Filter.

DataTable.Select()

' Nach Bedingung filtern
Dim olderThan25() As DataRow = table.Select("Age > 25")

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

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

' Ergebnisse verarbeiten
For Each row In olderThan25
    Console.WriteLine(row("Name"))
Next

Der Filterausdruck nutzt eine SQL-ähnliche Syntax: =, <>, >, <, LIKE, AND, OR, IN, IS NULL. Der Sortierausdruck nimmt einen Spaltennamen gefolgt von ASC oder DESC.

DataView für bindbares Filtern

Eine DataView umschließt eine DataTable und liefert eine gefilterte, sortierte Sicht, die direkt an UI-Controls gebunden werden kann:

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

' An DataGridView binden
DataGridView1.DataSource = view

' Filter zur Laufzeit ändern (UI aktualisiert sich automatisch)
view.RowFilter = "Name LIKE 'B%'"

DataView ist die bessere Wahl für eine DataGridView-Filterfunktion, weil sie das gebundene Control automatisch aktualisiert, wenn RowFilter oder Sort geändert werden.

Zeilen sortieren

Die DataTable selbst hat keine Sort()-Methode. Sortiert wird über Select() oder DataView:

' Sortieren mit Select (gibt DataRow-Array zurück)
Dim sortedRows() As DataRow = table.Select("", "Age DESC")

' Sortieren mit DataView (bindbar)
Dim view As New DataView(table)
view.Sort = "Name ASC, Age DESC"

' Sortieren mit LINQ (gibt neue Collection zurück)
Dim linqSorted = From row In table.AsEnumerable()
                 Order By row.Field(Of String)("Name")
                 Select row

Für DataGridView-Binding verwende DataView. Zum Verarbeiten von Zeilen im Code funktionieren die Select()-Methode und LINQ gleich gut.

Zeilen aktualisieren und löschen

' Feld aktualisieren
table.Rows(0)("Email") = "alice.new@example.com"

' Per Primärschlüssel aktualisieren
Dim target As DataRow = table.Rows.Find(2)
If target IsNot Nothing Then
    target("Age") = 26
End If

' Zeile löschen (markiert sie als gelöscht)
table.Rows(0).Delete()

' Zeile sofort entfernen
table.Rows.Remove(table.Rows(0))

' Alle ausstehenden Änderungen übernehmen
table.AcceptChanges()

Wichtiger Unterschied: Delete() markiert die Zeile mit RowState = Deleted, behält sie aber in der Tabelle, bis AcceptChanges() aufgerufen wird. Remove() löscht die Zeile sofort. Verwende Delete(), wenn du Change Tracking brauchst (z.B. beim Zurückschreiben in die Datenbank mit einem DataAdapter).

DataTable an ein DataGridView binden

Einer der häufigsten Einsatzzwecke einer DataTable ist die Anzeige in einem DataGridView:

' Direkte Bindung
DataGridView1.DataSource = table

' Bindung über DataView (mit Filter + Sortierung)
Dim view As New DataView(table)
view.RowFilter = "Age > 25"
view.Sort = "Name ASC"
DataGridView1.DataSource = view

Das DataGridView generiert die Spalten automatisch aus dem DataTable-Schema. Änderungen im Grid werden automatisch in die DataTable zurückgeschrieben. Für ein schreibgeschütztes Grid setze DataGridView1.ReadOnly = True.

Grid nach Datenänderungen aktualisieren

' Zeile programmatisch hinzufügen
table.Rows.Add(Nothing, "David", "david@example.com", 28)

' Grid aktualisiert sich automatisch bei gebundener DataTable
' Kein manuelles Refresh nötig

' Wenn du die gesamte DataTable austauschst, binde sie neu
DataGridView1.DataSource = Nothing
DataGridView1.DataSource = newTable

Daten aus einer Datenbank laden

DataTable funktioniert mit jedem ADO.NET-Provider. Hier ein Beispiel mit 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 enthält jetzt alle Zeilen der Contacts-Tabelle
DataGridView1.DataSource = table

Die Load()-Methode liest alle Zeilen aus einem DataReader und erstellt die Spalten automatisch anhand des Abfrageergebnisses. Das funktioniert mit SQL Server, MySQL, PostgreSQL und jedem anderen ADO.NET-Provider.

Alternative: DataAdapter verwenden

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

Der DataAdapter-Ansatz ist kürzer und unterstützt auch das Zurückschreiben von Änderungen in die Datenbank mit adapter.Update(table). Für einfacheren, stark typisierten Datenbankzugriff ohne DataTable ist Dapper eine Alternative.

Konvertierung zwischen DataTable und List

Manchmal muss man zwischen einer DataTable und einer typisierten List(Of T) wechseln:

DataTable zu 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

' DataTable-Zeilen in typisierte Liste konvertieren
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) zu 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

Der LINQ-Ansatz mit AsEnumerable() erfordert einen Verweis auf System.Data.DataSetExtensions. Im modernen .NET (5+) ist dieser standardmäßig enthalten.

Häufige Stolperfallen

DBNull ignorieren

DataTable-Felder können DBNull.Value statt Nothing enthalten. Ein direkter Cast wirft dann eine InvalidCastException:

' SCHLECHT - wirft InvalidCastException wenn Email DBNull ist
Dim email As String = CStr(row("Email"))

' GUT - erst auf DBNull prüfen
Dim email As String = If(row.IsNull("Email"), "", CStr(row("Email")))

' OPTIMAL - typisierte Field-Erweiterung verwenden
Dim email As String = row.Field(Of String)("Email")  ' gibt Nothing zurück bei DBNull

Zeilen in einer For-Each-Schleife löschen

Genau wie bei einer List wirft das Ändern einer DataTable während der Iteration eine Exception. Verwende eine rückwärts laufende For-Schleife oder sammle die Zeilen zuerst:

' SCHLECHT - Änderung während Iteration
For Each row As DataRow In table.Rows
    If CInt(row("Age")) < 18 Then
        row.Delete()
    End If
Next

' GUT - rückwärts iterieren
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()

AcceptChanges vergessen

Wenn du Delete() auf eine Zeile aufrufst, wird sie nur als gelöscht markiert. Die Zeile erscheint weiterhin in table.Rows.Count und kann unerwartetes Verhalten verursachen. Rufe AcceptChanges() nach einer Reihe von Löschungen auf, oder verwende Remove() für sofortiges Entfernen.

FAQ

Fazit

Die DataTable ist die richtige Wahl, wenn du schemabasierte, filterbare Tabellendaten mit nativer DataGridView-Bindung brauchst. Verwende Select() für schnelle Abfragen, DataView für live-gefilterte UI-Bindung und Field(Of T) zur sicheren DBNull-Behandlung. Für einfachere Anwendungsfälle mit typisierten Objekten ist eine List(Of T) oft die bessere Wahl. Für Datenbankzugriff ohne DataTable schau dir Dapper an.

Der Beitrag VB.NET DataTable – Erstellen, Füllen, Filtern (2026) erschien zuerst auf Robert Skibbe.

Was ist eine List(Of T) und wann setzt man sie ein?

Eine List(Of T) ist eine generische Collection aus dem System.Collections.Generic-Namespace. Das T steht für den Typ der gespeicherten Objekte: List(Of String) speichert Strings, List(Of Integer) Zahlen, List(Of Customer) eigene Objekte.

Verwende eine List, wenn:

• Du eine geordnete Sammlung brauchst, in der Elemente eine Position (Index) haben
• Die Anzahl der Elemente sich zur Laufzeit ändert (anders als bei Arrays, die eine feste Größe haben)
• Du eingebaute Methoden zum Sortieren, Suchen und Filtern brauchst
• Du Elemente nach Position abrufst, nicht nach einem Schlüssel

Wenn du stattdessen Key-Value-Lookups brauchst (z.B. einen Kunden per ID finden), verwende ein VB.NET Dictionary. Listen durchsuchen jedes Element der Reihe nach, was bei großen Datenmengen langsam wird. Dictionaries finden Einträge in konstanter Zeit.

Eine List erstellen

Die gängigsten Wege, eine List(Of T) zu erstellen:

' Leere Liste
Dim names As New List(Of String)

' Liste mit Startwerten
Dim numbers As New List(Of Integer) From {3, 5, 7, 9}

' Liste mit eigenen Objekten
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"}
}

Das From-Keyword zusammen mit den geschweiften Klammern ist ein Collection Initializer. Im Hintergrund wird für jedes Element Add() aufgerufen.

Initiale Kapazität setzen

Wenn du ungefähr weißt, wie viele Elemente die Liste aufnehmen wird, setze die Kapazität im Voraus. Das vermeidet wiederholtes internes Array-Resizing:

' Platz für ca. 500 Elemente vorbelegen
Dim largeList As New List(Of String)(500)

Das begrenzt die Liste nicht auf 500 Einträge. Es vermeidet nur unnötige Speicher-Allokationen, bis du diese Zahl überschreitest.

Elemente hinzufügen

Add und AddRange

Dim names As New List(Of String)

' Einzelne Elemente hinzufügen
names.Add("Alice")
names.Add("Bob")

' Mehrere Elemente auf einmal
names.AddRange({"Clara", "David", "Eva"})

' Elemente aus einer anderen Liste
Dim moreNames As New List(Of String) From {"Frank", "Grace"}
names.AddRange(moreNames)

An einer bestimmten Position einfügen

' "Zara" an Position 0 einfügen (Anfang)
names.Insert(0, "Zara")

' An Position 2 einfügen
names.Insert(2, "Maria")

Beachte, dass Insert() alle nachfolgenden Elemente verschiebt, was O(n) kostet. Für häufige Einfügungen am Anfang ist eine LinkedList(Of T) besser geeignet.

Auf Elemente zugreifen

Der Zugriff erfolgt über den nullbasierten Index:

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

' Zugriff per Index
Dim first As String = names(0)    ' "Alice"
Dim last As String = names(names.Count - 1)  ' "Clara"

' Mit For Each iterieren
For Each name In names
    Console.WriteLine(name)
Next

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

Ein ungültiger Index wirft eine ArgumentOutOfRangeException. Prüfe immer Count, bevor du einen bestimmten Index verwendest, oder nutze LINQ-Methoden wie FirstOrDefault().

Elemente entfernen

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

' Nach Wert entfernen (erstes Vorkommen)
names.Remove("Bob")   ' gibt True zurück wenn gefunden

' Nach Index entfernen
names.RemoveAt(0)      ' entfernt "Alice"

' Letztes Element entfernen
If names.Count > 0 Then
    names.RemoveAt(names.Count - 1)
End If

' Alle Elemente entfernen, die eine Bedingung erfüllen
names.RemoveAll(Function(n) n.StartsWith("C"))

' Alles leeren
names.Clear()

Remove() durchsucht die Liste von vorne und entfernt den ersten Treffer. Wenn das Element nicht existiert, gibt die Methode False zurück, ohne eine Exception zu werfen. RemoveAt() bei einem ungültigen Index wirft hingegen eine Exception.

Eine Liste sortieren

Einfache Sortierung

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

' Alphabetisch sortieren (in-place)
names.Sort()
' Ergebnis: Alice, Bob, Clara

' Reihenfolge umkehren
names.Reverse()
' Ergebnis: Clara, Bob, Alice

Eigene Sortierreihenfolge

Für eigene Objekte übergibst du einen Vergleichs-Lambda an 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}
}

' Nach Name sortieren
contacts.Sort(Function(a, b) String.Compare(a.Name, b.Name))

' Nach Alter absteigend sortieren
contacts.Sort(Function(a, b) b.Age.CompareTo(a.Age))

Sortieren mit LINQ (nicht-destruktiv)

Sort() verändert die Originalliste. Wenn du eine neue sortierte Liste willst, ohne das Original zu ändern, verwende LINQ:

' Original bleibt unverändert
Dim sorted = contacts.OrderBy(Function(c) c.Name).ToList()
Dim sortedDesc = contacts.OrderByDescending(Function(c) c.Age).ToList()

Suchen und Filtern mit LINQ

LINQ ist der mächtigste Weg, Listen in VB.NET abzufragen. Importiere System.Linq (ist standardmäßig importiert) und du bekommst ein volles Set an Abfragemethoden:

Elemente finden

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}
}

' Ersten Treffer finden (gibt Nothing zurück wenn nicht gefunden)
Dim alice = contacts.FirstOrDefault(Function(c) c.Name = "Alice")

' Prüfen ob irgendein Element passt
Dim hasOlderThan30 As Boolean = contacts.Any(Function(c) c.Age > 30)

' Prüfen ob alle Elemente passen
Dim allAdults As Boolean = contacts.All(Function(c) c.Age >= 18)

Elemente filtern

' Alle Kontakte älter als 25
Dim olderContacts = contacts.Where(Function(c) c.Age > 25).ToList()

' Nur die Namen extrahieren
Dim names = contacts.Select(Function(c) c.Name).ToList()

' Kombiniert: filtern + transformieren
Dim olderNames = contacts _
    .Where(Function(c) c.Age > 25) _
    .Select(Function(c) c.Name) _
    .ToList()

Aggregat-Abfragen

' 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)

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

Listen konvertieren

Listen lassen sich in andere Collection-Typen umwandeln und umgekehrt:

' Liste zu Array
Dim namesArray As String() = names.ToArray()

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

' Liste zu Dictionary (Schlüssel muss eindeutig sein)
Dim contactDict = contacts.ToDictionary(
    Function(c) c.Name,
    Function(c) c)

' String aus Liste (zusammenfügen)
Dim csv As String = String.Join(", ", names)
' Ergebnis: "Alice, Bob, Clara"

Die ToDictionary()-Konvertierung ist besonders nützlich, wenn du später schnelle Lookups per Schlüssel brauchst. Mehr dazu im Dictionary Guide.

List vs. Array vs. Dictionary

Die Wahl der richtigen Collection ist entscheidend für Lesbarkeit und Performance. Hier ein Vergleich der gängigsten Typen:

Einen detaillierten Performance-Vergleich mit echten Benchmarks findest du im C# List Guide. Die Ergebnisse gelten genauso für VB.NET, da beide die gleiche .NET-Runtime verwenden.

Häufige Stolperfallen

Liste während der Iteration ändern

Das ist einer der häufigsten Anfängerfehler. Elemente innerhalb einer For Each-Schleife zu entfernen wirft eine InvalidOperationException:

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

' GUT - RemoveAll verwenden
names.RemoveAll(Function(n) n.StartsWith("A"))

' EBENFALLS GUT - rückwärts mit For iterieren
For i As Integer = names.Count - 1 To 0 Step -1
    If names(i).StartsWith("A") Then
        names.RemoveAt(i)
    End If
Next

Liste für Lookups verwenden

Wenn du häufig Elemente nach einer eindeutigen Eigenschaft suchst (Name, ID, E-Mail), ist eine List die falsche Wahl. Jede Suche iteriert die gesamte Liste. Ein Dictionary findet das Element sofort. Der Unterschied wird bei Tausenden Einträgen massiv, wie in diesem Benchmark-Vergleich gezeigt.

ToList() vergessen

LINQ-Methoden wie Where() und Select() geben lazy IEnumerable-Objekte zurück, keine Listen. Jedes Mal wenn du iterierst, wird die Abfrage erneut ausgeführt. Ruf .ToList() auf, um das Ergebnis zu materialisieren:

' Lazy - führt den Filter zweimal aus!
Dim filtered = names.Where(Function(n) n.Length > 3)
Console.WriteLine(filtered.Count())   ' Filter läuft hier
Console.WriteLine(filtered.Count())   ' Filter läuft nochmal

' Besser - einmal materialisieren
Dim filteredList = names.Where(Function(n) n.Length > 3).ToList()
Console.WriteLine(filteredList.Count)  ' liest nur den Count
Console.WriteLine(filteredList.Count)  ' gleich, keine Neuauswertung

FAQ

Fazit

Die List(Of T) ist die Standard-Collection für geordnete, dynamische Daten in VB.NET. Verwende Add() und Remove() für Grundoperationen, Sort() mit einem Lambda für eigene Sortierung und LINQ für Filtern und Transformieren. Für schlüsselbasierte Lookups wechsle zum Dictionary. Die gleichen Konzepte gelten auch für C# mit leicht anderer Syntax, wie im C# List Guide gezeigt.

Der Beitrag VB.NET List – Erstellen, Sortieren, Filtern (2026) erschien zuerst auf Robert Skibbe.

Was ist Dapper und warum lohnt es sich?

Dapper ist ein leichtgewichtiger „Micro ORM“ für .NET, der ursprünglich vom Stack Overflow-Team entwickelt wurde, um deren eigene Performance-Probleme zu lösen. Er setzt auf IDbConnection auf und erweitert es mit praktischen Methoden wie Query(Of T) und Execute(). Hier ist, warum das relevant ist:

• Kein Boilerplate – kein manuelles SqliteCommand, AddWithValue, ExecuteReader und spaltenweises Mapping mehr
• Stark typisiert – Abfrageergebnisse werden direkt auf deine VB.NET-Klassen gemappt, anhand übereinstimmender Property-Namen
• Schnell – Dapper ist fast so schnell wie reines ADO.NET, deutlich schneller als Entity Framework bei einfachen Abfragen
• Keine Magie – du schreibst echtes SQL, also weißt du immer genau, was an die Datenbank geht
• Funktioniert mit jeder Datenbank – SQLite, SQL Server, PostgreSQL, MySQL, alles was eine IDbConnection hat

Wenn du den VB.NET SQLite Artikel gelesen hast, kennst du bereits die Grundlagen: Datenbank erstellen und Abfragen mit SqliteCommand ausführen. Dapper ersetzt diese manuelle Arbeit, während du die volle Kontrolle über dein SQL behältst.

Dapper per NuGet installieren

Öffne die Package Manager Console in Visual Studio (Tools → NuGet Package Manager → Package Manager Console) und führe aus:

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

Du brauchst beide Pakete: Dapper liefert die Extension Methods, Microsoft.Data.Sqlite die Datenbank-Verbindung. Wenn du Microsoft.Data.Sqlite aus einem früheren Projekt bereits installiert hast, reicht es, nur Dapper hinzuzufügen.

Alternativ: Rechtsklick auf das Projekt im Solution Explorer → NuGet-Pakete verwalten → nach Dapper suchen → Installieren. Dann für Microsoft.Data.Sqlite wiederholen, falls noch nicht vorhanden.

Die Model-Klasse anlegen

Bevor du Abfragen schreibst, definiere eine Klasse, deren Properties den Spaltennamen in deiner Tabelle entsprechen. Dapper mappt Spalten auf Properties anhand des Namens (Groß-/Kleinschreibung egal):

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

Das ist alles, was Dapper braucht. Keine Attribute, keine Basisklassen, keine Konfigurationsdateien. Wenn ein Spaltenname nicht zum Property-Namen passt, verwende einen SQL-Alias: SELECT first_name AS Name.

Verbindung herstellen und Tabellen erstellen

Dapper arbeitet auf Basis von IDbConnection. Die Verbindung erstellst du weiterhin selbst. Verwende AppContext.BaseDirectory für einen zuverlässigen Pfad, wie im Application Path Artikel beschrieben:

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

Beachte, wie connection.Execute() das gesamte SqliteCommand– / ExecuteNonQuery()-Pattern ersetzt. Dapper öffnet die Verbindung automatisch, wenn sie geschlossen ist, aber ich bevorzuge es, sie explizit zu öffnen.

Daten einfügen (INSERT)

Mit rohem ADO.NET würdest du einen Command erstellen, Parameter einzeln hinzufügen und ExecuteNonQuery() aufrufen. Mit Dapper übergibst du ein anonymes Objekt und die Properties werden automatisch auf die Parameter gemappt:

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

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

Dapper erzeugt automatisch parametrisierte Abfragen aus dem anonymen Objekt. Es besteht kein Risiko für SQL Injection, da die Werte nie in den SQL-String konkateniert werden.

Mehrere Zeilen auf einmal einfügen

Übergib eine Liste statt eines einzelnen Objekts und Dapper führt das Statement einmal pro Element aus:

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

Bei großen Datenmengen (Hunderte oder Tausende Zeilen) solltest du das in einer Transaktion kapseln, um die Performance deutlich zu verbessern. Dazu weiter unten mehr.

Daten abfragen (SELECT)

Hier zeigt Dapper seine wahre Stärke. Statt einen DataReader zu durchlaufen und jede Spalte manuell zu mappen, rufst du Query(Of T) auf und bekommst eine typisierte Collection zurück:

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

Das Ergebnis ist ein IEnumerable(Of Contact), das du iterieren, mit LINQ filtern oder direkt an ein DataGridView binden kannst.

Abfragen mit Parametern

Parameter übergibst du wie bei Execute() als anonymes Objekt:

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

Einzelne Zeile abfragen

Verwende QueryFirstOrDefault(Of T), wenn du genau ein Ergebnis erwartest (oder keines):

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

Weitere Varianten: QueryFirst (Exception wenn keine Zeilen), QuerySingle (Exception wenn nicht genau eine Zeile), QuerySingleOrDefault (Exception wenn mehr als eine Zeile).

Skalare Abfragen

Für Abfragen, die einen einzelnen Wert zurückgeben, verwende ExecuteScalar(Of T):

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

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

    Console.WriteLine($"{count} Kontakte in der Datenbank")
End Using

Daten aktualisieren und löschen

Updates und Deletes folgen dem gleichen Muster wie Inserts. Execute() gibt die Anzahl betroffener Zeilen zurück:

UPDATE

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

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

    Console.WriteLine($"{rowsAffected} Zeile(n) aktualisiert.")
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} Zeile(n) gelöscht.")
End Using

Komplettes Beispiel: ContactRepository mit Dapper

Hier ist eine vollständige Repository-Klasse für alle CRUD-Operationen. Vergleiche sie mit der manuellen ADO.NET-Version im SQLite-Artikel, um zu sehen, wie viel Code Dapper einspart:

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

Die Verwendung ist unkompliziert:

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

Dim newId = repo.AddContact("Max Mustermann", "max@example.com", "+49 123 456789")
Console.WriteLine($"Kontakt mit ID {newId} erstellt")

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

Transaktionen mit Dapper

Bei Bulk-Operationen solltest du eine Transaktion verwenden. Ohne Transaktion führt SQLite nach jedem einzelnen Statement einen Commit durch, was bei Hunderten von Inserts extrem langsam wird:

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 = $"Kontakt {i}",
                .Email = $"kontakt{i}@example.com"
            })
        Next

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

        transaction.Commit()
    End Using
End Using

Der entscheidende Unterschied zu rohem ADO.NET: Du übergibst das transaction-Objekt als Parameter an Execute(). Kein manuelles command.Transaction setzen. Und weil Dapper die Liste intern durchläuft, bekommst du Transaktionssicherheit für alle 1000 Inserts mit minimalem Code.

Async-Abfragen: GUI nicht einfrieren

Jede Dapper-Methode hat ein asynchrones Pendant. Wenn du eine WinForms- oder WPF-Anwendung baust, verwende sie, damit die Oberfläche während der Datenbankaufrufe nicht einfriert. Die Grundlagen findest du im 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

Verfügbare Async-Methoden: QueryAsync, QueryFirstOrDefaultAsync, ExecuteAsync, ExecuteScalarAsync. Sie funktionieren genau wie ihre synchronen Gegenstücke, nur mit Await.

Dapper vs. ADO.NET: Direktvergleich

Hier die gleiche „alle Kontakte laden“-Operation auf beide Arten. Zuerst reines ADO.NET, wie im SQLite-Artikel gezeigt:

' Reines ADO.NET - 13 Zeilen
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

Und jetzt das gleiche mit Dapper:

' Dapper - 4 Zeilen
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

Gleiches Ergebnis, gleiches SQL, gleiche Performance. Dapper übernimmt die Reader-Schleife, die Null-Checks und das Property-Mapping automatisch. Je komplexer das Datenmodell, desto größer der Unterschied.

Häufige Stolperfallen und Tipps

Property-Namen müssen zu Spaltennamen passen

Dapper mappt nach Name, Groß-/Kleinschreibung wird ignoriert. Wenn deine Tabelle first_name hat, dein Property aber FirstName heißt, verwende einen SQL-Alias:

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

NULL-Werte

Dapper behandelt NULL-Spalten automatisch. Wenn eine Spalte NULL ist und das Ziel-Property ein String, wird es zu Nothing. Wenn du stattdessen einen leeren String willst, initialisiere deine Properties mit Standardwerten:

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

Using-Blöcke nicht vergessen

Dapper verwaltet keine Verbindungs-Lebenszeiten. Du brauchst weiterhin Using-Blöcke für jede Verbindung, genau wie bei rohem ADO.NET. Eine offene Verbindung sperrt die SQLite-Datei.

Dapper und Dependency Injection

In größeren Anwendungen solltest du den Connection String per Injection übergeben statt ihn hardzucoden. Die ContactRepository-Klasse oben folgt bereits diesem Muster. Wenn du einen DI-Container wie Autofac einsetzt, schau dir den Dependency Injection Guide an.

FAQ

Fazit

Dapper eliminiert das repetitive ADO.NET-Boilerplate, während du die volle Kontrolle über dein SQL behältst. Installiere das NuGet-Paket, definiere eine Model-Klasse und ersetze dein manuelles SqliteCommand– / DataReader-Code durch Query(Of T) und Execute(). Wenn du deine Datenbank noch nicht aufgesetzt hast, starte zuerst mit dem VB.NET SQLite Guide und komm dann hierher zurück, um deine Datenzugriffsschicht zu vereinfachen.

Der Beitrag VB.NET Dapper – Micro ORM für sauberen Datenzugriff (2026) erschien zuerst auf Robert Skibbe.

Warum SQLite für Deine VB.NET-Anwendung?

Es gibt viele Datenbank-Engines, aber SQLite sticht bei lokalen VB.NET-Anwendungen besonders hervor. Die Gründe:

• Kein Setup – kein Serverprozess, keine Installation, keine Admin-Rechte nötig
• Eine einzige Datei – die gesamte Datenbank lebt in einer .db-Datei, die Du mit Deiner App ausliefern kannst
• Plattformübergreifend – läuft auf Windows, Linux und macOS
• Leichtgewichtig – perfekt für Desktop-Apps, Prototypen, Embedded-Systeme und Offline-First-Szenarien
• Zuverlässig – wird von Firefox, Chrome, Android und Millionen anderer Anwendungen eingesetzt

Wenn Du nur Einstellungen oder kleine Datenmengen speichern möchtest, reicht es oft auch, eine Textdatei in VB.NET zu schreiben. Sobald Du aber strukturierte Daten, Abfragen oder Beziehungen brauchst, ist SQLite die bessere Wahl.

Das NuGet-Paket installieren

Es gibt zwei populäre SQLite-Pakete für .NET:

1. Microsoft.Data.Sqlite – Microsofts offizielles, leichtgewichtiges Paket (empfohlen für .NET 5+ / .NET Framework 4.6.1+)
2. System.Data.SQLite – das ältere, umfangreichere Paket vom SQLite-Team (unterstützt auch .NET Framework 4.0)

In diesem Artikel verwende ich Microsoft.Data.Sqlite, da es schlanker ist und der empfohlene Weg für die Zukunft. Die API ist nahezu identisch, ein späterer Wechsel ist also unkompliziert.

Installation per Package Manager Console

Öffne die Package Manager Console in Visual Studio (Tools → NuGet Package Manager → Package Manager Console) und führe aus:

Install-Package Microsoft.Data.Sqlite

Alternativ: Rechtsklick auf das Projekt im Solution Explorer → NuGet-Pakete verwalten → nach Microsoft.Data.Sqlite suchen → Installieren.

Die Imports-Anweisung ergänzen

Am Anfang Deiner Code-Datei fügst Du folgenden Import hinzu:

Imports Microsoft.Data.Sqlite

Datenbank erstellen und verbinden

Ein großer Vorteil von SQLite: Du musst keine Datenbank manuell anlegen. Wenn die Datei noch nicht existiert, erstellt SQLite sie automatisch beim Öffnen der Verbindung.

Der Connection String

Der SQLite Connection String ist minimal. Du brauchst nur den Pfad zur Datenbankdatei:

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

Damit wird die Datei myapp.db im Arbeitsverzeichnis der Anwendung erstellt. Wenn Du die Datenbank neben der EXE-Datei ablegen möchtest, kannst Du den VB.NET Application Path verwenden, um einen zuverlässigen Pfad zu bauen:

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

Verbindung öffnen

Packe Deine Verbindung immer in einen Using-Block. So wird die Verbindung auch bei einer Exception sauber geschlossen und freigegeben:

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

    ' Deine Datenbankoperationen hier...

End Using ' Verbindung wird automatisch geschlossen

Das ist das Grundmuster für jede Datenbankoperation. Der Using-Block ist essenziell, um File-Locks und „database is locked“-Fehler zu vermeiden (dazu später mehr).

Tabellen anlegen

Bevor Du Daten speichern kannst, brauchst Du mindestens eine Tabelle. Verwende CREATE TABLE IF NOT EXISTS, damit der Befehl bei jedem App-Start sicher ausgeführt werden kann, ohne Fehler, falls die Tabelle schon existiert:

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-Datentypen

SQLite verwendet ein dynamisches Typsystem, das sich von SQL Server unterscheidet. Die gängigsten Typen sind:

• INTEGER – Ganzzahlen (entspricht Integer / Long in VB.NET)
• TEXT – Zeichenketten (entspricht String)
• REAL – Gleitkommazahlen (entspricht Double)
• BLOB – Binärdaten (entspricht Byte())
• NULL – kein Wert

Ein Tipp: SQLite hat keinen nativen DATETIME-Typ. Speichere Datumsangaben als TEXT im ISO-8601-Format (z. B. 2026-04-07T14:30:00) oder als INTEGER (Unix-Timestamp).

Daten einfügen (INSERT)

Jetzt fügen wir einen Datensatz in unsere Contacts-Tabelle ein. Verwende immer parametrisierte Abfragen statt String-Verkettung. Das schützt Deine App vor SQL Injection und behandelt Sonderzeichen korrekt:

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", "Max Mustermann")
        command.Parameters.AddWithValue("@email", "max@example.com")
        command.Parameters.AddWithValue("@phone", "+49 123 456789")
        command.ExecuteNonQuery()
    End Using
End Using

Warum parametrisierte Abfragen wichtig sind

Baue SQL-Strings niemals durch direktes Zusammensetzen von Benutzereingaben zusammen. Das ist der häufigste Sicherheitsfehler, der zu SQL Injection führt:

' ❌ NIEMALS so machen - SQL-Injection-Schwachstelle!
command.CommandText = "INSERT INTO Contacts (Name) VALUES ('" & txtName.Text & "')"

' ✅ Immer Parameter verwenden
command.CommandText = "INSERT INTO Contacts (Name) VALUES (@name)"
command.Parameters.AddWithValue("@name", txtName.Text)

Die zuletzt eingefügte ID abfragen

Nach dem Einfügen einer Zeile möchtest Du häufig die automatisch generierte ID wissen. Dafür gibt es last_insert_rowid():

command.CommandText = "INSERT INTO Contacts (Name, Email) VALUES (@name, @email)"
command.Parameters.AddWithValue("@name", "Erika Musterfrau")
command.Parameters.AddWithValue("@email", "erika@example.com")
command.ExecuteNonQuery()

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

Daten lesen (SELECT)

Verwende ExecuteReader(), um Daten abzufragen und über die Ergebnisse zu iterieren. Auch hier: alles in Using-Blöcke verpacken:

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

Filtern mit WHERE

Um nach bestimmten Datensätzen zu suchen, verwende eine parametrisierte WHERE-Klausel:

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()
            ' Ergebnisse verarbeiten...
        End While
    End Using
End Using

Die Ergebnisse lassen sich anschließend beispielsweise in einem VB.NET DataGridView anzeigen. Zum Speichern der Ergebnisse nach Schlüssel ist das VB.NET Dictionary eine passende Datenstruktur.

Daten aktualisieren und löschen

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", "neue-email@example.com")
        command.Parameters.AddWithValue("@id", 1)

        Dim rowsAffected As Integer = command.ExecuteNonQuery()
        Console.WriteLine($"{rowsAffected} Zeile(n) aktualisiert.")
    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} Zeile(n) gelöscht.")
    End Using
End Using

Komplettes Beispiel: Kontaktverwaltung

Jetzt bringen wir alles zusammen. Hier ist eine komplette Helper-Klasse, die alle CRUD-Operationen für eine Contacts-Tabelle kapselt. Du kannst sie als Ausgangspunkt für Deine eigenen Projekte verwenden:

Imports Microsoft.Data.Sqlite

Public Class ContactRepository

    Private ReadOnly _connectionString As String

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

    ''' Stellt sicher, dass die Contacts-Tabelle existiert.
    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

    ''' Fügt einen neuen Kontakt hinzu und gibt die generierte Id zurück.
    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

    ''' Gibt alle Kontakte als Liste von Dictionaries zurück.
    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

    ''' Aktualisiert einen Kontakt anhand der 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

    ''' Löscht einen Kontakt anhand der 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

Das ContactRepository verwenden

So verwendest Du die Klasse, zum Beispiel im Form_Load-Event einer WinForms-Anwendung:

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

' Tabelle anlegen (kann bei jedem Start aufgerufen werden)
repo.InitializeDatabase()

' Kontakt hinzufügen
Dim newId As Long = repo.AddContact("Robert Skibbe", "mail@robbelroot.de", "+49 123 456")
Console.WriteLine($"Kontakt mit ID {newId} angelegt")

' Alle Kontakte auslesen
For Each contact In repo.GetAllContacts()
    Console.WriteLine($"[{contact("Id")}] {contact("Name")} - {contact("Email")}")
Next

' Kontakt aktualisieren
repo.UpdateContact(newId, "Robert S.", "neu@robbelroot.de", "+49 999 999")

' Kontakt löschen
repo.DeleteContact(newId)

Transaktionen verwenden

Wenn Du mehrere Zeilen auf einmal einfügen oder aktualisieren musst, packe sie in eine Transaktion. Das ist sowohl schneller als auch sicherer: entweder gelingen alle Operationen oder keine.

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", $"Kontakt {i}")
                command.Parameters.AddWithValue("@email", $"kontakt{i}@example.com")
                command.ExecuteNonQuery()
            Next
        End Using

        transaction.Commit()
    End Using
End Using

Ohne Transaktion kann das Einfügen von 1.000 Zeilen mehrere Sekunden dauern, da SQLite nach jedem einzelnen INSERT committet. Mit Transaktion ist die gleiche Operation in Millisekunden erledigt.

Async/Await: GUI nicht einfrieren

Läuft eine Datenbankabfrage auf dem UI-Thread, friert die gesamte Benutzeroberfläche so lange ein. Mit Async/Await verlagerst Du die Arbeit in den Hintergrund, während die GUI weiter reagiert. Alles zum Thema findest Du im Beitrag zur asynchronen Programmierung 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

Das Muster gilt für alle Operationen: OpenAsync() statt Open(), ExecuteNonQueryAsync() statt ExecuteNonQuery(), ReadAsync() statt Read(). Die aufrufende Methode muss dafür als Async Function deklariert sein.

Häufige Stolperfallen und Lösungen

„Database is locked“

Das ist der häufigste SQLite-Fehler. Er tritt auf, wenn mehrere Threads oder Verbindungen gleichzeitig in die Datenbank schreiben wollen. So vermeidest Du ihn:

• Verbindungen immer freigeben – verwende Using-Blöcke konsequent. Eine vergessene offene Verbindung sperrt die Datei.
• WAL-Modus aktivieren – Write-Ahead Logging erlaubt gleichzeitiges Lesen und einen schreibenden Zugriff:

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

• Busy-Timeout setzen – statt sofort zu scheitern, lässt Du SQLite ein paar Sekunden lang erneut versuchen:

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

• Transaktionen nutzen bei Bulk-Operationen, statt Verbindungen in einer engen Schleife zu öffnen und zu schließen.
• Lange Lesezugriffe vermeiden während geschrieben wird. Für komplexere Hintergrundarbeit bietet sich asynchrone Programmierung in VB.NET an.

Dateipfad-Probleme

Ein relativer Pfad wie Data Source=myapp.db wird relativ zum aktuellen Arbeitsverzeichnis aufgelöst, das sich je nach Startart unterscheiden kann (Doppelklick vs. Kommandozeile). Verwende einen absoluten Pfad auf Basis von AppContext.BaseDirectory, wie im Application-Path-Artikel gezeigt.

NULL-Behandlung

Prüfe beim Lesen von nullable Spalten immer mit reader.IsDBNull(), bevor Du GetString() oder GetInt64() aufrufst. Sonst bekommst Du zur Laufzeit eine InvalidCastException. Beim Einfügen von NULL-Werten übergibst Du DBNull.Value statt Nothing.

FAQ

Fazit

SQLite ist der schnellste Weg, eine lokale Datenbank in Deine VB.NET-Anwendung einzubauen. Installiere Microsoft.Data.Sqlite per NuGet, verwende Using-Blöcke für jede Verbindung und schreibe ausschließlich parametrisierte Abfragen. Für Multi-Thread-Szenarien aktiviere den WAL-Modus und setze einen Busy-Timeout, um „database is locked“-Fehler zu vermeiden.

Downloads

Der Beitrag VB.NET SQLite Datenbank – Verbinden, Lesen, Schreiben (2026) erschien zuerst auf Robert Skibbe.

Wie formatiert man einen String in C#?

Es gibt viele Situationen, in denen du sauber formatierte Strings brauchst. Stell dir eine Rechnung vor, bei der der Betrag einfach „14“ lautet. Zunächst könnte man fragen: „Vierzehn wovon?“ Und in der Regel möchte man zwei Dezimalstellen sehen. Aber auch das Anzeigen einer Personenliste in einer WPF ListView berührt das Thema String-Formatierung.

Die verschiedenen Ansätze zur String-Formatierung

Wenn es um das Formatieren von Strings in C# geht, gibt es 3 Hauptansätze:

• Strings manuell verketten
• eine Funktion der String-Klasse verwenden
• die neuere String-Interpolation nutzen

Verkettung (Concatenation) bedeutet, mehrere Strings zu einem zusammenzufügen. Das einfachste Beispiel dafür folgt im nächsten Abschnitt: zwei Namensteile zu einem vollständigen Namen zusammensetzen.

Einen String durch manuelle Verkettung formatieren

Schauen wir uns die erste Methode zur String-Formatierung an: die einfache Verkettung. Wie bereits erklärt, entsteht dabei ein komplett neuer String aus mehreren Einzelteilen. Du bist dabei nicht auf eine bestimmte Anzahl von Strings beschränkt.

Betrachten wir nun das erste kleine Beispiel: einen vollständigen Namen aus Namensteilen zusammensetzen. Dazu erstellen wir im ersten Schritt zwei Variablen und kombinieren sie dann.

string firstName = "John";
string lastName = "Doe";

Nach dem Erstellen der Variablen können wir sie zu einem neuen String verketten. Beachte dabei, dass C#-Strings unveränderlich (immutable) sind und die gängigen Operatoren und Funktionen immer einen neuen String erzeugen.

string fullName = firstName + " " + lastName;

Das war die einfachste Art, einen String zu formatieren. Aber was, wenn es etwas komplexer sein muss? Was, wenn der Nutzer sein eigenes Format festlegen können soll?

Einen String in C# „auf die alte Art“ formatieren

Das Beispiel von oben war recht simpel und bietet dem Nutzer keine Anpassungsmöglichkeit. Wenn jemand dein Programm nutzt und die Reihenfolge ändern möchte, müsste er Vor- und Nachname selbst tauschen. Klar, manchmal ist das nicht nötig, aber gut zu wissen!

Schauen wir uns nun eine Hilfsfunktion der String-Klasse des .NET Frameworks an, die einfach „Format“ heißt. Wir verwenden diese Funktion, um den gleichen vollständigen Namen wie oben zu erzeugen.

Dazu schauen wir uns zunächst die Funktionsparameter an. Es gibt verschiedene Überladungen, aber wir konzentrieren uns auf die mit einem String als erstem Parameter und einem Object-Array als zweitem. Der erste Parameter erwartet eine Art Formatierungs-„Formel“. Der zweite erwartet die Objekte, die an den entsprechenden Stellen eingesetzt werden. Das geschieht über geschweifte Klammern mit dem jeweiligen Index des Objekts.

Einen String dynamisch formatieren

Wir können beliebige Objekte (aktuell zwei Strings) kommagetrennt übergeben. Im nächsten Beispiel übergebe ich die beiden Namensteile. Die Variable firstName hat dann den Index 0, lastName den Index 1.

string firstName = "John";
string lastName= "Doe";
string fullName = string.Format("{0} {1}", firstName, lastName);

Jetzt könnte der Nutzer bei Bedarf ein eigenes Format eingeben. Im folgenden Beispiel habe ich die Reihenfolge der Namen getauscht. Das erzeugt einen neuen String mit dem Inhalt „Doe John“ statt „John Doe“.

// z.B. aus einer TextBox übernommen
string userWantedFormat = "{1} {0}";
string firstName = "John";
string lastName= "Doe";
string fullName = string.Format(format, firstName, lastName);

Du könntest die übergebenen Werte natürlich auch dynamisch über eine Liste steuern und Einträge hinzufügen oder weglassen. Die Funktion akzeptiert auch eine Liste beliebiger Objekte als Parameter.

C# String Format mit Interpolation

Ich bevorzuge den modernen Ansatz namens „String-Interpolation“. Damit kannst du die gewünschten Werte direkt an der richtigen Stelle im String platzieren. Bauen wir das obige Beispiel damit nach.

Neben der direkten Positionierung ist es auch viel einfacher zu erkennen, was wo steht. Im vorherigen Beispiel konnten wir nur sagen: „Setze den String mit Index 0 hierhin“, aber was passiert, wenn sich der Index ändert? Weißt du dann noch, welche Position korrekt ist?

Hier das Beispiel von oben, jetzt mit String-Interpolation. Dafür setzen wir ein Dollarzeichen vor den String und geben die Variablennamen in geschweiften Klammern an. Meiner Meinung nach ist das deutlich einfacher und übersichtlicher als alle bisherigen Varianten.

So können wir auch die lästigen Anführungszeichen und „+“-Zeichen vergessen. Weniger Code, bessere Lesbarkeit.

string firstName = "John";
string lastName = "Doe";
string fullName = $"{firstName} {lastName}";

Zahlen und Währungen formatieren

Nachdem wir bisher nur mit dem einfachen Namensbeispiel gearbeitet haben, gehen wir jetzt einen Schritt weiter. Strings zu Strings formatieren ist nicht schwer, aber schauen wir uns an, wie es mit komplexeren Typen aussieht. Der erste etwas komplexere (aber trotzdem einfache) Typ ist eine gewöhnliche Zahl, wie die Rechnungssumme vom Anfang dieses Beitrags (die 14).

In der Regel zeigt man den Gesamtbetrag einer Rechnung mit zwei Dezimalstellen an. Neben den Dezimalstellen verwendet man z. B. auch das Euro-Zeichen. Versuchen wir die einfache Darstellung der Zahl 14 aus dem Bild oben.

Dafür können wir eine der bereits gezeigten Methoden verwenden:

• manuelle Formatierung
• die Format-Methode der String-Klasse
• String-Interpolation

Formatieren mit der „ToString“-Basisfunktion

Zunächst ein Beispiel mit der „manuellen“ Variante über die typische „ToString“-Funktion, die von der Basisklasse Object geerbt wird. Wir verwenden die Überladung, bei der man ein Format als String angeben kann. Das Format „N2“ steht für: Zahl mit zwei Dezimalstellen.

decimal totalNet = 14.95M;
string displayValue = totalNet.ToString("N2");
// Ergebnis: "14.95" bei en-US Systemeinstellung

Mit string.Format oder Interpolation

Das gleiche Ergebnis lässt sich auch mit den anderen beiden Techniken erreichen. Hier beide Varianten:

decimal totalNet = 14.95M;
// mit string.Format
string displayValue = string.Format(totalNet, "{0:N2}");
// mit String-Interpolation
string displayValue = $"{totalNet:N2}";

Eine bestimmte Kultur / Sprache / Locale angeben

Wie im Kommentar zu sehen, erhältst du einen Wert wie „14.95“. Beachte, dass das Ergebnis von der Spracheinstellung abhängt. Du kannst über den Parameter „FormatProvider“ auch z. B. die deutsche Spracheinstellung vorgeben.

// Import nicht vergessen!
// using System.Globalization;
// entweder so
CultureInfo deDeCulture = new CultureInfo("de-DE");
// oder so
CultureInfo enUsCulture = new CultureInfo("en-US");
decimal totalNet = 14.95M;
// als zweiten Parameter übergeben
string displayValue = totalNet.ToString("N2", deDeCulture);
// Ergebnis: en-US = 14.95, de-DE = 14,95

Um String-Interpolation mit einer Kultur zu verwenden, kannst du einen „FormattableString“ erstellen und diesen statt eines normalen Strings verwenden.

decimal totalNet = 14.95M;
// erzeugt automatisch einen FormattableString!
FormattableString displayValue = $"Der Gesamtpreis beträgt {totalNet:N2}.";
CultureInfo enUsCulture = new CultureInfo("en-US");
string message = displayValue.ToString(enUsCulture);
// en-US = 14.95, de-DE = 14,95

Die Kultur global setzen, nicht pro Aufruf

Im nächsten Schritt kannst du es noch einfacher machen, je nach Anwendungsfall, indem du die „CultureInfo“ global setzt. Damit überschreibst du die systemspezifische Standardeinstellung:

// Import nicht vergessen
// using System.Threading;
CultureInfo deDeCulture = new CultureInfo("de-DE");
CultureInfo enUsCulture = new CultureInfo("en-US");
// System-Standard überschreiben
Thread.CurrentThread.CurrentCulture = enUsCulture;

Alle nachfolgenden Aufrufe von Formatierungsfunktionen wie „ToString“ verwenden nun „enUsCulture“ als Standard (anstelle der Systemvorgabe).

Währungsformatierte Strings ausgeben

Nach der normalen Zahlenformatierung können wir nun eine einfache währungsbezogene Zahl anzeigen. Das funktioniert fast identisch, nur mit einem anderen Buchstaben. Statt „N2“ (Zahl mit 2 Dezimalstellen) verwende ich „C2“ (Währung mit 2 Dezimalstellen).

// siehe auch die vorherigen Beispiele mit string.Format und manueller Variante
FormattableString displayValue = $"Der Gesamtpreis beträgt {totalNet:C2}.";
CultureInfo enUsCulture = new CultureInfo("en-US");
string message = displayValue.ToString(enUsCulture);

DateTimes oder komplexere Objekte formatieren

Im nächsten Abschnitt schauen wir uns das Formatieren von komplexeren Objekten an. Zum Beispiel die DateTime-Klasse und eventuell auch eigene Klassen.

Was, wenn du einen Kunden hast, der entweder Privat- oder Geschäftskunde sein kann, und du per C# String Format dessen Anzeige steuern willst? Zeigst du den Firmennamen oder Vor- und Nachname an?

DateTimes formatieren

Beginnen wir mit ein paar Beispielen zur Formatierung einer C# DateTime-Instanz. Ich bleibe bei der String-Interpolation, du kannst aber auch die anderen Techniken von oben verwenden. Nach einem einfachen Datumsstring geht es weiter mit Monats- und Zeitformaten.

// aktuelles Datum und Uhrzeit als Beispiel
DateTime now = DateTime.Now;
// typisch deutsches Datum - z.B. 30.03.2023
string displayValue = $"{now:dd.MM.yyyy}";
// typisch englisches Datum - Backslashes beachten, alternativ
// die doppelten Backslashes weglassen und den @-Prefix nutzen: @$
string displayValue = $"{now:MM\\dd\\yyyy}";
// mit Uhrzeit arbeiten
string displayTimeValue = @$"{now:HH:mm}";

Eigene Objekte wie eine Kunden-Klasse formatieren

In diesem letzten Abschnitt schauen wir uns das Formatieren einer eigenen Kunden-Klasse an. Die Klasse ist bewusst einfach gehalten mit nur wenigen Properties. Wir erstellen zwei „Typen“ von Kunden: Geschäftskunden und Privatkunden. Der Geschäftskunde hat nur seinen Firmennamen, der Privatkunde Vor- und Nachnamen.

public class Customer
{

  public string Company { get; set; }

  public string FirstName { get; set; }

  public string LastName { get; set; }

  public Customer(string company)
  {
    Company = company;
  }

  public Customer(string firstName, string lastName)
  {
    FirstName = firstName;
    LastName = lastName;
  }

}

Dann können wir einen Privat- und einen Geschäftskunden so erstellen:

Customer privateCustomer = new Customer("John", "Doe");
Customer businessCustomer = new Customer("Doe Max Profit ltd.");

Wenn du sie jetzt so formatierst, erhältst du etwas wie „Customer: ProjektName.ClassName“. So sehen Objekte ohne Überschreibung der „ToString“-Funktion aus.

// enthält z.B. Customer: ProjektName.Customer
string text = $"Customer: {privateCustomer}";

Wir müssen also nur die „ToString“-Funktion überschreiben. In diesem Beispiel priorisiere ich den Firmennamen. Ist keiner vorhanden, gebe ich den vollständigen Namen zurück. Wenn du über mehrere Kunden iterieren musst, schau dir C# ForEach an.

public class Customer
{

  // ...
  // restlicher Code von oben
  // ...

  public override ToString()
  {
    if (string.IsNullOrEmpty(Company)) {
      return Company;
    }
    return $"{FirstName} {LastName}";
  }
}

Schau dir nun die Ergebnisse der folgenden Codezeilen an:

Customer privateCustomer = new Customer("John", "Doe");
Customer businessCustomer = new Customer("Doe Max Profit ltd.");
// enthält Customer: John Doe
string text = $"Customer: {privateCustomer}";
// enthält Customer: Doe Max Profit ltd.
string text = $"Customer: {businessCustomer}";

Wie in den Kommentaren zu sehen, erhalten wir nun unterschiedliche und besser lesbare Ergebnisse.

FAQ

Fazit

C# bietet drei Wege zur String-Formatierung: manuelle Verkettung, String.Format und String-Interpolation. Für neuen Code empfehle ich Interpolation, da sie am lesbarsten ist. Verwende CultureInfo, wenn deine Anwendung mehrere Sprachen unterstützen muss. Für ein weiteres praktisches C#-Beispiel schau dir C# LINQ Sum an.

Der Beitrag C# String Format – Interpolation, Zahlen, Datum (2026) erschien zuerst auf Robert Skibbe.