The short answer

VB.NET is not dead in the sense that it stops working. Your existing code compiles and runs on .NET 8, .NET 9 and beyond. But it is effectively in maintenance mode: no new language features, no new frameworks like Blazor or MAUI, and a shrinking developer community. If you have a running VB.NET project, it will keep running. If you are starting something new, choose C#.

Microsoft’s official stance

In 2020, Microsoft officially announced that VB.NET will no longer receive new language features. The language will continue to be supported in .NET (including .NET 8 and .NET 9), but only for bug fixes and compatibility. New frameworks and APIs are C#-only:

• Blazor: C# only
• .NET MAUI: C# only
• Minimal APIs: C# only
• Source generators: C# only
• WinForms / WPF: Still supported in VB.NET
• Console apps: Still supported in VB.NET

This means VB.NET is not „dead“ today, but it is on a clear path toward irrelevance for new projects. Microsoft maintains it so existing codebases keep working, not because they see a future in it.

Usage data: Google Trends and real-world numbers

Google Trends paints a clear picture. Comparing „Visual Basic .NET“, „VB.NET“, and „C#“ over the past 12 months worldwide, VB.NET barely registers. The interest has been declining steadily for years.

But Google Trends is not the full story. As a freelance .NET developer, I still receive regular VB.NET project requests. Looking at my incoming programming jobs by language over the past years, VB.NET accounts for a significant share of .NET-related work:

The requests are surprisingly balanced between VB.NET and C# in my niche. This does not mean VB.NET is thriving globally, but it shows that real demand still exists, especially for maintaining and extending legacy applications.

Who still uses VB.NET

After 17+ years in this field, working with YouTube subscribers, website visitors, and customers, I can give a fairly clear picture of who still writes VB.NET code:

• Hobbyists and self-taught developers: People who learned VB.NET years ago and build small tools for personal use or to automate their day jobs
• Companies with legacy codebases: Businesses running WinForms or WPF applications built 10-15 years ago that still work and generate revenue
• Automation and measurement projects: VB.NET is common in industrial automation, data logging, and measurement tools
• Excel/Office integration: VBA developers who stepped up to VB.NET for more complex tooling

Honestly, most VB.NET developers I encounter are 50+ years old and many operate at a hobbyist skill level. Clean code, unit testing, and SOLID principles are the exception, not the rule. This is not VB.NET’s fault as a language. It is capable of clean, professional code. But the community that remains tends to prioritize „it works“ over maintainability. If you want to write better code regardless of language, check out my Clean Code guide.

What VB.NET is still good for

Despite its declining trajectory, VB.NET has legitimate use cases:

• Learning programming: The English-like syntax makes it one of the most approachable languages for beginners. If x > 5 Then reads like a sentence. For someone who has never written code, this lowers the barrier significantly.
• Maintaining existing applications: If you have a running WinForms app with 100k lines of VB.NET, rewriting it in C# just for the sake of it makes no business sense. Maintain it, extend it, and migrate incrementally if needed.
• Small internal tools: Quick automation tools, data converters, or reporting utilities where the developer already knows VB.NET.
• Prototyping: VB.NET’s WinForms designer is still one of the fastest ways to throw together a UI for testing an idea.

VB.NET is perfectly capable of professional work. For example, see how to properly use a VB.NET Dictionary or how to write text files in VB.NET.

Why you should learn C# instead

If you are starting fresh or considering your next step, the answer is C#. Not because VB.NET is bad, but because the ecosystem has moved on:

• Every new .NET feature targets C# first (and often only)
• Job market: C# job listings outnumber VB.NET listings by a factor of 20+
• Community and resources: Stack Overflow answers, tutorials, NuGet packages, and blog posts overwhelmingly target C#
• Cross-platform: .NET MAUI, Blazor, ASP.NET Minimal APIs are all C#-only
• Career growth: Knowing C# opens doors to web, mobile, cloud, and game development (Unity)

The good news: if you know VB.NET, learning C# is not that hard. The .NET framework is the same. The syntax is different, but the concepts (classes, events, LINQ, async/await) transfer directly. Many of the patterns you already know from VB.NET work identically. For example, event handling with AddHandler in VB.NET maps directly to C#’s += operator.

My personal take

I started programming with VB.NET when I was around 13 years old. I had tried C and C++ before and quit out of frustration. VB.NET’s approachable syntax got me through the door, and I never left the world of software development. Today I work primarily in C#, but VB.NET is still part of my regular toolkit.

