VB.NET AndAlso

Du möchtest mehr über den VB.NET AndAlso Operator lernen und verstehen wie Er funktioniert?

In diesem Beitrag zeige ich Dir einige Bespiele des VB.NET AndAlso Operators und erkläre Dir die Vorteile wie z. B. die Performance bezogenen Aspekte.

Vielleicht interessieren Dich z. B. auch noch folgende Beiträge: Application Path, PDF Öffnen, oder Button Click auslösen.

Vorarbeit – Wetter-Sensor

Um das VB.NET AndAlso Beispiel klarer zu gestalten, leisten wir ein wenig Vorarbeit, indem wir eine kleine WetterSensor-Klasse bauen.

Keine Sorge, dabei wir es sich um relativ stupide Daten ohne jegliche Anbindung einer API handeln.

Die Sensor-Klasse dient letztendlich nur der einfacheren Visualisierung und dem Verständnis hinter den Kulissen.

Achtung – Textbox-Referenz

Ich verwende hier beabsichtigt eine Referenz zur Log-Textbox, normalerweise sollte man dies nicht tun.

Mein Ziel ist es aber, das Beispiel so einfach wie möglich zu halten und Dir irgendwelche Handler zu ersparen.

Die Sensor-Klasse soll also beabsichtigt direkt in die Textbox loggen und somit eine direkte Abhängigkeit zu Ihr besitzen.

WeatherSensor-Klasse

An diesem Punkt stelle ich kurz die WeatherSensor–Klasse vor:

Public Class WeatherSensor

    Public Property TbLog As TextBox

    Sub New(tbLog As TextBox)
        Me.TbLog = tbLog
    End Sub

    Public Async Function IsSunny() As Task(Of Boolean)
        Log($"{NameOf(IsSunny)}()")
        Await ConnectToSensor()
        Await DisconnectFromSensor()
        Return False
    End Function

    Public Async Function IsRaining() As Task(Of Boolean)
        Log($"{NameOf(IsRaining)}()")
        Await ConnectToSensor()
        Await DisconnectFromSensor()
        Return True
    End Function

    Private Async Function ConnectToSensor() As Task
        Log($"{NameOf(ConnectToSensor)}()")
        Await Task.Delay(1000)
        Log("Connected to sensor")
        Log("------")
    End Function

    Private Async Function DisconnectFromSensor() As Task
        Log($"{NameOf(DisconnectFromSensor)}()")
        Await Task.Delay(1000)
        Log("Disconnected from sensor")
        Log("------")
    End Function

    Private Sub Log(txt As String)
        TbLog.AppendText($"[{Now:HH:mm:ss}] {txt}{Environment.NewLine}")
    End Sub

End Class

Eigenschaften

TbLog

Hier speichern wir die Referenz, um direkt aus der Klasse loggen zu können (bitte Hinweise beachten).

Konstruktoren

new(TextBox)

Der erste und einzige Konstruktor der Klasse benötigt die Referenz zur Log-Textbox.

Methoden

IsSunny

Eine Funktion um festzustellen, ob es aktuell sonnig ist.

Im Hintergrund müssen wir uns natürlich – simuliert – zum Sensor verbinden, etc.

IsRaining

Mit dieser Funktion stellen wir fest, ob es aktuell regnet (die Intensität spielt hier keine Rolle).

Auch hier muss im Hintergrund natürlich eine „Verbindung hergestellt“ werden.

ConnectToSensor

Simuliert eine Verbindung zum Sensor aufzubauen.

DisconnectFromSensor

Tut so, als ob die Instanz sich vom Sensor trennen würde.

Log(String)

Eine Hilfsfunktion um Daten direkt in die Textbox zu loggen (bitte auch hier Hinweise beachten!).

Grafische Oberfläche

Für unser „VB.NET AndAlso„-Beispiel kannst Du Dir am besten die folgende, oder eine ähnliche Oberfläche zusammenklicken:

VB.NET And – der linke Button

