Types

C# 言語の型は、2 つの主なカテゴリに分類されます。値の型参照型します。The types of the C# language are divided into two main categories: value types and reference types. 値型と参照型の両方がありますジェネリック型、これは、1 つ以上時間がかかるパラメーター入力します。Both value types and reference types may be generic types, which take one or more type parameters. 型パラメーターでは、両方の値の型を指定でき、型を参照することができます。Type parameters can designate both value types and reference types.

type
    : value_type
    | reference_type
    | type_parameter
    | type_unsafe
    ;

型、ポインターの最終的なカテゴリは、アンセーフ コードでのみ使用できます。The final category of types, pointers, is available only in unsafe code. これについては説明でさらにポインター型します。This is discussed further in Pointer types.

値の型とは異なりは参照型で値型の変数は、データを直接格納変数参照の種類のストアは参照として認識されている後者、データにオブジェクト.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. 参照型では 2 つの変数が同じオブジェクトを参照できるため、他の変数によって参照されるオブジェクトに影響を与える 1 つの変数に対する操作。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. 値型の場合は、各変数が独自のデータのコピーにあり、操作に影響を与えるもう 1 つのことはできません。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.

C#型システムは任意の型の値をオブジェクトとして処理できるように統合されます。C#'s type system is unified such that a value of any type can be treated as an object. C# における型はすべて、直接的または間接的に object クラス型から派生し、object はすべての型の究極の基底クラスです。Every type in C# directly or indirectly derives from the object class type, and object is the ultimate base class of all types. 参照型の値は、値を単純に object 型としてみなすことによってオブジェクトとして扱われます。Values of reference types are treated as objects simply by viewing the values as type object. 値型の値がボックス化とボックス化解除操作を実行することによってオブジェクトとして扱われます (ボックス化とボックス化解除)。Values of value types are treated as objects by performing boxing and unboxing operations (Boxing and unboxing).

値型Value types

値型は、構造体の型または列挙型のいずれかです。A value type is either a struct type or an enumeration type. C# と呼ばれる定義済みの構造体の型のセットを提供する、単純型します。C# provides a set of predefined struct types called the simple types. 単純型は、予約語によって特定されます。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
    ;

参照型の変数とは異なり、値型の変数には、値も含めることができますnull値の型が null 許容型である場合にのみです。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. すべての null 非許容値型の値と値の同じセットを示す対応する null 許容値型はnullします。For every non-nullable value type there is a corresponding nullable value type denoting the same set of values plus the value null.

値型の変数への代入では、割り当てられている値のコピーを作成します。Assignment to a variable of a value type creates a copy of the value being assigned. これは、コピー、参照が参照によって識別されるオブジェクトではなく、参照型の変数に割り当てと異なります。This differs from assignment to a variable of a reference type, which copies the reference but not the object identified by the reference.

System.ValueType 型The System.ValueType type

すべての値型がクラスから暗黙的に継承System.ValueTypeであり、さらに、クラスを継承objectします。All value types implicitly inherit from the class System.ValueType, which, in turn, inherits from class object. 任意の種類、値型から派生することはできませんし、値の型が暗黙的にシールしたがって (クラスをシール)。It is not possible for any type to derive from a value type, and value types are thus implicitly sealed (Sealed classes).

なおSystem.ValueType自体ではありません、 value_typeします。Note that System.ValueType is not itself a value_type. Class_typeすべてからvalue_types が自動的に派生します。Rather, it is a class_type from which all value_types are automatically derived.

既定のコンストラクターDefault constructors

すべての値型が暗黙的に呼び出されるパラメーターなしのパブリック インスタンス コンス トラクターを宣言、既定のコンス トラクターします。All value types implicitly declare a public parameterless instance constructor called the default constructor. 既定のコンス トラクターと呼ばれる、ゼロ初期化のインスタンスを返します、既定値値の型。The default constructor returns a zero-initialized instance known as the default value for the value type:

  • すべてのsimple_types、既定値はすべてゼロのビット パターンで生成される値。For all simple_types, the default value is the value produced by a bit pattern of all zeros:
    • sbytebyteshortushortintuintlong、およびulong、既定値は0します。For sbyte, byte, short, ushort, int, uint, long, and ulong, the default value is 0.
    • char、既定値は'\x0000'します。For char, the default value is '\x0000'.
    • float、既定値は0.0fします。For float, the default value is 0.0f.
    • double、既定値は0.0dします。For double, the default value is 0.0d.
    • decimal、既定値は0.0mします。For decimal, the default value is 0.0m.
    • bool、既定値はfalseします。For bool, the default value is false.
  • Enum_type E、既定値は0型に変換されたEします。For an enum_type E, the default value is 0, converted to the type E.
  • Struct_type、既定値は、すべての値型フィールドが既定値をすべて参照型フィールドに設定された値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.
  • Nullable_type既定値は、対象のインスタンス、HasValueプロパティが false とValueプロパティが定義されていません。For a nullable_type the default value is an instance for which the HasValue property is false and the Value property is undefined. 既定値とも呼ばれますが、 null 値null 許容型のです。The default value is also known as the null value of the nullable type.

使用して値型の既定のコンス トラクターを呼び出すその他のインスタンス コンスのように、new演算子。Like any other instance constructor, the default constructor of a value type is invoked using the new operator. 効率性の理由から、この要件はコンス トラクターの呼び出しを生成する実装が実際にあるありません。For efficiency reasons, this requirement is not intended to actually have the implementation generate a constructor call. 変数の下の例ではij両方は 0 に初期化します。In the example below, variables i and j are both initialized to zero.

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

すべての値型に暗黙的には、パラメーターなしのパブリック インスタンス コンス トラクターがあるために、パラメーターなしのコンス トラクターの明示的な宣言を格納する構造体の型のことはできません。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. パラメーター化されたインスタンス コンス トラクターを宣言する構造体の型が許可されているただし (コンス トラクター)。A struct type is however permitted to declare parameterized instance constructors (Constructors).

構造体の型Struct types

構造体の型とは、定数、フィールド、メソッド、プロパティ、インデクサー、演算子、インスタンス コンス トラクター、静的コンス トラクター、および入れ子にされた型を宣言する値型です。A struct type is a value type that can declare constants, fields, methods, properties, indexers, operators, instance constructors, static constructors, and nested types. 構造体型の宣言については、「構造体の宣言します。The declaration of struct types is described in Struct declarations.

単純型Simple types