I also think VB.NET gets unfair treatment. The language itself is not the problem. It supports clean code, SOLID principles, and proper architecture. The problem is that it attracts beginners who never progress beyond „it works“ code. That gives the language a bad reputation it does not fully deserve.

If someone asks me „Should I start with VB.NET or C#?“, my answer is always C#. But if someone asks „Is VB.NET dead?“, my honest answer is: it is slowly fading out, but it is not dead yet. And if learning VB.NET is what gets you into programming, then it served its purpose.

FAQ

Wrapping up

Visual Basic .NET is not dead, but it is fading. Microsoft maintains it for compatibility, not for innovation. The community is shrinking, new frameworks skip it entirely, and the job market overwhelmingly favors C#. If you have existing VB.NET code, keep maintaining it. If you are starting fresh, go with C#. And if VB.NET is what got you into programming, be thankful for it and move forward. For hands-on VB.NET content, see the VB.NET Timer guide or the VB.NET List guide.

Der Beitrag Is Visual Basic Dead? The Real State of VB.NET (2026) erschien zuerst auf Robert Skibbe.

Die kurze Antwort

VB.NET ist nicht tot in dem Sinne, dass es aufhört zu funktionieren. Dein vorhandener Code kompiliert und läuft auf .NET 8, .NET 9 und darüber hinaus. Aber es befindet sich effektiv im Wartungsmodus: keine neuen Sprachfeatures, keine neuen Frameworks wie Blazor oder MAUI und eine schrumpfende Entwickler-Community. Wenn du ein laufendes VB.NET-Projekt hast, wird es weiter laufen. Wenn du etwas Neues startest, wähle C#.

Microsofts offizielle Position

2020 hat Microsoft offiziell angekündigt, dass VB.NET keine neuen Sprachfeatures mehr erhalten wird. Die Sprache wird weiterhin in .NET unterstützt (einschließlich .NET 8 und .NET 9), aber nur für Bugfixes und Kompatibilität. Neue Frameworks und APIs sind C#-exklusiv:

• Blazor: nur C#
• .NET MAUI: nur C#
• Minimal APIs: nur C#
• Source Generators: nur C#
• WinForms / WPF: weiterhin mit VB.NET nutzbar
• Konsolen-Apps: weiterhin mit VB.NET nutzbar

Das bedeutet: VB.NET ist heute nicht „tot“, aber es befindet sich auf einem klaren Weg in die Bedeutungslosigkeit für neue Projekte. Microsoft pflegt es, damit bestehende Codebasen weiter funktionieren, nicht weil sie eine Zukunft darin sehen.

Nutzungsdaten: Google Trends und echte Zahlen

Google Trends zeigt ein deutliches Bild. Vergleicht man „Visual Basic .NET“, „VB.NET“ und „C#“ über die letzten 12 Monate weltweit, registriert VB.NET kaum noch. Das Interesse sinkt seit Jahren stetig.

Aber Google Trends ist nicht die ganze Geschichte. Als freiberuflicher .NET-Entwickler erhalte ich weiterhin regelmäßig VB.NET-Projektanfragen. Betrachtet man meine eingehenden Programmieraufträge nach Sprache über die letzten Jahre, macht VB.NET einen signifikanten Anteil der .NET-bezogenen Arbeit aus:

Die Anfragen sind in meiner Nische überraschend ausgewogen zwischen VB.NET und C#. Das bedeutet nicht, dass VB.NET global floriert, aber es zeigt, dass echte Nachfrage noch existiert, besonders für die Wartung und Erweiterung von Legacy-Anwendungen.

Wer nutzt VB.NET noch

Nach über 17 Jahren in diesem Bereich, im Austausch mit YouTube-Zuschauern, Website-Besuchern und Kunden, kann ich ein recht klares Bild zeichnen, wer noch VB.NET-Code schreibt:

• Hobby-Entwickler und Autodidakten: Menschen, die VB.NET vor Jahren gelernt haben und kleine Tools für den persönlichen Gebrauch bauen oder ihren Arbeitsalltag automatisieren
• Unternehmen mit Legacy-Codebasen: Firmen, die WinForms- oder WPF-Anwendungen betreiben, die vor 10-15 Jahren gebaut wurden und immer noch funktionieren und Umsatz generieren
• Automatisierungs- und Messprojekte: VB.NET ist verbreitet bei industrieller Automatisierung, Datenerfassung und Messwerkzeugen
• Excel/Office-Integration: VBA-Entwickler, die für komplexere Tooling-Aufgaben zu VB.NET gewechselt sind