Zuerst einmal schauen wir uns an, wie man das normale „And„, also den normalen And-Operator verwendet.

Wie schon angepriesen verwenden wir dafür die erstellte WetterSensor-Klasse, um eine sinnvoll gestützte Basis zu haben.

Doppelklicke den linken Button und füge den folgenden Code ein (vergiss nicht die Sub als Async zu deklarieren):

    Private Async Sub btnCheckWeatherByAnd_Click(sender As Object, e As EventArgs) Handles btnCheckWeatherByAnd.Click
        tbLog.Clear()
        Dim isNiceWeather = Await WeatherSensor.IsSunny() And Await WeatherSensor.IsRaining()
        ' do something
    End Sub

Im ersten Schritt löschen wir den aktuellen Inhalt des Logs, damit wir bei jedem Durchgang einen sauberen Start haben.

Dann legen wir eine Variable fest, worin wir das boolesche Ergebnis des einfachen „And“-Operators speichern.

Letztendlich ist für uns hier nur das Ergebnis im Log relevant, um zu überprüfen, was, wie und wann passiert ist.

Wir können im Log beobachten, dass beide Funktionen (IsSunny und IsRaining) unabhängig vom ersten Ergebnis aufgerufen werden.

Bei einer „Verundung“ müssen alle Bestandteile True ergeben, damit letztendlich das Ergebnis den Wert True erhält.

Trotz des „False„-Wertes, also trotz des Ausschlusses, dass der erste Wert überhaupt True sein kann, wird die zweite Funktion „IsRaining“ aufgerufen!

Das dies natürlich absolut sinnlos ist, liegt auf der Hand, doch wie verhindern wir das?

Nicht nur die sinnlosen Verbindungsversuche der Klasse zum Sensor stoßen hier übel auf.

Ebenso stören auch die dabei verschwendeten Ressourcen und die sinnlose Warterei.

VB.NET AndAlso – der rechte Button

Schauen wir uns als nächstes die Vorgehensweise im rechten Button an:

    Private Async Sub btnCheckWeatherByAndAlso_Click(sender As Object, e As EventArgs) Handles btnCheckWeatherByAndAlso.Click
        tbLog.Clear()
        Dim isNiceWeather = Await WeatherSensor.IsSunny() AndAlso Await WeatherSensor.IsRaining()
    End Sub

Dir wird vermutlich schnell auffallen, dass der Code im Handler des zweiten Buttons nur ein anderes Wort enthält.

Statt des „And„-Operators verwenden wir hier den „AndAlso„-Operator und verändern somit die Verhaltensweise.

Werfen wir nun das zweite Mal einen Blick auf das Log:

Nun können wir mit glücklicher Miene feststellen, dass nur die „IsSunny„-Funktion aufgerufen wird und die „IsRaining“-Funktion außen vor bleibt.

Somit finden keine unnötigen Verbindungsversuche und auch keine Verschwendung von Ressourcen statt, SUPER!

Kompletter Code – VB.NET AndAlso

Public Class Form1

    Private ReadOnly WeatherSensor As WeatherSensor

    Sub New()
        InitializeComponent()
        WeatherSensor = New WeatherSensor(tbLog)
    End Sub

    Private Sub btnClearLog_Click(sender As Object, e As EventArgs) Handles btnClearLog.Click
        tbLog.Clear()
    End Sub

    Private Async Sub btnCheckWeatherByAnd_Click(sender As Object, e As EventArgs) Handles btnCheckWeatherByAnd.Click
        tbLog.Clear()
        Dim isNiceWeather = Await WeatherSensor.IsSunny() And Await WeatherSensor.IsRaining()
    End Sub

    Private Async Sub btnCheckWeatherByAndAlso_Click(sender As Object, e As EventArgs) Handles btnCheckWeatherByAndAlso.Click
        tbLog.Clear()
        Dim isNiceWeather = Await WeatherSensor.IsSunny() AndAlso Await WeatherSensor.IsRaining()
    End Sub

