TypenTypes

Die Typen von c#-Sprache sind in zwei Hauptkategorien unterteilt: Werttypen und Verweistypen.The types of the C# language are divided into two main categories: value types and reference types. Werttypen und Verweistypen möglicherweise generische Typen, dies dauern mindestens Typparameter.Both value types and reference types may be generic types, which take one or more type parameters. Typparameter können bestimmen sowohl Werttypen und Verweistypen.Type parameters can designate both value types and reference types.

type
    : value_type
    | reference_type
    | type_parameter
    | type_unsafe
    ;

Die letzten Kategorie von Typen, Zeigern, steht nur in unsicheren Code zur Verfügung.The final category of types, pointers, is available only in unsafe code. Informationen finden Sie weiter unten in Zeigertypen.This is discussed further in Pointer types.

Werttypen unterscheiden sich von Verweistypen, Variablen von Werttypen ihre Daten direkt enthalten, während Variablen des Verweises Typen Store Verweise auf ihre Daten, die letztere wird bezeichnet als Objekte.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. Mit Verweistypen ist es möglich, dass zwei Variablen auf dasselbe Objekt verweisen, und so können Vorgänge auf eine Variable auf das Objekt, das die andere Variable verweist auswirken.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 besitzt jede Variable eine eigene Kopie der Daten, und es ist nicht möglich, für Vorgänge auf einem anderen zu beeinflussen.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.

# Typsystem ist dahingehend vereinheitlicht, dass 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, durch Ausführen von Vorgängen für Boxing und unboxing (Boxing und unboxing).Values of value types are treated as objects by performing boxing and unboxing operations (Boxing and unboxing).

WerttypenValue types

Ein Werttyp ist, einen Strukturtyp oder ein Enumerationstyp.A value type is either a struct type or an enumeration type. C# bietet eine Reihe von vordefinierten Strukturtypen, die Namen der einfache Typen.C# provides a set of predefined struct types called the simple types. Die einfachen Typen werden über reservierte Wörter 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
    ;

Im Gegensatz zu einer Variable eines Referenztyps eine Variable eines Werttyps kann den Wert enthalten null nur dann, wenn der Werttyp ein nullable-Typ ist.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 NULL-Werte besteht ein entsprechende Werttyp, der den gleichen Satz von Werten und der Wert angibt null.For every non-nullable value type there is a corresponding nullable value type denoting the same set of values plus the value null.

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

Die System.ValueType-TypThe System.ValueType type

Alle Werttypen werden implizit von der Klasse erben System.ValueType, das wiederum erbt von Klasse object.All value types implicitly inherit from the class System.ValueType, which, in turn, inherits from class object. Es ist nicht möglich, für jeden Typ ein Werttyp abgeleitet und 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 ist nicht selbst eine Value_type.Note that System.ValueType is not itself a value_type. Es handelt sich vielmehr eine Class_type von der alle Value_types automatisch abgeleitet werden.Rather, it is a class_type from which all value_types are automatically derived.

StandardkonstruktorenDefault constructors

Alle Werttypen werden implizit einen öffentlichen, parameterlosen Konstruktor wird aufgerufen, deklarieren die Standardkonstruktor.All value types implicitly declare a public parameterless instance constructor called the default constructor. Der Standardkonstruktor gibt eine 0 (null) initialisierten Instanz genannt die Standardwert für den Werttyp:The default constructor returns a zero-initialized instance known as the default value for the value type:

  • Für alle Simple_types, der Standardwert ist der Wert, der durch ein Bitmuster mit ausschließlich Nullen generiert:For all simple_types, 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, der Standardwert ist 0.For sbyte, byte, short, ushort, int, uint, long, and ulong, the default value is 0.
    • Für char, der Standardwert ist '\x0000'.For char, the default value is '\x0000'.
    • Für float, der Standardwert ist 0.0f.For float, the default value is 0.0f.
    • Für double, der Standardwert ist 0.0d.For double, the default value is 0.0d.
    • Für decimal, der Standardwert ist 0.0m.For decimal, the default value is 0.0m.
    • Für bool, der Standardwert ist false.For bool, the default value is false.
  • Für eine Enum_type E, der Standardwert ist 0, in den Typ konvertiert E.For an enum_type E, the default value is 0, converted to the type E.
  • Für eine Struct_type, der Standardwert ist der Wert, der durch Festlegen von alle Werttypfelder auf ihre Standardwerte und alle Verweise auf Felder generiert 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.
  • Für eine Nullable_type der Standardwert ist eine Instanz für die die HasValue Eigenschaft ist "false" und die Value Eigenschaft ist nicht definiert.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 ist auch bekannt als die null-Wert von nullable-Typ.The default value is also known as the null value of the nullable type.

Wie alle anderen Instanzkonstruktor, wird der Standardkonstruktor eines Werttyps aufgerufen, mit der new Operator.Like any other instance constructor, the default constructor of a value type is invoked using the new operator. Aus Effizienzgründen der Fall ist diese Anforderung nicht vorgesehen, um die Implementierung, die einen Konstruktoraufruf generiert haben.For efficiency reasons, this requirement is not intended to actually have the implementation generate a constructor call. Im folgenden Beispiel wird Variablen i und j sind beide auf 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 einen öffentlichen parameterlosen Instanzenkonstruktor verfügt, ist es nicht möglich, für einen Strukturtyp in eine explizite Deklaration von parameterlosen Konstruktoren enthalten.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, parametrisierte Instanzkonstruktoren deklarieren (Konstruktoren).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 geschachtelte Typen deklarieren können.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 finden Sie im Strukturdeklarationen.The declaration of struct types is described in Struct declarations.

Einfache TypenSimple types