Ehrlich gesagt: Die meisten VB.NET-Entwickler, denen ich begegne, sind über 50 und viele arbeiten auf Hobby-Niveau. Clean Code, Unit Tests und SOLID-Prinzipien sind die Ausnahme, nicht die Regel. Das ist aber nicht VB.NETs Schuld als Sprache. Es ist zu sauberem, professionellem Code fähig. Aber die verbleibende Community priorisiert tendenziell „es funktioniert“ über Wartbarkeit. Wenn du unabhängig von der Sprache besseren Code schreiben willst, sieh dir meinen Clean Code Guide an.

Wofür VB.NET noch gut ist

Trotz des abnehmenden Trends hat VB.NET legitime Einsatzbereiche:

• Programmieren lernen: Die englisch-ähnliche Syntax macht es zu einer der zugänglichsten Sprachen für Einsteiger. If x > 5 Then liest sich wie ein Satz. Für jemanden, der noch nie Code geschrieben hat, senkt das die Einstiegshürde erheblich.
• Bestehende Anwendungen warten: Wenn du eine laufende WinForms-App mit 100.000 Zeilen VB.NET hast, macht ein Rewrite in C# nur um des Rewrite willen keinen geschäftlichen Sinn. Pflege sie, erweitere sie und migriere inkrementell, wenn nötig.
• Kleine interne Tools: Schnelle Automatisierungs-Tools, Datenkonverter oder Reporting-Werkzeuge, bei denen der Entwickler bereits VB.NET kennt.
• Prototyping: VB.NETs WinForms-Designer ist immer noch eine der schnellsten Möglichkeiten, eine UI zum Testen einer Idee zusammenzubauen.

VB.NET ist durchaus in der Lage für professionelle Arbeit. Siehe zum Beispiel wie man ein VB.NET Dapper Setup nutzt oder wie man Textdateien in VB.NET schreibt.

Warum du lieber C# lernen solltest

Wenn du frisch anfängst oder deinen nächsten Schritt planst, ist die Antwort C#. Nicht weil VB.NET schlecht ist, sondern weil das Ökosystem weitergezogen ist:

• Jedes neue .NET-Feature zielt zuerst auf C# ab (und oft ausschließlich)
• Arbeitsmarkt: C#-Stellenangebote übertreffen VB.NET um den Faktor 20+
• Community und Ressourcen: Stack-Overflow-Antworten, Tutorials, NuGet-Pakete und Blogposts zielen überwiegend auf C#
• Cross-Platform: .NET MAUI, Blazor, ASP.NET Minimal APIs sind alle C#-exklusiv
• Karrierewachstum: C#-Kenntnisse öffnen Türen zu Web, Mobile, Cloud und Game Development (Unity)

Die gute Nachricht: Wenn du VB.NET kannst, ist C# lernen nicht so schwer. Das .NET Framework ist dasselbe. Die Syntax ist anders, aber die Konzepte (Klassen, Events, LINQ, Async/Await) übertragen sich direkt. Viele Muster die du bereits aus VB.NET kennst funktionieren identisch. Zum Beispiel lässt sich Event-Handling mit AddHandler in VB.NET direkt auf C#’s +=-Operator übertragen.

Meine persönliche Einschätzung

Ich habe mit etwa 13 Jahren angefangen, mit VB.NET zu programmieren. Vorher hatte ich C und C++ ausprobiert und aus Frustration aufgegeben. VB.NETs zugängliche Syntax hat mir den Einstieg ermöglicht und ich habe die Welt der Softwareentwicklung nie wieder verlassen. Heute arbeite ich hauptsächlich in C#, aber VB.NET ist immer noch Teil meines regelmäßigen Werkzeugkastens.

Ich finde auch, dass VB.NET unfair behandelt wird. Die Sprache selbst ist nicht das Problem. Sie unterstützt Clean Code, SOLID-Prinzipien und saubere Architektur. Das Problem ist, dass sie Einsteiger anzieht, die nie über „es funktioniert“-Code hinauskommen. Das gibt der Sprache einen schlechten Ruf, den sie nicht vollständig verdient.

Wenn mich jemand fragt „Soll ich mit VB.NET oder C# anfangen?“, ist meine Antwort immer C#. Aber wenn jemand fragt „Ist VB.NET tot?“, ist meine ehrliche Antwort: Es schwindet langsam, aber es ist noch nicht tot. Und wenn VB.NET lernen der Weg ist, der dich zum Programmieren bringt, dann hat es seinen Zweck erfüllt.

FAQ

Fazit

