Freigeben über

Ausdrücke in C#

  • Artikel

Aktualisiert: November 2007

Dieses Thema gilt für folgende Anwendungsbereiche:

Edition

Visual Basic

C#

C++

Web Developer

Express

Standard

Pro und Team

Tabellenlegende:

Vorhanden

Nicht vorhanden

Befehl oder Befehle, die standardmäßig ausgeblendet sind.

Die verwaltete Ausdrucksauswertung unterstützt die meisten der in C# geschriebenen Ausdrücke. In den folgenden Abschnitten erhalten Sie neben spezifischen Informationen auch Erläuterungen zu einigen nicht unterstützten Ausdruckstypen:

  • Bezeichner und Typen

  • Methodenauswertung

  • Operatoren

  • Überladene Operatoren

  • Zeichenfolgen

  • Typumwandlungen

  • typeof-Operator und sizeof-Operator

  • Eigenschaftenauswertung

Die Ausdrucksauswertung ignoriert die Zugriffsmodifizierer public, protected, internal und private. Sie können eine private-Methode z. B. im Fenster Überwachen aufrufen. Da die Ausdrucksauswertung Zugriffsmodifizierer ignoriert, ist es möglich, dass ein unerwartetes Laden aufgerufen wird.

Die Ausdrucksauswertung führt alle Auswertungen in einem impliziten, unsicheren Kontext durch. Das geschieht unabhängig davon, ob der ausgeführte Code sicher oder unsicher ist.

Die Ausdrucksauswertung ignoriert auch geprüfte Blöcke und die /checked-Compileroption. Alle Ausdrücke werden in einem nicht geprüften Kontext ausgewertet.

Sie können die Anzeige von benutzerdefinierten Datentypen mithilfe von Attributen anpassen. Weitere Informationen finden Sie unter Anzeigen von benutzerdefinierten Datentypen.

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-Methode angehalten wird, können Sie jeden innerhalb von Magh sichtbaren Bezeichner verwenden, einschließlich Konstanten, Variablennamen und Methodennamen.

Der Debugger kann alle primitiven, systeminternen und Enumerationsvariablen 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.Claws würden Sie in diesem Fall den korrekten Wert für ein Objekt vom Typ Lion erhalten.

Sie können jedem linksseitigen Ausdruck einen neuen Wert zuweisen, der einen l-Wert darstellt. Dazu gehören zum Beispiel primitive Typen, Klassentypen und System.Object-Typen.

Methodenauswertung

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

Time.Set();
Time.Set(atime);

Beim Auswerten einer Methode im Debugger wird der Code dieser Methode aufgerufen und ausgeführt. Wenn die Methode Nebeneffekte aufweist, wird durch das Auswerten der Methode in einem Debugfenster der Status des Programms geändert, was zu unerwarteten Ergebnissen führen kann.

Wenn Sie in einer überladenen Methode einen Haltepunkt festlegen, hängt dessen Position davon ab, wie Sie die Methode angeben. Wenn Sie dagegen die vollständige Signatur angeben (Methodenname und komplette Argumentliste), wird nur an der angegebenen Überladung ein Haltepunkt festgelegt. Wenn Sie nur den Methodennamen angeben, hängt das Verhalten des Debuggers von einer Visual Studio-Optionseinstellung ab. Wenn das Kontrollkästchen Funktionsnamen mit IntelliSense überprüfen deaktiviert ist, legt der Debugger bei jeder Überladung dieses Methodennamens einen Haltepunkt fest. Andernfalls wird das Dialogfeld Haltepunkt auswählen geöffnet. Damit können Sie angeben, bei welchen Überladungen der Haltepunkt gesetzt werden soll. Weitere Informationen finden Sie unter Gewusst wie: Festlegen eines Funktionshaltepunkts.

Die Erstellung neuer anonymer Methoden wird in dieser Version von Visual Studio im Debugger nicht unterstützt.

Operatoren