C# と呼ばれる定義済みの構造体の型のセットを提供する、単純型します。C# provides a set of predefined struct types called the simple types. 予約語を使って単純型が識別されますが、これらの予約語は定義済みの構造体の型に対する単なるエイリアス、System名前空間では、次の表で説明されているとします。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.

予約語Reserved word エイリアスの型Aliased 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

単純型のエイリアスは、構造体型、ため、すべての単純型はメンバーがあります。Because a simple type aliases a struct type, every simple type has members. たとえば、intで宣言されたメンバーが含まれてSystem.Int32から継承したメンバーとSystem.Objectと、次のステートメントが許可されます。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

単純型は、ある追加の操作を許可している点で、他の構造体型とは異なります。The simple types differ from other struct types in that they permit certain additional operations:

  • ほとんどの単純型を記述して作成する値を許可するリテラル(リテラル)。Most simple types permit values to be created by writing literals (Literals). たとえば、123型のリテラルは、int'a'型のリテラルは、charします。For example, 123 is a literal of type int and 'a' is a literal of type char. C# の場合は、構造体の型のリテラルをプロビジョニングする一般に、他の構造体の型の既定以外の値が常にこれらの構造体の型のインスタンス コンス トラクターを通じて作成最終的に。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.
  • 式のオペランドがすべて単純型の定数の場合は、コンパイラはコンパイル時に式の評価になります。When the operands of an expression are all simple type constants, it is possible for the compiler to evaluate the expression at compile-time. このような式と呼ばれる、 constant_expression (定数式)。Such an expression is known as a constant_expression (Constant expressions). その他の構造体の型で定義された演算子を含む式は定数式と見なされません。Expressions involving operators defined by other struct types are not considered to be constant expressions.
  • を通じてconst単純型の定数を宣言することは、宣言 (定数)。Through const declarations it is possible to declare constants of the simple types (Constants). その他の構造体の型の定数を持つことはありませんが、同様の効果がによって提供されるstatic readonlyフィールド。It is not possible to have constants of other struct types, but a similar effect is provided by static readonly fields.
  • 単純型を使用する変換は、他の構造体型で定義された変換演算子の評価に参加できますが、ユーザー定義変換演算子がもう 1 つのユーザー定義演算子の評価に参加できることはありません (の評価ユーザー定義の変換)。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).

整数型Integral types

C# では、9 つの整数型: sbytebyteshortushortintuintlongulong、およびcharします。C# supports nine integral types: sbyte, byte, short, ushort, int, uint, long, ulong, and char. 整数型では、次のサイズと値の範囲があります。The integral types have the following sizes and ranges of values:

  • sbyte符号付き 8 ビット整数-128 から 127 まで値の型を表します。The sbyte type represents signed 8-bit integers with values between -128 and 127.
  • byte型が符号なし 8 ビット整数 0 ~ 255 の範囲の値を表します。The byte type represents unsigned 8-bit integers with values between 0 and 255.
  • short署名された-32768 から 32767 の値を 16 ビット整数の型を表します。The short type represents signed 16-bit integers with values between -32768 and 32767.
  • ushort型が符号なし 16 ビット整数 0 ~ 65535 の値を表します。The ushort type represents unsigned 16-bit integers with values between 0 and 65535.
  • int符号付き 32 ビット整数-2147483648 から 2147483647 までの値の型を表します。The int type represents signed 32-bit integers with values between -2147483648 and 2147483647.
  • uint型は、0 ~ 4294967295 の値の符号なし 32 ビット整数を表します。The uint type represents unsigned 32-bit integers with values between 0 and 4294967295.
  • long符号付き 64 ビット整数-9223372036854775808 から 9223372036854775807 まで値の型を表します。The long type represents signed 64-bit integers with values between -9223372036854775808 and 9223372036854775807.
  • ulong型が符号なし 64 ビット整数 0 から 18446744073709551615 までの値を表します。The ulong type represents unsigned 64-bit integers with values between 0 and 18446744073709551615.
  • char型が符号なし 16 ビット整数 0 ~ 65535 の値を表します。The char type represents unsigned 16-bit integers with values between 0 and 65535. 使用できる値のセット、char種類は、Unicode 文字セットに対応します。The set of possible values for the char type corresponds to the Unicode character set. charと同じ表現を持つushort、他の 1 つの型で許可されているすべての操作が許可されています。Although char has the same representation as ushort, not all operations permitted on one type are permitted on the other.

整数型の単項および二項演算子は、常に符号付き 32 ビットの有効桁数、符号なし 32 ビットの有効桁数、符号付き 64 ビットの有効桁数、または符号なし 64 ビットの精度の動作します。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:

  • 単項+~演算子、オペランドを型に変換されますTここで、Tの最初のintuintlong、およびulongすべてを完全にはオペランドの値。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. 操作が型の有効桁数を使用して実行し、 T、および結果の型はTします。The operation is then performed using the precision of type T, and the type of the result is T.
  • 単項-演算子、オペランドを型に変換されますTここで、Tの最初のintlongオペランドのすべての値を表す完全ことができます。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. 操作が型の有効桁数を使用して実行し、 T、および結果の型はTします。The operation is then performed using the precision of type T, and the type of the result is T. 単項-演算子は、型のオペランドに適用することはできませんulongします。The unary - operator cannot be applied to operands of type ulong.
  • バイナリの+-*/%&^|==!=><>=、および<=演算子、オペランドを型に変換されますTここで、Tの最初のintuintlong、およびulongすべてを表す完全両方のオペランドの値。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. 操作が型の有効桁数を使用して実行し、 T、および結果の型はT(またはbool関係演算子)。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). 1 つのオペランドの型は許可されていませんlongおよびその他の型ulong二項演算子でします。It is not permitted for one operand to be of type long and the other to be of type ulong with the binary operators.
  • バイナリの<<>>演算子、左のオペランドを型に変換されますTここで、Tの最初のintuintlong、およびulongすべてを完全にはオペランドの値。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. 操作が型の有効桁数を使用して実行し、 T、および結果の型はTします。The operation is then performed using the precision of type T, and the type of the result is T.