Visual Basic .NET ist nicht tot, aber es schwindet. Microsoft pflegt es für Kompatibilität, nicht für Innovation. Die Community schrumpft, neue Frameworks überspringen es komplett und der Arbeitsmarkt favorisiert C# überwältigend. Wenn du bestehenden VB.NET-Code hast, pflege ihn weiter. Wenn du neu anfängst, nimm C#. Und wenn VB.NET dich zum Programmieren gebracht hat, sei dankbar dafür und geh weiter. Für praktische VB.NET-Inhalte, siehe den VB.NET Timer Guide oder den VB.NET List Guide.

Der Beitrag Ist Visual Basic tot? Der echte Stand von VB.NET (2026) erschien zuerst auf Robert Skibbe.

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.

What you need

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

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

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

How the WhatsApp Cloud API works

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

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

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

Sending a text message

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

Imports System.Net.Http
Imports System.Text

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

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

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

Call it from a button click or any event handler:

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

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

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

Sending a template message

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

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

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

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

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

Template message with variables

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

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

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

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

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

Reading the API response

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

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

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

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

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

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

Sending to multiple recipients

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

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

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

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

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

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

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

Storing credentials safely

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

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

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

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

Using Twilio as an alternative

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

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

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

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

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

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

Common mistakes

Sending free-form text outside the 24-hour window

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

Wrong phone number format

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

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

Hardcoding the access token

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

FAQ

Wrapping up

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

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

MsgBox vs. MessageBox.Show

VB.NET 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.

MsgBox vs. MessageBox.Show

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

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

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

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

MsgBox syntax

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

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

Simple message

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

MsgBox("The file has been saved.")

With a title and information icon:

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

Yes/No confirmation

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

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

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

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

Yes/No/Cancel

For unsaved changes, offer three options:

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

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

All button styles

All icon styles

Setting the default button

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

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

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

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

The same examples with MessageBox.Show

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

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

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

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

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

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

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

When to use which

Use MsgBox when:

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

Use MessageBox.Show when:

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

Complete example: save-before-close pattern

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

Private _hasChanges As Boolean = False

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

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

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

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

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

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

Common mistakes

Ignoring the return value

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

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

Confusing MsgBox with VBScript MsgBox

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

Using MsgBox in a background thread

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

FAQ

Wrapping up

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

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

Handles vs. AddHandler

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

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

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

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

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

AddHandler syntax

AddHandler Object.Event, AddressOf MethodName

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

Basic example

A button click using AddHandler instead of Handles:

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

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

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

Creating dynamic controls

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

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

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

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

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

Complete example: numpad keyboard

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

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

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

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

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

RemoveHandler: disconnecting events

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

' Assign handler
AddHandler btn.Click, AddressOf Button_Click

' Remove handler
RemoveHandler btn.Click, AddressOf Button_Click

Use RemoveHandler whenever you:

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

Multiple events, one handler

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

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

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

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

Custom events with AddHandler

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

Public Class FileWatcher
    Public Event FileChanged(filePath As String)

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

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

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

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

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

Common mistakes

Handler registered multiple times

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

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

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

Wrong method signature

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

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

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

Forgetting RemoveHandler for dynamic controls

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

FAQ

Wrapping up

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

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

What is the FolderBrowserDialog?

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

Use it when:

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

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

Basic example

The simplest FolderBrowserDialog that displays the selected path:

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

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

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

Setting the root folder

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

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

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

Common values for RootFolder:

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

Pre-selecting a folder

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

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

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

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

Hiding the New Folder button

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

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

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

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

Complete example: batch-processing files

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

Imports System.IO
Imports System.Text

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

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

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

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

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

Including subfolders

To process files recursively, add SearchOption.AllDirectories:

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

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

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

Using Environment.SpecialFolder

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

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

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

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

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

All important properties at a glance

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

Common mistakes

Using the path without checking DialogResult

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

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

Confusing RootFolder and SelectedPath

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

Forgetting the Using block

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

FAQ

Wrapping up

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

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

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.

What is the OpenFileDialog?

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

Use it when:

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

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

Basic example

The simplest OpenFileDialog that reads a text file:

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

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

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

Setting up file type filters

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

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

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

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

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

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

Setting the default folder

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

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

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

Common choices for InitialDirectory:

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

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

Selecting multiple files

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

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

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

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

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

Complete example: reading a text file

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

Imports System.IO
Imports System.Text

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

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

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

Reading binary files (images, PDFs)

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

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

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

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

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

Reading large files with StreamReader

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

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

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

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

All important properties at a glance

Common mistakes

Reading without checking DialogResult

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

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

Using FileName instead of FileNames with Multiselect

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

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

Forgetting the Using block

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

FAQ

Wrapping up

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

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