C# bietet eine Reihe von vordefinierten Strukturtypen, die Namen der einfache Typen.C# provides a set of predefined struct types called the simple types. Die einfachen Typen über reservierte Wörter identifiziert werden, aber diese reservierte Wörter sind einfach Aliase für vordefinierte Strukturtypen in die 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 AliastypAliased 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 der einfache Typ einen Alias ein Strukturtyps, verfügt über alle einfachen Typen auf Member.Because a simple type aliases a struct type, every simple type has members. Z. B. int wurde im deklarierten Member System.Int32 und die Mitglieder von geerbt 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:

  • Die meisten einfachen Typen ermöglichen, Werte für das Schreiben von zu erstellenden Literale (Literale).Most simple types permit values to be created by writing literals (Literals). Z. B. 123 ist ein Literal vom Typ int und 'a' ist ein Literal vom Typ char.For example, 123 is a literal of type int and 'a' is a literal of type char. In c# keine Bereitstellung für Literale der Strukturtypen im Allgemeinen wird, und nicht standardmäßigen Werten anderer Strukturtypen sind letztendlich immer über Instanzkonstruktoren dieser Struct-Typen 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 die Operanden eines Ausdrucks auf alle einfache Typkonstanten sind, ist es möglich, dass der Compiler zum Auswerten des Ausdrucks während der Kompilierung.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 bezeichnet ein Constant_expression (Konstante Ausdrücke).Such an expression is known as a constant_expression (Constant expressions). Ausdrücke, die im Zusammenhang mit anderen Strukturtypen definierten Operatoren sind nicht als Konstante Ausdrücke sein.Expressions involving operators defined by other struct types are not considered to be constant expressions.
  • Über const Deklarationen kann zum Deklarieren von Konstanten der einfachen Typen (Konstanten).Through const declarations it is possible to declare constants of the simple types (Constants). Es ist nicht möglich, die Konstanten, die von anderen Strukturtypen haben, aber ein ähnliches Ergebnis erfolgt über static readonly Felder.It is not possible to have constants of other struct types, but a similar effect is provided by static readonly fields.
  • Konvertierungen, die im Zusammenhang mit einfachen Typen Auswertung von Konvertierungsoperatoren, die von anderen Strukturtypen definiert teilnehmen können, aber ein benutzerdefinierten Konvertierungsoperator kann nie teilnehmen Auswertung von einem anderen benutzerdefinierten Operator (Auswertung Benutzerdefinierte 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 haben die folgenden Größen und Wertebereiche:The integral types have the following sizes and ranges of values:

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

Der vom integralen Typ unären und binären Operatoren setzen immer mit 32-Bit-Präzision, ohne Vorzeichen 32-Bit-präziser, signierten 64-Bit-Präzision oder ohne Vorzeichen 64-Bit-präziser: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 den unären + und ~ Operatoren, die den Operanden wird in den Typ konvertiert T, wobei T ist der erste Teil int, uint, long, und ulong , können alle vollständig darstellen Mögliche Werte des Operanden.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 erfolgt dann mit der Genauigkeit des Datentyps T, und der Typ des Ergebnisses 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, der Operand den Typ konvertiert wird T, wobei T ist der erste Teil int und long , die alle möglichen Werte des Operanden vollständig darstellen können.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 erfolgt dann mit der Genauigkeit des Datentyps T, und der Typ des Ergebnisses 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 des Typs angewendet werden ulong.The unary - operator cannot be applied to operands of type ulong.
  • Für die Binärdatei +, -, *, /, %, &, ^, |, ==, !=, >, <, >=, und <= Operatoren, die Operanden werden in den Typ konvertiert T, wobei T ist der erste Teil int, uint, long, und ulong , die alle vollständig darstellen können die Werte der beiden Operanden.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 erfolgt dann mit der Genauigkeit des Datentyps T, und der Typ des Ergebnisses 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 Typ ulong mit binären Operatoren.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ärdatei << und >> Operatoren, der linke Operand wird in den Typ konvertiert T, wobei T ist der erste Teil int, uint, long, und ulong , können alle vollständig darstellen Mögliche Werte des Operanden.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 erfolgt dann mit der Genauigkeit des Datentyps T, und der Typ des Ergebnisses ist T.The operation is then performed using the precision of type T, and the type of the result is T.

Die char Typ wird als ein ganzzahliger Typ klassifiziert, aber es unterscheidet sich von anderen ganzzahligen Typen gibt es zwei Möglichkeiten: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 der char Typ.There are no implicit conversions from other types to the char type. Insbesondere, obwohl die sbyte, byte, und ushort aufweisen Wertebereiche, die vollständig auf darstellbar mithilfe der char eingeben, implizite Konvertierungen von sbyte, byte, oder ushort auf char nicht vorhanden sind.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.
  • Die Konstanten der char Typ geschrieben werden muss, als Character_literals oder als Integer_literals in Kombination mit einer Umwandlung in den Typ char.Constants of the char type must be written as character_literals or as integer_literals in combination with a cast to type char. Beispielsweise hat (char)10 die gleiche Wirkung wie '\x000A'.For example, (char)10 is the same as '\x000A'.

Die checked und unchecked Operatoren und Anweisungen werden verwendet, um überlaufprüfung für arithmetische Operationen für ganzzahlige Typen und Konvertierungen zu steuern (checked und unchecked Operatoren).The 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 ist ein Überlauf erzeugt einen Fehler während der Kompilierung oder bewirkt, dass eine System.OverflowException ausgelöst wird.In a checked context, an overflow produces a compile-time error or causes a System.OverflowException to be thrown. In einer unchecked Kontext Ü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.

GleitkommatypenFloating point types

C# unterstützt zwei Gleitkommatypen: float und double.C# supports two floating point types: float and double. Die float und double Typen werden mit den 32-Bit mit einfacher Genauigkeit und 64-Bit-Gleitkommazahl mit doppelter Genauigkeit IEEE 754-Formaten, die die folgenden Sätze von Werten bereitstellen dargestellt: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 Nullen und negative 0 (null).Positive zero and negative zero. In den meisten Fällen, positive und Negative 0 (null) Verhalten sich identisch, der einfachen Wert 0 (null), aber bestimmte Vorgänge, die zwischen den beiden unterscheiden (Divisionsoperator).In most situations, positive zero and negative zero behave identically as the simple value zero, but certain operations distinguish between the two (Division operator).
  • Plus unendlich und negativ unendlich.Positive infinity and negative infinity. Unendliche Werte werden durch Vorgänge wie dividiert eine Zahl ungleich NULL durch 0 (null) erstellt.Infinities are produced by such operations as dividing a non-zero number by zero. Z. B. 1.0 / 0.0 plus unendlich ergibt und -1.0 / 0.0 negative Unendlichkeit.For example, 1.0 / 0.0 yields positive infinity, and -1.0 / 0.0 yields negative infinity.
  • Die Not-a-Number Wert, häufig abgekürzt als NaN.The Not-a-Number value, often abbreviated NaN. NaN-Werte werden durch ungültige Gleitkommaoperationen, z. B. Division von 0 (null) von 0 (null) erstellt.NaNs are produced by invalid floating-point operations, such as dividing zero by zero.
  • Die begrenzte Menge von Werten ungleich Null des Formulars s * m * 2^e, wobei s 1 oder-1 ist, und m und e hängen von den entsprechenden Gleitkommatyp: 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 Gleitkommazahlen gelten als gültige nicht-NULL-Werte.Denormalized floating-point numbers are considered valid non-zero values.

Die float Typ kann Werte im Bereich von ungefähr darstellen 1.5 * 10^-45 zu 3.4 * 10^38 mit einer Genauigkeit von 7 Stellen.The float type can represent values ranging from approximately 1.5 * 10^-45 to 3.4 * 10^38 with a precision of 7 digits.

Die double Typ kann Werte im Bereich von ungefähr darstellen 5.0 * 10^-324 zu 1.7 × 10^308 mit einer Genauigkeit von 15 – 16 Stellen.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 des binären Operators ein Gleitkommatyp ist, dann muss der andere Operand ein ganzzahliger Typ oder Gleitkommatyp 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, den der Gleitkommatyp 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.
  • Klicken Sie dann, wenn einer der Operanden des Typs double, wird der andere Operand in konvertiert double, der Vorgang ausgeführt wird, mit mindestens double Bereich und Genauigkeit, und der Typ des Ergebnisses double (oder bool für die Relationale 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 ist der Vorgang mit mindestens ausgeführt float Bereich und Genauigkeit, und der Typ des Ergebnisses 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).

Der Gleitkomma-Operatoren, einschließlich der Zuweisungsoperatoren sind erzeugen niemals Ausnahmen aus.The floating-point operators, including the assignment operators, never produce exceptions. Stattdessen erzeugt in Ausnahmefällen, Gleitkommaoperationen 0 (null), unendlich oder NaN ist, wie im folgenden beschrieben:Instead, in exceptional situations, floating-point operations produce zero, infinity, or NaN, as described below:

  • Wenn das Ergebnis einer Gleitkommaoperation zu klein für das Zielformat ist, wird das Ergebnis des Vorgangs positiv oder negative 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 Gleitkommaoperation für das Zielformat zu groß ist, wird das Ergebnis des Vorgangs positive oder negative Unendlichkeit.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 eine Gleitkommaoperation ungültig ist, wird das Ergebnis des Vorgangs NaN.If a floating-point operation is invalid, the result of the operation becomes NaN.
  • Wenn eine oder beide der Operanden einer Gleitkommaoperation ist NaN, wird das Ergebnis des Vorgangs NaN.If one or both operands of a floating-point operation is NaN, the result of the operation becomes NaN.

Gleitkommaoperationen können mit einer höheren Genauigkeit als der Ergebnistyp des Vorgangs ausgeführt werden.Floating-point operations may be performed with higher precision than the result type of the operation. Beispielsweise unterstützen einige Hardwarearchitekturen einen "erweiterten" oder "long double" vom Typ Gleitkommazahlen mit größeren Bereich und Genauigkeit als den double geben, und führen Sie alle Operationen mit Gleitkommazahlen mit dem folgenden höhere Genauigkeit Typ implizit.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 auf eine übermäßige Abstriche bei der Leistung können solche Hardwarearchitekturen zum Ausführen von Operations mit Gleitkommazahlen mit geringerer Genauigkeit und anstelle eine Implementierung, die in Anspruch genommenen Leistung und Genauigkeit erfordern, lässt c# einen höheren Genauigkeit Typ für alle Operationen mit Gleitkommazahlen verwendet.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. Als die Bereitstellung eine genauere Ergebnisse, hat dies nur selten keine messbaren Auswirkungen.Other than delivering more precise results, this rarely has any measurable effects. In Ausdrücken des Formulars x * y / z, in denen die Multiplikation für ein Ergebnis erzeugt, die außerhalb der double Bereich, aber die nachfolgende Division wird das temporäre Ergebnis wieder in die double liegen, die Tatsache, dass der Ausdruck ausgewertet, in einem höheren Bereich Format kann dazu führen, dass eine endliche Ergebnis unendlich erstellt werden.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 decimal-TypThe 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. Die decimal Typ kann im Bereich von Werten darstellen 1.0 * 10^-28 auf ungefähr 7.9 * 10^28 mit 28 bis 29 signifikanten Stellen.The decimal type can represent values ranging from 1.0 * 10^-28 to approximately 7.9 * 10^28 with 28-29 significant digits.

Die begrenzte Menge von Werten des Typs decimal weisen folgendes Format (-1)^s * c * 10^-e, wobei das Vorzeichen s gleich 0 oder 1, den Koeffizienten c , angegeben durch 0 <= *c* < 2^96, und der Skala e ist so, dass 0 <= e <= 28. Die decimal Typ unterstützt nicht mit Nullen, unendliche und 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. Ein decimal wird als eine 96-Bit-Ganzzahl, die durch eine Potenz von 10 skaliert dargestellt.A decimal is represented as a 96-bit integer scaled by a power of ten. Für decimals mit einem absoluten Wert kleiner als 1.0m, der Wert ist genau auf die 28. Dezimalstelle, 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 decimals mit einem absoluten Wert größer als oder gleich 1.0m, der Wert ist auf 28 oder 29 Stellen genau.For decimals with an absolute value greater than or equal to 1.0m, the value is exact to 28 or 29 digits. Gattungsbezeichnung der float und double -Datentypen, wie z. B. 0,1 Dezimalzahlen dargestellt werden können in genau der decimal Darstellung.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 Darstellungen, diese Zahlen sind häufig unendliche Brüche angegeben, wodurch die Darstellung anfälliger für runden Fehler.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 des binären Operators vom Typ decimal, muss der andere Operand ein ganzzahliger Typ oder vom Typ werden 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 Operand integralen Typ vorhanden ist, wird eine Konvertierung in decimal , bevor der Vorgang ausgefü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 vom Typ decimal besteht darin, dass die Berechnung eines genauen Ergebnis (Staffelung beibehalten, wie für die einzelnen Operatoren definiert), und klicken Sie dann entsprechend die Darstellung runden entstehen würden.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. Ergebnisse werden gerundet, um den nächsten darstellbaren Wert und, wenn ein Ergebnis gleichmäßig in der Nähe zwei Werte dargestellt werden kann, auf den Wert, der eine gerade Anzahl an der Position der am wenigsten signifikanten Ziffern verfügt (Dies ist bekannt als "unverzerrte Rundung der").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 0 und einer Skala von 0.A zero result always has a sign of 0 and a scale of 0.

Wenn eine dezimale arithmetische Operation auf einen Wert kleiner als oder gleich erzeugt 5 * 10^-29 in absoluten Wert 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 führt zu einem Ergebnis, das für zu groß ist die decimal -Format eine System.OverflowException ausgelöst.If a decimal arithmetic operation produces a result that is too large for the decimal format, a System.OverflowException is thrown.

Die decimal Typ verfügt über höhere Genauigkeit aber kleineren Bereich als das Gleitkomma-Datentypen.The decimal type has greater precision but smaller range than the floating-point types. Daher Konvertierungen von Gleitkommatypen auf decimal Stapelüberlauf-Ausnahmen und Konvertierungen von erzeugen möglicherweise decimal auf die Gleitkomma-Datentypen möglicherweise zu Genauigkeitsverlust 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 werden keine impliziten Konvertierungen zwischen Gleitkommatypen vorhanden und decimal, und ohne explizite Umwandlungen ist es nicht möglich, Gleitkomma mischen und decimal Operanden in dem gleichen Ausdruck.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 Typ "bool"The bool type

Die bool Boolesche logische Mengen darstellt.The bool type represents boolean logical quantities. Die möglichen Werte des Typs bool sind true und false.The possible values of type bool are true and false.

Keine standardkonvertierungen bestehen zwischen bool und anderen Typen.No standard conversions exist between bool and other types. Insbesondere die bool verschieden und getrennt von ganzzahligen Typen ist und ein bool Wert kann nicht verwendet werden, statt einen ganzzahligen Wert (und umgekehrt).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 Sprachen C und C++ einen ganzzahligen oder Gleitkomma Nullwert oder ein null-Zeiger auf den booleschen Wert konvertiert werden kann false, und einen Wert ungleich NULL, ganzzahligen oder Gleitkomma oder ein nicht-Null-Zeiger auf den booleschen Wert konvertiert werden kann 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. Solche Konvertierungen werden in c# erreicht, durch die explizite Vergleich einen ganzzahligen oder Gleitkomma-Wert 0 (null) oder durch die explizite Vergleich einen Objektverweis auf 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 eigenständiger Typ mit benannter Konstanten.An enumeration type is a distinct type with named constants. Jeder Enumerationstyp hat einen zugrunde liegenden Typ, der sein muss byte, sbyte, short, ushort, int, uint, long oder ulong.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 der 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 über Enumerationsdeklarationen definiert (Enumerationsdeklarationen).Enumeration types are defined through enumeration declarations (Enum declarations).

Auf NULL festlegbare TypenNullable types

Ein nullable-Typ kann alle Werte der darstellen der zugrunde liegender Typ plus eine zusätzliche null-Wert.A nullable type can represent all values of its underlying type plus an additional null value. Ein nullable-Typ geschrieben T?, wobei T ist der zugrunde liegenden Typ.A nullable type is written T?, where T is the underlying type. Diese Syntax ist die Kurzform für System.Nullable<T>, und die beiden Formen sind austauschbar.This syntax is shorthand for System.Nullable<T>, and the two forms can be used interchangeably.

Ein nicht auf NULL festlegbarer Werttyp ist im Gegensatz dazu jeder Werttyp außer System.Nullable<T> und die Kurzschreibweise T? (für alle T), sowie einen Typparameter, der ein NULL-Werttyp (d. h. alle ist beschränkt ist Geben Sie Parameter mit einem 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). Die System.Nullable<T> Typ gibt an, der werttypeinschränkung für T (Geben Sie die Einschränkungen für Typparameter), was bedeutet, dass der zugrunde liegende Typ einen nullable-Typ NULL-Werttyp werden kann.The 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 nullable-Typs darf keinen nullable-Typ oder ein Verweistyp sein.The underlying type of a nullable type cannot be a nullable type or a reference type. Z. B. int?? und string? ist ein ungültiger Typ.For example, int?? and string? are invalid types.

Eine Instanz von einem nullable-Typ T? hat zwei öffentliche schreibgeschützte Eigenschaften:An instance of a nullable type T? has two public read-only properties:

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

Eine Instanz für die HasValue ist "true" gilt als nicht Null sein.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 ist "false" gilt als null sein.An instance for which HasValue is false is said to be null. Eine null-Instanz verfügt über einen nicht definierten Wert.A null instance has an undefined value. Beim Lesen der Value führt dazu, dass eine null-Instanz eine System.InvalidOperationException ausgelöst wird.Attempting to read the Value of a null instance causes a System.InvalidOperationException to be thrown. Der Prozess für den Zugriff auf die Value Eigenschaft einer Instanz mit NULL-Werte zulässt, die Verfügbarkeitsklasse zum Entpacken.The process of accessing the Value property of a nullable instance is referred to as unwrapping.

Zusätzlich zu den Standardkonstruktor, der alle nullable-Typ T? verfügt über einen öffentlichen Konstruktor, der ein einzelnes vom Typ Argument T.In addition to the default constructor, every nullable type T? has a public constructor that takes a single argument of type T. Ein Wert zugewiesen x des Typs T, einen Konstruktoraufruf des FormularsGiven a value x of type T, a constructor invocation of the form

new T?(x)

erstellt eine Instanz ungleich Null der T? für die die Value Eigenschaft x.creates a non-null instance of T? for which the Value property is x. Erstellen Sie eine nicht-Null-Instanz, der einen nullable-Typ für ein bestimmten Wert als bezeichnet wrapping.The process of creating a non-null instance of a nullable type for a given value is referred to as wrapping.

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

VerweistypenReference types

Ein Verweistyp ist ein Klassentyp, einen Schnittstellentyp, einen Arraytyp oder einen Delegattyp aufweisen.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 verweistypwert ist ein Verweis auf ein Instanz des Typs, der letzten bekannten als ein Objekt.A reference type value is a reference to an instance of the type, the latter known as an object. Der spezielle Wert null ist kompatibel mit alle Verweistypen zulässig, und gibt das Fehlen einer Instanz.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 Daten Mitglieder (Konstanten und Feldern), Funktionsmember (Methoden, Eigenschaften, Ereignisse, Indexer, Operatoren, Instanzkonstruktoren, Destruktoren und statische Konstruktoren) und geschachtelte 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 die Vererbung, einen Mechanismus, bei dem abgeleitete Klassen können erweitert und Basisklassen spezialisiert.Class types support inheritance, a mechanism whereby derived classes can extend and specialize base classes. Instanzen von Klassentypen werden mit erstellt Object_creation_expressions (Erstellung Objektausdrücke).Instances of class types are created using object_creation_expressions (Object creation expressions).

Klassentypen werden in beschrieben Klassen.Class types are described in Classes.

Bestimmte vordefinierte Klassentypen haben eine besondere Bedeutung in der C#-Sprache, 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. Finden Sie unter den Objekttyp.See The object type.
System.String Der Zeichenfolgentyp der C#-Sprache.The string type of the C# language. Finden Sie unter Zeichenfolgentyps.See The string type.
System.ValueType Die Basisklasse aller Typen von Wert.The base class of all value types. Finden Sie unter die System.ValueType-Typ.See The System.ValueType type.
System.Enum Die Basisklasse aller Enum-Typen.The base class of all enum types. Finden Sie unter Enumerationen.See Enums.
System.Array Die Basisklasse für alle Arraytypen.The base class of all array types. Siehe Arrays.See Arrays.
System.Delegate Die Basisklasse aller Delegattypen.The base class of all delegate types. Finden Sie unter Delegaten.See Delegates.
System.Exception Die Basisklasse aller Art der Ausnahme.The base class of all exception types. Finden Sie unter Ausnahmen.See Exceptions.

Der ObjekttypThe object type

Die 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# geschrieben, direkt oder indirekt, abgeleitet aus den object Klassentyp.Every type in C# directly or indirectly derives from the object class type.

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

Der dynamische TypThe dynamic type

Die dynamic eingeben, z. B. object, kann jedes beliebige Objekt verweisen.The dynamic type, like object, can reference any object. Wenn Operatoren angewendet werden auf Ausdrücke vom Typ dynamic, deren Auflösung wird 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. Daher dass der Operator kann nicht gesetzlich für das referenzierte Objekt angewendet werden, kein Fehler während der Kompilierung erhält.Thus, if the operator cannot legally be applied to the referenced object, no error is given during compilation. Stattdessen wird eine Ausnahme ausgelöst werden, 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.

Ihr Zweck ist, können dynamische Bindung, die ausführlich beschrieben wird dynamische Bindung.Its purpose is to allow dynamic binding, which is described in detail in Dynamic binding.

dynamic wird als identisch betrachtet object mit Ausnahme der in folgender Hinsicht:dynamic is considered identical to object except in the following respects:

  • Vorgänge für Ausdrücke vom Typ dynamic dynamisch gebunden werden kann (dynamische Bindung).Operations on expressions of type dynamic can be dynamically bound (Dynamic binding).
  • Typrückschluss (Typrückschluss) am liebsten dynamic über object Wenn beide in Frage kommen.Type inference (Type inference) will prefer dynamic over object if both are candidates.

Aufgrund dieser Äquivalenz enthält die folgenden Schritte aus:Because of this equivalence, the following holds:

  • Es gibt eine implizite identitätsänderung Konvertierung zwischen object und dynamic, und zwischen konstruierte Typen, die gleich, beim Ersetzen von sind dynamic mit 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 in und aus object gelten auch in den und aus dynamic.Implicit and explicit conversions to and from object also apply to and from dynamic.
  • Methodensignaturen, die gleich, beim Ersetzen von sind dynamic mit object gelten die gleiche SignaturMethod signatures that are the same when replacing dynamic with object are considered the same signature
  • Der Typ dynamic wird nicht von Unterschieden object zur Laufzeit.The type dynamic is indistinguishable from object at run-time.
  • Ein Ausdruck vom Typ dynamic wird als bezeichnet ein dynamischen Ausdrucks.An expression of the type dynamic is referred to as a dynamic expression.

Der String-DatentypThe string type

Die string Typ ist ein Typ von versiegelten Klasse, die direkt von erbt object.The string type is a sealed class type that inherits directly from object. Instanzen der string Klasse dar, Unicode-Zeichenfolgen.Instances of the string class represent Unicode character strings.

Werte von der string Typ geschrieben werden kann, als Zeichenfolgenliterale (Zeichenfolgenliterale).Values of the string type can be written as string literals (String literals).

Das Schlüsselwort string ist einfach ein Alias für die vordefinierten 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 Basisschnittstellen 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 in beschrieben Schnittstellen.Interface types are described in Interfaces.

ArraytypenArray types

Ein Array ist eine Datenstruktur, die NULL oder mehr Variablen enthält, die über berechnete Indizes zugegriffen wird.An array is a data structure that contains zero or more variables which are accessed through computed indices. In einem Array, das die Elemente des Arrays, so genannte enthaltenen Variablen sind alle vom selben Typ, und diese Art wird den 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.

Arraytypen sind in beschriebenen Arrays.Array types are described in Arrays.

DelegattypenDelegate types

Ein Delegat ist eine Datenstruktur, die auf mindesten eine Methode verweist.A delegate is a data structure that refers to one or more methods. Z. B. Methoden, bezieht er sich auch auf ihre entsprechenden Objektinstanzen.For instance methods, it also refers to their corresponding object instances.

Am nächsten eines Delegaten in C oder C++ entspricht ein Funktionszeiger, aber während ein Funktionszeiger nur statische Funktionen verweisen kann, ein Delegaten verweisen sowohl statische und Instanzenmethoden kann.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 Delegaten nicht nur einen Verweis auf den Einstiegspunkt der Methode, sondern auch einen Verweis auf die Objektinstanz, auf dem zum Aufrufen der Methode.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 in beschrieben Delegaten.Delegate types are described in Delegates.

Boxing und UnboxingBoxing and unboxing

Das Konzept von Boxing und unboxing ist für die # Typsystem.The concept of boxing and unboxing is central to C#'s type system. Es stellt eine Brücke zwischen Value_types und Reference_types Anwesenheitsebene einen Wert für die ein Value_type zum und vom Typ konvertiert werden object.It provides a bridge between value_types and reference_types by permitting any value of a value_type to be converted to and from type object. Boxing und unboxing ermöglicht eine einheitliche Ansicht des Typsystems, bei dem 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-KonvertierungBoxing conversions

Ermöglicht eine Boxingkonvertierung einer Value_type implizit zu konvertierenden eine Reference_type.A boxing conversion permits a value_type to be implicitly converted to a reference_type. Die folgenden Boxing-Konvertierung sind vorhanden:The following boxing conversions exist:

  • Von jedem Value_type in den Typ object.From any value_type to the type object.
  • Von jedem Value_type in den Typ System.ValueType.From any value_type to the type System.ValueType.
  • Von jedem Non_nullable_value_type auf Interface_type implementiert die Value_type.From any non_nullable_value_type to any interface_type implemented by the value_type.
  • Von jedem Nullable_type auf Interface_type von den zugrunde liegenden Typ implementiert die Nullable_type.From any nullable_type to any interface_type implemented by the underlying type of the nullable_type.
  • Von jedem Enum_type in den Typ System.Enum.From any enum_type to the type System.Enum.
  • Von jedem Nullable_type mit einem zugrunde liegenden Enum_type in den 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 eine Boxingkonvertierung ausgeführt wird, wenn zur Laufzeit das Konvertieren von Werttypen auf einen Referenztyp führt (implizite Konvertierungen, die im Zusammenhang 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).

Boxing-Wert eine Non_nullable_value_type besteht aus eine Objektinstanz zuordnen und das Kopieren der Non_nullable_value_type Wert in dieser 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.

Boxing-Wert eine Nullable_type erzeugt einen null-Verweis, ist dies die null Wert (HasValue ist false), oder das Ergebnis von entpacken und den zugrunde liegenden Wert andernfalls boxing.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 der boxing-Wert eine Non_nullable_value_type am besten lässt sich vorstellen, das Vorhandensein eines generischen Boxingklasse, die verhält, als ob es wie folgt deklariert wurden: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;
    }
}