char型が整数型に分類されますが、2 つの方法で他の整数型とは異なります。The char type is classified as an integral type, but it differs from the other integral types in two ways:

  • 他の型から暗黙的な変換がない、char型。There are no implicit conversions from other types to the char type. 具体的には、場合でも、 sbytebyte、およびushort型を使用して完全に表現できる値の範囲がある、charから暗黙的な変換を入力しますsbytebyte、またはushortに。charはありません。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.
  • 定数、charとして型を記述する必要がありますcharacter_literals またはinteger_literal型へのキャストと組み合わせて scharします。Constants of the char type must be written as character_literals or as integer_literals in combination with a cast to type char. たとえば、(char)10'\x000A' と同じです。For example, (char)10 is the same as '\x000A'.

checkedunchecked演算子とステートメントは、整数型の算術演算および変換に対するオーバーフロー チェックの制御に使用されます (checked と unchecked 演算子)。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). checkedコンテキスト、オーバーフローがコンパイル時エラーを生成またはにより、System.OverflowExceptionがスローされます。In a checked context, an overflow produces a compile-time error or causes a System.OverflowException to be thrown. uncheckedコンテキストはオーバーフローは無視され、変換先の型に適合しない任意の上位ビットは破棄されます。In an unchecked context, overflows are ignored and any high-order bits that do not fit in the destination type are discarded.

浮動小数点型Floating point types

C# には、2 つがサポートしている浮動小数点型:floatdoubleします。C# supports two floating point types: float and double. floatdouble形式を使用して、32 ビット単精度と 64 ビット倍精度 IEEE 754、次の値のセットを提供する型が表されます。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 zero and negative zero. ほとんどの場合、正のゼロと負のゼロ動作は同じように、単純な値のゼロが区別して 2 つの特定の操作 (除算演算子)。In most situations, positive zero and negative zero behave identically as the simple value zero, but certain operations distinguish between the two (Division operator).
  • 正の無限大と負の無限大。Positive infinity and negative infinity. 無限大は、0 以外の数値をゼロ除算などの操作によって生成されます。Infinities are produced by such operations as dividing a non-zero number by zero. たとえば、1.0 / 0.0正の無限大と-1.0 / 0.0と負の無限大。For example, 1.0 / 0.0 yields positive infinity, and -1.0 / 0.0 yields negative infinity.
  • Not 非数値、NaN の多くの場合省略されます。The Not-a-Number value, often abbreviated NaN. Nan は、0 を 0 除算などの無効な浮動小数点演算によって生成されます。NaNs are produced by invalid floating-point operations, such as dividing zero by zero.
  • フォームの値が 0 以外の有限のセットs * m * 2^eここで、 s 1 または-1 の場合とmeは、特定の浮動小数点型によって決まります。float0 < m < 2^24-149 <= e <= 104、およびdouble0 < m < 2^531075 <= 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. 非正規化浮動小数点数は、有効な値が 0 以外と見なされます。Denormalized floating-point numbers are considered valid non-zero values.

float型が約範囲の値を表す1.5 * 10^-453.4 * 10^387 桁の有効桁数を持つ。The float type can represent values ranging from approximately 1.5 * 10^-45 to 3.4 * 10^38 with a precision of 7 digits.

double型が約範囲の値を表す5.0 * 10^-3241.7 × 10^30815 ~ 16 桁の有効桁数を持つ。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.

二項演算子のオペランドの 1 つの浮動小数点型の場合、し、もう一方のオペランドが整数型または浮動小数点型のある必要があり、操作は次のように評価されます。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:

  • 整数型のオペランドのいずれかの場合は、そのオペランドがもう一方のオペランドの浮動小数点型に変換されます。If one of the operands is of an integral type, then that operand is converted to the floating-point type of the other operand.
  • 型のオペランドのいずれかの場合は、 double、もう一方のオペランドに変換double、少なくともを使用して、操作を実行double範囲と有効桁数、および結果の型はdouble(またはboolの関係演算子)。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).
  • それ以外の場合、操作を使用して実行少なくともfloat範囲と有効桁数、および結果の型はfloat(またはbool関係演算子)。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).

浮動小数点の演算子、代入演算子を含む例外が発生することはありません。The floating-point operators, including the assignment operators, never produce exceptions. 代わりに、例外的な状況は、浮動小数点演算が生成 0、無限大、または NaN の場合、以下に示すよう。Instead, in exceptional situations, floating-point operations produce zero, infinity, or NaN, as described below:

  • 浮動小数点演算の結果が変換先の形式に対して小さすぎる場合は、操作の結果は正の値 0 になるか、負のゼロ。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.
  • 浮動小数点演算の結果が大きすぎて変換先の形式の場合、操作の結果は正の無限大または負の無限大になります。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.
  • 浮動小数点演算が有効でない場合、操作の結果は NaN になります。If a floating-point operation is invalid, the result of the operation becomes NaN.
  • 浮動小数点演算のオペランドの一方または両方が NaN の場合は、操作の結果は NaN になります。If one or both operands of a floating-point operation is NaN, the result of the operation becomes NaN.

浮動小数点演算は、操作の結果の型よりも高い精度で実行できます。Floating-point operations may be performed with higher precision than the result type of the operation. 一部のハードウェア アーキテクチャでの大きい範囲とより有効桁数を持つ「拡張」または"long double"浮動小数点型のサポートなど、 double 「」暗黙的にこのより高い有効桁数型を使用してすべての浮動小数点演算を実行します。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. 過剰なパフォーマンス コストでのみこのようなハードウェア アーキテクチャにできる、低精度の浮動小数点演算を実行して、パフォーマンスと精度の両方を犠牲にする必要があるのではなく c# を使用するより高い有効桁数の型すべての浮動小数点演算に使用されます。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. 正確な結果を提供する以外はこのことはほとんどありません、測定可能な影響を与えます。Other than delivering more precise results, this rarely has any measurable effects. ただし、フォームの式でx * y / z乗算が外部にある結果を生成します、double範囲が、後続の除算に一時的な結果を表示、double式であるという事実の範囲評価上の範囲で形式、無限値ではなく生成する有限の結果が発生する可能性があります。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.

10 進数型The decimal type

decimal 型は 128 ビットのデータ型で、財務や通貨の計算に適しています。The decimal type is a 128-bit data type suitable for financial and monetary calculations. decimal型は、範囲の値を表すことができます1.0 * 10^-28に約7.9 * 10^2828 ~ 29 桁を使用します。The decimal type can represent values ranging from 1.0 * 10^-28 to approximately 7.9 * 10^28 with 28-29 significant digits.

