TypenTypes

Die Typen der Programmiersprache c# sind in zwei Hauptkategorien unterteilt: Werttypen _ und _Verweis Typen*.The types of the C# language are divided into two main categories: value types _ and _reference types*. Sowohl Werttypen als auch Verweis Typen können generische Typen sein, die einen oder mehrere _ *-Typparameter annehmen * *.Both value types and reference types may be generic types, which take one or more _*type parameters**. Typparameter können sowohl Werttypen als auch Verweis Typen bestimmen.Type parameters can designate both value types and reference types.

type
    : value_type
    | reference_type
    | type_parameter
    | type_unsafe
    ;

Die letzte Kategorie von Typen, Zeiger, ist nur in unsicherem Code verfügbar.The final category of types, pointers, is available only in unsafe code. Dies wird in Zeiger Typenausführlicher erläutert.This is discussed further in Pointer types.

Werttypen unterscheiden sich von Verweis Typen in den Variablen der Werttypen, die Ihre Daten direkt enthalten, wohingegen Variablen der Verweis Typen *Verweise _ auf die Daten speichern, letztere werden als _ Objects * bezeichnet.Value types differ from reference types in that variables of the value types directly contain their data, whereas variables of the reference types store references _ to their data, the latter being known as _objects**. Bei Verweis Typen können zwei Variablen auf das gleiche Objekt verweisen, und so können Vorgänge in einer Variablen das Objekt beeinflussen, auf das von der anderen Variablen verwiesen wird.With reference types, it is possible for two variables to reference the same object, and thus possible for operations on one variable to affect the object referenced by the other variable. Bei Werttypen verfügen die Variablen jeweils über eine eigene Kopie der Daten, und es ist nicht möglich, dass sich der Vorgang auf einen anderen auswirkt.With value types, the variables each have their own copy of the data, and it is not possible for operations on one to affect the other.

Das Typsystem von c# ist einheitlich, sodass ein Wert eines beliebigen Typs als Objekt behandelt werden kann.C#'s type system is unified such that a value of any type can be treated as an object. Jeder Typ in C# ist direkt oder indirekt vom object-Klassentyp abgeleitet, und object ist die ultimative Basisklasse aller Typen.Every type in C# directly or indirectly derives from the object class type, and object is the ultimate base class of all types. Werte von Verweistypen werden als Objekte behandelt, indem die Werte einfach als Typ object angezeigt werden.Values of reference types are treated as objects simply by viewing the values as type object. Werte von Werttypen werden als Objekte behandelt, indem Boxing-und Unboxing-Vorgänge (Boxing und Unboxing) durchgeführt werden.Values of value types are treated as objects by performing boxing and unboxing operations (Boxing and unboxing).

WerttypenValue types

Ein Werttyp ist entweder ein Strukturtyp oder ein Enumerationstyp.A value type is either a struct type or an enumeration type. C# stellt einen Satz vordefinierter Strukturtypen bereit, die als einfache Typen bezeichnet werden.C# provides a set of predefined struct types called the simple types. Die einfachen Typen werden mithilfe von reservierten Wörtern identifiziert.The simple types are identified through reserved words.

value_type
    : struct_type
    | enum_type
    ;

struct_type
    : type_name
    | simple_type
    | nullable_type
    ;

simple_type
    : numeric_type
    | 'bool'
    ;

numeric_type
    : integral_type
    | floating_point_type
    | 'decimal'
    ;

integral_type
    : 'sbyte'
    | 'byte'
    | 'short'
    | 'ushort'
    | 'int'
    | 'uint'
    | 'long'
    | 'ulong'
    | 'char'
    ;

floating_point_type
    : 'float'
    | 'double'
    ;

nullable_type
    : non_nullable_value_type '?'
    ;

non_nullable_value_type
    : type
    ;

enum_type
    : type_name
    ;

Anders als bei einer Variablen eines Verweis Typs kann eine Variable eines Werttyps den Wert null nur enthalten, wenn der Werttyp ein Typ ist, der NULL-Werte zulässt.Unlike a variable of a reference type, a variable of a value type can contain the value null only if the value type is a nullable type. Für jeden Werttyp, der nicht auf NULL festgelegt werden kann, gibt es einen entsprechenden Werte zulässt-Werttyp, der denselben Satz von Werten und den Wert bezeichnet null .For every non-nullable value type there is a corresponding nullable value type denoting the same set of values plus the value null.

Durch die Zuweisung zu einer Variablen eines Werttyps wird eine Kopie des zugewiesenen Werts erstellt.Assignment to a variable of a value type creates a copy of the value being assigned. Dies unterscheidet sich von der Zuweisung zu einer Variablen eines Verweis Typs, die den Verweis, aber nicht das durch den Verweis identifizierte Objekt kopiert.This differs from assignment to a variable of a reference type, which copies the reference but not the object identified by the reference.

Der Typ "System. ValueType"The System.ValueType type

Alle Werttypen erben implizit von der-Klasse System.ValueType , die wiederum von der-Klasse erbt object .All value types implicitly inherit from the class System.ValueType, which, in turn, inherits from class object. Es ist nicht möglich, dass ein Typ von einem Werttyp abgeleitet wird. Werttypen sind daher implizit versiegelt (versiegelte Klassen).It is not possible for any type to derive from a value type, and value types are thus implicitly sealed (Sealed classes).

Beachten Sie, dass System.ValueType nicht selbst ein value_type ist.Note that System.ValueType is not itself a value_type. Vielmehr handelt es sich um eine class_type , von der alle value_type s automatisch abgeleitet werden.Rather, it is a class_type from which all value_type s are automatically derived.

StandardkonstruktorenDefault constructors

Alle Werttypen deklarieren implizit einen öffentlichen Parameter losen Instanzenkonstruktor, der als *Standardkonstruktor _ bezeichnet wird.All value types implicitly declare a public parameterless instance constructor called the *default constructor _. Der Standardkonstruktor gibt eine NULL initialisierte-Instanz zurück, die als _-Standardwert* für den Werttyp bekannt ist:The default constructor returns a zero-initialized instance known as the _ default value* for the value type:

  • Der Standardwert für alle Simple_Type s ist der Wert, der von einem Bitmuster aller Nullen erzeugt wird:For all simple_type s, the default value is the value produced by a bit pattern of all zeros:
    • Für sbyte , byte , short , ushort , int , uint , long und ulong ist der Standardwert 0 .For sbyte, byte, short, ushort, int, uint, long, and ulong, the default value is 0.
    • charDer Standardwert für ist '\x0000' .For char, the default value is '\x0000'.
    • floatDer Standardwert für ist 0.0f .For float, the default value is 0.0f.
    • doubleDer Standardwert für ist 0.0d .For double, the default value is 0.0d.
    • decimalDer Standardwert für ist 0.0m .For decimal, the default value is 0.0m.
    • boolDer Standardwert für ist false .For bool, the default value is false.
  • Bei einem enum_type E ist der Standardwert 0 , der in den-Typ konvertiert wird E .For an enum_type E, the default value is 0, converted to the type E.
  • Bei einem struct_type ist der Standardwert der Wert, der erzeugt wird, indem alle Werttyp Felder auf ihren Standardwert und alle Verweistyp Felder auf festgelegt werden null .For a struct_type, the default value is the value produced by setting all value type fields to their default value and all reference type fields to null.
  • Bei einem- nullable_type ist der Standardwert eine-Instanz, für die die HasValue -Eigenschaft false ist und die- Value Eigenschaft nicht definiert ist.For a nullable_type the default value is an instance for which the HasValue property is false and the Value property is undefined. Der Standardwert wird auch als NULL- Wert des Typs bezeichnet, der NULL-Werte zulässt.The default value is also known as the null value of the nullable type.

Wie jeder andere Instanzkonstruktor wird der Standardkonstruktor eines Werttyps mit dem- new Operator aufgerufen.Like any other instance constructor, the default constructor of a value type is invoked using the new operator. Aus Effizienzgründen ist diese Anforderung nicht dafür vorgesehen, dass die Implementierung einen konstruktorbefehl generiert.For efficiency reasons, this requirement is not intended to actually have the implementation generate a constructor call. Im folgenden Beispiel i werden Variablen und j beide mit 0 (null) initialisiert.In the example below, variables i and j are both initialized to zero.

class A
{
    void F() {
        int i = 0;
        int j = new int();
    }
}

Da jeder Werttyp implizit über einen öffentlichen Parameter losen Instanzenkonstruktor verfügt, ist es nicht möglich, dass ein Strukturtyp eine explizite Deklaration eines Parameter losen Konstruktors enthält.Because every value type implicitly has a public parameterless instance constructor, it is not possible for a struct type to contain an explicit declaration of a parameterless constructor. Ein Strukturtyp ist jedoch zulässig, um parametrisierte Instanzkonstruktoren (Konstruktoren) zu deklarieren.A struct type is however permitted to declare parameterized instance constructors (Constructors).

StrukturtypenStruct types

Ein Strukturtyp ist ein Werttyp, der Konstanten, Felder, Methoden, Eigenschaften, Indexer, Operatoren, Instanzkonstruktoren, statische Konstruktoren und Strukturtypen deklarieren kann.A struct type is a value type that can declare constants, fields, methods, properties, indexers, operators, instance constructors, static constructors, and nested types. Die Deklaration von Strukturtypen wird in Struktur Deklarationenbeschrieben.The declaration of struct types is described in Struct declarations.

Einfache TypenSimple types

C# stellt einen Satz vordefinierter Strukturtypen bereit, die als einfache Typen bezeichnet werden.C# provides a set of predefined struct types called the simple types. Die einfachen Typen werden mithilfe von reservierten Wörtern identifiziert. diese reservierten Wörter sind jedoch einfach Aliase für vordefinierte Strukturtypen im- System Namespace, wie in der folgenden Tabelle beschrieben.The simple types are identified through reserved words, but these reserved words are simply aliases for predefined struct types in the System namespace, as described in the table below.