Boxing eines Werts v des Typs T besteht nun der Ausführung des Ausdrucks new Box<T>(v), und die daraus resultierende Instanz zurückgegeben, als ein Wert vom Typ 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. Daher die AnweisungenThus, the statements

int i = 123;
object box = i;

im Prinzip entsprechenconceptually correspond to

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

Eine Boxingklasse wie Box<T> höher ist nicht tatsächlich vorhanden und der dynamische Typ der einen geschachtelten Wert ist nicht tatsächlich einen 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 einen geschachtelten Wert vom Typ T weist den Typ der dynamischen T, und einem Typ "dynamic" Überprüfen Sie mithilfe der 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. Ein auf ein Objekt angewendeterFor example,

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

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

Eine Boxingkonvertierung impliziert eine Kopie des Werts geschachtelt werden.A boxing conversion implies making a copy of the value being boxed. Dies unterscheidet sich von der Konvertierung einer Reference_type eingeben object, in denen der Wert weiterhin dieselbe Instanz verweisen, und wird einfach als weniger stark abgeleiteten Typ betrachtet 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. Z. B. im Falle folgender 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 implizites Boxing-Vorgang, der bei der Zuweisung von auftritt, p zu box wird der Wert des p kopiert werden soll.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. Hatte Point wurde deklariert eine class stattdessen wäre der Wert 20 ausgegeben werden, da p und box würde die gleiche Instanz zu verweisen.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