型の値の有限のセットdecimalの形式は(-1)^s * c * 10^-eここで、符号sが 0 または 1、係数cで指定されます0 <= *c* < 2^96、および小数点以下桁数eはように0 <= e <= 28します。decimal符号付きのゼロ、無限大、または 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. Adecimalは 10 の累乗によってスケーリング 96 ビット整数として表されます。A decimal is represented as a 96-bit integer scaled by a power of ten. decimal絶対値を使用してより小さい1.0m値は 28 小数点に正確ながありません。For decimals with an absolute value less than 1.0m, the value is exact to the 28th decimal place, but no further. decimal絶対値より大きいまたは等しいを1.0m値が 28 または 29 桁までは正確です。For decimals with an absolute value greater than or equal to 1.0m, the value is exact to 28 or 29 digits. Contrary、floatdoubleデータ型、0.1 などの 10 進数の小数値で正確に表すことができます、decimal表現。Contrary to the float and double data types, decimal fractional numbers such as 0.1 can be represented exactly in the decimal representation. floatdouble表現、このような数値は多くの場合、無限の小数できるため、表現の丸めを受けやすいエラー。In the float and double representations, such numbers are often infinite fractions, making those representations more prone to round-off errors.

型のかどうかは、二項演算子のオペランドの 1 つdecimal、もう一方のオペランドが整数型または型にする必要があります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. 整数型のオペランドが存在する場合に変換されますdecimal操作を実行する前にします。If an integral type operand is present, it is converted to decimal before the operation is performed.

型の値に演算の結果decimalから正確な結果 (維持拡張、オペレーターごとに定義されている) を計算して、表現に合わせて丸め処理し、なることができます。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. 結果が丸められる、最も近い表現可能な値は、し、結果が均等に最下位ビットが 0 (これと呼ばれる「銀行型丸め」) である値に 2 つの表現可能な値。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"). 0 個の結果は、0 の符号とスケールは 0 を常に持ちます。A zero result always has a sign of 0 and a scale of 0.

10 進数の算術演算の値以下と等しいかそれよりも場合5 * 10^-29絶対値で操作の結果はゼロになります。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. 場合、decimal算術演算が大きすぎて結果の生成、decimal形式、System.OverflowExceptionがスローされます。If a decimal arithmetic operation produces a result that is too large for the decimal format, a System.OverflowException is thrown.

decimal型がより高い精度浮動小数点型よりも、小さい範囲です。The decimal type has greater precision but smaller range than the floating-point types. 浮動小数点型から変換したがって、decimalオーバーフロー例外、および変換から生じる可能性がありますdecimal浮動小数点型の有効桁数の損失を伴う可能性があります。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. これらの理由から、暗黙的な変換が存在しない浮動小数点型の間とdecimal、明示的なキャストしないことはできません浮動小数点を混在させると、decimal同じ式のオペランド。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.

Bool 型The bool type

bool型がブール論理の数量を表します。The bool type represents boolean logical quantities. 型の有効な値booltruefalseします。The possible values of type bool are true and false.

間の標準変換が存在しないboolおよび他の型。No standard conversions exist between bool and other types. 具体的には、bool型は別に整数の型から独立して、bool整数値では、代わりに、その逆の値は使用できません。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.

C および C++ の言語で、ゼロ整数または浮動小数点の値または null ポインターをブール値に変換できるfalse、0 以外の整数または浮動小数点値または null 以外のポインターは、ブール値に変換できると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. C# で、このような変換を 0、整数または浮動小数点値を明示的に比較することで、または明示的にオブジェクト参照を比較することで行われます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.

列挙型Enumeration types

列挙型は、名前付き定数を使用して別個の型です。An enumeration type is a distinct type with named constants. すべての列挙型がある必要があります、基になる型bytesbyteshortushortintuintlongまたはulongします。Every enumeration type has an underlying type, which must be byte, sbyte, short, ushort, int, uint, long or ulong. 列挙型の値のセットでは、基になる型の値のセットと同じです。The set of values of the enumeration type is the same as the set of values of the underlying type. 列挙型の値では、名前付き定数の値に限定されません。Values of the enumeration type are not restricted to the values of the named constants. 列挙型が列挙体の宣言で定義されている (列挙型宣言)。Enumeration types are defined through enumeration declarations (Enum declarations).

Null 許容型Nullable types

Null 許容型のすべての値を表すことができます、基になる型さらに null 値を追加します。A nullable type can represent all values of its underlying type plus an additional null value. Null 許容型が書き込まれるT?ここで、Tは、基になる型です。A nullable type is written T?, where T is the underlying type. この構文の短縮形は、 System.Nullable<T>、し、2 つの形式は同じ意味で使用されることができます。This syntax is shorthand for System.Nullable<T>, and the two forms can be used interchangeably.

A null 非許容値型以外の任意の値型を逆にはSystem.Nullable<T>とその省略T?(いずれかのT)、さらに (つまり、いずれかの null 非許容値型に制約されている任意の型パラメーターパラメーターの入力をstruct制約)。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). System.Nullable<T>型の値の型の制約を指定するT(パラメーターの制約入力)、null 許容型の基になる型は任意の null 非許容値型であることを意味します。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. Null 許容型の基になる型は、null 許容型または参照型にすることはできません。The underlying type of a nullable type cannot be a nullable type or a reference type. たとえば、int??string?種類が無効です。For example, int?? and string? are invalid types.

Null 許容型のインスタンスT?は 2 つのパブリックな読み取り専用プロパティがあります。An instance of a nullable type T? has two public read-only properties:

  • AHasValue型のプロパティ boolA HasValue property of type bool
  • AValue型のプロパティ TA Value property of type T

インスタンスHasValueが true は null 以外と呼ばれます。An instance for which HasValue is true is said to be non-null. Null 以外のインスタンスには、既知の値が含まれていますとValueその値を返します。A non-null instance contains a known value and Value returns that value.

インスタンスHasValueは、false は null と呼ばれます。An instance for which HasValue is false is said to be null. Null インスタンスには、未定義の値があります。A null instance has an undefined value. 読み取ろうとした、Valueの null インスタンスにより、System.InvalidOperationExceptionがスローされます。Attempting to read the Value of a null instance causes a System.InvalidOperationException to be thrown. アクセスするプロセス、 Value null 許容型のインスタンスのプロパティと呼びますラップ解除します。The process of accessing the Value property of a nullable instance is referred to as unwrapping.

既定のコンス トラクター、すべての null 許容型だけでなくT?型の 1 つの引数を受け取るパブリック コンス トラクターを持つTします。In addition to the default constructor, every nullable type T? has a public constructor that takes a single argument of type T. 値が指定されるx型のTフォームのコンス トラクターの呼び出しGiven a value x of type T, a constructor invocation of the form

