Ausdrücke in Visual Basic

Dieses Thema gilt für folgende Anwendungsbereiche:

Edition	Visual Basic	C#	F#	C++	Web Developer
Express
Pro, Premium und Ultimate

Die meisten in Visual Basic verfassten Ausdrücke werden von der verwalteten Ausdrucksauswertung akzeptiert. Im Direktfenster unterstützt die Ausdrucksauswertung nur einzeilige Anweisungen.

In den folgenden Abschnitten erhalten Sie neben spezifischen Informationen auch Erläuterungen zu einigen nicht oder nur teilweise unterstützten Ausdruckstypen:

• Typumwandlungen

• Dynamische Objekte

• Funktionsauswertung

• Bezeichner und Typen

• Importaliase

• Objektvariablen mit systeminternen Typen

• Operatoren

• Eigenschaftenauswertung

• Zeichenfolgen

• Operator TypeOf

• Nicht unterstützte Schlüsselwörter

• Variablendeklarationen

• WebMethods

Die Regeln für die automatische Erweiterung, mit denen der Inhalt eines Datentyps in aussagekräftiger Form angezeigt werden kann, werden in Visual Basic nicht unterstützt. Weitere Informationen finden Sie unter Anzeigen von Elementen eines benutzerdefinierten Datentyps.

Typumwandlungen

Einfache Typumwandlungen funktionieren im Debugger:

A = CStr(B)

Dynamische Objekte

Der Ausdrucksauswerter kann Variablen auswerten, die statisch als dynamisch typisiert sind. Es kann auch Objekte auswerten, die die IDynamicObject-Schnittstelle implementieren. Wenn Objekte, die die IDynamicObject-Schnittstelle implementieren, im Fenster Überwachung ausgewertet werden, wird ein dynamischer Ansichtsknoten hinzugefügt. Der dynamische Ansichtsknoten zeigt Member an, ermöglicht aber keine Bearbeitung der Memberwerte.

Die folgenden Funktionen dynamischer Objekte werden nicht unterstützt:

• Die zusammengesetzten Operatoren +=, -=, %=, /= und *=

• Viele Umwandlungen, einschließlich numerischer Umwandlungen und Typargumentumwandlungen

• Methodenaufrufe mit mehr als zwei Argumenten

• Eigenschaftengetter mit mehr als zwei Argumenten

• Eigenschaftensetter mit Argumenten

• Zuweisen zu einem Indexer

• Die booleschen Operatoren "&&" und "||"

Funktionsauswertung

Der Debugger unterstützt die Auswertung von Funktionen, einschließlich überladener Funktionen. Daher können Sie einen der folgenden Ausdrücke eingeben, um die korrekte Version der überladenen Funktion aufzurufen:

myFunction (param1)

myFunction (param1, param2)

Beim Auswerten einer Funktion im Debugger wird der Code dieser Funktion aufgerufen und ausgeführt. Wenn die Funktion Nebeneffekte aufweist (z. B. Belegen von Speicher oder Ändern des Werts einer globalen Variablen), wird durch das Auswerten der Funktion in einem Debugfenster der Status des Programms geändert, was zu unerwarteten Ergebnissen führen kann.

Wenn Sie in einer überladenen Funktion einen Haltepunkt festlegen, hängt dessen Position davon ab, wie Sie die Funktion angeben. Wenn Sie lediglich den Namen der Funktion angeben, legt der Debugger an jeder Überladung dieses Funktionsnamens einen Haltepunkt fest. Wenn Sie dagegen die vollständige Signatur angeben, d. h. Funktionsname und komplette Argumentliste, wird nur an der angegebenen Überladung ein Haltepunkt festgelegt.

Bezeichner und Typen

In Debuggerausdrücken können alle Bezeichner verwendet werden, die innerhalb des aktuellen Gültigkeitsbereichs sichtbar sind. Wenn der Debugger beispielsweise in der Magh-Funktion angehalten wird, können Sie die meisten der innerhalb von Magh sichtbaren Bezeichner verwenden (hierzu zählen auch Variablennamen und Funktionsnamen). Lokale Konstanten werden nicht unterstützt. Sie können den Wert jeder innerhalb des aktuellen Gültigkeitsbereichs sichtbaren Variablen festlegen.

Der Debugger kann jede Variable primitiven oder systeminternen Typs ordnungsgemäß anzeigen. Bei Klassentypvariablen zeigt der Debugger den Wert für den in der Ableitungshierarchie ganz unten stehenden Typ ordnungsgemäß an. Angenommen, es gibt ein Objekt leo vom Typ Lion, der vom Typ Cat abgeleitet ist. Bei Auswertung von leo.Clawlength würden Sie in diesem Fall den korrekten Wert für ein Objekt vom Typ Lion erhalten.