End Class

Public Class WeatherSensor

    Public Property TbLog As TextBox

    Sub New(tbLog As TextBox)
        Me.TbLog = tbLog
    End Sub

    Public Async Function IsSunny() As Task(Of Boolean)
        Log($"{NameOf(IsSunny)}()")
        Await ConnectToSensor()
        Await DisconnectFromSensor()
        Return False
    End Function

    Public Async Function IsRaining() As Task(Of Boolean)
        Log($"{NameOf(IsRaining)}()")
        Await ConnectToSensor()
        Await DisconnectFromSensor()
        Return True
    End Function

    Private Async Function ConnectToSensor() As Task
        Log($"{NameOf(ConnectToSensor)}()")
        Await Task.Delay(1000)
        Log("Connected to sensor")
        Log("------")
    End Function

    Private Async Function DisconnectFromSensor() As Task
        Log($"{NameOf(DisconnectFromSensor)}()")
        Await Task.Delay(1000)
        Log("Disconnected from sensor")
        Log("------")
    End Function

    Private Sub Log(txt As String)
        TbLog.AppendText($"[{Now:HH:mm:ss}] {txt}{Environment.NewLine}")
    End Sub

End Class

Downloads

Der Beitrag VB.NET AndAlso erschien zuerst auf Robert Skibbe.

Handles vs. AddHandler

In WinForms gibt es zwei Wege, ein Ereignis mit einer Methode zu verbinden:

' Weg 1: Handles-Klausel (statisch, zur Designzeit)
Private Sub BtnSave_Click(sender As Object, e As EventArgs) Handles BtnSave.Click
    ' Wird automatisch vom Designer verdrahtet
End Sub

' Weg 2: AddHandler (dynamisch, zur Laufzeit)
AddHandler BtnSave.Click, AddressOf BtnSave_Click

Private Sub BtnSave_Click(sender As Object, e As EventArgs)
    ' Kein "Handles" nötig
End Sub

Die Handles-Klausel funktioniert nur mit Controls, die zur Designzeit existieren. AddHandler funktioniert immer, auch mit Controls die du erst per Code erstellst. Sobald du Controls dynamisch erzeugst, ist AddHandler der einzige Weg.

AddHandler Syntax

AddHandler Objekt.Ereignis, AddressOf MethodenName

• Objekt.Ereignis ist das Ereignis, das du abonnieren willst (z.B. Button1.Click)
• AddressOf gibt einen Verweis auf die Methode zurück, die aufgerufen werden soll
• Die Signatur der Methode muss zum Ereignis passen (z.B. sender As Object, e As EventArgs)

Einfaches Beispiel

Ein Button-Click per AddHandler statt 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("Hallo!")
    End Sub
End Class

Beachte, dass die Methode BtnGreet_Click kein Handles am Ende hat. Die Verknüpfung passiert ausschließlich über AddHandler im Load-Event.

Dynamische Controls erstellen

Der häufigste Einsatzfall für AddHandler: Controls werden per Code erzeugt und brauchen Event-Handler. Hier ein Beispiel mit dynamisch erstellten Buttons:

Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    Dim categories = New List(Of String) From {
        "Privat", "Geschäft", "Archiv"
    }

    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($"Kategorie: {btn.Text}")
End Sub

Jeder Button bekommt denselben Click-Handler. Über DirectCast(sender, Button) ermittelst du, welcher Button geklickt wurde. Das funktioniert mit beliebig vielen Controls, ohne dass du für jedes einen eigenen Handler brauchst.

Komplettes Beispiel: Numpad-Tastatur

Ein realistisches Beispiel, das eine virtuelle Numpad-Tastatur zur Laufzeit erstellt. Jeder Tasten-Button wird per AddHandler mit einem gemeinsamen Handler verbunden:

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

Du brauchst dafür nur ein FlowLayoutPanel (ca. 180 x 260 Pixel) und eine TextBox auf dem Form. Die Buttons werden komplett per Code erstellt, kein Designer nötig.

