Was bedeutet in VB.NET 2003 die Fehlermeldung 'Das angegebene Argument liegt außerhalb des gültigen Wertebereichs.'?

Question

Was bedeutet in VB.NET 2003 die Fehlermeldung 'Das angegebene Argument liegt außerhalb des gültigen Wertebereichs.'?

Antwort

Verwandte Fragen

"if shinfo.hicon <> IntPtr.Zero Then ..." verursacht in VB.NET 2003 einen Fehler?

Warum markiert VB.NET 2003 die Zeile 'If hookHandle <> IntPtr.Zero ...' in 'Public Class MouseHook' als Fehler?

Wie finde ich heraus, welche Datei in VB.NET 2003 fehlt, wenn nur 'Datei 1 nicht gefunden' angezeigt wird?

Welchen Einfluss haben überflüssig importierte Klassen mittels Imports in VB.NET 2003 auf ein Programm?

Wie behebe ich den Python-Fehler 'NameError: name 'Querschnitt' is not defined' in KI_D1602_ZeitvarianteMatrix_MaxRPM_Steuern?

Können in VB.NET 2003 außer Icons auch GIF/PNG für ownerdrawn Contextmenüs verwendet werden?

Wie speichere ich in VB.NET 2003 ein mit SHGetFileInfo extrahiertes Icon unter einem anderen Namen?

Wie kann ich in VB.NET 2003 den Fehler 'Der Vorgang "read" konnte nicht auf dem Speicher...' abfangen?

Wie kann ich in VB.NET 2003 einem Contextmenü Icons hinzufügen?

Welchen Datentyp hat der Wert für PictureBox.SizeMode in VB.NET 2003?

Accepted Answer