Ermöglicht eine unboxing-Konvertierung einer Reference_type explizit zu konvertierenden 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 auf Value_type.From the type object to any value_type.
  • Vom Typ System.ValueType auf Value_type.From the type System.ValueType to any value_type.
  • Von jedem Interface_type auf Non_nullable_value_type , implementiert die Interface_type.From any interface_type to any non_nullable_value_type that implements the interface_type.
  • Von jedem Interface_type auf Nullable_type , dessen zugrunde liegenden Typ implementiert die Interface_type.From any interface_type to any nullable_type whose underlying type implements the interface_type.
  • Vom Typ System.Enum auf Enum_type.From the type System.Enum to any enum_type.
  • Vom Typ System.Enum auf Nullable_type mit einem zugrunde liegenden Enum_type.From the type System.Enum to any nullable_type with an underlying enum_type.
  • Beachten Sie, dass eine explizite Konvertierung für einen Typparameter als einer unboxing-Konvertierung ausgeführt wird, wenn zur Laufzeit das Konvertieren von einem Referenztyp in einen Werttyp führt (explizite dynamische Konvertierungen).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 um eine Non_nullable_value_type zunächst geprüft wird, die die Objektinstanz einen geschachtelten Wert besteht aus der angegebenen Non_nullable_value_type, und kopieren Sie den Wert von der -Instanz.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.