RemoveHandler: Ereignis wieder trennen

Mit RemoveHandler trennst du die Verbindung wieder. Das ist wichtig, um Memory Leaks zu vermeiden, wenn Controls zur Laufzeit entfernt werden:

' Handler zuweisen
AddHandler btn.Click, AddressOf Button_Click

' Handler wieder entfernen
RemoveHandler btn.Click, AddressOf Button_Click

Verwende RemoveHandler immer dann, wenn:

• Du dynamische Controls entfernst (z.B. beim Schließen eines Tabs)
• Du den Handler austauschen willst (erst Remove, dann Add)
• Du verhindern willst, dass ein Event mehrfach feuert

Mehrere Events, ein Handler

Ein Handler kann mehrere Events verarbeiten. Das ist besonders nützlich bei Formularen mit vielen ähnlichen 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

Alle drei TextBoxen teilen sich den ValidateField-Handler. Über sender wird erkannt, welche TextBox sich geändert hat.

Eigene Events mit AddHandler

Du kannst auch eigene Events definieren und per AddHandler abonnieren. Das ist nützlich für lose gekoppelte Kommunikation zwischen Klassen:

Public Class FileWatcher
    Public Event FileChanged(filePath As String)

    Public Sub CheckForChanges()
        ' Prüflogik...
        RaiseEvent FileChanged("C:\data\config.xml")
    End Sub
End Class

' Im 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($"Datei geändert: {filePath}")
End Sub

Mit RaiseEvent löst die Klasse das Event aus. Der Abonnent reagiert darauf per AddHandler. So bleibt die FileWatcher-Klasse unabhängig vom Form.

Häufige Fehler

Handler wird mehrfach registriert

' SCHLECHT - bei jedem Klick wird ein weiterer Handler hinzugefügt
Private Sub BtnRefresh_Click(sender As Object, e As EventArgs) Handles BtnRefresh.Click
    AddHandler Timer1.Tick, AddressOf Timer1_Tick
End Sub

' GUT - Handler nur einmal im Load registrieren
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    AddHandler Timer1.Tick, AddressOf Timer1_Tick
End Sub

Wenn du AddHandler mehrfach für dasselbe Event und dieselbe Methode aufrufst, wird die Methode auch mehrfach ausgeführt. Registriere Handler in Load oder stelle sicher, dass du vorher RemoveHandler aufrufst. Zum Thema Timer gibt es auch den VB.NET Timer Guide.

Falsche Methodensignatur

' SCHLECHT - Parameter stimmen nicht mit dem Event überein
Private Sub Button_Click(text As String)
End Sub

' GUT - Signatur passt zum Click-Event
Private Sub Button_Click(sender As Object, e As EventArgs)
End Sub

Die Methode muss exakt die Parameter-Typen haben, die das Event erwartet. Bei Click ist das (sender As Object, e As EventArgs). Der Compiler meldet einen Fehler, wenn die Signatur nicht passt.

RemoveHandler vergessen bei dynamischen Controls

Wenn du Controls per Controls.Remove() entfernst, aber den Handler nicht trennst, hält die Referenz das Objekt im Speicher. Rufe immer RemoveHandler auf, bevor du ein dynamisches Control entfernst.

FAQ

Fazit

Die AddHandler-Anweisung macht dein Event-Handling in VB.NET flexibel. Verwende sie für dynamisch erstellte Controls, wenn du Handler zur Laufzeit zuweisen oder austauschen willst, und für eigene Events in deinen Klassen. Denke daran, RemoveHandler aufzurufen, wenn du Controls entfernst, und registriere Handler nur einmal, um Mehrfach-Ausführungen zu vermeiden. Für verwandte Themen schau dir den VB.NET Timer Guide und den VB.NET List Guide an.

Der Beitrag VB.NET AddHandler – Events dynamisch verknüpfen (2026) erschien zuerst auf Robert Skibbe.