Die Fehlermeldung „Das angegebene Argument liegt außerhalb des gültigen Wertebereichs.“ in VB.NET 2003 bedeutet, dass du einer Methode, Funktion oder Eigenschaft einen Wert übergeben hast, der nicht zulässig ist. Das kann zum Beispiel passieren, wenn: - Ein Index außerhalb der Grenzen eines Arrays oder einer Liste liegt (z. B. `myArray(10)` bei einem Array mit nur 5 Elementen). - Ein Wert kleiner oder größer als der erlaubte Bereich ist (z. B. `ScrollBar.Value = 200` bei einer ScrollBar mit Maximum 100). - Ein Parameter `Nothing` ist, obwohl ein Wert erwartet wird. **Typische Ursachen:** - Falsche Schleifenindizes - Falsche Werte bei Methodenaufrufen (z. B. `Substring`, `Remove`, `Insert`) - Falsche Werte bei Steuerelementen (z. B. ListBox, ComboBox, ScrollBar) **Beispiel:** ```vb.net Dim arr(4) As Integer ' Indizes 0 bis 4 arr(5) = 10 ' Fehler: Index 5 ist außerhalb des gültigen Bereichs ``` **Fehlersuche:** 1. Prüfe die Zeilennummer in der Fehlermeldung (sofern vorhanden). 2. Kontrolliere alle Werte, die du an Methoden oder Eigenschaften übergibst. 3. Überprüfe insbesondere Indizes und Wertebereiche. **Tipp:** Setze Haltepunkte und nutze den Debugger, um die Werte der Variablen vor dem Fehler zu prüfen. Weitere Infos findest du in der offiziellen Microsoft-Dokumentation: [ArgumentOutOfRangeException (Microsoft)](https://learn.microsoft.com/de-de/dotnet/api/system.argumentoutofrangeexception) Wenn du den konkreten Codeabschnitt postest, kann gezielter geholfen werden.

Accepted Answer

Ja, in **VB.NET 2003** kann folgender Vergleich zu einem Fehler führen: ```vb If shinfo.hIcon <> IntPtr.Zero Then ' ... End If ``` **Grund:** In VB.NET 2003 (also .NET Framewor... [mehr]

Accepted Answer

Ja, in **VB.NET 2003** kann folgender Vergleich zu einem Fehler führen: ```vb If shinfo.hIcon <> IntPtr.Zero Then ' ... End If ``` **Grund:** In VB.NET 2003 (also .NET Framework 1.1) gibt es den Typ `IntPtr` noch nicht in der heute gewohnten Form. Viele APIs und Beispiele, die `IntPtr` verwenden, setzen mindestens .NET Framework 2.0 voraus. In .NET 1.1 ist `IntPtr` zwar vorhanden, aber die Verwendung ist eingeschränkt und viele Hilfskonstanten wie `IntPtr.Zero` sind nicht so komfortabel nutzbar wie in späteren Versionen. **Typische Fehlerursache:** - `shinfo.hIcon` ist meist ein `Integer` (bzw. `Int32`) und kein `IntPtr`. - Der Vergleich eines `Integer` mit einem `IntPtr` führt zu einem Typkonflikt. **Lösung:** Vergleiche den Wert direkt mit `0` (so wie es in VB6 oder frühem VB.NET üblich war): ```vb If shinfo.hIcon <> 0 Then ' ... End If ``` **Zusatz:** Falls du aus Kompatibilitätsgründen doch mit `IntPtr` arbeiten musst, dann konvertiere explizit: ```vb If shinfo.hIcon.ToInt32() <> 0 Then ' ... End If ``` oder ```vb If Not shinfo.hIcon.Equals(IntPtr.Zero) Then ' ... End If ``` Aber in VB.NET 2003 ist der direkte Vergleich mit `0` meist der richtige Weg. **Fazit:** Der Fehler entsteht durch einen Typkonflikt zwischen `hIcon` (vermutlich `Integer`) und `IntPtr.Zero`. In VB.NET 2003 solltest du stattdessen mit `0` vergleichen.

Accepted Answer

In VB.NET 2003 gibt es einige Unterschiede zu neueren Versionen, insbesondere im Umgang mit Datentypen wie `IntPtr`. Der Fehler tritt häufig auf, weil der Typ `IntPtr` in .NET Framework 1.1 (welc... [mehr]

Accepted Answer

In VB.NET 2003 gibt es einige Unterschiede zu neueren Versionen, insbesondere im Umgang mit Datentypen wie `IntPtr`. Der Fehler tritt häufig auf, weil der Typ `IntPtr` in .NET Framework 1.1 (welches VB.NET 2003 verwendet) **nicht** so umfassend unterstützt wird wie in späteren Versionen. **Mögliche Ursachen und Lösungen:** 1. **IntPtr ist nicht verfügbar oder nicht korrekt importiert:** - In .NET 1.1 ist `IntPtr` zwar vorhanden, aber manchmal wird er nicht korrekt erkannt, wenn der Namespace fehlt. - Stelle sicher, dass du am Anfang deiner Datei folgendes hast: ```vb Imports System ``` 2. **Vergleich mit IntPtr.Zero:** - In .NET 1.1 kann der Vergleich mit `IntPtr.Zero` manchmal problematisch sein, weil Operatoren für `IntPtr` nicht überladen sind. - Stattdessen kannst du die Eigenschaft `.ToInt32()` verwenden: ```vb If hookHandle.ToInt32() <> 0 Then ' ... End If ``` - Oder, falls du mit Handles arbeitest, kannst du auch direkt mit `Integer` arbeiten, z.B.: ```vb Dim hookHandle As Integer = 0 ' ... If hookHandle <> 0 Then ' ... End If ``` 3. **Beispiel für eine MouseHook-Klasse in VB.NET 2003:** ```vb Public Class MouseHook Private hookHandle As IntPtr = IntPtr.Zero Public Sub Unhook() If hookHandle.ToInt32() <> 0 Then ' Unhook logic hookHandle = IntPtr.Zero End If End Sub End Class ``` **Zusammenfassung:** Der Fehler entsteht meist, weil der Vergleich `If hookHandle <> IntPtr.Zero` in VB.NET 2003 nicht direkt unterstützt wird. Verwende stattdessen `If hookHandle.ToInt32() <> 0` oder arbeite mit `Integer`-Handles. **Weitere Infos zu IntPtr:** [Microsoft-Dokumentation zu IntPtr](https://learn.microsoft.com/de-de/dotnet/api/system.intptr) Falls du noch mit VB.NET 2003 arbeitest, empfiehlt sich ein Upgrade auf eine neuere .NET-Version, da viele moderne Sprachfeatures und Typen dort besser unterstützt werden.

Accepted Answer

Wenn in VB.NET 2003 beim Ausführen oder Debuggen die Fehlermeldung erscheint, dass „Datei 1 nicht gefunden werden kann“, ist das meist ein Hinweis darauf, dass eine benötigte Dat... [mehr]

Accepted Answer

Wenn in VB.NET 2003 beim Ausführen oder Debuggen die Fehlermeldung erscheint, dass „Datei 1 nicht gefunden werden kann“, ist das meist ein Hinweis darauf, dass eine benötigte Datei (z.B. eine DLL, ein Bild, eine Datenbankdatei oder eine Konfigurationsdatei) fehlt, aber der genaue Dateiname nicht angezeigt wird. Um herauszufinden, welche Datei tatsächlich fehlt, kannst du folgende Schritte durchführen: 1. **Fehlermeldung genau prüfen:** Manchmal steht im Stacktrace oder in der Detailansicht der Fehlermeldung mehr als nur „Datei 1“. Klicke auf „Details“ oder schaue dir die Exception-Details im Debugger an. 2. **Try-Catch-Block erweitern:** Fange die Exception im Code ab und gib die Exception-Message und den Stacktrace aus: ```vb Try ' Dein Code Catch ex As Exception MessageBox.Show(ex.Message & vbCrLf & ex.StackTrace) End Try ``` Oft steht in `ex.Message` der genaue Dateiname. 3. **Fusion Log Viewer (nur für .NET-Assemblies):** Wenn es sich um eine fehlende .NET-Assembly (DLL) handelt, kannst du das [Fusion Log Viewer Tool (fuslogvw.exe)](https://learn.microsoft.com/en-us/dotnet/framework/tools/fuslogvw-exe-assembly-binding-log-viewer) verwenden. Damit siehst du, welche Assembly geladen werden sollte und wo gesucht wurde. 4. **Dateizugriffe überwachen (Process Monitor):** Mit dem kostenlosen Tool [Process Monitor von Microsoft (Sysinternals)](https://docs.microsoft.com/de-de/sysinternals/downloads/procmon) kannst du alle Dateioperationen deines Programms überwachen. Filtere nach deinem Prozessnamen und suche nach „NAME NOT FOUND“. So siehst du, welche Datei gesucht und nicht gefunden wurde. 5. **Projekt- und Build-Einstellungen prüfen:** Überprüfe, ob alle benötigten Dateien im Projekt als „In den Ausgabepfad kopieren“ markiert sind (Eigenschaften der Datei im Projektmappen-Explorer). 6. **Manuelle Kontrolle:** Prüfe, ob alle Ressourcen, die dein Programm benötigt, im Ausgabeverzeichnis (meist `bin\Debug` oder `bin\Release`) vorhanden sind. **Zusammengefasst:** Am schnellsten findest du die fehlende Datei mit dem Process Monitor heraus. Alternativ hilft oft schon ein erweiterter Try-Catch-Block, um die Exception-Details zu sehen. Weitere Infos zu den genannten Tools findest du hier: - [Fusion Log Viewer (fuslogvw.exe)](https://learn.microsoft.com/en-us/dotnet/framework/tools/fuslogvw-exe-assembly-binding-log-viewer) - [Process Monitor (Sysinternals)](https://docs.microsoft.com/de-de/sysinternals/downloads/procmon)

Accepted Answer

In VB.NET 2003 (also .NET Framework 1.1) hat das Hinzufügen von Imports-Anweisungen für nicht verwendete Namespaces oder Klassen in der Regel **keinen nennenswerten Einfluss auf die Grö... [mehr]

Accepted Answer

In VB.NET 2003 (also .NET Framework 1.1) hat das Hinzufügen von Imports-Anweisungen für nicht verwendete Namespaces oder Klassen in der Regel **keinen nennenswerten Einfluss auf die Größe oder Performance** des kompilierten Programms. **Begründung:** - Die `Imports`-Anweisung dient nur dazu, den Code lesbarer zu machen, indem du auf Klassen ohne vollständigen Namespace zugreifen kannst. - Beim Kompilieren werden nur die tatsächlich verwendeten Typen und Namespaces in den kompilierten Code aufgenommen. - Nicht verwendete Imports führen **nicht** dazu, dass zusätzliche Bibliotheken oder Klassen in die ausführbare Datei eingebunden werden. - Die einzige Auswirkung ist eine minimale Unübersichtlichkeit im Quellcode und eventuell eine leicht verlängerte Kompilierzeit, da der Compiler mehr Namespaces durchsuchen muss, um Typen aufzulösen. **Fazit:** Überflüssige Imports-Anweisungen in VB.NET 2003 haben praktisch keinen Einfluss auf die Größe oder Laufzeit deines Programms. Sie sind hauptsächlich ein Thema für die Codequalität und Übersichtlichkeit, nicht für die Performance oder Dateigröße.

Accepted Answer

Die Fehlermeldung ``` Python Error: NameError: name 'Querschnitt' is not defined ``` bedeutet, dass im Python-Code eine Variable oder ein Objekt mit dem Namen Quchnitt verwendet wird, bevo... [mehr]

Accepted Answer

Die Fehlermeldung ``` Python Error: NameError: name 'Querschnitt' is not defined ``` bedeutet, dass im Python-Code eine Variable oder ein Objekt mit dem Namen Quchnitt verwendet wird, bevor es definiert oder importiert wurde. Das kann folgende Ursachen haben: 1. **Variable nicht definiert:** Du hast vergessen, Querschnitt vorher im Code zu erstellen oder zuzuweisen. 2. **Falsche Schreibweise:** Es gibt einen Tippfehler im Namen (z.B. Groß-/Kleinschreibung). 3. **Import fehlt:** Falls Querschnitt aus einem anderen Modul stammt, wurde es nicht importiert. **Lösungsvorschläge:** - Überprüfe, ob Querschnitt vor der fehlerhaften Zeile korrekt definiert wurde (z.B. `Querschnitt = ...`). - Kontrolliere, ob du eventuell `querschnitt` statt `Querschnitt` geschrieben hast (Python ist case-sensitive). - Falls Querschnitt eine Klasse oder Funktion aus einem anderen Modul ist, stelle sicher, dass du sie importiert hast, z.B.: ```python from mein_modul import Querschnitt ``` **Tipp:** Suche im Code nach der ersten Stelle, an der Querschnitt verwendet wird, und prüfe, ob davor eine Definition oder ein Import existiert. Weitere Informationen zur Fehlermeldung findest du auch in der [offiziellen Python-Dokumentation](https://docs.python.org/3/tutorial/errors.html#nameerror).

Accepted Answer

In **VB.NET 2003** (also .NET Framework 1.1) ist die Unterstützung für Bilder in Menüs standardmäßig auf **Icons** (also `.ico`-Dateien) beschränkt. Das betrifft sowohl... [mehr]

Accepted Answer

In **VB.NET 2003** (also .NET Framework 1.1) ist die Unterstützung für Bilder in Menüs standardmäßig auf **Icons** (also `.ico`-Dateien) beschränkt. Das betrifft sowohl normale als auch ownerdrawn-Menüs. Die Standard-API und die Windows Forms-Menüklassen (`MenuItem`, `ContextMenu`) bieten keine direkte Möglichkeit, GIF- oder PNG-Bilder als Menüicons zu verwenden. **ABER:** Wenn du ein **OwnerDraw**-Menü verwendest, hast du die volle Kontrolle über das Zeichnen der Menüeinträge. Das bedeutet, du kannst im `DrawItem`-Event **beliebige Grafiken** zeichnen, also auch PNG oder GIF (inklusive Transparenz). **Vorgehen:** 1. Lade das Bild (PNG, GIF) als `Image`-Objekt (z.B. mit `Image.FromFile`). 2. Im `DrawItem`-Event des Menüeintrags kannst du das Bild mit `e.Graphics.DrawImage` zeichnen. **Beispiel:** ```vb ' Bild laden (z.B. PNG) Dim myImage As Image = Image.FromFile("C:\pfad\bild.png") ' Im DrawItem-Event: Private Sub MenuItem_DrawItem(sender As Object, e As DrawItemEventArgs) ' Bild zeichnen e.Graphics.DrawImage(myImage, e.Bounds.Left, e.Bounds.Top, 16, 16) ' Text daneben zeichnen e.Graphics.DrawString(CType(sender, MenuItem).Text, e.Font, Brushes.Black, e.Bounds.Left + 20, e.Bounds.Top) End Sub ``` **Wichtig:** - Transparenz von PNGs wird unterstützt, GIF-Animationen jedoch nicht (es wird nur das erste Frame angezeigt). - Du musst das OwnerDraw-Flag für den Menüeintrag setzen: `MenuItem.OwnerDraw = True`. **Fazit:** Ja, mit OwnerDraw kannst du in VB.NET 2003 auch PNG- oder GIF-Bilder in ContextMenüs verwenden, aber du musst das Zeichnen selbst übernehmen. Standardmäßig werden nur Icons unterstützt. Weitere Infos zu OwnerDraw-Menüs in .NET findest du z.B. bei Microsoft: [https://learn.microsoft.com/en-us/dotnet/api/system.windows.forms.menuitem.ownerdraw](https://learn.microsoft.com/en-us/dotnet/api/system.windows.forms.menuitem.ownerdraw)

Accepted Answer

Um ein mit `SHGetFileInfo` extrahiertes Icon in VB.NET 2003 unter einem anderen Namen zu speichern, gehst du wie folgt vor: 1. **Icon extrahieren:** Mit `SHGetFileInfo` erhältst du einen Handle... [mehr]

Accepted Answer

Um ein mit `SHGetFileInfo` extrahiertes Icon in VB.NET 2003 unter einem anderen Namen zu speichern, gehst du wie folgt vor: 1. **Icon extrahieren:** Mit `SHGetFileInfo` erhältst du einen Handle auf das Icon (`hIcon`). 2. **Icon-Objekt erstellen:** Erzeuge daraus ein .NET-`Icon`-Objekt. 3. **Icon speichern:** Speichere das Icon mit der gewünschten Methode und unter dem gewünschten Namen. Hier ein Beispielcode: ```vb.net Imports System.Runtime.InteropServices Imports System.Drawing Imports System.IO Public Class IconExtractor <StructLayout(LayoutKind.Sequential)> Public Structure SHFILEINFO Public hIcon As IntPtr Public iIcon As Integer Public dwAttributes As Integer <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=260)> Public szDisplayName As String <MarshalAs(UnmanagedType.ByValTStr, SizeConst:=80)> Public szTypeName As String End Structure <DllImport("shell32.dll")> Public Shared Function SHGetFileInfo( _ ByVal pszPath As String, _ ByVal dwFileAttributes As Integer, _ ByRef psfi As SHFILEINFO, _ ByVal cbFileInfo As Integer, _ ByVal uFlags As Integer) As IntPtr End Function <DllImport("user32.dll", SetLastError:=True)> Public Shared Function DestroyIcon(ByVal hIcon As IntPtr) As Boolean End Function Public Const SHGFI_ICON As Integer = &H100 Public Const SHGFI_LARGEICON As Integer = &H0 ' 32x32 Public Const SHGFI_SMALLICON As Integer = &H1 ' 16x16 Public Shared Sub SaveIcon(ByVal filePath As String, ByVal saveAs As String) Dim shinfo As New SHFILEINFO() Dim hImg As IntPtr = SHGetFileInfo(filePath, 0, shinfo, Marshal.SizeOf(shinfo), SHGFI_ICON Or SHGFI_LARGEICON) If shinfo.hIcon <> IntPtr.Zero Then Dim icon As Icon = Icon.FromHandle(shinfo.hIcon) Using fs As New FileStream(saveAs, FileMode.Create) icon.Save(fs) End Using DestroyIcon(shinfo.hIcon) End If End Sub End Class ``` **Verwendung:** ```vb.net IconExtractor.SaveIcon("C:\Windows\notepad.exe", "C:\Temp\notepad_icon.ico") ``` **Hinweise:** - Der Code speichert das extrahierte Icon als `.ico`-Datei unter dem gewünschten Namen. - Achte darauf, den Icon-Handle nach der Verwendung mit `DestroyIcon` freizugeben, um Speicherlecks zu vermeiden. Weitere Infos zu [SHGetFileInfo (Microsoft Doku)](https://learn.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-shgetfileinfoa).

Accepted Answer

Der Fehler „Der Vorgang 'read' konnte nicht auf dem Speicher...“ ist kein typischer .NET-Fehler, sondern ein Zugriffsverletzungsfehler (Access Violation), der meist auftritt, wen... [mehr]

Accepted Answer

Der Fehler „Der Vorgang 'read' konnte nicht auf dem Speicher...“ ist kein typischer .NET-Fehler, sondern ein Zugriffsverletzungsfehler (Access Violation), der meist auftritt, wenn unsicherer oder nativer Code (z.B. über DLLs, COM-Objekte oder API-Aufrufe) auf ungültige Speicherbereiche zugreift. In VB.NET 2003 (also .NET Framework 1.1) kannst du solche Fehler **nicht** direkt mit einem normalen `Try...Catch`-Block abfangen, da Zugriffsverletzungen (AccessViolationException) in dieser .NET-Version nicht als verwaltete Ausnahmen behandelt werden. Das Programm wird in der Regel sofort beendet. **Mögliche Ansätze:** 1. **Code überprüfen:** Prüfe, ob du unsicheren Code, P/Invoke, COM-Objekte oder Drittanbieter-DLLs verwendest. Fehler in diesen Bereichen sind die häufigste Ursache. 2. **Try...Catch für COM-Interoperabilität:** Wenn du mit COM-Objekten arbeitest, kannst du zumindest COMException abfangen: ```vb.net Try ' COM-Aufruf Catch ex As System.Runtime.InteropServices.COMException ' Fehlerbehandlung End Try ``` Das hilft aber nur, wenn der Fehler als COMException geworfen wird. 3. **AppDomain.UnhandledException:** Du kannst einen globalen Handler für nicht abgefangene Ausnahmen setzen: ```vb.net AddHandler AppDomain.CurrentDomain.UnhandledException, AddressOf MyHandler Sub MyHandler(ByVal sender As Object, ByVal e As UnhandledExceptionEventArgs) ' Logging oder Benutzerbenachrichtigung End Sub ``` Aber: Auch hier kannst du den Fehler nicht wirklich „abfangen“ und das Programm läuft danach nicht stabil weiter. 4. **Debugging und Fehlerquellen finden:** Da du den Fehler nicht abfangen kannst, solltest du versuchen, die Ursache zu finden: - Nutze Debugging-Tools. - Überprüfe alle externen DLL-Aufrufe. - Achte auf falsche Pointer, Buffer Overflows etc. **Fazit:** In .NET 1.1 (VB.NET 2003) kannst du diesen Fehler nicht wirklich abfangen oder behandeln. Die beste Lösung ist, die Ursache zu finden und zu beheben. In neueren .NET-Versionen (ab 2.0) gibt es die `AccessViolationException`, aber auch dort ist ein Abfangen und Weiterarbeiten nicht empfohlen. **Weitere Infos:** - [Microsoft-Dokumentation zu AccessViolationException](https://learn.microsoft.com/de-de/dotnet/api/system.accessviolationexception) - [COMException in .NET](https://learn.microsoft.com/de-de/dotnet/api/system.runtime.interopservices.comexception) Falls du mit nativen DLLs arbeitest, prüfe die Übergabeparameter und Speicherverwaltung sehr genau.

Accepted Answer

In **VB.NET 2003** (Visual Studio .NET 2003) gibt es für das Standard-`ContextMenu`-Steuerelement keine direkte Unterstützung für Icons neben den Menüeinträgen. Das Hinzuf&uum... [mehr]

Accepted Answer

In **VB.NET 2003** (Visual Studio .NET 2003) gibt es für das Standard-`ContextMenu`-Steuerelement keine direkte Unterstützung für Icons neben den Menüeinträgen. Das Hinzufügen von Icons zu einem Kontextmenü ist erst ab späteren .NET-Versionen mit dem `ContextMenuStrip`-Steuerelement möglich. **In VB.NET 2003 gibt es zwei gängige Workarounds:** ### 1. Eigenes Zeichnen des Menüs (Owner Draw) Du kannst das Menü als "Owner Draw" deklarieren und die Icons selbst zeichnen. Das ist allerdings recht aufwändig und erfordert einiges an Code. **Kurzes Beispiel:** 1. Setze die `OwnerDraw`-Eigenschaft jedes `MenuItem` auf `True`. 2. Behandle die `DrawItem`- und `MeasureItem`-Ereignisse. ```vb ' Beispiel für ein MenuItem mit Icon Dim menuItem As New MenuItem("Öffnen") menuItem.OwnerDraw = True AddHandler menuItem.DrawItem, AddressOf menuItem_DrawItem AddHandler menuItem.MeasureItem, AddressOf menuItem_MeasureItem ' Füge das MenuItem dem ContextMenu hinzu ContextMenu1.MenuItems.Add(menuItem) ' Beispiel-Handler Private Sub menuItem_DrawItem(ByVal sender As Object, ByVal e As DrawItemEventArgs) Dim icon As Icon = New Icon("C:\Pfad\zu\deinem\icon.ico") e.Graphics.DrawIcon(icon, e.Bounds.Left, e.Bounds.Top) e.Graphics.DrawString(CType(sender, MenuItem).Text, e.Font, Brushes.Black, e.Bounds.Left + 20, e.Bounds.Top) End Sub Private Sub menuItem_MeasureItem(ByVal sender As Object, ByVal e As MeasureItemEventArgs) e.ItemHeight = 20 e.ItemWidth = 100 End Sub ``` ### 2. Drittanbieter-Komponenten verwenden Es gibt kommerzielle und freie Komponenten, die erweiterte Menüs mit Icon-Unterstützung bieten, z.B. [DevExpress](https://www.devexpress.com/), [ComponentOne](https://www.grapecity.com/componentone), oder [Infragistics](https://www.infragistics.com/). --- **Fazit:** Im Standard-`ContextMenu` von VB.NET 2003 ist das Hinzufügen von Icons nur über OwnerDraw-Workarounds oder Drittanbieter-Komponenten möglich. Einfache native Unterstützung gibt es erst ab .NET 2.0 mit `ContextMenuStrip`.

Accepted Answer

Der Wert für die Eigenschaft `PictureBox.SizeMode` in VB.NET 2003 hat den Datentyp [`PictureBoxSizeMode`](https://learn.microsoft.com/de-de/dotnet/api/system.windows.forms.pictureboxsizemode?view... [mehr]

Accepted Answer

Der Wert für die Eigenschaft `PictureBox.SizeMode` in VB.NET 2003 hat den Datentyp [`PictureBoxSizeMode`](https://learn.microsoft.com/de-de/dotnet/api/system.windows.forms.pictureboxsizemode?view=netframework-1.1), also einen **Enum** (Aufzählungstyp). Die möglichen Werte sind z.B.: - `Normal` - `StretchImage` - `AutoSize` - `CenterImage` - `Zoom` Der Datentyp ist also: **System.Windows.Forms.PictureBoxSizeMode** (Enum)