Importaliase

Importaliase können im Debuggerfenster nicht verwendet werden.

Objektvariablen mit systeminternen Typen

Objektvariablen, die systeminterne Variablentypen enthalten, beispielsweise ganze Zahlen, werden in einer Art und Weise angezeigt und bearbeitet, die möglicherweise nicht besonders intuitiv erscheint. Z. B. könnte der Quellcode folgende Objektvariable enthalten:

Dim obj As Object = 5

Der Wert der Variablen obj wird im Fenster Überwachen angezeigt als:

5 {Integer}

Um den Wert dieser Variablen in 6 zu ändern, müssten Sie Folgendes eingeben:

6

Folgende Eingabe wäre jedoch falsch:

6 {Integer}

Nachdem Sie den Wert bearbeitet haben, werden Sie feststellen, dass der Debugger {Integer} für Sie hinzufügt.

Operatoren

Der Debugger wertet die meisten Operatoren ordnungsgemäß aus, z. B.:

• Arithmetische Operatoren: ( expr1 + expr2, expr1 - expr2, expr1 * expr2, expr1 / expr2, expr1 \ expr2, expr1 ^ expr2 , expr1 Mod expr2 ).

• Zuweisungsoperatoren: ( var1 = expr2, var1 ^= expr2, var1 *= expr2, var1 /= expr2, var1 \= expr2, var1 += expr2, var1 -= expr2, var1 &= expr2).

• Vergleichsoperatoren: (expr2 < expr2, expr2 <= expr2, expr1 > expr2, expr1 >= expr2, expr1 = expr2, expr1 <> expr2).

• Verkettungsoperatoren: (expr1 & expr2, expr1 + expr2).

• Logische Operatoren: (expr1 And expr2, expr1 Or expr2, expr1 XOr expr2, expr1 AndAlso expr2, expr1 OrElse expr2, Not expr1).

• Unäre Operatoren: ( - expr1, Not expr1, GetType (type) ).

Eigenschaftenauswertung

Der Debugger kann in beliebigen Variablenfenstern Eigenschaften auswerten. Beim Auswerten von Eigenschaften im Debugger können jedoch Nebeneffekte, z. B. geänderte Variablenwerte, auftreten, die sich auf die Programmergebnisse auswirken. Sie können die Eigenschaftenauswertung im Dialogfeld Allgemein, Debuggen, Optionen deaktivieren, um eventuelle Nebeneffekte durch eine versehentliche Auswertung zu vermeiden.

Zeichenfolgen

In Visual Basic können Sie den Operator Length für eine Zeichenfolge verwenden:

mystring.Length

– oder –

"hello world".Length

Operator TypeOf

In Visual Basic können Sie in den Debuggerfenstern den Operator TypeOf verwenden:

TypeOf Ausdruck Is Typ

Beispiel:

TypeOf Me Is Integer

zeigt den Wert false an.

Wenn Sie den Operator TypeOf verwenden, muss dieser Operator Teil eines Ausdrucks sein, der Is verwendet. Wenn Sie TypeOf ohne Is verwenden, wird die folgende Fehlermeldung angezeigt:

Is required

Nicht unterstützte Schlüsselwörter

Die folgenden Visual Basic-Schlüsselwörter werden in Ausdrücken des Debuggerfensters nicht unterstützt:

• AddressOf

• End

• Error

• Exit

• Goto

• On Error

• Return

• Resume

• Select/Case

• Stop

• SyncLock

• Throw

• Try/Catch/Finally

• With

Außerdem werden Schlüsselwörter der Namespace- oder Modulebene, wie End Sub oder Module, nicht unterstützt.

Variablendeklarationen

Neue Variablen können in Debuggerfenstern nicht explizit deklariert werden.

Zuweisungen zu einer impliziten Variablen sind im Direktfenster jedoch möglich. Diese impliziten Variablen sind auf den Bereich des Debuggers beschränkt; von außerhalb des Debuggers kann nicht darauf zugegriffen werden. Die Anweisung o = 5 beispielsweise erstellt eine neue Variable o und weist ihr den Wert 5 zu. Solche impliziten Variablen sind vom Typ Object, sofern der Typ nicht durch den Debugger abgeleitet werden kann.

WebMethods

WebMethods können nicht über ein Debuggerfenster aufgerufen werden.

Siehe auch

Weitere Ressourcen

Ausdrücke im Debugger

Sprachreferenz zu Visual Basic