Der Debugger wertet die meisten integrierten Operatoren ordnungsgemäß aus, einschließlich der folgenden:

  • Relationale Operatoren und Gleichheitsoperatoren: (expr1 > expr2, expr1 < expr2, expr1 <= expr2, expr1 => expr2, expr1 == expr2, expr1 != expr2).

  • Boolesche Operatoren: (expr1 && expr2, expr1 || expr2, expr1 ? expr2 : expr3).

  • Arithmetische Operatoren: (expr1 + expr2,expr1 - expr2, expr1 * expr2, expr1 / expr2, expr1 % expr2 ).

  • Logische Operatoren: (expr1 & expr2, expr1 ^ expr2, expr1 | expr2 ).

  • Schiebeoperatoren: (expr1 >> expr2, expr1 << expr2 ).

  • Zuweisungsoperatoren: (lvalue = expr2, lvalue *= expr2lvalue /= expr2, lvalue %= expr2, lvalue += expr2, lvalue -= expr2, lvalue <<= expr2, lvalue >>= expr2, lvalue &= expr2, lvalue ^= expr2, lvalue |= expr2).

  • Unäre Operatoren: (+expr1, - expr1, expr1++, ++expr1, expr1--, --expr1).

Überladene Operatoren

Die meisten überladenen Operatoren funktionieren im Debugger.

Die überladenen Infixoperatoren +, -, /, % und & funktionieren:

  • expr1 + expr2

  • expr1expr2

  • expr1 / expr2

  • expr1 % expr2

  • expr1 & expr2

Die überladenen Infixoperatoren =, &&, & und || funktionieren nicht:

  • expr1 = expr2

  • expr1 && expr2

  • expr1 & expr2

  • expr1 || expr2

Die überladenen Infixoperatoren << und >> funktionieren nicht, wenn beide Operanden Klassenvariablen sind:

  • object1 <<object2

  • object1 >> object2

Die überladenen Präfixoperatoren +, -, ++, --, ! und ~ funktionieren:

  • +expr1

  • -expr1

  • ++expr1

  • --expr1

  • !expr1

  • ~expr1

Die überladenen Suffixoperatoren ++ und -- funktionieren:

  • expr1++

  • expr1--

Überladene Indexer funktionieren:

  • expr1[expr2]

Zeichenfolgen

Der Debugger erkennt den indizierten Operator sowohl bei der Verwendung mit Zeichenfolgen als auch bei der Verwendung mit Arrays. Sie können also beispielsweise Folgendes eingeben:

"hello world"[0]

Im Fenster Überwachen wird der richtige Wert angezeigt:

'h'

Im Gegensatz zu systemeigenem C/C++ können Sie in C# den Wert einer Zeichenfolge im Debugger bearbeiten. Darüber hinaus können Sie den Length-Operator für eine Zeichenfolge verwenden:

mystring.Length

– oder –

"hello world".Length

In C# können Zeichenfolgen verkettet werden:

"hello" + "world"

Typumwandlungen

Einfache Typumwandlungsausdrücke funktionieren im Debugger:

(A)x

Typumwandlungen mit Zeigern funktionieren dagegen nicht.

typeof-Operator und sizeof-Operator

Der Debugger unterstützt den typeof-Operator und den sizeof-Operator, indem er ihn jeweils in die entsprechende .NET Framework-Funktion umwandelt.

typeof ( expression )

wird umgewandelt in:

System.Type.GetType( expression )

Anschließend wertet der Debugger diesen umgewandelten Ausdruck aus.

Der Debugger unterstützt den sizeof-Operator.

Eigenschaftenauswertung

Der Debugger kann in beliebigen Variablenfenstern Eigenschaften auswerten. Beim Auswerten von Eigenschaften im Debugger können jedoch Nebeneffekte auftreten, die unerwartete und unerwünschte Ergebnisse liefern. Sie können die Eigenschaftenauswertung im Dialogfeld Optionen deaktivieren, um eventuellen Nebeneffekten durch eine versehentliche Auswertung vorzubeugen.

WebMethods

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

Siehe auch

Weitere Ressourcen

Ausdrücke im Debugger

C#-Referenz