Reserviertes WortReserved word Alias-TypAliased type
sbyte System.SByte
byte System.Byte
short System.Int16
ushort System.UInt16
int System.Int32
uint System.UInt32
long System.Int64
ulong System.UInt64
char System.Char
float System.Single
double System.Double
bool System.Boolean
decimal System.Decimal

Da ein einfacher Typ einen Strukturtyp Aliase, verfügt jeder einfache Typ über Member.Because a simple type aliases a struct type, every simple type has members. Beispielsweise int verfügt über die in deklarierten Member System.Int32 und die von geerbten Member System.Object , und die folgenden Anweisungen sind zulässig:For example, int has the members declared in System.Int32 and the members inherited from System.Object, and the following statements are permitted:

int i = int.MaxValue;           // System.Int32.MaxValue constant
string s = i.ToString();        // System.Int32.ToString() instance method
string t = 123.ToString();      // System.Int32.ToString() instance method

Die einfachen Typen unterscheiden sich von anderen Strukturtypen dadurch, dass sie bestimmte zusätzliche Vorgänge ermöglichen:The simple types differ from other struct types in that they permit certain additional operations:

  • Bei den meisten einfachen Typen können Werte erstellt werden, indem Literale (Literale) geschrieben werden.Most simple types permit values to be created by writing literals (Literals). Beispielsweise 123 ist ein Literaltyp, int und 'a' ist ein Literaltyp char .For example, 123 is a literal of type int and 'a' is a literal of type char. C# stellt im Allgemeinen keine Bereitstellung von literalen von Strukturtypen bereit, und nicht standardmäßige Werte anderer Strukturtypen werden letztendlich immer durch Instanzkonstruktoren dieser Strukturtypen erstellt.C# makes no provision for literals of struct types in general, and non-default values of other struct types are ultimately always created through instance constructors of those struct types.
  • Wenn es sich bei den Operanden eines Ausdrucks um einfache Typkonstanten handelt, kann der Compiler den Ausdruck zur Kompilierzeit auswerten.When the operands of an expression are all simple type constants, it is possible for the compiler to evaluate the expression at compile-time. Ein solcher Ausdruck wird als constant_expression (Konstante Ausdrücke) bezeichnet.Such an expression is known as a constant_expression (Constant expressions). Ausdrücke mit Operatoren, die von anderen Strukturtypen definiert werden, werden nicht als Konstante Ausdrücke betrachtet.Expressions involving operators defined by other struct types are not considered to be constant expressions.
  • Mithilfe const von Deklarationen ist es möglich, Konstanten der einfachen Typen (Konstanten) zu deklarieren.Through const declarations it is possible to declare constants of the simple types (Constants). Es ist nicht möglich, Konstanten anderer Strukturtypen zu haben, aber es wird ein ähnlicher Effekt durch static readonly Felder bereitgestellt.It is not possible to have constants of other struct types, but a similar effect is provided by static readonly fields.
  • Konvertierungen, die einfache Typen umfassen, können an der Auswertung von Konvertierungs Operatoren teilnehmen, die von anderen Strukturtypen definiert werden, aber ein benutzerdefinierter Konvertierungs Operator kann nie an der Auswertung eines anderen benutzerdefinierten Operators teilnehmen (Auswertung benutzerdefinierter Konvertierungen).Conversions involving simple types can participate in evaluation of conversion operators defined by other struct types, but a user-defined conversion operator can never participate in evaluation of another user-defined operator (Evaluation of user-defined conversions).

Ganzzahlige TypenIntegral types

C# unterstützt neun ganzzahlige Typen: sbyte , byte , short , ushort , int , uint , long , ulong und char .C# supports nine integral types: sbyte, byte, short, ushort, int, uint, long, ulong, and char. Die ganzzahligen Typen weisen die folgenden Größen und Wertebereiche auf:The integral types have the following sizes and ranges of values:

  • Der sbyte -Typ stellt signierte 8-Bit-Ganzzahlen mit Werten zwischen-128 und 127 dar.The sbyte type represents signed 8-bit integers with values between -128 and 127.
  • Der- byte Typ stellt nicht signierte 8-Bit-Ganzzahlen mit Werten zwischen 0 und 255 dar.The byte type represents unsigned 8-bit integers with values between 0 and 255.
  • Der short -Typ stellt signierte 16-Bit-Ganzzahlen mit Werten zwischen-32768 und 32767 dar.The short type represents signed 16-bit integers with values between -32768 and 32767.
  • Der- ushort Typ stellt ganze 16-Bit-Ganzzahlen ohne Vorzeichen mit Werten zwischen 0 und 65535 dar.The ushort type represents unsigned 16-bit integers with values between 0 and 65535.
  • Der- int Typ stellt signierte 32-Bit-Ganzzahlen mit Werten zwischen-2147483648 und 2147483647 dar.The int type represents signed 32-bit integers with values between -2147483648 and 2147483647.
  • Der uint -Typ stellt nicht signierte 32-Bit-Ganzzahlen mit Werten zwischen 0 und 4294967295 dar.The uint type represents unsigned 32-bit integers with values between 0 and 4294967295.
  • Der- long Typ stellt signierte 64-Bit-Ganzzahlen mit Werten zwischen-9.223.372.036.854.775.808 und 9223372036854775807 dar.The long type represents signed 64-bit integers with values between -9223372036854775808 and 9223372036854775807.
  • Der ulong -Typ stellt nicht signierte 64-Bit-Ganzzahlen mit Werten zwischen 0 und 18446744073709551615 dar.The ulong type represents unsigned 64-bit integers with values between 0 and 18446744073709551615.
  • Der- char Typ stellt ganze 16-Bit-Ganzzahlen ohne Vorzeichen mit Werten zwischen 0 und 65535 dar.The char type represents unsigned 16-bit integers with values between 0 and 65535. Die Menge der darstellbaren Werte für den char-Typ stimmt mit dem Unicode-Zeichensatz überein.The set of possible values for the char type corresponds to the Unicode character set. Obwohl char die gleiche Darstellung wie hat ushort , sind nicht alle Vorgänge zulässig, die für einen Typ zulässig sind.Although char has the same representation as ushort, not all operations permitted on one type are permitted on the other.

Der unäre und binäre Operator des ganzzahligen Typs funktionieren immer mit der signierten 32-Bit-Genauigkeit, der 32-Bit-Genauigkeit ohne Vorzeichen, der 64-Bit-Genauigkeit mit Vorzeichen oder der 64-Bit-Genauigkeit ohne Vorzeichen:The integral-type unary and binary operators always operate with signed 32-bit precision, unsigned 32-bit precision, signed 64-bit precision, or unsigned 64-bit precision:

  • Für die unären + ~ Operatoren und wird der Operand in den Typ konvertiert T , wobei T der erste von int ,, und ist, der uint long ulong alle möglichen Werte des Operanden vollständig darstellen kann.For the unary + and ~ operators, the operand is converted to type T, where T is the first of int, uint, long, and ulong that can fully represent all possible values of the operand. Der Vorgang wird dann mit der Genauigkeit des Typs ausgeführt T , und der Ergebnistyp ist T .The operation is then performed using the precision of type T, and the type of the result is T.
  • Für den unären - Operator wird der Operand in den Typ konvertiert T . dabei T ist der erste von int und long , der alle möglichen Werte des Operanden vollständig darstellen kann.For the unary - operator, the operand is converted to type T, where T is the first of int and long that can fully represent all possible values of the operand. Der Vorgang wird dann mit der Genauigkeit des Typs ausgeführt T , und der Ergebnistyp ist T .The operation is then performed using the precision of type T, and the type of the result is T. Der unäre - Operator kann nicht auf Operanden vom Typ angewendet werden ulong .The unary - operator cannot be applied to operands of type ulong.
  • Für die binären Operatoren,,,,, + - ,, * / % & ^ | , == , != ,,, > < >= und <= werden die Operanden in den-Typ konvertiert T . dabei T ist der erste von int , uint , und, long ulong der alle möglichen Werte beider Operanden vollständig darstellen kann.For the binary +, -, *, /, %, &, ^, |, ==, !=, >, <, >=, and <= operators, the operands are converted to type T, where T is the first of int, uint, long, and ulong that can fully represent all possible values of both operands. Der Vorgang wird dann mit der Genauigkeit des Typs durchgeführt T , und der Ergebnistyp ist T (oder bool für die relationalen Operatoren).The operation is then performed using the precision of type T, and the type of the result is T (or bool for the relational operators). Es ist nicht zulässig, dass ein Operand vom Typ long und der andere vom Typ ulong mit den binären Operatoren ist.It is not permitted for one operand to be of type long and the other to be of type ulong with the binary operators.
  • Für die binären << -und- >> Operatoren wird der linke Operand in den-Typ konvertiert T , wobei T der erste von int ,, und ist, der uint long ulong alle möglichen Werte des Operanden vollständig darstellen kann.For the binary << and >> operators, the left operand is converted to type T, where T is the first of int, uint, long, and ulong that can fully represent all possible values of the operand. Der Vorgang wird dann mit der Genauigkeit des Typs ausgeführt T , und der Ergebnistyp ist T .The operation is then performed using the precision of type T, and the type of the result is T.

Der char Typ wird als ganzzahliger Typ klassifiziert, aber er unterscheidet sich von den anderen ganzzahligen Typen auf zwei Arten:The char type is classified as an integral type, but it differs from the other integral types in two ways:

  • Es gibt keine impliziten Konvertierungen anderen Typen in Typ char.There are no implicit conversions from other types to the char type. Insbesondere wenn die sbyte byte Typen, und ushort Wertebereiche aufweisen, die mithilfe des-Typs vollständig Darstell Bar sind char , sind implizite Konvertierungen von sbyte , byte oder ushort char nicht vorhanden.In particular, even though the sbyte, byte, and ushort types have ranges of values that are fully representable using the char type, implicit conversions from sbyte, byte, or ushort to char do not exist.
  • Konstanten des char Typs müssen in Kombination mit einer Umwandlung in den Typ als character_literal s oder als integer_literal s geschrieben werden char .Constants of the char type must be written as character_literal s or as integer_literal s in combination with a cast to type char. (char)10 entspricht beispielsweise '\x000A'.For example, (char)10 is the same as '\x000A'.