new T?(x)

null 以外のインスタンスを作成しますT?Valueプロパティはxします。creates a non-null instance of T? for which the Value property is x. 指定した値と呼びますの null 許容型の null 以外のインスタンスを作成するプロセスラッピングします。The process of creating a non-null instance of a nullable type for a given value is referred to as wrapping.

暗黙的な変換はから利用可能なnullリテラルをT?(Null リテラル変換) との間TT?(暗黙的な null 許容変換).Implicit conversions are available from the null literal to T? (Null literal conversions) and from T to T? (Implicit nullable conversions).

参照型Reference types

参照型は、クラス型、インターフェイス型、配列型、またはデリゲート型です。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
    ;

参照型の値はへの参照、インスタンスとして知ら、型のオブジェクトします。A reference type value is a reference to an instance of the type, the latter known as an object. 特殊な値nullすべての参照型と互換性が、インスタンスのないことを示します。The special value null is compatible with all reference types and indicates the absence of an instance.

クラス型Class types

クラス型では、データ メンバー (定数とフィールド)、関数メンバー (メソッド、プロパティ、イベント、インデクサー、演算子、インスタンス コンス トラクター、デストラクター、静的コンス トラクター) と入れ子にされた型を含むデータ構造を定義します。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. クラス型では、継承、派生クラスが基底クラスを拡張および限定するためのメカニズムをサポートします。Class types support inheritance, a mechanism whereby derived classes can extend and specialize base classes. 使用してクラス型のインスタンスが作成されたobject_creation_expressions (オブジェクト作成式)。Instances of class types are created using object_creation_expressions (Object creation expressions).

クラス型が記載されてクラスします。Class types are described in Classes.

特定の種類の定義済みのクラスは、次の表に示すように、c# 言語では、特別な意味を持ちます。Certain predefined class types have special meaning in the C# language, as described in the table below.

クラス型Class type 説明Description
System.Object その他のすべての種類の最終的な基本クラス。The ultimate base class of all other types. 参照してくださいオブジェクトの種類します。See The object type.
System.String C# 言語の文字列型。The string type of the C# language. 参照してください文字列型します。See The string type.
System.ValueType すべての値型の基本クラス。The base class of all value types. 参照してください、System.ValueType 型します。See The System.ValueType type.
System.Enum すべての列挙型の基本クラス。The base class of all enum types. 参照してください列挙型します。See Enums.
System.Array すべての配列型の基本クラス。The base class of all array types. 配列」を参照してください。See Arrays.
System.Delegate すべてのデリゲート型の基本クラス。The base class of all delegate types. 参照してくださいデリゲートします。See Delegates.
System.Exception すべての例外の種類の基本クラス。The base class of all exception types. 参照してください例外します。See Exceptions.

オブジェクトの種類The object type

objectクラス型が他のすべての型の基本クラス。The object class type is the ultimate base class of all other types. すべての型 (C#) で直接的または間接的に派生から、objectクラス型。Every type in C# directly or indirectly derives from the object class type.

キーワードobjectは定義済みのクラスのエイリアスにすぎませんSystem.Objectします。The keyword object is simply an alias for the predefined class System.Object.

動的な型The dynamic type

dynamic入力と、このようなobject、任意のオブジェクトを参照できます。The dynamic type, like object, can reference any object. 型の式に演算子を適用するdynamic、その解決方法は、プログラムが実行されるまでに遅延します。When operators are applied to expressions of type dynamic, their resolution is deferred until the program is run. そのため、オペレーターは、参照先オブジェクトに適用することはできません合法的に場合、エラーを指定しないコンパイル時にします。Thus, if the operator cannot legally be applied to the referenced object, no error is given during compilation. 代わりに実行時に、演算子の解決が失敗したときに例外がスローされます。Instead an exception will be thrown when resolution of the operator fails at run-time.

その目的はで詳しく説明されている、動的バインドを許可するのには、動的バインドします。Its purpose is to allow dynamic binding, which is described in detail in Dynamic binding.

dynamic 同じと見なされますobject次の点を除きます。dynamic is considered identical to object except in the following respects:

  • 型の式に対して操作dynamic動的にバインドすることができます (動的バインド)。Operations on expressions of type dynamic can be dynamically bound (Dynamic binding).
  • 型の推論 (型推論) が優先されますdynamic経由でobject両方の候補にする場合。Type inference (Type inference) will prefer dynamic over object if both are candidates.

この同等性のため、次の処理が保持されます。Because of this equivalence, the following holds:

  • 間の暗黙的な id 変換がobjectdynamic、および置換するときに、同じ構築された型の間でdynamicobjectThere is an implicit identity conversion between object and dynamic, and between constructed types that are the same when replacing dynamic with object
  • 明示的および暗黙的な変換との間objectとの間にも適用dynamicします。Implicit and explicit conversions to and from object also apply to and from dynamic.
  • 置換するときに、同じメソッド シグネチャdynamicobjectは同じシグネチャと見なされますMethod signatures that are the same when replacing dynamic with object are considered the same signature
  • dynamicは区別できませんobject実行時にします。The type dynamic is indistinguishable from object at run-time.
  • 型の式dynamicと呼ばれますが、動的な式します。An expression of the type dynamic is referred to as a dynamic expression.

文字列型The string type

string型がシール クラス型から直接継承されるobjectします。The string type is a sealed class type that inherits directly from object. インスタンス、stringクラスは Unicode 文字の文字列を表します。Instances of the string class represent Unicode character strings.

値、string型は文字列リテラルとして記述できます (文字列リテラル)。Values of the string type can be written as string literals (String literals).

キーワードstringは定義済みのクラスのエイリアスにすぎませんSystem.Stringします。The keyword string is simply an alias for the predefined class System.String.

インターフェイス型Interface types

インターフェイスは、コントラクトを定義します。An interface defines a contract. クラスまたはインターフェイスを実装する構造体は、そのコントラクトに従う必要があります。A class or struct that implements an interface must adhere to its contract. 複数の基底インターフェイスから継承でき、クラスまたは構造体には、複数のインターフェイスを実装できます。An interface may inherit from multiple base interfaces, and a class or struct may implement multiple interfaces.

インターフェイスの種類が記載されてインターフェイスします。Interface types are described in Interfaces.

配列型Array types

配列は、算出されたインデックスを介してアクセスされる 0 個以上の変数を含むデータ構造です。An array is a data structure that contains zero or more variables which are accessed through computed indices. 配列の要素とも呼ばれます。 配列に含まれる変数はすべて、同じ型と、この型には、配列の要素の型が呼び出されます。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 types are described in Arrays.

デリゲート型Delegate types

デリゲートは、1 つまたは複数のメソッドを参照するデータ構造です。A delegate is a data structure that refers to one or more methods. インスタンスのメソッドも参照、対応するオブジェクトのインスタンス。For instance methods, it also refers to their corresponding object instances.

C または C++ では、デリゲートの最も近いは、関数ポインターが関数ポインターは、静的関数を参照できるのみ、一方デリゲートは両方の静的な参照しインスタンス メソッド。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. 後者の場合、デリゲートは、メソッドのエントリ ポイントへの参照だけでなく、メソッドの呼び出し元となるオブジェクトのインスタンスへの参照を格納します。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.

デリゲート型が記載されてデリゲートします。Delegate types are described in Delegates.

ボックス化とボックス化解除Boxing and unboxing

ボックス化とボックス化解除の概念が中心となるC#のシステムを入力します。The concept of boxing and unboxing is central to C#'s type system. 間のブリッジを提供value_types とreference_types のすべての値を許可、 value_type型との間に変換する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 and unboxing enables a unified view of the type system wherein a value of any type can ultimately be treated as an object.

ボックス化変換Boxing conversions

ボックス化変換では、 value_typeに暗黙的に変換する、 reference_typeします。A boxing conversion permits a value_type to be implicitly converted to a reference_type. 次のボックス化変換は次のとおりです。The following boxing conversions exist:

  • いずれかからvalue_type型にobjectします。From any value_type to the type object.
  • いずれかからvalue_type型にSystem.ValueTypeします。From any value_type to the type System.ValueType.
  • いずれかからnon_nullable_value_typeいずれかにinterface_typeによって実装される、 value_typeします。From any non_nullable_value_type to any interface_type implemented by the value_type.
  • いずれかからnullable_typeいずれかにinterface_typeの基になる型によって実装される、 nullable_typeします。From any nullable_type to any interface_type implemented by the underlying type of the nullable_type.
  • いずれかからenum_type型にSystem.Enumします。From any enum_type to the type System.Enum.
  • いずれかからnullable_type基になるとenum_type型にSystem.Enumします。From any nullable_type with an underlying enum_type to the type System.Enum.
  • 実行時に最終的には値型から参照型に変換する場合に、型パラメーターからの暗黙的な変換、ボックス化変換として実行されることに注意してください (型パラメーターを使用する暗黙的な変換)。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).