Unboxing zu einer Nullable_type erzeugt den null-Wert von der Nullable_type ist Quelloperanden null, oder das umschlossene Ergebnis von unboxing die Objektinstanz, die den zugrunde liegenden Typ der 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.

Um der imaginären Boxingklasse, die im vorherigen Abschnitt beschrieben, einer unboxing-Konvertierung eines Objekts verweisen box zu einem Value_type T besteht 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. Daher die AnweisungenThus, the statements

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

im Prinzip entsprechenconceptually correspond to

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

Für ein unboxing-Konvertierung in einen angegebenen Non_nullable_value_type um zur Laufzeit erfolgreich ausgeführt werden, muss der Wert des Quelloperanden einen Verweis auf einen geschachtelten Wert, der Non_nullable_value_type.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 Quelloperand ist null, System.NullReferenceException ausgelöst.If the source operand is null, a System.NullReferenceException is thrown. Wenn Quelloperanden ein Verweis auf ein Objekt nicht kompatibel ist eine System.InvalidCastException ausgelöst.If the source operand is a reference to an incompatible object, a System.InvalidCastException is thrown.

Für ein unboxing-Konvertierung in einen angegebenen Nullable_type um zur Laufzeit erfolgreich ausgeführt werden, muss der Wert des Quelloperanden werden entweder null oder ein Verweis auf einen geschachtelten Wert des zugrunde liegenden Non_nullable_value_type von der Nullable_type.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 Quelloperanden ein Verweis auf ein Objekt nicht kompatibel ist eine System.InvalidCastException ausgelöst.If the source operand is a reference to an incompatible object, a System.InvalidCastException is thrown.