Die checked unchecked Operatoren und und Anweisungen werden verwendet, um die Überlauf Überprüfung bei arithmetischen Operationen und Konvertierungenvon ganzzahligen Typen zu steuernThe checked and unchecked operators and statements are used to control overflow checking for integral-type arithmetic operations and conversions (The checked and unchecked operators). In einem checked Kontext erzeugt ein Überlauf einen Kompilierzeitfehler oder bewirkt, dass eine ausgelöst System.OverflowException wird.In a checked context, an overflow produces a compile-time error or causes a System.OverflowException to be thrown. In einem unchecked Kontext werden Überläufe ignoriert, und alle höherwertigen Bits, die nicht in den Zieltyp passen, werden verworfen.In an unchecked context, overflows are ignored and any high-order bits that do not fit in the destination type are discarded.

Gleit Komma TypenFloating point types

C# unterstützt zwei Gleit Komma Typen: float und double .C# supports two floating point types: float and double. Der float - double Typ und der-Typ werden mithilfe der 32-Bit-Formate für die einfache Genauigkeit und 64 Bit mit doppelter 754 Genauigkeit dargestellt, die die folgenden Werte Sätze bereitstellen:The float and double types are represented using the 32-bit single-precision and 64-bit double-precision IEEE 754 formats, which provide the following sets of values:

  • Positive null (+0) und negative null (-0):Positive zero and negative zero. In den meisten Fällen verhalten sich positiv NULL und negatives NULL identisch mit dem einfachen Wert 0 (null), aber bestimmte Vorgänge unterscheiden zwischen den beiden (Divisions Operator).In most situations, positive zero and negative zero behave identically as the simple value zero, but certain operations distinguish between the two (Division operator).
  • Positiv unendlich und minus unendlich.Positive infinity and negative infinity. Unendlich ist das Ergebnis von Vorgängen wie das Teilen einer Zahl ungleich null (0) durch null (0).Infinities are produced by such operations as dividing a non-zero number by zero. 1.0 / 0.0 ergibt beispielsweise positiv unendlich und -1.0 / 0.0 negativ unendlich.For example, 1.0 / 0.0 yields positive infinity, and -1.0 / 0.0 yields negative infinity.
  • Der not-a-Number- Wert, häufig als NaN abgekürzt.The Not-a-Number value, often abbreviated NaN. NaN-Werte werden durch ungültige Gleitkommavorgänge erzeugt, z. B. beim Teilen von null durch null.NaNs are produced by invalid floating-point operations, such as dividing zero by zero.
  • Der endliche Satz von Werten ungleich 0 (null) im Formular s * m * 2^e , wobei s 1 oder-1 ist, und m und e durch den jeweiligen Gleit kommatyp bestimmt werden: für float , 0 < m < 2^24 und -149 <= e <= 104 , und für double 0 < m < 2^53 und -1075 <= e <= 970 .The finite set of non-zero values of the form s * m * 2^e, where s is 1 or -1, and m and e are determined by the particular floating-point type: For float, 0 < m < 2^24 and -149 <= e <= 104, and for double, 0 < m < 2^53 and -1075 <= e <= 970. Denormalisierte Gleit Komma Zahlen gelten als gültige Werte ungleich 0 (null).Denormalized floating-point numbers are considered valid non-zero values.

Der- float Typ kann Werte zwischen ungefähr 1.5 * 10^-45 und 3.4 * 10^38 und einer Genauigkeit von 7 Ziffern darstellen.The float type can represent values ranging from approximately 1.5 * 10^-45 to 3.4 * 10^38 with a precision of 7 digits.

Der- double Typ kann Werte zwischen ungefähr 5.0 * 10^-324 und 1.7 × 10^308 und einer Genauigkeit von 15-16 Ziffern darstellen.The double type can represent values ranging from approximately 5.0 * 10^-324 to 1.7 × 10^308 with a precision of 15-16 digits.

Wenn einer der Operanden eines binären Operators ein Gleit kommatyp ist, muss der andere Operand ein ganzzahliger Typ oder ein Gleit kommatyp sein, und der Vorgang wird wie folgt ausgewertet:If one of the operands of a binary operator is of a floating-point type, then the other operand must be of an integral type or a floating-point type, and the operation is evaluated as follows:

  • Wenn einer der Operanden ein ganzzahliger Typ ist, wird dieser Operand in den Gleit kommatyp des anderen Operanden konvertiert.If one of the operands is of an integral type, then that operand is converted to the floating-point type of the other operand.
  • Wenn einer der Operanden vom Typ ist double , wird der andere Operand in konvertiert double , der Vorgang wird mit mindestens double Bereich und Genauigkeit durchgeführt, und der Ergebnistyp ist double (oder bool für die relationalen Operatoren).Then, if either of the operands is of type double, the other operand is converted to double, the operation is performed using at least double range and precision, and the type of the result is double (or bool for the relational operators).
  • Andernfalls wird der Vorgang mit mindestens float Bereich und Genauigkeit durchgeführt, und der Ergebnistyp ist float (oder bool für die relationalen Operatoren).Otherwise, the operation is performed using at least float range and precision, and the type of the result is float (or bool for the relational operators).

Die Gleit Komma Operatoren, einschließlich der Zuweisungs Operatoren, führen niemals zu Ausnahmen.The floating-point operators, including the assignment operators, never produce exceptions. In Ausnahmefällen wird von Gleit Komma Vorgängen, wie unten beschrieben, NULL, unendlich oder NaN erzeugt:Instead, in exceptional situations, floating-point operations produce zero, infinity, or NaN, as described below:

  • Wenn das Ergebnis einer Gleit Komma Operation für das Zielformat zu klein ist, wird das Ergebnis des Vorgangs positiv 0 (null) oder negativ 0 (null).If the result of a floating-point operation is too small for the destination format, the result of the operation becomes positive zero or negative zero.
  • Wenn das Ergebnis einer Gleit Komma Operation für das Zielformat zu groß ist, wird das Ergebnis des Vorgangs positiv unendlich oder negativ unendlich.If the result of a floating-point operation is too large for the destination format, the result of the operation becomes positive infinity or negative infinity.
  • Wenn ein Gleit Komma Vorgang ungültig ist, wird das Ergebnis des Vorgangs "NaN".If a floating-point operation is invalid, the result of the operation becomes NaN.
  • Wenn einer der Operanden oder beide Operanden eines Gleitkommavorgangs NaN ergibt, ist das Ergebnis des Vorgangs NaN.If one or both operands of a floating-point operation is NaN, the result of the operation becomes NaN.

Gleit Komma Operationen können mit höherer Genauigkeit ausgeführt werden als der Ergebnistyp des Vorgangs.Floating-point operations may be performed with higher precision than the result type of the operation. Beispielsweise unterstützen einige Hardwarearchitekturen einen "Extended"-oder "long Double"-Gleit kommatyp mit größerem Bereich und präziser als den double -Typ und führen implizit alle Gleit Komma Vorgänge mit diesem Typ höherer Genauigkeit aus.For example, some hardware architectures support an "extended" or "long double" floating-point type with greater range and precision than the double type, and implicitly perform all floating-point operations using this higher precision type. Nur zu hohen Leistungseinbußen können solche Hardwarearchitekturen zum Ausführen von Gleit Komma Vorgängen mit geringerer Genauigkeit gemacht werden, und anstatt eine Implementierung zu erfordern, um sowohl die Leistung als auch die Genauigkeit zu verlieren, kann c# für alle Gleit Komma Vorgänge einen höheren Genauigkeits-Typ verwenden.Only at excessive cost in performance can such hardware architectures be made to perform floating-point operations with less precision, and rather than require an implementation to forfeit both performance and precision, C# allows a higher precision type to be used for all floating-point operations. Abgesehen von der Bereitstellung präziseren Ergebnisse hat dies nur selten messbare Auswirkungen.Other than delivering more precise results, this rarely has any measurable effects. In Ausdrücken der Form x * y / z , in denen die Multiplikation ein Ergebnis erzeugt, das außerhalb des double Bereichs liegt, aber die nachfolgende Division das temporäre Ergebnis wieder in den double Bereich bringt, kann die Tatsache, dass der Ausdruck in einem höheren Bereichs Format ausgewertet wird, dazu führen, dass ein endliches Ergebnis anstelle von unendlich erzeugt wird.However, in expressions of the form x * y / z, where the multiplication produces a result that is outside the double range, but the subsequent division brings the temporary result back into the double range, the fact that the expression is evaluated in a higher range format may cause a finite result to be produced instead of an infinity.

Der DezimaltypThe decimal type

Der decimal-Typ ist ein für Finanz-und Währungsberechnungen geeigneter 128-Bit-Datentyp.The decimal type is a 128-bit data type suitable for financial and monetary calculations. Der- decimal Typ kann Werte von 1.0 * 10^-28 bis zu ungefähr 7.9 * 10^28 mit 28-29 signifikanten Ziffern darstellen.The decimal type can represent values ranging from 1.0 * 10^-28 to approximately 7.9 * 10^28 with 28-29 significant digits.