値をボックス化、 non_nullable_value_typeオブジェクト インスタンスの割り当てとコピーから成る、 non_nullable_value_type値をそのインスタンスにします。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.

値をボックス化、 nullable_typeである場合は、null 参照を生成、null値 (HasValuefalse)、またはラップの解除とそれ以外の場合、基になる値をボックス化の結果。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.

実際の値をボックス化のプロセスをnon_nullable_value_typeを仮定すると、汎用の存在をわかりやすく説明ボックス化クラス、次のように宣言された場合と同様にします。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;
    }
}

値のボックス化v型のT式を実行するようになりましたはnew Box<T>(v)、型の値として生成されたインスタンスを返すと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. そのため、ステートメントThus, the statements

int i = 123;
object box = i;

概念的に対応していますconceptually correspond to

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

ようにボックス化クラスBox<T>以上が存在しない実際にボックス化された値の動的な型がクラス型では実際にはありません。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. 代わりに、型のボックス化された値T動的な型を持つTを使用して動的な型チェックと、is演算子は単に型を参照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. 例えば以下のようにします。For example,

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

文字列の出力は"Box contains an int"コンソール。will output the string "Box contains an int" on the console.

ボックス化変換では、ボックス化される値のコピーを意味します。A boxing conversion implies making a copy of the value being boxed. これは、別の変換から、 reference_type入力object、値引き続き同じインスタンスを参照すると、単に弱い派生型と見なさ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. たとえば、宣言について考えます。For example, given the declaration

struct Point
{
    public int x, y;

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

次のステートメントthe following statements

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

に、コンソールで、値 10 が出力の割り当てで発生する暗黙的なボックス化操作pboxの値と、pをコピーします。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. Pointされて宣言されている、class代わりに、値 20 出力されるため、pbox同じインスタンスを参照します。Had Point been declared a class instead, the value 20 would be output because p and box would reference the same instance.

ボックス化解除変換Unboxing conversions

ボックス化解除の変換では、 reference_typeに明示的に変換する、 value_typeします。An unboxing conversion permits a reference_type to be explicitly converted to a value_type. 次のボックス化解除変換が存在します。The following unboxing conversions exist:

  • 型からobjectいずれかにvalue_typeします。From the type object to any value_type.
  • 型からSystem.ValueTypeいずれかにvalue_typeします。From the type System.ValueType to any value_type.
  • いずれかからinterface_typeいずれかにnon_nullable_value_typeを実装する、 interface_typeします。From any interface_type to any non_nullable_value_type that implements the interface_type.
  • いずれかからinterface_typeいずれかにnullable_type基になる型を実装して、 interface_typeします。From any interface_type to any nullable_type whose underlying type implements the interface_type.
  • 型からSystem.Enumいずれかにenum_typeします。From the type System.Enum to any enum_type.
  • 型からSystem.Enumいずれかにnullable_type基になるとenum_typeします。From the type System.Enum to any nullable_type with an underlying enum_type.
  • 実行時に最終的には、参照型から値型に変換する場合に、型パラメーターに明示的な変換、アンボックス変換として実行されることに注意してください (動的の明示的な変換)。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).

ボックス化解除の操作をnon_nullable_value_typeオブジェクト インスタンスのボックス化された値は、最初に確認から成る、指定されたnon_nullable_value_type、しの値をコピーして、インスタンス。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.

ボックス化解除、 nullable_typeの null 値を生成、 nullable_typeソース オペランドの場合null、またはオブジェクト インスタンスの基になる型をボックス化解除のラップされた結果、nullable_typeそれ以外の場合。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.

オブジェクトのアンボックス変換、前のセクションで説明されている仮想のボックス化クラスを参照するboxvalue_type T式を実行から成る((Box<T>)box).valueReferring 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. そのため、ステートメントThus, the statements

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