Konstruierte TypenConstructed types

Gibt die Deklaration eines generischen Typs selbst eine ungebundene generischen Typ , der als "Blaupause" verwendet wird, um viele verschiedene Arten, über die Anwendung bilden Typargumente.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 in spitzen Klammern geschrieben werden (< und >) unmittelbar nach dem Namen des generischen Typs.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 heißt eine konstruierter Typ.A type that includes at least one type argument is called a constructed type. Ein konstruierter Typ kann in den meisten stellen in der Sprache verwendet werden, in dem ein Typnamen 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 verwendet werden, in einem Typeof_expression (der Typeof-Operator).An unbound generic type can only be used within a typeof_expression (The typeof operator).

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

Wenn eine Namespace_or_type_name ist die richtige Anzahl von Parametern gelten als Typ ausgewertete, die nur generische Typen.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, die den gleichen Bezeichner zu verwenden, um unterschiedliche Typen aufweisen, ermitteln, solange die Typen eine unterschiedliche Anzahl von Typparametern haben.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 hilfreich, wenn generische und nicht generischen Klassen im selben Programm zu kombinieren: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 möglicherweise einen konstruierten Typ zu identifizieren, obwohl sie direkt Typparameter angeben nicht.A type_name might identify a constructed type even though it doesn't specify type parameters directly. Dies kann auftreten, in denen ein Typ in der Deklaration einer generischen Klasse geschachtelt ist und der Instanztyp der enthaltenden Deklaration wird implizit für die Namenssuche verwendet (geschachtelte Typen in generischen Klassen):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 nicht als ein konstruierter Typ verwendet werden eine Unmanaged_type (Zeigertypen).In unsafe code, a constructed type cannot be used as an unmanaged_type (Pointer types).