Der endliche Satz von Werten vom Typ decimal hat die Form (-1)^s * c * 10^-e , wobei das Vorzeichen s 0 oder 1 ist, der Koeffizienten c von angegeben wird 0 <= *c* < 2^96 und die Skala e so ist 0 <= e <= 28 . Der decimal Typ unterstützt keine signierten Nullen, Infinities oder NaN.The finite set of values of type decimal are of the form (-1)^s * c * 10^-e, where the sign s is 0 or 1, the coefficient c is given by 0 <= *c* < 2^96, and the scale e is such that 0 <= e <= 28.The decimal type does not support signed zeros, infinities, or NaN's. Eine decimal wird als 96-Bit-Ganzzahl dargestellt, die durch eine Potenz von zehn skaliert wird.A decimal is represented as a 96-bit integer scaled by a power of ten. Für decimal s mit einem absoluten Wert 1.0m , der kleiner als ist, entspricht der Wert exakt dem 28. Dezimaltrennzeichen, aber nicht weiter.For decimals with an absolute value less than 1.0m, the value is exact to the 28th decimal place, but no further. Für decimal s mit einem absoluten Wert, der größer oder gleich ist 1.0m , entspricht der Wert exakt 28 oder 29 Ziffern.For decimals with an absolute value greater than or equal to 1.0m, the value is exact to 28 or 29 digits. Im Gegensatz zu float den double Datentypen und können dezimale Bruchzahlen wie 0,1 genau in der-Darstellung dargestellt werden decimal .Contrary to the float and double data types, decimal fractional numbers such as 0.1 can be represented exactly in the decimal representation. In der float -und double -Darstellung sind solche Zahlen häufig unendliche Bruchzahlen, sodass diese Darstellungen anfälliger für Probleme bei der Durchführung von Fehlern werden.In the float and double representations, such numbers are often infinite fractions, making those representations more prone to round-off errors.

Wenn einer der Operanden eines binären Operators vom Typ ist decimal , muss der andere Operand ein ganzzahliger Typ oder vom Typ sein decimal .If one of the operands of a binary operator is of type decimal, then the other operand must be of an integral type or of type decimal. Wenn ein ganzzahliger Typoperand vorhanden ist, wird er in konvertiert, decimal bevor der Vorgang durchgeführt wird.If an integral type operand is present, it is converted to decimal before the operation is performed.

Das Ergebnis eines Vorgangs für Werte des Typs decimal ist, dass sich das Ergebnis aus der Berechnung eines exakten Ergebnisses ergibt (wie für jeden Operator definiert, wie für jeden Operator definiert) und dann an die Darstellung angepasst wird.The result of an operation on values of type decimal is that which would result from calculating an exact result (preserving scale, as defined for each operator) and then rounding to fit the representation. Die Ergebnisse werden auf den nächstgelegenen darstellbaren Wert gerundet und, wenn ein Ergebnis gleich nah bei zwei darstellbaren Werten ist, bis zu dem Wert, der eine gerade Zahl in der am wenigsten wichtigen Ziffern Position aufweist (Dies wird als "Banker srundung" bezeichnet).Results are rounded to the nearest representable value, and, when a result is equally close to two representable values, to the value that has an even number in the least significant digit position (this is known as "banker's rounding"). Ein NULL-Ergebnis hat immer ein Vorzeichen von 0 und eine Skala von 0.A zero result always has a sign of 0 and a scale of 0.

Wenn eine arithmetische decimal-Operation einen Wert erzeugt, der kleiner als oder gleich dem 5 * 10^-29 absoluten Wert ist, wird das Ergebnis des Vorgangs 0 (null).If a decimal arithmetic operation produces a value less than or equal to 5 * 10^-29 in absolute value, the result of the operation becomes zero. Wenn eine decimal arithmetische Operation ein Ergebnis erzeugt, das zu groß für das decimal Format ist, wird eine ausgelöst System.OverflowException .If a decimal arithmetic operation produces a result that is too large for the decimal format, a System.OverflowException is thrown.

Der- decimal Typ hat eine höhere Genauigkeit, aber einen kleineren Bereich als die Gleit Komma Typen.The decimal type has greater precision but smaller range than the floating-point types. Folglich können Konvertierungen von Gleit Komma Typen in decimal Überlauf Ausnahmen erzeugen, und Konvertierungen von decimal in den Gleit Komma Typen können zu Genauigkeits Verlusten führen.Thus, conversions from the floating-point types to decimal might produce overflow exceptions, and conversions from decimal to the floating-point types might cause loss of precision. Aus diesen Gründen gibt es keine impliziten Konvertierungen zwischen den Gleit Komma Typen und und decimal ohne explizite Umwandlungen ist es nicht möglich, Gleit Komma Zahlen und decimal Operanden im gleichen Ausdruck zu mischen.For these reasons, no implicit conversions exist between the floating-point types and decimal, and without explicit casts, it is not possible to mix floating-point and decimal operands in the same expression.

Der boolesche TypThe bool type

Der bool Typ stellt boolesche logische Mengen dar.The bool type represents boolean logical quantities. Mögliche Werte vom Typ bool sind true und false .The possible values of type bool are true and false.

Zwischen und anderen Typen sind keine Standard Konvertierungen vorhanden bool .No standard conversions exist between bool and other types. Der bool -Typ ist insbesondere eindeutig und von den ganzzahligen Typen getrennt, und ein bool Wert kann nicht anstelle eines ganzzahligen Werts und umgekehrt verwendet werden.In particular, the bool type is distinct and separate from the integral types, and a bool value cannot be used in place of an integral value, and vice versa.

In den Programmiersprachen C und C++ kann ein ganzzahliger Wert oder ein Gleit Komma Wert von 0 (null) oder ein NULL-Zeiger in den booleschen Wert konvertiert werden false , und ein ganzzahliger oder Gleit Komma Wert ungleich NULL bzw. ein nicht-NULL-Zeiger kann in den booleschen Wert konvertiert werden true .In the C and C++ languages, a zero integral or floating-point value, or a null pointer can be converted to the boolean value false, and a non-zero integral or floating-point value, or a non-null pointer can be converted to the boolean value true. In c# werden solche Konvertierungen durch explizites Vergleichen eines ganzzahligen oder Gleit Komma Werts mit 0 (null) oder durch explizites Vergleichen eines Objekt Verweises mit erreicht null .In C#, such conversions are accomplished by explicitly comparing an integral or floating-point value to zero, or by explicitly comparing an object reference to null.

EnumerationstypenEnumeration types

Ein Enumerationstyp ist ein eindeutiger Typ mit benannten Konstanten.An enumeration type is a distinct type with named constants. Jeder Enumerationstyp verfügt über einen zugrunde liegenden Typ, der byte ,, sbyte short , ushort , int , uint long oder ulong sein muss.Every enumeration type has an underlying type, which must be byte, sbyte, short, ushort, int, uint, long or ulong. Der Satz von Werten des Enumerationstyps ist mit dem Satz von Werten des zugrunde liegenden Typs identisch.The set of values of the enumeration type is the same as the set of values of the underlying type. Werte des Enumerationstyps sind nicht auf die Werte der benannten Konstanten beschränkt.Values of the enumeration type are not restricted to the values of the named constants. Enumerationstypen werden durch Enumerationsdeklarationen (Enumerationsdeklarationen)definiert.Enumeration types are defined through enumeration declarations (Enum declarations).

Nullable-TypenNullable types

Ein Typ, der NULL-Werte zulässt, kann alle Werte seines zugrunde liegenden Typs und einen zusätzlichen NULL-Wert darstellen.A nullable type can represent all values of its underlying type plus an additional null value. Ein Typ, der NULL-Werte zulässt, wird geschrieben T? , wobei T der zugrunde liegende Typ ist.A nullable type is written T?, where T is the underlying type. Diese Syntax ist eine System.Nullable<T> Kurzform für, und die beiden Formen können austauschbar verwendet werden.This syntax is shorthand for System.Nullable<T>, and the two forms can be used interchangeably.

Ein Werttyp , der nicht auf NULL festgelegt werden kann, ist umgekehrt ein beliebiger Werttyp als System.Nullable<T> und seine Kurzform T? (für Any T ) sowie alle Typparameter, die auf einen Werttyp beschränkt sind, der keine NULL-Werte zulässt (d. h. alle Typparameter mit einer struct Einschränkung).A non-nullable value type conversely is any value type other than System.Nullable<T> and its shorthand T? (for any T), plus any type parameter that is constrained to be a non-nullable value type (that is, any type parameter with a struct constraint). Der System.Nullable<T> Typ gibt die Werttyp Einschränkung für T (Typparameter Einschränkungen) an. Dies bedeutet, dass der zugrunde liegende Typ eines Typs, der NULL-Werte zulässt, ein beliebiger Werttyp sein kannThe System.Nullable<T> type specifies the value type constraint for T (Type parameter constraints), which means that the underlying type of a nullable type can be any non-nullable value type. Der zugrunde liegende Typ eines Typs, der NULL-Werte zulässt, kann kein Typ oder Verweistyp sein, der NULL-Werte zulässt.The underlying type of a nullable type cannot be a nullable type or a reference type. Beispielsweise int?? sind und string? ungültige Typen.For example, int?? and string? are invalid types.

Eine Instanz eines Typs, der NULL-Werte zulässt, T? verfügt über zwei öffentliche schreibgeschützte Eigenschaften:An instance of a nullable type T? has two public read-only properties:

  • Eine HasValue Eigenschaft vom Typ. boolA HasValue property of type bool
  • Eine Value Eigenschaft vom Typ. TA Value property of type T

Eine-Instanz, für die HasValue true ist, wird als ungleich NULL bezeichnet.An instance for which HasValue is true is said to be non-null. Eine nicht-NULL-Instanz enthält einen bekannten Wert und Value gibt diesen Wert zurück.A non-null instance contains a known value and Value returns that value.

Eine-Instanz, für die HasValue false ist, wird als NULL bezeichnet.An instance for which HasValue is false is said to be null. Eine NULL-Instanz hat einen nicht definierten Wert.A null instance has an undefined value. Der Versuch, den einer NULL-Instanz zu lesen, Value bewirkt System.InvalidOperationException , dass eine ausgelöst wird.Attempting to read the Value of a null instance causes a System.InvalidOperationException to be thrown. Der Prozess des Zugriffs auf die- Value Eigenschaft einer Instanz, die NULL-Werte zulässt, wird als zum Entpacken bezeichnet.The process of accessing the Value property of a nullable instance is referred to as unwrapping.