概念的に対応していますconceptually correspond to

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

ボックス化解除変換の指定されたnon_nullable_value_typeソース オペランドの値が実行時に成功するをボックス化された値への参照をある必要があります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. ソース オペランドの場合nullSystem.NullReferenceExceptionがスローされます。If the source operand is null, a System.NullReferenceException is thrown. ソース オペランドが、互換性のないオブジェクトへの参照の場合、System.InvalidCastExceptionがスローされます。If the source operand is a reference to an incompatible object, a System.InvalidCastException is thrown.

ボックス化解除変換の指定されたnullable_typeに成功すると、実行時に、ソース オペランドの値はいずれかのことがありますnullまたは基になるのボックス化された値への参照non_nullable_value_typenullable_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. ソース オペランドが、互換性のないオブジェクトへの参照の場合、System.InvalidCastExceptionがスローされます。If the source operand is a reference to an incompatible object, a System.InvalidCastException is thrown.

構築された型Constructed types

ジェネリック型の宣言では、単独で表します、ジェネリック型にバインドされていないの適用を使用して、さまざまな種類のフォームに「ブルー プリント」として使用される引数を入力します。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. 型引数は山かっこ内に書き込まれます (<>) すぐに次のジェネリック型の名前。The type arguments are written within angle brackets (< and >) immediately following the name of the generic type. 少なくとも 1 つの型引数を含む型が呼び出される、構築型します。A type that includes at least one type argument is called a constructed type. 構築された型は、型名の表示に使用できる言語のほとんどの場所で使用できます。A constructed type can be used in most places in the language in which a type name can appear. バインドされていないのジェネリック型は内でのみ使用できます、 typeof_expression (typeof 演算子)。An unbound generic type can only be used within a typeof_expression (The typeof operator).

単純な名前として式で構築された型は使用もできます (簡易名) メンバーにアクセスするとき、または (メンバー アクセス)。Constructed types can also be used in expressions as simple names (Simple names) or when accessing a member (Member access).

ときに、 namespace_or_type_nameと見なされますパラメーター型の正しい数と種類の評価された、汎用のみです。When a namespace_or_type_name is evaluated, only generic types with the correct number of type parameters are considered. そのため、型がある型パラメーターの数が異なる限り、さまざまな種類を識別するために同じ識別子を使用することです。Thus, it is possible to use the same identifier to identify different types, as long as the types have different numbers of type parameters. これは、機能は、同じプログラム内でジェネリックと非ジェネリックのクラスが混在する場合に便利です。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
    }
}

A type_name型パラメーターを直接指定しない場合でも、構築された型を識別する可能性があります。A type_name might identify a constructed type even though it doesn't specify type parameters directly. これは、問題は、型がジェネリック クラス宣言の中で入れ子になった、外側の宣言のインスタンスの型が暗黙的に名前参照の使用に発生することができます (ジェネリック クラスの型を入れ子になった)。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
}

アンセーフ コードで構築された型として使用できません、 unmanaged_type (ポインター型)。In unsafe code, a constructed type cannot be used as an unmanaged_type (Pointer types).

型引数Type arguments

型引数リストの各引数は単に、します。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
    ;

安全でないコード (アンセーフ コード)、 type_argumentポインター型ができない可能性があります。In unsafe code (Unsafe code), a type_argument may not be a pointer type. 各型引数の型パラメーターの対応する、制約を満たす必要があります (パラメーターの制約入力)。Each type argument must satisfy any constraints on the corresponding type parameter (Type parameter constraints).

オープン型Open and closed types

すべての種類は、いずれかに分類できますの種類を開くまたはクローズ型します。All types can be classified as either open types or closed types. オープン型は、型パラメーターを含む型です。An open type is a type that involves type parameters. 具体的には。More specifically:

  • 型パラメーターは、オープン型を定義します。A type parameter defines an open type.
  • 要素の型がオープン型場合にのみ、配列型はオープン型が。An array type is an open type if and only if its element type is an open type.
  • 構築された型はオープン型がオープン型の 1 つ以上の型引数の場合にのみA constructed type is an open type if and only if one or more of its type arguments is an open type. 構築された入れ子にされた型はオープン型がオープン型の 1 つ以上の型引数または外側の型の型引数の場合にのみ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.

閉じている型は、オープン型ではない型です。A closed type is a type that is not an open type.

実行時にには、ジェネリック宣言する型引数を適用することによって作成された構築されたクローズ型のコンテキストでのジェネリック型の宣言内でコードをすべて実行されます。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. ジェネリック型内の各型パラメーターは、特定の実行時の型にバインドされます。Each type parameter within the generic type is bound to a particular run-time type. すべてのステートメントと式の実行時の処理は、常には、クローズ型が発生し、コンパイル時にのみ発生するオープン型が処理します。The run-time processing of all statements and expressions always occurs with closed types, and open types occur only during compile-time processing.

構築されたクローズ型をそれぞれが、独自の静的変数は、クローズ構築型と共有されていないセット。Each closed constructed type has its own set of static variables, which are not shared with any other closed constructed types. 実行時にオープン型が存在しないために、オープン型に関連付けられている静的変数はありません。Since an open type does not exist at run-time, there are no static variables associated with an open type. 2 つのクローズ構築型は、同じバインドされていないジェネリック型から構築されると、対応する型引数は、同じ型である場合、同じ型です。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.

バインドとバインドされていない型Bound and unbound types

用語型にバインドされていない非ジェネリック型または非バインドのジェネリック型を表します。The term unbound type refers to a non-generic type or an unbound generic type. 用語型にバインドされている非ジェネリック型または構築された型を表します。The term bound type refers to a non-generic type or a constructed type.

バインドされていない型は、型宣言で宣言されたエンティティを指します。An unbound type refers to the entity declared by a type declaration. 非バインドのジェネリック型自体ではなく、型と、変数、引数または戻り値の型として、または基本データ型として使用できません。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. バインドされていないジェネリック型を参照できる唯一のコンストラクトをtypeof式 (typeof 演算子)。The only construct in which an unbound generic type can be referenced is the typeof expression (The typeof operator).

制約の充足Satisfying constraints