TypargumenteType arguments

Jedes Argument in einer Liste der Typargumente ist einfach eine 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 (unsicheren Code), ein Type_argument möglicherweise kein Zeigertyp.In unsafe code (Unsafe code), a type_argument may not be a pointer type. Jedes Typargument erfüllen muss, alle Einschränkungen für den entsprechenden Typparameter (Geben Sie die Einschränkungen für Typparameter).Each type argument must satisfy any constraints on the corresponding type parameter (Type parameter constraints).

Offene und geschlossene TypenOpen and closed types

Alle Typen klassifiziert werden können, entweder als offene Typen oder geschlossene Typen.All types can be classified as either open types or closed types. Ein offener Typ ist ein Typ, der Parameter vom Typ umfasst.An open type is a type that involves type parameters. Genauer gesagt:More specifically:

  • Ein Typparameter definiert einen offenen Typ.A type parameter defines an open type.
  • Array-Typ ist ein offener Typ, wenn der 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 mindestens eines seiner Typargumente einen offenen 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 geschachtelten konstruierter Typ ist ein offener Typ, wenn mindestens eines seiner Typargumente oder die Typargumente der enthaltenden Typs einen offenen 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, der nicht auf einen offenen Typ handelt.A closed type is a type that is not an open type.

Zur Laufzeit der gesamte Code in der Deklaration eines generischen Typs wird ausgeführt im Kontext eines geschlossenen konstruierten Typs, die 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. Jeden von Typparameter in der generischen Typ ist für eine bestimmte Art von zur Laufzeit gebunden.Each type parameter within the generic type is bound to a particular run-time type. Immer die Laufzeit die Verarbeitung aller Anweisungen und Ausdrücke geschieht geschlossene Typen, und offene Typen auftreten nur während der Kompilierzeit-Verarbeitung.The run-time processing of all statements and expressions always occurs with closed types, and open types occur only during compile-time processing.

Jede geschlossener konstruierter Typ verfügt über einen eigenen Satz von statischen 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, die ein offener Typ zugeordnet.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 über den gleichen ungebundenen generischen Typ erstellt werden, und ihre entsprechenden Typargumente desselben Typs.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.

Gebunden ist, und nicht gebundene TypenBound and unbound types

Der Begriff nicht gebundenen Typ bezieht sich 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 Typ gebunden bezieht sich 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 bezieht sich auf die Entität deklariert, indem eine Typdeklaration.An unbound type refers to the entity declared by a type declaration. Ein ungebundener generischer Typ ist selbst ein Typ und kann nicht als Typ einer Variablen, Argument oder Rückgabewert 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. Ist das einzige Konstrukt in der ein ungebundener generischer Typ verwiesen werden kann die typeof Ausdruck (der Typeof-Operator).The only construct in which an unbound generic type can be referenced is the typeof expression (The typeof operator).

Zufriedenstellendes EinschränkungenSatisfying constraints