Zusätzlich zum Standardkonstruktor verfügt jeder Typ, der NULL-Werte zulässt, T? über einen öffentlichen Konstruktor, der ein einzelnes Argument vom Typ annimmt T .In addition to the default constructor, every nullable type T? has a public constructor that takes a single argument of type T. Bei einem Wert x vom Typ T , einem Konstruktoraufruf des FormularsGiven a value x of type T, a constructor invocation of the form

new T?(x)

erstellt eine Instanz von T? , die nicht NULL ist und für die die- Value Eigenschaft ist x .creates a non-null instance of T? for which the Value property is x. Das Erstellen einer nicht-NULL-Instanz eines Typs, der NULL-Werte zulässt, wird als Wrapping bezeichnet.The process of creating a non-null instance of a nullable type for a given value is referred to as wrapping.

Implizite Konvertierungen sind aus dem null -Literalwert für T? (NULL-Literale Konvertierungen) und von T in verfügbar T? (implizite Konvertierungen, die NULL zulassen)Implicit conversions are available from the null literal to T? (Null literal conversions) and from T to T? (Implicit nullable conversions).

VerweistypenReference types

Bei einem Verweistyp handelt es sich um einen Klassentyp, einen Schnittstellentyp, einen Arraytyp oder einen Delegattyp.A reference type is a class type, an interface type, an array type, or a delegate type.

reference_type
    : class_type
    | interface_type
    | array_type
    | delegate_type
    ;

class_type
    : type_name
    | 'object'
    | 'dynamic'
    | 'string'
    ;

interface_type
    : type_name
    ;

array_type
    : non_array_type rank_specifier+
    ;

non_array_type
    : type
    ;

rank_specifier
    : '[' dim_separator* ']'
    ;

dim_separator
    : ','
    ;

delegate_type
    : type_name
    ;

Ein Verweistyp Wert ist ein Verweis auf eine *instance _ des Typs, der letztere als _ -Objekt * bezeichnet.A reference type value is a reference to an instance _ of the type, the latter known as an _object**. Der spezielle Wert null ist mit allen Verweis Typen kompatibel und gibt an, dass keine Instanz vorhanden ist.The special value null is compatible with all reference types and indicates the absence of an instance.

KlassentypenClass types

Ein Klassentyp definiert eine Datenstruktur, die Datenmember (Konstanten und Felder), Funktionsmember (Methoden, Eigenschaften, Ereignisse, Indexer, Operatoren, Instanzkonstruktoren, destrukturatoren und statische Konstruktoren) und die in der Struktur enthaltenen Typen enthält.A class type defines a data structure that contains data members (constants and fields), function members (methods, properties, events, indexers, operators, instance constructors, destructors and static constructors), and nested types. Klassentypen unterstützen Vererbung, einen Mechanismus, bei dem abgeleitete Klassen die Basisklassen erweitern und spezialisieren können.Class types support inheritance, a mechanism whereby derived classes can extend and specialize base classes. Instanzen von Klassentypen werden mithilfe von object_creation_expression s erstellt (Objekt Erstellungs Ausdrücke).Instances of class types are created using object_creation_expression s (Object creation expressions).

Klassentypen werden in Klassenbeschrieben.Class types are described in Classes.

Bestimmte vordefinierte Klassentypen haben in der c#-Sprache eine besondere Bedeutung, wie in der folgenden Tabelle beschrieben.Certain predefined class types have special meaning in the C# language, as described in the table below.

KlassentypClass type BeschreibungDescription
System.Object Die ultimative Basisklasse aller anderen Typen.The ultimate base class of all other types. Siehe Objekttyp.See The object type.
System.String Der Zeichen Folgentyp der Programmiersprache c#.The string type of the C# language. Siehe den String-Typ.See The string type.
System.ValueType Die Basisklasse aller Werttypen.The base class of all value types. Siehe den Typ System. ValueType.See The System.ValueType type.
System.Enum Die Basisklasse aller Enumerationstypen.The base class of all enum types. Siehe -Auffinden.See Enums.
System.Array Die Basisklasse aller Array Typen.The base class of all array types. Siehe Arrays.See Arrays.
System.Delegate Die Basisklasse aller Delegattypen.The base class of all delegate types. Siehe Delegaten.See Delegates.
System.Exception Die Basisklasse aller Ausnahme Typen.The base class of all exception types. Siehe Ausnahmen.See Exceptions.

den ObjekttypThe object type

Der object Klassentyp ist die ultimative Basisklasse aller anderen Typen.The object class type is the ultimate base class of all other types. Jeder Typ in c# ist direkt oder indirekt vom object Klassentyp abgeleitet.Every type in C# directly or indirectly derives from the object class type.

Das Schlüsselwort object ist einfach ein Alias für die vordefinierte Klasse System.Object .The keyword object is simply an alias for the predefined class System.Object.

Der dynamische TypThe dynamic type

Der dynamic Typ, wie object , kann auf ein beliebiges Objekt verweisen.The dynamic type, like object, can reference any object. Wenn Operatoren auf Ausdrücke vom Typ angewendet werden dynamic , wird die Auflösung so lange verzögert, bis das Programm ausgeführt wird.When operators are applied to expressions of type dynamic, their resolution is deferred until the program is run. Wenn der Operator daher nicht auf das Objekt angewendet werden kann, auf das verwiesen wird, wird während der Kompilierung kein Fehler angegeben.Thus, if the operator cannot legally be applied to the referenced object, no error is given during compilation. Stattdessen wird eine Ausnahme ausgelöst, wenn die Auflösung des Operators zur Laufzeit fehlschlägt.Instead an exception will be thrown when resolution of the operator fails at run-time.

Der Zweck besteht darin, dynamische Bindungen zuzulassen, die im Detail unter dynamische Bindungbeschrieben werden.Its purpose is to allow dynamic binding, which is described in detail in Dynamic binding.

dynamic gilt als identisch mit, object außer in den folgenden Punkten:dynamic is considered identical to object except in the following respects:

  • Vorgänge für Ausdrücke vom Typ dynamic können dynamisch gebunden werden (dynamische Bindung).Operations on expressions of type dynamic can be dynamically bound (Dynamic binding).
  • Der Typrückschluss (Typrückschluss) wird bevorzugt, dynamic object Wenn beide Kandidaten sind.Type inference (Type inference) will prefer dynamic over object if both are candidates.

Aufgrund dieser Äquivalenz enthält Folgendes:Because of this equivalence, the following holds:

  • Es gibt eine implizite Identitäts Konvertierung zwischen object und dynamic sowie zwischen konstruierten Typen, die beim Ersetzen von mit identisch sind. dynamic``objectThere is an implicit identity conversion between object and dynamic, and between constructed types that are the same when replacing dynamic with object
  • Implizite und explizite Konvertierungen von und in object gelten auch für und von dynamic .Implicit and explicit conversions to and from object also apply to and from dynamic.
  • Methoden Signaturen, die bei der Ersetzung durch identisch sind, dynamic object werden als dieselbe Signatur angesehenMethod signatures that are the same when replacing dynamic with object are considered the same signature
  • Der Typ kann dynamic von zur Laufzeit nicht unterschieden werden object .The type dynamic is indistinguishable from object at run-time.
  • Ein Ausdruck des Typs dynamic wird als dynamischer Ausdruck bezeichnet.An expression of the type dynamic is referred to as a dynamic expression.

Der ZeichenfolgentypThe string type

Der string Typ ist ein versiegelter Klassentyp, der direkt von erbt object .The string type is a sealed class type that inherits directly from object. Instanzen der- string Klasse stellen Unicode-Zeichen folgen dar.Instances of the string class represent Unicode character strings.

Werte des string Typs können als Zeichen folgen Literale (Zeichenfolgenliterale) geschrieben werden.Values of the string type can be written as string literals (String literals).

Das Schlüsselwort string ist einfach ein Alias für die vordefinierte Klasse System.String .The keyword string is simply an alias for the predefined class System.String.

SchnittstellentypenInterface types

Eine Schnittstelle definiert einen Vertrag.An interface defines a contract. Eine Klasse oder Struktur, die eine Schnittstelle implementiert, muss ihren Vertrag einhalten.A class or struct that implements an interface must adhere to its contract. Eine Schnittstelle kann von mehreren Basis Schnittstellen erben, und eine Klasse oder Struktur kann mehrere Schnittstellen implementieren.An interface may inherit from multiple base interfaces, and a class or struct may implement multiple interfaces.

Schnittstellentypen werden unter Schnittstellenbeschrieben.Interface types are described in Interfaces.

ArraytypenArray types

Ein Array ist eine Datenstruktur, die NULL oder mehr Variablen enthält, auf die über berechnete Indizes zugegriffen wird.An array is a data structure that contains zero or more variables which are accessed through computed indices. Die im Array enthaltenen Variablen, auch Elemente des Arrays genannt, weisen alle denselben Typ auf. Dieser Typ wird als Elementtyp des Arrays bezeichnet.The variables contained in an array, also called the elements of the array, are all of the same type, and this type is called the element type of the array.

Array Typen werden in Arraysbeschrieben.Array types are described in Arrays.

DelegattypenDelegate types

Bei einem Delegaten handelt es sich um eine Datenstruktur, die auf eine oder mehrere Methoden verweist.A delegate is a data structure that refers to one or more methods. Bei Instanzmethoden bezieht sie sich auch auf ihre entsprechenden Objektinstanzen.For instance methods, it also refers to their corresponding object instances.

Die nächstliegende Entsprechung eines Delegaten in C oder C++ ist ein Funktionszeiger, während ein Funktionszeiger nur auf statische Funktionen verweisen kann, kann ein Delegat sowohl auf statische Methoden als auch auf Instanzmethoden verweisen.The closest equivalent of a delegate in C or C++ is a function pointer, but whereas a function pointer can only reference static functions, a delegate can reference both static and instance methods. Im letzteren Fall speichert der Delegat nicht nur einen Verweis auf den Einstiegspunkt der Methode, sondern auch einen Verweis auf die Objektinstanz, für die die Methode aufgerufen werden soll.In the latter case, the delegate stores not only a reference to the method's entry point, but also a reference to the object instance on which to invoke the method.