構築された型またはジェネリック メソッドを参照すると、指定された型引数はジェネリック型またはメソッドで宣言された型パラメーターの制約に照らしてチェック (パラメーターの制約入力)。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). where句では、型引数A名前付きに対応する型パラメーターは、次のように制約に照らしてチェックします。For each where clause, the type argument A that corresponds to the named type parameter is checked against each constraint as follows:

  • クラス型、インターフェイス型または型パラメーターの制約である場合、C制約に表示される任意の型パラメーターに指定された型引数の制約が置き換えことを表します。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. 制約を満たす必要がありますは、型Aは型に変換C次のいずれか。To satisfy the constraint, it must be the case that type A is convertible to type C by one of the following:
  • 制約が参照型の制約である場合 (class)、型A次のいずれかを満たす必要があります。If the constraint is the reference type constraint (class), the type A must satisfy one of the following:
    • A インターフェイス型、クラス型、デリゲート型または配列型。A is an interface type, class type, delegate type or array type. なおSystem.ValueTypeSystem.Enumはこの制約を満たす参照型です。Note that System.ValueType and System.Enum are reference types that satisfy this constraint.
    • A 参照型があることがわかっている型パラメーターは、(パラメーターの制約入力)。A is a type parameter that is known to be a reference type (Type parameter constraints).
  • 制約が値型の制約である場合 (struct)、型A次のいずれかを満たす必要があります。If the constraint is the value type constraint (struct), the type A must satisfy one of the following:
    • A 構造体の型または列挙型を null 許容型ではなくです。A is a struct type or enum type, but not a nullable type. なおSystem.ValueTypeSystem.Enumはこの制約を満たしていない参照型です。Note that System.ValueType and System.Enum are reference types that do not satisfy this constraint.
    • A 値型の制約を持つ型パラメーター (パラメーターの制約入力)。A is a type parameter having the value type constraint (Type parameter constraints).
  • 制約は、コンス トラクター制約が場合new()、型A必要がありますabstractパブリック パラメーターなしのコンス トラクターが必要とします。If the constraint is the constructor constraint new(), the type A must not be abstract and must have a public parameterless constructor. これが満たされるは、次のいずれかが true の場合。This is satisfied if one of the following is true:

指定された型引数によって 1 つ以上の型パラメーターの制約が満たされない場合、コンパイル時エラーが発生します。A compile-time error occurs if one or more of a type parameter's constraints are not satisfied by the given type arguments.

制約はありませんので、型パラメーターは継承されず、いずれかを継承します。Since type parameters are not inherited, constraints are never inherited either. 次の例でD、型パラメーターに制約を指定する必要があるTようにT基底クラスによって課される制約を満たす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>. これに対し、クラスEために、制約を指定する必要がありますList<T>実装IEnumerableTします。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>> {...}

型パラメーターType parameters

型パラメーターでは、値型またはパラメーターは、実行時にバインドされている参照型を指定する識別子です。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
    ;

型パラメーターは、多くのさまざまな実際の型引数でインスタンス化することができます、ために、型パラメーターには、若干異なる操作とその他の型よりも制限があります。Since a type parameter can be instantiated with many different actual type arguments, type parameters have slightly different operations and restrictions than other types. 不足している機能には次が含まれます。These include:

型パラメーター、型では、純粋なコンパイル時の構成要素があります。As a type, type parameters are purely a compile-time construct. 実行時に、それぞれの型パラメーターは、ジェネリック型の宣言する型引数を指定することによって指定された実行時の型にバインドされます。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. したがって、変数の型を宣言で型パラメーターは、実行時に、クローズ構築型になります (オープンとクローズ型)。Thus, the type of a variable declared with a type parameter will, at run-time, be a closed constructed type (Open and closed types). すべての型パラメーターを含む式とステートメントの実行時の実行は、そのパラメーターの型引数として渡された実際の型を使用します。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

式ツリー実行可能コードではなく、データ構造として表されるラムダ式を許可します。Expression trees permit lambda expressions to be represented as data structures instead of executable code. 式ツリーは値の式ツリー型フォームのSystem.Linq.Expressions.Expression<D>ここで、Dはデリゲート型。Expression trees are values of expression tree types of the form System.Linq.Expressions.Expression<D>, where D is any delegate type. 短縮形を使用してこれらの型をこの仕様の残りの部分参照Expression<D>します。For the remainder of this specification we will refer to these types using the shorthand Expression<D>.

変換が存在するかどうか、ラムダ式からデリゲート型にD、変換は、式ツリー型にも存在する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>. ラムダ式をデリゲート型の変換では、ラムダ式の実行可能コードを参照するデリゲートを生成する一方、式ツリー型への変換は、ラムダ式の式ツリー表現を作成します。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.

式ツリーは、ラムダ式の効率的なメモリ内データ表現および透過的と明示的なラムダ式の構造を作成します。Expression trees are efficient in-memory data representations of lambda expressions and make the structure of the lambda expression transparent and explicit.

デリゲート型と同様にDExpression<D>パラメーターと戻り値の型があるといいますのものと同じである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.

次の例では、実行可能コードと、式ツリーの両方に、ラムダ式を表します。The following example represents a lambda expression both as executable code and as an expression tree. 変換が存在するためFunc<int,int>、変換が存在する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

次のデリゲートのこれらの割り当てdelを返すメソッドを参照x + 1、式ツリーとexp式を記述するデータ構造を参照x => x + 1Following 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.

ジェネリック型の正確な定義Expression<D>ラムダ式を式ツリー型に変換する場合は、式ツリーを構築するための正確なルールとは、どちらもこの仕様の範囲外です。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.

2 つのことを明示する重要なのとおりです。Two things are important to make explicit:

  • すべてのラムダ式は、式ツリーに変換できます。Not all lambda expressions can be converted to expression trees. たとえば、ステートメントの本体でラムダ式と代入式を含むラムダ式を表示することはできません。For instance, lambda expressions with statement bodies, and lambda expressions containing assignment expressions cannot be represented. このような場合は、変換が存在しますはコンパイル時に失敗します。In these cases, a conversion still exists, but will fail at compile-time. これらの例外の詳細については匿名関数の変換します。These exceptions are detailed in Anonymous function conversions.

  • Expression<D> インスタンス メソッドを提供していますCompile型のデリゲートを生成するD:。Expression<D> offers an instance method Compile which produces a delegate of type D:

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

    このデリゲートの呼び出しが実行される式ツリーによって表されるコードです。Invoking this delegate causes the code represented by the expression tree to be executed. したがって、上記の定義を指定するには、del と del2 はそれと同等と、次の 2 つのステートメントは同じ効果があります。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);
    

    このコードを実行した後i1i2どちらにも値2します。After executing this code, i1 and i2 will both have the value 2.