Wenn es sich bei einem konstruierten Typ oder eine generische Methode verwiesen wird, werden die angegebenen Typargumente mit Einschränkungen für Typparameter für den generischen Typ oder Methode deklariert verglichen (Geben Sie die Einschränkungen für Typparameter).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, die das Typargument A , entspricht die benannte Parameter vom Typ überprüft wird jede Einschränkung wie folgt:For each where clause, the type argument A that corresponds to the named type parameter is checked against each constraint as follows:

  • Wenn die Einschränkung eines Klassentyps, einen Schnittstellentyp aufweisen oder ein Typparameter ist, können C stellen dar, dass die Einschränkung mit der angegebenen Typargumente für Typparameter ersetzt, die in der Einschränkung angezeigt werden.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 es der Fall, die eingeben A konvertiert werden kann, geben Sie C durch einen der folgenden:To satisfy the constraint, it must be the case that type A is convertible to type C by one of the following:
  • Wenn die Einschränkung der verweistypeinschränkung ist (class), den Typ A erfüllen müssen, eine der folgenden:If the constraint is the reference type constraint (class), the type A must satisfy one of the following:
    • A ist ein Schnittstellentyp, der Klassentyp, der Delegattyp oder Arraytyp.A is an interface type, class type, delegate type or array type. Beachten Sie, dass System.ValueType und System.Enum sind Verweistypen, die diese Einschränkung zu erfüllen.Note that System.ValueType and System.Enum are reference types that satisfy this constraint.
    • A Ein Typparameter, der bekannt ist, dass ein Verweistyp sein (Geben Sie die Einschränkungen für Typparameter).A is a type parameter that is known to be a reference type (Type parameter constraints).
  • Wenn die Einschränkung der werttypeinschränkung ist (struct), den Typ A erfüllen müssen, eine der folgenden:If the constraint is the value type constraint (struct), the type A must satisfy one of the following:
    • A ist ein Strukturtyp oder Enum-Typ, aber keinen nullable-Typ.A is a struct type or enum type, but not a nullable type. Beachten Sie, dass System.ValueType und System.Enum sind Verweistypen, 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 werttypeinschränkung (Geben Sie die Einschränkungen für Typparameter).A is a type parameter having the value type constraint (Type parameter constraints).
  • Wenn die Einschränkung die Konstruktoreinschränkung ist new(), den Typ A darf nicht sein abstract und muss über einen öffentlichen parameterlosen 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 erfüllt wird, wenn eine der folgenden Aussagen zutrifft:This is satisfied if one of the following is true:

Ein Fehler während der Kompilierung tritt auf, wenn eine oder mehrere der Einschränkungen für einen Typparameter 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 der Typparameter nicht geerbt werden, sind niemals Einschränkungen entweder geerbt.Since type parameters are not inherited, constraints are never inherited either. Im folgenden Beispiel wird D muss die Einschränkung für den Typparameter angeben T , damit T erfüllt die Einschränkung auferlegt, die von der Basisklasse 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 Klasse E eine Einschränkung müssen nicht angeben, da List<T> implementiert IEnumerable für alle 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, die festlegen, ein Werttyp oder Verweistyp, der die Parameter zur Laufzeit gebunden wird.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ächliche Typargumenten instanziiert werden kann, über Typparameter verfügen, leicht unterschiedliche Vorgänge und Einschränkungen als die anderen 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:

Als Typ sind Typparameter ausschließlich ein Kompilierzeit-Konstrukt.As a type, type parameters are purely a compile-time construct. Zur Laufzeit ist jeden von Typparameter auf einen Typ zur Laufzeit gebunden, die durch Angabe von Typargument für die Deklaration des generischen Typs 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 der Typ einer Variablen, die mit einer Typ-Parameter wird zur Laufzeit, deklariert ein geschlossener konstruierter Typ sein (offene und geschlossene 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 Ausführung zur Laufzeit alle Anweisungen und Ausdrücke, die im Zusammenhang mit Typparametern verwendet den tatsächlichen Typ, der übergeben wurde, als Typargument für diesen Parameter.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.

AusdrucksbaumstrukturtypenExpression tree types

Ausdrucksbaumstrukturen zulassen von Lambda-Ausdrücke als Datenstrukturen statt ausführbaren Codes dargestellt werden.Expression trees permit lambda expressions to be represented as data structures instead of executable code. Ausdrucksbaumstrukturen sind die Werte der ausdrucksbaumstrukturtypen des Formulars System.Linq.Expressions.Expression<D>, wobei D jeden 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 bezeichnen wir diese Typen mit der Kurzform Expression<D>.For the remainder of this specification we will refer to these types using the shorthand Expression<D>.

Falls eine Konvertierung aus einem Lambdaausdruck vorhanden, auf einen Delegattyp ist D, eine Konvertierung auch vorhanden ist, um den Typ für die Ausdrucksbaumstruktur 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 in einen Delegattyp einen Lambda-Ausdruck ein Delegat, die ausführbaren Code für den Lambda-Ausdruck verweist generiert, wird die Konvertierung in einen Typ für die Ausdrucksbaumstruktur ein ausdrucksbaumstrukturdarstellung des Lambda-Ausdrucks erstellt.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.

Ausdrucksbaumstrukturen sind effiziente Nutzung von Daten in-Memory-Darstellungen von Lambda-Ausdrücke, und stellen 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 einen Delegattyp D, Expression<D> Parameter- und Rückgabetypen, hat die sind identisch mit denen der 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.

Das folgende Beispiel zeigt einen Lambda-Ausdruck als ausführbarer Code sowohl als eine Ausdrucksbaumstruktur.The following example represents a lambda expression both as executable code and as an expression tree. Da eine Konvertierung vorhanden ist, auf Func<int,int>, eine Konvertierung auch vorhanden ist, um 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

Befolgen diese Zuweisungen, die der Delegat del verweist auf eine Methode, die zurückgibt x + 1, und die Ausdrucksbaumstruktur exp 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 genauen Regeln für die Erstellung einer Ausdrucksbaumstruktur, wenn ein Lambda-Ausdruck in einen Typ für die Ausdrucksbaumstruktur konvertiert wird, sind außerhalb des 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, deutlich zu machen:Two things are important to make explicit:

  • Nicht alle Lambda-Ausdrücke können in Ausdrucksbaumstrukturen konvertiert werden.Not all lambda expressions can be converted to expression trees. Lambda-Ausdrücken mit Anweisung und Lambda-Ausdrücke mit Zuweisungsausdrücken, die können z. B. nicht dargestellt werden.For instance, lambda expressions with statement bodies, and lambda expressions containing assignment expressions cannot be represented. In diesen Fällen ist eine Konvertierung weiterhin vorhanden, aber zum Zeitpunkt der Kompilierung fehl.In these cases, a conversion still exists, but will fail at compile-time. Diese Ausnahmen werden ausführlich unter anonyme Funktion Konvertierungen.These exceptions are detailed in Anonymous function conversions.

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

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

    Aufrufen dieses Delegaten bewirkt, dass den Code, der von der Ausdrucksbaumstruktur dargestellt wird, ausgeführt werden.Invoking this delegate causes the code represented by the expression tree to be executed. Daher erhalten die oben genannten Definitionen, del und del2 sind äquivalent, und die folgenden beiden Anweisungen müssen die gleiche Auswirkung: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 der Ausführung des Codes, i1 und i2 müssen beide den Wert 2.After executing this code, i1 and i2 will both have the value 2.