Delegattypen werden inDelegaten beschrieben.Delegate types are described in Delegates.

Boxing und UnboxingBoxing and unboxing

Das Konzept von Boxing und Unboxing ist für das Typsystem von c# von zentraler Bedeutung.The concept of boxing and unboxing is central to C#'s type system. Sie bietet eine Brücke zwischen value_type s und reference_type s, indem es ermöglicht wird, dass jeder Wert eines value_type in einen und aus dem Typ konvertiert werden kann object .It provides a bridge between value_type s and reference_type s by permitting any value of a value_type to be converted to and from type object. Boxing und Unboxing ermöglichen eine einheitliche Ansicht des Typsystems, wobei ein Wert eines beliebigen Typs letztendlich als Objekt behandelt werden kann.Boxing and unboxing enables a unified view of the type system wherein a value of any type can ultimately be treated as an object.

Boxing-KonvertierungenBoxing conversions

Eine Boxing-Konvertierung ermöglicht eine implizite Konvertierung einer value_type in eine reference_type.A boxing conversion permits a value_type to be implicitly converted to a reference_type. Die folgenden boxkonvertierungen sind vorhanden:The following boxing conversions exist:

  • Von einem beliebigen value_type bis zum-Typ object .From any value_type to the type object.
  • Von einem beliebigen value_type bis zum-Typ System.ValueType .From any value_type to the type System.ValueType.
  • Von allen non_nullable_value_type bis INTERFACE_TYPE , die vom value_type implementiert werden.From any non_nullable_value_type to any interface_type implemented by the value_type.
  • Von allen nullable_type bis INTERFACE_TYPE , die vom zugrunde liegenden Typ des nullable_type implementiert werden.From any nullable_type to any interface_type implemented by the underlying type of the nullable_type.
  • Von einem beliebigen enum_type bis zum-Typ System.Enum .From any enum_type to the type System.Enum.
  • Von allen nullable_type mit einer zugrunde liegenden enum_type bis zum-Typ System.Enum .From any nullable_type with an underlying enum_type to the type System.Enum.
  • Beachten Sie, dass eine implizite Konvertierung von einem Typparameter als Boxing-Konvertierung ausgeführt wird, wenn Sie zur Laufzeit von einem Werttyp in einen Verweistyp konvertiert wird (implizite Konvertierungen mit Typparametern).Note that an implicit conversion from a type parameter will be executed as a boxing conversion if at run-time it ends up converting from a value type to a reference type (Implicit conversions involving type parameters).

Das Boxing eines Werts einer non_nullable_value_type besteht aus der Zuordnung einer Objektinstanz und dem Kopieren des non_nullable_value_type Werts in diese Instanz.Boxing a value of a non_nullable_value_type consists of allocating an object instance and copying the non_nullable_value_type value into that instance.

Das Boxing eines Werts einer nullable_type erzeugt einen NULL-Verweis, wenn es sich um den null Wert ( HasValue ist false ) handelt, oder das Ergebnis der entpacken und Boxing des zugrunde liegenden Werts andernfalls.Boxing a value of a nullable_type produces a null reference if it is the null value (HasValue is false), or the result of unwrapping and boxing the underlying value otherwise.

Der eigentliche Prozess des Boxens eines Werts eines non_nullable_value_type wird am besten erläutert, indem das vorhanden sein einer generischen Boxing-Klasse dargestellt wird, die sich so verhält, als wäre sie wie folgt deklariert:The actual process of boxing a value of a non_nullable_value_type is best explained by imagining the existence of a generic boxing class, which behaves as if it were declared as follows:

sealed class Box<T>: System.ValueType
{
    T value;

    public Box(T t) {
        value = t;
    }
}

Das Boxing eines Werts v vom Typ T besteht jetzt aus der Ausführung des Ausdrucks new Box<T>(v) und dem Zurückgeben der resultierenden Instanz als Wert des Typs object .Boxing of a value v of type T now consists of executing the expression new Box<T>(v), and returning the resulting instance as a value of type object. Folglich werden die AnweisungenThus, the statements

int i = 123;
object box = i;

konzeptionell entsprechenconceptually correspond to

int i = 123;
object box = new Box<int>(i);

Eine Boxing-Klasse wie Box<T> oben ist nicht vorhanden, und der dynamische Typ eines geschachtelten Werts ist eigentlich kein Klassentyp.A boxing class like Box<T> above doesn't actually exist and the dynamic type of a boxed value isn't actually a class type. Stattdessen hat ein geachtelter Wert des Typs T den dynamischen Typ T , und eine dynamische Typüberprüfung mit dem is Operator kann einfach auf den Typ verweisen T .Instead, a boxed value of type T has the dynamic type T, and a dynamic type check using the is operator can simply reference type T. Beispiel:For example,

int i = 123;
object box = i;
if (box is int) {
    Console.Write("Box contains an int");
}

die Zeichenfolge " Box contains an int " wird in der Konsole ausgegeben.will output the string "Box contains an int" on the console.

Eine Boxing-Konvertierung impliziert das Erstellen einer Kopie des Werts, der gekapselt wird.A boxing conversion implies making a copy of the value being boxed. Dies unterscheidet sich von der Konvertierung eines reference_type in den Typ object , in dem der Wert weiterhin auf dieselbe Instanz verweist und einfach als weniger abgeleiteter Typ angesehen wird object .This is different from a conversion of a reference_type to type object, in which the value continues to reference the same instance and simply is regarded as the less derived type object. Beispielsweise mit der DeklarationFor example, given the declaration

struct Point
{
    public int x, y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

die folgenden Anweisungenthe following statements

Point p = new Point(10, 10);
object box = p;
p.x = 20;
Console.Write(((Point)box).x);

Gibt den Wert 10 in der Konsole aus, da der implizite Boxing-Vorgang, der bei der Zuweisung von auf auftritt, bewirkt, dass p box der Wert von p kopiert wird.will output the value 10 on the console because the implicit boxing operation that occurs in the assignment of p to box causes the value of p to be copied. PointWurde stattdessen als deklariert class . der Wert 20 würde ausgegeben, weil p und auf box dieselbe Instanz verweisen würden.Had Point been declared a class instead, the value 20 would be output because p and box would reference the same instance.

Unboxing-KonvertierungenUnboxing conversions

Eine Unboxing-Konvertierung ermöglicht das explizite Konvertieren eines reference_type in eine value_type.An unboxing conversion permits a reference_type to be explicitly converted to a value_type. Die folgenden Unboxing-Konvertierungen sind vorhanden:The following unboxing conversions exist:

  • Vom Typ object zu beliebigen value_type.From the type object to any value_type.
  • Vom Typ System.ValueType zu beliebigen value_type.From the type System.ValueType to any value_type.
  • Von allen INTERFACE_TYPE bis zu non_nullable_value_type , die die INTERFACE_TYPE implementiert.From any interface_type to any non_nullable_value_type that implements the interface_type.
  • Von allen INTERFACE_TYPE zu beliebigen nullable_type , deren zugrunde liegender Typ den INTERFACE_TYPE implementiert.From any interface_type to any nullable_type whose underlying type implements the interface_type.
  • Vom Typ System.Enum zu beliebigen enum_type.From the type System.Enum to any enum_type.
  • Vom Typ System.Enum zu einer beliebigen nullable_type mit einer zugrunde liegenden enum_type.From the type System.Enum to any nullable_type with an underlying enum_type.
  • Beachten Sie, dass eine explizite Konvertierung in einen Typparameter als Unboxing-Konvertierung ausgeführt wird, wenn Sie zur Laufzeit von einem Verweistyp in einen Werttyp (explizite dynamische Konvertierungen) konvertiert wird.Note that an explicit conversion to a type parameter will be executed as an unboxing conversion if at run-time it ends up converting from a reference type to a value type (Explicit dynamic conversions).

Ein Unboxing-Vorgang für eine non_nullable_value_type besteht darin, zuerst zu überprüfen, ob die Objektinstanz ein geachtelter Wert der angegebenen non_nullable_value_type ist, und dann den Wert aus der-Instanz zu kopieren.An unboxing operation to a non_nullable_value_type consists of first checking that the object instance is a boxed value of the given non_nullable_value_type, and then copying the value out of the instance.

Beim Unboxing in eine nullable_type wird der NULL-Wert des nullable_type erzeugt, wenn der Quell Operand ist null , oder das umschließende Ergebnis des Unboxing der Objektinstanz in den zugrunde liegenden Typ des nullable_type andernfalls.Unboxing to a nullable_type produces the null value of the nullable_type if the source operand is null, or the wrapped result of unboxing the object instance to the underlying type of the nullable_type otherwise.

Bei der im vorherigen Abschnitt beschriebenen imaginären Boxingklasse besteht eine Unboxing-Konvertierung eines Objekts box in eine value_type T aus der Ausführung des Ausdrucks ((Box<T>)box).value .Referring to the imaginary boxing class described in the previous section, an unboxing conversion of an object box to a value_type T consists of executing the expression ((Box<T>)box).value. Folglich werden die AnweisungenThus, the statements

object box = 123;
int i = (int)box;

konzeptionell entsprechenconceptually correspond to

object box = new Box<int>(123);
int i = ((Box<int>)box).value;

Damit eine Unboxing-Konvertierung in eine angegebene non_nullable_value_type zur Laufzeit erfolgreich ausgeführt werden kann, muss der Wert des Quell Operanden ein Verweis auf einen geachtelten Wert dieses non_nullable_value_type sein.For an unboxing conversion to a given non_nullable_value_type to succeed at run-time, the value of the source operand must be a reference to a boxed value of that non_nullable_value_type. Wenn der Quell Operand ist null , wird eine ausgelöst System.NullReferenceException .If the source operand is null, a System.NullReferenceException is thrown. Wenn der Quell Operand ein Verweis auf ein inkompatibles Objekt ist, wird eine ausgelöst System.InvalidCastException .If the source operand is a reference to an incompatible object, a System.InvalidCastException is thrown.

Damit eine Unboxing-Konvertierung in eine angegebene nullable_type zur Laufzeit erfolgreich ausgeführt werden kann, muss der Wert des Quell Operanden entweder null oder ein Verweis auf einen geachtelten Wert der zugrunde liegenden non_nullable_value_type der nullable_type sein.For an unboxing conversion to a given nullable_type to succeed at run-time, the value of the source operand must be either null or a reference to a boxed value of the underlying non_nullable_value_type of the nullable_type. Wenn der Quell Operand ein Verweis auf ein inkompatibles Objekt ist, wird eine ausgelöst System.InvalidCastException .If the source operand is a reference to an incompatible object, a System.InvalidCastException is thrown.

Constructed types (Konstruierte Typen)Constructed types

Eine generische Typdeklaration gibt allein einen ungebundenen generischen Typ _ an, der als "Blueprint" verwendet wird, um viele verschiedene Typen durch Anwenden von _Typargumenten*_ zu bilden.A generic type declaration, by itself, denotes an unbound generic type _ that is used as a "blueprint" to form many different types, by way of applying _type arguments*_. Die Typargumente werden in spitzen Klammern ( < und > ) direkt nach dem Namen des generischen Typs geschrieben.The type arguments are written within angle brackets (< and >) immediately following the name of the generic type. Ein Typ, der mindestens ein Typargument enthält, wird als konstruierter Typ bezeichnet.A type that includes at least one type argument is called a constructed type. Ein konstruierter Typ kann an den meisten Stellen in der Sprache verwendet werden, in der ein Typname angezeigt werden kann.A constructed type can be used in most places in the language in which a type name can appear. Ein ungebundener generischer Typ kann nur innerhalb einer _typeof_expression * verwendet werden (der typeof-Operator).An unbound generic type can only be used within a _typeof_expression* (The typeof operator).

Konstruierte Typen können auch in Ausdrücken als einfache Namen (einfache Namen) oder beim Zugriff auf einen Member (Member Access) verwendet werden.Constructed types can also be used in expressions as simple names (Simple names) or when accessing a member (Member access).

Wenn ein namespace_or_type_name ausgewertet wird, werden nur generische Typen mit der richtigen Anzahl von Typparametern berücksichtigt.When a namespace_or_type_name is evaluated, only generic types with the correct number of type parameters are considered. Daher ist es möglich, denselben Bezeichner zu verwenden, um unterschiedliche Typen zu identifizieren, sofern die Typen eine unterschiedliche Anzahl von Typparametern aufweisen.Thus, it is possible to use the same identifier to identify different types, as long as the types have different numbers of type parameters. Dies ist nützlich, wenn generische und nicht generische Klassen in demselben Programm gemischt werden:This is useful when mixing generic and non-generic classes in the same program:

namespace Widgets
{
    class Queue {...}
    class Queue<TElement> {...}
}

namespace MyApplication
{
    using Widgets;

