{"id":55000515,"date":"2026-08-01T00:00:00","date_gmt":"2026-11-12T13:05:33","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=515"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Select_Case_in_der_Praxis","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Select_Case_in_der_Praxis\/","title":{"rendered":"Select Case in der Praxis"},"content":{"rendered":"

\"\"Wer VBA-Bedingungen schreibt, greift fast automatisch zu If…Then…ElseIf<\/b>. Das funktioniert, wird aber bei mehr als zwei, drei Zweigen schnell unübersichtlich – und fehleranfällig, weil jede Zeile den Prüfausdruck wiederholt. Select Case<\/b> ist die Alternative: kompakter, lesbarer und in vielen Fällen auch schneller. Dieser Beitrag zeigt die Grundform, alle Varianten der Case<\/b>-Klausel und drei Praxismuster, die über das hinausgehen, was die meisten VBA-Entwickler kennen.<\/b><\/p>\n

Die Grundform<\/h2>\n

Select Case<\/b> prüft einen Ausdruck gegen eine Reihe von Werten. Trifft ein Case<\/b>-Zweig zu, führt VBA die darin enthaltenen Anweisungen aus und springt danach direkt zu End Select<\/b> – es gibt kein Durchfallen wie in manchen anderen Sprachen:<\/p>\n

Select Case intWochentag\r\n    Case <\/span>1\r\n        strName = \"Montag\"\r\n    Case <\/span>2\r\n        strName = \"Dienstag\"\r\n    Case <\/span>3\r\n        strName = \"Mittwoch\"\r\n    Case Else<\/span>\r\n        strName = \"(anderer Tag)\"\r\nEnd Select<\/span><\/pre>\n
Der Ausdruck hinter Select Case<\/b> wird genau einmal ausgewertet. Das ist ein Vorteil gegenüber einer If…ElseIf<\/b>-Kette, in der wir denselben Ausdruck in jeder Zeile wiederholen müssten.<\/p>\n
Bei aufwendigen Funktionsaufrufen spart das nicht nur Tipparbeit, sondern auch Rechenzeit.<\/p>\n
Case Else als Sicherheitsnetz<\/h2>\n
Der Case Else<\/b>-Zweig fängt alles auf, was keiner der vorangehenden Case<\/b>-Klauseln entspricht. Er ist optional, aber in der Praxis fast immer empfehlenswert – er macht explizit, was passiert, wenn ein unerwarteter Wert auftaucht. Das gilt besonders für Eingaben von Benutzern oder Werte aus Datenbanken, die sich jederzeit ändern können.<\/p>\n
Wer sicher ist, dass alle möglichen Werte abgedeckt sind, kann Case Else<\/b> als Wachposten nutzen – mit einer Fehlermeldung, die auf den Programmierfehler hinweist:<\/p>\n
Case Else<\/span>\r\n    Err.Raise vbObjectError + 1001, _\r\n        \"StatusText\", \"Unbekannter Status: \" & intStatus<\/pre>\n
Mehrere Werte in einer Case-Klausel<\/h2>\n
Eine Case<\/b>-Klausel kann mehrere Werte aufnehmen, durch Komma getrennt. Das spart Zweige, wenn dieselbe Aktion für verschiedene Werte gelten soll:<\/p>\n
Select Case intWochentag\r\n    Case <\/span>1, 2, 3, 4, 5\r\n        strTyp = \"Werktag\"\r\n    Case <\/span>6, 7\r\n        strTyp = \"Wochenende\"\r\nEnd Select<\/span><\/pre>\n
Die Werte müssen nicht aufeinanderfolgend sein. Case 1, 3, 5, 7<\/b> ist genauso gültig. Bei aufeinanderfolgenden Werten gibt es allerdings eine elegantere Lösung – den To<\/b>-Bereich.<\/p>\n
Bereiche mit To<\/h2>\n
Mit Case 1 To 5<\/b> prüfen wir, ob der Wert zwischen 1<\/b> und 5<\/b> liegt – beide Grenzen eingeschlossen. Das funktioniert auch mit Strings und Datumsangaben. Das Wochentagbeispiel von eben wird damit noch kompakter:<\/p>\n
Select Case intWochentag\r\n    Case <\/span>1 To 5\r\n        strTyp = \"Werktag\"\r\n    Case <\/span>6 To 7\r\n        strTyp = \"Wochenende\"\r\nEnd Select<\/span><\/pre>\n
Bereiche, Einzelwerte und Is<\/b>-Vergleiche lassen sich in derselben Case<\/b>-Klausel mischen. Ein Beispiel: Case 1 To 5, 10, Is > 100<\/b> trifft auf die Werte 1<\/b> bis 5<\/b>, auf 10<\/b> und auf alles über 100<\/b> zu.<\/p>\n
Vergleiche mit Is<\/h2>\n
Manchmal brauchen wir keine exakten Werte, sondern Schwellenwerte. Dafür gibt es das Schlüsselwort Is<\/b> in Kombination mit einem Vergleichsoperator. Ein typisches Beispiel ist die Bewertung einer Punktzahl:<\/p>\n
Public Function <\/span>Bewertung(ByVal lngPunkte As Long<\/span>) As String<\/span>\r\n    Select Case lngPunkte\r\n        Case <\/span>Is >= 90\r\n            Bewertung = \"sehr gut\"\r\n        Case <\/span>Is >= 75\r\n            Bewertung = \"gut\"\r\n        Case <\/span>Is >= 50\r\n            Bewertung = \"befriedigend\"\r\n        Case <\/span>Is >= 25\r\n            Bewertung = \"ausreichend\"\r\n        Case Else<\/span>\r\n            Bewertung = \"mangelhaft\"\r\n    End Select<\/span>\r\nEnd Function<\/span><\/pre>\n
Wichtig ist die Reihenfolge: VBA prüft die Case<\/b>-Klauseln von oben nach unten und nimmt den ersten Treffer. Wer Case Is >= 25<\/b> an den Anfang stellt, bekommt für 95 Punkte nur „ausreichend“, weil diese Klausel bereits zutrifft. Die Reihenfolge muss also vom engsten zum weitesten Kriterium laufen.<\/p>\n
Select Case mit Strings<\/h2>\n
Select Case<\/b> funktioniert nicht nur mit Zahlen. Strings werden nach den Regeln verglichen, die Option Compare<\/b> vorgibt – in Access-Modulen also standardmässig ohne Berücksichtigung der Gross-\/Kleinschreibung:<\/p>\n
Public Function <\/span>DateiTyp( _\r\n        ByVal strErweiterung As String<\/span>) As String<\/span>\r\n    Select Case LCase$(strErweiterung)\r\n        Case <\/span>\"accdb\", \"accde\", \"mdb\"\r\n            DateiTyp = \"Access-Datenbank\"\r\n        Case <\/span>\"xlsx\", \"xlsm\", \"xls\"\r\n            DateiTyp = \"Excel-Arbeitsmappe\"\r\n        Case <\/span>\"docx\", \"docm\", \"doc\"\r\n            DateiTyp = \"Word-Dokument\"\r\n        Case <\/span>\"pdf\"\r\n            DateiTyp = \"PDF-Dokument\"\r\n        Case <\/span>\"csv\", \"txt\"\r\n            DateiTyp = \"Textdatei\"\r\n        Case Else<\/span>\r\n            DateiTyp = \"Unbekannt\"\r\n    End Select<\/span>\r\nEnd Function<\/span><\/pre>\n
In diesem Listing sichern wir mit LCase$<\/b> ab, dass der Vergleich unabhängig von der Schreibweise funktioniert – auch in Modulen mit Option Compare Binary<\/b>. Mit To<\/b> lassen sich auch String-Bereiche prüfen: Case „A“ To „M“<\/b> trifft auf alle Strings zu, die mit einem Buchstaben zwischen A und M beginnen.<\/p>\n
Das Pattern: Select Case True<\/h2>\n
Das mächtigste – und am wenigsten bekannte – Muster ist Select Case True<\/b>. Hier prüft VBA nicht einen Wert gegen Konstanten, sondern wertet in jeder Case<\/b>-Klausel einen beliebigen Booleschen Ausdruck aus. Das ist die VBA-Variante eines cond<\/b> oder when<\/b> aus anderen Sprachen:<\/p>\n
Public Function <\/span>Versandkosten(ByVal dblGewicht As Double<\/span>, _\r\n        ByVal strLand As String<\/span>) As Currency<\/span>\r\n    Select Case True<\/span>\r\n        Case <\/span>strLand <> \"DE\"\r\n            Versandkosten = 14.9\r\n        Case <\/span>dblGewicht <= 1\r\n            Versandkosten = 4.99\r\n        Case <\/span>dblGewicht <= 5\r\n            Versandkosten = 6.99\r\n        Case <\/span>dblGewicht <= 20\r\n            Versandkosten = 9.99\r\n        Case Else<\/span>\r\n            Versandkosten = 14.99\r\n    End Select<\/span>\r\nEnd Function<\/span><\/pre>\n
Die Funktion aus diesem Listing prüft zuerst das Land, dann das Gewicht – zwei verschiedene Variablen in derselben Struktur. Mit If…ElseIf<\/b> wäre das genauso möglich, aber weniger übersichtlich, weil jede Zeile mit ElseIf<\/b> beginnt und der Blick zwischen Bedingung und Zuweisung hin- und herspringt.<\/p>\n
Die Reihenfolge ist auch hier entscheidend: Ein Paket mit 3 kg nach Österreich kostet 14,90 €, weil der Landcheck zuerst greift. Würden wir die Gewichtsprüfung an den Anfang stellen, bekäme dasselbe Paket nur 6,99 € – der Auslandsaufschlag gälte nicht.<\/p>\n
Praxis: Statusmaschine für Aufträge<\/h2>\n
Ein häufiges Muster in Geschäftsanwendungen: Ein Auftrag durchläuft mehrere Zustände, und je nach aktuellem Status sind nur bestimmte Übergänge erlaubt. Select Case<\/b> bildet das direkt ab.<\/p>\n
Listing 2 zeigt verschachtelte Select Case<\/b>-Blöcke: Der äussere Block prüft den aktuellen Status, der innere die gewünschte Aktion. Ist die Aktion im jeweiligen Status nicht vorgesehen, bleibt der Status unverändert. Das ist lesbarer als eine verschachtelte If…ElseIf<\/b>-Kette und lässt sich leicht um neue Status oder Aktionen erweitern.<\/p>\n
Public Function <\/span>NaechsterStatus(ByVal strAktuell As String<\/span>, _\r\n        ByVal strAktion As String<\/span>) As String<\/span>\r\n    Select Case strAktuell\r\n        Case <\/span>\"Entwurf\"\r\n            Select Case strAktion\r\n                Case <\/span>\"Freigeben\"\r\n                    NaechsterStatus = \"Freigegeben\"\r\n                Case <\/span>\"Verwerfen\"\r\n                    NaechsterStatus = \"Verworfen\"\r\n                Case Else<\/span>\r\n                    NaechsterStatus = strAktuell\r\n            End Select<\/span>\r\n        Case <\/span>\"Freigegeben\"\r\n            Select Case strAktion\r\n                Case <\/span>\"Versenden\"\r\n                    NaechsterStatus = \"Versendet\"\r\n                Case <\/span>\"Zurueckziehen\"\r\n                    NaechsterStatus = \"Entwurf\"\r\n                Case Else<\/span>\r\n                    NaechsterStatus = strAktuell\r\n            End Select<\/span>\r\n        Case <\/span>\"Versendet\"\r\n            Select Case strAktion\r\n                Case <\/span>\"Abschliessen\"\r\n                    NaechsterStatus = \"Abgeschlossen\"\r\n                Case Else<\/span>\r\n                    NaechsterStatus = strAktuell\r\n            End Select<\/span>\r\n        Case Else<\/span>\r\n            ' Endstatus: keine Aenderung moeglich\r\n            NaechsterStatus = strAktuell\r\n    End Select<\/span>\r\nEnd Function<\/span><\/pre>\n
Listing 1: Verschachteltes Select Case als Statusmaschine<\/span><\/b><\/p>\n
Praxis: Steuerelemente ein- und ausblenden<\/h2>\n
In Access-Formularen steuern wir oft die Sichtbarkeit von Steuerelementen abhängig von einem Kategoriefeld. Select Case<\/b> hält die Logik kompakt:<\/p>\n
Private Sub <\/span>cboKategorie_AfterUpdate()\r\n    ' Alle optionalen Felder zunaechst ausblenden\r\n    Me.txtSeriennummer.Visible = False<\/span>\r\n    Me.txtAblaufdatum.Visible = False<\/span>\r\n    Me.txtLizenzkey.Visible = False<\/span>\r\n    Select Case Nz(Me.cboKategorie, \"\")\r\n        Case <\/span>\"Hardware\"\r\n            Me.txtSeriennummer.Visible = True<\/span>\r\n        Case <\/span>\"Software\"\r\n            Me.txtLizenzkey.Visible = True<\/span>\r\n            Me.txtAblaufdatum.Visible = True<\/span>\r\n        Case <\/span>\"Verbrauchsmaterial\"\r\n            ' Keine zusaetzlichen Felder\r\n    End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n
Das Muster aus diesem Listing beginnt damit, alle optionalen Felder auszublenden. Danach schaltet der passende Case<\/b>-Zweig nur die relevanten Felder wieder ein. So brauchen wir keinen Case Else<\/b>-Zweig, weil der Ausgangszustand bereits stimmt. Das ist robuster als das Gegenteil – erst alles einblenden und dann gezielt ausblenden -, weil bei einem neuen Kategoriewert nichts versehentlich sichtbar bleibt.<\/p>\n
Wann Select Case, wann If?<\/h2>\n
Nicht jede Bedingung eignet sich für Select Case<\/b>. Eine kurze Orientierung:<\/p>\n
    \n
  • Select Case<\/b>: wenn ein einzelner Ausdruck gegen mehrere Werte, Bereiche oder Schwellen geprüft wird. Je mehr Zweige, desto grösser der Vorteil.<\/li>\n
  • Select Case True<\/b>: wenn mehrere verschiedene Ausdruecke geprüft werden sollen und die Reihenfolge die Logik bestimmt.<\/li>\n
  • If…Then<\/b>: wenn nur ein oder zwei Zweige existieren oder wenn die Bedingungen so komplex sind, dass sie in einer Case<\/b>-Klausel unleserlich würden.<\/li>\n<\/ul>\n
    Eine Faustregel: Ab drei Zweigen, die denselben Ausdruck prüfen, lohnt sich Select Case<\/b> fast immer.<\/p>\n
    Zusammenfassung und Ausblick<\/h2>\n
    Select Case<\/b> ist mehr als eine Kurzschreibweise für If…ElseIf<\/b>. Mit To<\/b>-Bereichen, Is<\/b>-Vergleichen und kombinierten Klauseln deckt es die meisten Verzweigungslogiken kompakt und lesbar ab. Das Select Case True<\/b>-Pattern erweitert den Einsatzbereich auf beliebige Bedingungen mit unterschiedlichen Variablen. Und verschachtelt eignet es sich als einfache Statusmaschine, die ohne Tabellen oder Klassen auskommt.<\/p>\n
    Wer die Grundlagen der VBA-Verzweigungen nachlesen möchte, findet sie im Beitrag VBA Basics: Bedingungen<\/b> (www.vbentwickler.de\/336<\/b>).<\/p>\n","protected":false},"excerpt":{"rendered":"
    Wer VBA-Bedingungen schreibt, greift fast automatisch zu If…Then…ElseIf. Das funktioniert, wird aber bei mehr als zwei, drei Zweigen schnell unübersichtlich – und fehleranfällig, weil jede Zeile den Prüfausdruck wiederholt. Select Case ist die Alternative: kompakter, lesbarer und in vielen Fällen auch schneller. Dieser Beitrag zeigt die Grundform, alle Varianten der Case-Klausel und drei Praxismuster, die über das hinausgehen, was die meisten VBA-Entwickler kennen.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"footnotes":""},"categories":[662026,66042026,44000025],"tags":[],"yst_prominent_words":[],"class_list":["post-55000515","post","type-post","status-publish","format-standard","hentry","category-662026","category-66042026","category-VBAProgrammierung"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t