    class X
    {
        Queue q1;            // Non-generic Widgets.Queue
        Queue<int> q2;       // Generic Widgets.Queue
    }
}

Ein TYPE_NAME kann einen konstruierten Typ identifizieren, obwohl er keine Typparameter direkt angibt.A type_name might identify a constructed type even though it doesn't specify type parameters directly. Dies kann vorkommen, wenn ein Typ in einer generischen Klassen Deklaration geschachtelt ist und der Instanztyp der enthaltenden Deklaration implizit für die Namenssuche (geschachtelteTypen in generischen Klassen) verwendet wird:This can occur where a type is nested within a generic class declaration, and the instance type of the containing declaration is implicitly used for name lookup (Nested types in generic classes):

class Outer<T>
{
    public class Inner {...}

    public Inner i;                // Type of i is Outer<T>.Inner
}

In unsicherem Code kann ein konstruierter Typ nicht als unmanaged_type (Zeiger Typen) verwendet werden.In unsafe code, a constructed type cannot be used as an unmanaged_type (Pointer types).

TypargumenteType arguments

Jedes Argument in einer Typargument Liste ist einfach ein Typ.Each argument in a type argument list is simply a type.

type_argument_list
    : '<' type_arguments '>'
    ;

type_arguments
    : type_argument (',' type_argument)*
    ;

type_argument
    : type
    ;

In unsicherem Code (unsicherer Code) ist ein type_argument möglicherweise kein Zeigertyp.In unsafe code (Unsafe code), a type_argument may not be a pointer type. Jedes Typargument muss alle Einschränkungen für den entsprechenden Typparameter (Typparameter Einschränkungen) erfüllen.Each type argument must satisfy any constraints on the corresponding type parameter (Type parameter constraints).

Open-und Closed-TypenOpen and closed types

Alle Typen können entweder als *Open Types _-oder _ Closed-Typen * klassifiziert werden.All types can be classified as either open types _ or _closed types**. Ein offener Typ ist ein Typ, der Typparameter umfasst.An open type is a type that involves type parameters. Dies gilt insbesondere in folgenden Fällen:More specifically:

  • Ein Typparameter definiert einen geöffneten Typ.A type parameter defines an open type.
  • Ein Arraytyp ist nur dann ein offener Typ, wenn sein Elementtyp ein offener Typ ist.An array type is an open type if and only if its element type is an open type.
  • Ein konstruierter Typ ist ein offener Typ, wenn es sich bei mindestens einem Typargument um einen geöffneten Typ handelt.A constructed type is an open type if and only if one or more of its type arguments is an open type. Ein konstruierter, von einem Typ erstellter Typ ist ein offener Typ, wenn es sich bei mindestens einem Typargument oder den Typargumenten der enthaltenden Typen um einen geöffneten Typ handelt.A constructed nested type is an open type if and only if one or more of its type arguments or the type arguments of its containing type(s) is an open type.

Ein geschlossener Typ ist ein Typ, bei dem es sich nicht um einen geöffneten Typ handelt.A closed type is a type that is not an open type.

Zur Laufzeit wird der gesamte Code in einer generischen Typdeklaration im Kontext eines geschlossenen konstruierten Typs ausgeführt, der durch Anwenden von Typargumenten auf die generische Deklaration erstellt wurde.At run-time, all of the code within a generic type declaration is executed in the context of a closed constructed type that was created by applying type arguments to the generic declaration. Jeder Typparameter innerhalb des generischen Typs ist an einen bestimmten Lauf Zeittyp gebunden.Each type parameter within the generic type is bound to a particular run-time type. Die Lauf Zeit Verarbeitung aller Anweisungen und Ausdrücke tritt immer bei geschlossenen Typen auf, und offene Typen werden nur während der Kompilierungszeit verarbeitet.The run-time processing of all statements and expressions always occurs with closed types, and open types occur only during compile-time processing.

Jeder geschlossene konstruierte Typ verfügt über einen eigenen Satz statischer Variablen, die nicht gemeinsam mit anderen geschlossenen konstruierten Typen verwendet werden.Each closed constructed type has its own set of static variables, which are not shared with any other closed constructed types. Da ein offener Typ zur Laufzeit nicht vorhanden ist, sind keine statischen Variablen mit einem geöffneten Typ verknüpft.Since an open type does not exist at run-time, there are no static variables associated with an open type. Zwei geschlossene konstruierte Typen weisen denselben Typ auf, wenn Sie aus demselben ungebundenen generischen Typ erstellt werden und die entsprechenden Typargumente denselben Typ haben.Two closed constructed types are the same type if they are constructed from the same unbound generic type, and their corresponding type arguments are the same type.

Gebundene und ungebundene TypenBound and unbound types

Der Begriff *ungebundener Typ _ verweist auf einen nicht generischen Typ oder einen ungebundenen generischen Typ.The term *unbound type _ refers to a non-generic type or an unbound generic type. Der Begriff _ gebundener Typ* verweist auf einen nicht generischen Typ oder einen konstruierten Typ.The term _ bound type* refers to a non-generic type or a constructed type.

Ein ungebundener Typ verweist auf die durch eine Typdeklaration deklarierte Entität.An unbound type refers to the entity declared by a type declaration. Ein ungebundener generischer Typ ist nicht selbst ein Typ und kann nicht als Typ einer Variablen, eines Arguments oder eines Rückgabewerts oder als Basistyp verwendet werden.An unbound generic type is not itself a type, and cannot be used as the type of a variable, argument or return value, or as a base type. Das einzige Konstrukt, in dem auf einen ungebundenen generischen Typ verwiesen werden kann, ist der typeof Ausdruck (der typeof-Operator).The only construct in which an unbound generic type can be referenced is the typeof expression (The typeof operator).

Erfüllen von EinschränkungenSatisfying constraints

Wenn auf einen konstruierten Typ oder eine generische Methode verwiesen wird, werden die angegebenen Typargumente mit den Typparameter Einschränkungen überprüft, die für den generischen Typ oder die generische Methode deklariert sind (Typparameter Einschränkungen).Whenever a constructed type or generic method is referenced, the supplied type arguments are checked against the type parameter constraints declared on the generic type or method (Type parameter constraints). Für jede where Klausel wird das Typargument, A das dem benannten Typparameter entspricht, wie folgt für jede Einschränkung überprüft:For each where clause, the type argument A that corresponds to the named type parameter is checked against each constraint as follows:

  • Wenn es sich bei der Einschränkung um einen Klassentyp, einen Schnittstellentyp oder einen Typparameter handelt, C Stellen Sie diese Einschränkung mit den bereitgestellten Typargumenten dar, die für Typparameter ersetzt werden, die in der Einschränkung vorkommen.If the constraint is a class type, an interface type, or a type parameter, let C represent that constraint with the supplied type arguments substituted for any type parameters that appear in the constraint. Um die Einschränkung zu erfüllen, muss der Typ wie A folgt in den Typ konvertiert werden C :To satisfy the constraint, it must be the case that type A is convertible to type C by one of the following:
  • Wenn es sich bei der Einschränkung um die Verweistyp Einschränkung ( class ) handelt, muss der Typ A eine der folgenden Bedingungen erfüllen:If the constraint is the reference type constraint (class), the type A must satisfy one of the following:
    • A ist ein Schnittstellentyp, Klassentyp, Delegattyp oder Arraytyp.A is an interface type, class type, delegate type or array type. Beachten Sie, dass System.ValueType und System.Enum Verweis Typen sind, die diese Einschränkung erfüllen.Note that System.ValueType and System.Enum are reference types that satisfy this constraint.
    • A ein Typparameter, bei dem es sich um einen Verweistyp (Typparameter Einschränkungen) handelt.A is a type parameter that is known to be a reference type (Type parameter constraints).
  • Wenn es sich bei der Einschränkung um die Werttyp Einschränkung ( struct ) handelt, muss der Typ A eine der folgenden Bedingungen erfüllen:If the constraint is the value type constraint (struct), the type A must satisfy one of the following:
    • A ist ein Strukturtyp oder ein Aufzählungs Typ, aber kein Typ, der NULL-Werte zulässt.A is a struct type or enum type, but not a nullable type. Beachten Sie, dass System.ValueType und System.Enum Verweis Typen sind, die diese Einschränkung nicht erfüllen.Note that System.ValueType and System.Enum are reference types that do not satisfy this constraint.
    • A ein Typparameter mit der Werttyp Einschränkung (Typparameter Einschränkungen).A is a type parameter having the value type constraint (Type parameter constraints).
  • Wenn es sich bei der Einschränkung um die Konstruktoreinschränkung handelt new() , darf der Typ A nicht sein, abstract und er muss über einen öffentlichen Parameter losen Konstruktor verfügen.If the constraint is the constructor constraint new(), the type A must not be abstract and must have a public parameterless constructor. Dies ist erfüllt, wenn eine der folgenden Bedingungen zutrifft:This is satisfied if one of the following is true:

Ein Kompilierzeitfehler tritt auf, wenn eine oder mehrere der Einschränkungen eines Typparameters nicht durch die angegebenen Typargumente erfüllt werden.A compile-time error occurs if one or more of a type parameter's constraints are not satisfied by the given type arguments.

Da Typparameter nicht vererbt werden, werden Einschränkungen nie geerbt.Since type parameters are not inherited, constraints are never inherited either. Im folgenden Beispiel D muss die-Einschränkung für den Typparameter angeben, T sodass T die von der Basisklasse erzwungene Einschränkung erfüllt B<T> .In the example below, D needs to specify the constraint on its type parameter T so that T satisfies the constraint imposed by the base class B<T>. Im Gegensatz dazu muss die Klasse E keine Einschränkung angeben, da List<T> IEnumerable für beliebige implementiert T .In contrast, class E need not specify a constraint, because List<T> implements IEnumerable for any T.

class B<T> where T: IEnumerable {...}

class D<T>: B<T> where T: IEnumerable {...}

class E<T>: B<List<T>> {...}

TypparameterType parameters

Ein Typparameter ist ein Bezeichner, der einen Werttyp oder Verweistyp festlegt, an den der Parameter zur Laufzeit gebunden ist.A type parameter is an identifier designating a value type or reference type that the parameter is bound to at run-time.

type_parameter
    : identifier
    ;

Da ein Typparameter mit vielen verschiedenen tatsächlichen Typargumenten instanziiert werden kann, haben Typparameter etwas andere Vorgänge und Einschränkungen als andere Typen.Since a type parameter can be instantiated with many different actual type arguments, type parameters have slightly different operations and restrictions than other types. Dazu gehören:These include:

Typparameter sind ein reines Kompilierzeit Konstrukt.As a type, type parameters are purely a compile-time construct. Zur Laufzeit wird jeder Typparameter an einen Lauf Zeittyp gebunden, der durch Bereitstellen eines Typarguments an die generische Typdeklaration angegeben wurde.At run-time, each type parameter is bound to a run-time type that was specified by supplying a type argument to the generic type declaration. Daher ist der Typ einer Variablen, die mit einem Typparameter deklariert wird, zur Laufzeit ein geschlossener konstruierter Typ (Open-und Closed-Typen).Thus, the type of a variable declared with a type parameter will, at run-time, be a closed constructed type (Open and closed types). Die Lauf Zeit Ausführung aller Anweisungen und Ausdrücke, die Typparameter betreffen, verwendet den eigentlichen Typ, der als Typargument für diesen Parameter angegeben wurde.The run-time execution of all statements and expressions involving type parameters uses the actual type that was supplied as the type argument for that parameter.

Expression tree types (Ausdrucksbaumstrukturtypen)Expression tree types

*Expression Trees _ zulassen, dass Lambda-Ausdrücke als Datenstrukturen anstelle von ausführbarem Code dargestellt werden.*Expression trees _ permit lambda expressions to be represented as data structures instead of executable code. Ausdrucks Baumstrukturen sind Werte von _ Expression tree types* der Form System.Linq.Expressions.Expression<D> , wobei D ein beliebiger Delegattyp ist.Expression trees are values of _ expression tree types* of the form System.Linq.Expressions.Expression<D>, where D is any delegate type. Für den Rest dieser Spezifikation werden diese Typen mit der kurzzeile bezeichnet Expression<D> .For the remainder of this specification we will refer to these types using the shorthand Expression<D>.

Wenn eine Konvertierung von einem Lambda-Ausdruck in einen Delegattyp vorhanden D ist, ist auch eine Konvertierung für den Ausdrucks bauentyp vorhanden Expression<D> .If a conversion exists from a lambda expression to a delegate type D, a conversion also exists to the expression tree type Expression<D>. Während die Konvertierung eines Lambda-Ausdrucks in einen Delegattyp einen Delegaten generiert, der auf den ausführbaren Code für den Lambda-Ausdruck verweist, erstellt die Konvertierung in einen Ausdrucks Strukturtyp eine Ausdrucks Baumstruktur-Darstellung des Lambda Ausdrucks.Whereas the conversion of a lambda expression to a delegate type generates a delegate that references executable code for the lambda expression, conversion to an expression tree type creates an expression tree representation of the lambda expression.

Ausdrucks Baumstrukturen sind effiziente in-Memory-Daten Darstellungen von Lambda-Ausdrücken und machen die Struktur des Lambda Ausdrucks transparent und explizit.Expression trees are efficient in-memory data representations of lambda expressions and make the structure of the lambda expression transparent and explicit.

Genau wie ein Delegattyp weist D Expression<D> auch Parameter-und Rückgabe Typen auf, die mit denen von identisch sind D .Just like a delegate type D, Expression<D> is said to have parameter and return types, which are the same as those of D.

Im folgenden Beispiel wird ein Lambda-Ausdruck sowohl als ausführbarer Code als auch als Ausdrucks Baumstruktur dargestellt.The following example represents a lambda expression both as executable code and as an expression tree. Da eine Konvertierung in vorhanden Func<int,int> ist, gibt es auch eine Konvertierung in Expression<Func<int,int>> :Because a conversion exists to Func<int,int>, a conversion also exists to Expression<Func<int,int>>:

Func<int,int> del = x => x + 1;                    // Code

Expression<Func<int,int>> exp = x => x + 1;        // Data

Nach diesen Zuweisungen verweist der Delegat auf del eine Methode, die zurückgibt x + 1 , und die Ausdrucks Baum exp Struktur verweist auf eine Datenstruktur, die den Ausdruck beschreibt x => x + 1 .Following these assignments, the delegate del references a method that returns x + 1, and the expression tree exp references a data structure that describes the expression x => x + 1.

Die genaue Definition des generischen Typs Expression<D> sowie die präzisen Regeln zum Erstellen einer Ausdrucks Baumstruktur, wenn ein Lambda Ausdruck in einen Ausdrucks Strukturtyp konvertiert wird, liegen sowohl außerhalb des Gültigkeits Bereichs dieser Spezifikation.The exact definition of the generic type Expression<D> as well as the precise rules for constructing an expression tree when a lambda expression is converted to an expression tree type, are both outside the scope of this specification.

Zwei Dinge sind wichtig, um explizit zu machen:Two things are important to make explicit:

  • Nicht alle Lambda-Ausdrücke können in Ausdrucks Baumstrukturen konvertiert werden.Not all lambda expressions can be converted to expression trees. Beispielsweise können Lambda-Ausdrücke mit Anweisungs Text und Lambda-Ausdrücke, die Zuweisungs Ausdrücke enthalten, nicht dargestellt werden.For instance, lambda expressions with statement bodies, and lambda expressions containing assignment expressions cannot be represented. In diesen Fällen ist noch eine Konvertierung vorhanden, schlägt jedoch zur Kompilierzeit fehl.In these cases, a conversion still exists, but will fail at compile-time. Diese Ausnahmen werden in anonymen Funktions Konvertierungenausführlich erläutert.These exceptions are detailed in Anonymous function conversions.

  • Expression<D> bietet eine Instanzmethode Compile , die einen Delegaten vom Typ erzeugt D :Expression<D> offers an instance method Compile which produces a delegate of type D:

    Func<int,int> del2 = exp.Compile();
    

    Das Aufrufen dieses Delegaten bewirkt, dass der durch die Ausdrucks Baumstruktur dargestellte Code ausgeführt wird.Invoking this delegate causes the code represented by the expression tree to be executed. Folglich sind die oben aufgeführten Definitionen gleichwertig, und die folgenden zwei Anweisungen haben die gleiche Wirkung:Thus, given the definitions above, del and del2 are equivalent, and the following two statements will have the same effect:

    int i1 = del(1);
    
    int i2 = del2(1);
    

    Nach dem Ausführen dieses Codes i1 i2 haben und beide den Wert 2 .After executing this code, i1 and i2 will both have the value 2.