유형Types

C# 언어의 형식은 값 형식참조 형식이라는 두 가지 주요 범주로 구분 됩니다.The types of the C# language are divided into two main categories: value types and reference types. 값 형식과 참조 형식은 모두 하나 이상의 형식 매개 변수를 사용 하는 제네릭 형식일수 있습니다.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. 참조 형식을 사용 하는 경우 두 변수가 같은 개체를 참조할 수 있으므로 한 변수에 대 한 작업이 다른 변수에서 참조 하는 개체에 영향을 줄 수 있습니다.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. 값 형식을 사용 하는 경우 변수에는 각각 고유한 데이터 사본이 있으며 한 변수에 대 한 작업이 다른 변수에 영향을 줄 수 없습니다.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. 값 형식의 값은 boxing 및 unboxing 작업 (boxing 및 unboxing)을 수행 하 여 개체로 처리 됩니다.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
    ;

참조 형식의 변수와 달리 값 형식의 변수에는 값 형식이 nullable 형식인 경우에만 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값을 더한 값과 동일한 값 집합을 나타내는 해당 nullable 값 형식이 있습니다.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.object 형식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. 대신 모든 value_types가 자동으로 파생 되는 class_type 입니다.Rather, it is a class_type from which all value_types are automatically derived.

기본 생성자Default constructors

모든 값 형식은 기본 생성자라고 하는 매개 변수가 없는 public 인스턴스 생성자를 암시적으로 선언 합니다.All value types implicitly declare a public parameterless instance constructor called the default constructor. 기본 생성자는 값 형식에 대 한 기본값 이라고 하는 0으로 초기화 된 인스턴스를 반환 합니다.The default constructor returns a zero-initialized instance known as the default value for the value type:

  • 모든 simple_types의 경우 기본값은 모든 0의 비트 패턴에 의해 생성 된 값입니다.For all simple_types, the default value is the value produced by a bit pattern of all zeros:
    • sbyte, byte, short, ushort, int, uint, longulong의 경우 기본값은 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. 기본값은 nullable 형식의 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();
    }
}

모든 값 형식에는 매개 변수가 없는 public 인스턴스 생성자가 암시적으로 있으므로 구조체 형식에 매개 변수가 없는 생성자의 명시적 선언이 포함 될 수 없습니다.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). 예를 들어 123int 형식의 리터럴입니다. '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.
  • 단순 형식을 포함 하는 변환은 다른 구조체 형식에 의해 정의 된 변환 연산자의 평가에 참여할 수 있지만 사용자 정의 변환 연산자는 다른 사용자 정의 연산자의 평가에 참여할 수 없습니다 (계산 사용자 정의 변환).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#에서는 sbyte, byte, short, ushort, int, uint, long, ulong, char의 9 가지 정수 형식을 지원 합니다.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 형식은-128과 127 사이의 값을 가진 부호 있는 8 비트 정수를 나타냅니다.The sbyte type represents signed 8-bit integers with values between -128 and 127.
  • byte 형식은 0에서 255 사이의 값을 가진 부호 없는 8 비트 정수를 나타냅니다.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 형식은 0에서 65535 사이의 값을 가진 부호 없는 16 비트 정수를 나타냅니다.The ushort type represents unsigned 16-bit integers with values between 0 and 65535.
  • int 형식은-2147483648에서 2147483647 사이의 값을 가진 부호 있는 32 비트 정수를 나타냅니다.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 형식은-9223372036854775808과 9223372036854775807 사이의 값을 가진 부호 있는 64 비트 정수를 나타냅니다.The long type represents signed 64-bit integers with values between -9223372036854775808 and 9223372036854775807.
  • ulong 형식은 0에서 18446744073709551615 사이의 값을 가진 부호 없는 64 비트 정수를 나타냅니다.The ulong type represents unsigned 64-bit integers with values between 0 and 18446744073709551615.
  • char 형식은 0에서 65535 사이의 값을 가진 부호 없는 16 비트 정수를 나타냅니다.The char type represents unsigned 16-bit integers with values between 0 and 65535. char 형식에 사용할 수 있는 값 집합은 유니코드 문자 집합에 해당 합니다.The set of possible values for the char type corresponds to the Unicode character set. charushort와 동일한 표현 이지만 한 형식에서 허용 되는 모든 작업은 다른 형식에서 허용 되지 않습니다.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은 피연산자의 모든 가능한 값을 완전히 표현할 수 있는 int, uint, longulong의 첫 번째입니다.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은 두 피연산자의 모든 가능한 값을 완전히 표현할 수 있는 int, uint, longulong 중 첫 번째입니다.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). 한 피연산자가 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는 피연산자의 모든 가능한 값을 완전히 표현할 수 있는 int, uint, long, 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 형식은 정수 계열 형식으로 분류 되지만 두 가지 방법으로 다른 정수 계열 형식과 다릅니다.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. 특히 sbyte, byteushort 형식에 char 형식을 사용 하 여 완전히 표현할 수 있는 값 범위가 있지만 sbyte, byte또는 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로 작성 하거나 형식 char에 대 한 캐스트와 함께 integer_literals로 작성 해야 합니다.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 throw 됩니다.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#에서는 두 개의 부동 소수점 형식 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:

  • 양수 0과 음수 0입니다.Positive zero and negative zero. 대부분의 경우 양의 0과 음수 0은 단순 값 0과 동일 하 게 작동 하지만 특정 연산은 두 (나누기 연산자)를 구분 합니다.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이 아닌 숫자를 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.
  • 숫자가 아닌 값 (종종 약어 NaN)입니다.The Not-a-Number value, often abbreviated NaN. Nan는 0으로 나누기와 같은 잘못 된 부동 소수점 연산에 의해 생성 됩니다.NaNs are produced by invalid floating-point operations, such as dividing zero by zero.
  • 0이 아닌 형식의 유한 값 집합 s * m * 2^e(s 1 또는-1, me 특정 부동 소수점 형식에 의해 결정 됩니다. float, 0 < m < 2^24-149 <= e <= 104``double, 0 < m < 2^53-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. 비 정규화 된 부동 소수점 숫자는 0이 아닌 유효한 값으로 간주 됩니다.Denormalized floating-point numbers are considered valid non-zero values.

float 형식은 약 1.5 * 10^-45부터 전체 자릿수가 7 자리인 3.4 * 10^38 까지의 값을 나타낼 수 있습니다.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^-324부터 15-16 자리의 전체 자릿수 까지의 값 1.7 × 10^308을 나타낼 수 있습니다.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.

이항 연산자의 피연산자 중 하나가 부동 소수점 형식인 경우 다른 피연산자는 정수 형식 또는 부동 소수점 형식 이어야 하며 연산은 다음과 같이 계산 됩니다.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 또는 음수 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. 예를 들어 일부 하드웨어 아키텍처는 double 형식 보다 범위 및 전체 자릿수가 크고 전체 자릿수를 사용 하는 "확장" 또는 "long 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.

Decimal 형식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^28 약 28-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이 고 계수 c0 <= *c* < 2^96에 의해 제공 되며 소수 자릿수 e 해당 0 <= e <= 28입니다. decimal 형식이 서명 된 0, 무한대 또는 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. decimal는 10의 거듭제곱으로 확장 된 96 비트 정수로 표시 됩니다.A decimal is represented as a 96-bit integer scaled by a power of ten. 1.0m보다 작은 절대값을 가진 decimal의 경우 값은 28 번째 소수 자릿수와 동일 하지만 더 이상 필요 하지 않습니다.For decimals with an absolute value less than 1.0m, the value is exact to the 28th decimal place, but no further. 1.0m보다 크거나 같은 절대값을 가진 decimal의 경우 값은 28 또는 29 자리 숫자로 정확 합니다.For decimals with an absolute value greater than or equal to 1.0m, the value is exact to 28 or 29 digits. floatdouble 데이터 형식과 달리 0.1와 같은 소수 소수 자릿수는 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.

이항 연산자의 피연산자 중 하나가 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. 결과는 가장 가까운 표현 가능한 값으로 반올림 되 고, 결과는 두 개의 표현할 수 있는 값과 동일 하 게 비슷한 경우 ("은행원의 반올림" 이라고 함)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.

Decimal 산술 연산이 절대 값 5 * 10^-29 보다 작거나 같은 값을 생성 하는 경우 연산 결과가 0이 됩니다.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이 throw 됩니다.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. bool 형식에 사용할 수 있는 값은 truefalse입니다.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++ 언어에서 0 정수 계열 또는 부동 소수점 값 또는 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. 모든 열거형 형식에는 byte, sbyte, short, ushort, int, uint, long 또는 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).

Nullable 형식Nullable types

Nullable 형식은 해당 기본 형식 및 추가 null 값의 모든 값을 나타낼 수 있습니다.A nullable type can represent all values of its underlying type plus an additional null value. Nullable 형식은 T?작성 됩니다. 여기서 T는 기본 형식입니다.A nullable type is written T?, where T is the underlying type. 이 구문은 System.Nullable<T>에 대 한 축약형 이며 두 형태를 교대로 사용할 수 있습니다.This syntax is shorthand for System.Nullable<T>, and the two forms can be used interchangeably.

Null을 허용 하지 않는 값 형식 반대로는 System.Nullable<T> 및 해당 줄임 T? (모든 T의 경우) 이외의 모든 값 형식과 nullable이 아닌 값 형식 (즉, 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 (형식 매개 변수 제약 조건)에 대 한 값 형식 제약 조건을 지정 합니다. 즉, nullable 형식의 기본 형식이 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. Nullable 형식의 기본 형식은 nullable 형식 또는 참조 형식일 수 없습니다.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.

Nullable T? 형식의 인스턴스에는 다음과 같은 두 개의 public 읽기 전용 속성이 있습니다.An instance of a nullable type T? has two public read-only properties:

  • 형식의 HasValue 속성 boolA HasValue property of type bool
  • 형식의 Value 속성 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. Null 인스턴스의 Value를 읽으려고 하면 System.InvalidOperationException throw 됩니다.Attempting to read the Value of a null instance causes a System.InvalidOperationException to be thrown. Nullable 인스턴스의 Value 속성에 액세스 하는 프로세스를 래핑 해제라고 합니다.The process of accessing the Value property of a nullable instance is referred to as unwrapping.

기본 생성자 외에도 모든 nullable 형식 T?T형식의 단일 인수를 사용 하는 public 생성자가 있습니다.In addition to the default constructor, every nullable type T? has a public constructor that takes a single argument of type T. T형식의 x 값이 지정 된 경우 폼의 생성자 호출입니다.Given a value x of type T, a constructor invocation of the form

new T?(x)

Value 속성이 x되는 T?의 null이 아닌 인스턴스를 만듭니다.creates a non-null instance of T? for which the Value property is x. 지정 된 값에 대해 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 리터럴 변환) 및 T에서 T?로 (암시적 nullable 변환) 사용할 수 있습니다.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.object 형식을참조 하십시오.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

object와 같이 dynamic 형식은 개체를 참조할 수 있습니다.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. 대신 런타임에 연산자의 확인이 실패 하면 예외가 throw 됩니다.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).
  • 형식 유추 (형식 유추)는 둘 다 후보 인 경우 objectdynamic 하는 것을 선호 합니다.Type inference (Type inference) will prefer dynamic over object if both are candidates.

이러한 동등성 때문에 다음이 포함 됩니다.Because of this equivalence, the following holds:

  • objectdynamic간에 암시적 id 변환이 있고 dynamic을로 바꿀 때 생성 된 형식 간에는 objectThere 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 클래스의 인스턴스는 유니코드 문자열을 나타냅니다.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

대리자는 하나 이상의 메서드를 참조 하는 데이터 구조입니다.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 및 unboxingBoxing and unboxing

Boxing 및 unboxing의 개념은 형식 시스템의 C#핵심입니다.The concept of boxing and unboxing is central to C#'s type system. Value_types와 reference_type간의 브리지를 제공 합니다 .이는 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 및 unboxing을 사용 하면 모든 형식의 값을 궁극적으로 개체로 처리할 수 있는 형식 시스템의 통합 뷰를 사용할 수 있습니다.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 변환Boxing conversions

Boxing 변환을 사용 하면 value_typereference_type로 암시적으로 변환할 수 있습니다.A boxing conversion permits a value_type to be implicitly converted to a reference_type. 다음 boxing 변환이 있습니다.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 에서 value_type에 의해 구현 된 interface_typeFrom any non_nullable_value_type to any interface_type implemented by the value_type.
  • 모든 nullable_type 에서 nullable_type의 기본 형식에 의해 구현 된 interface_typeFrom 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.
  • 기본 enum_type 를 사용 하는 모든 nullable_type 에서 System.Enum형식으로From any nullable_type with an underlying enum_type to the type System.Enum.
  • 런타임에 형식 매개 변수에서의 암시적 변환은 값 형식에서 참조 형식으로의 변환 (형식 매개 변수를 포함 하는 암시적 변환)을 종료 하는 경우 boxing 변환으로 실행 됩니다.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 의 값을 Boxing 하는 것은 개체 인스턴스를 할당 하 고 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 의 값을 Boxing 하면 null 값 (HasValue false) 이거나, 래핑 해제의 결과인 경우 null 참조가 생성 되 고, 그렇지 않은 경우에는 기본 값이 사용 됩니다.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 의 값을 boxing 하는 실제 프로세스는 다음과 같이 선언 된 것 처럼 동작 하는 일반 boxing 클래스의 존재를 발견 하 여 설명 하는 것이 가장 좋습니다.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;
    }
}

이제 T 형식 v의 Boxing은 식 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>와 같은 boxing 클래스는 실제로 존재 하지 않으며 boxed 값의 동적 형식은 실제로 클래스 형식이 아닙니다.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 형식의 boxed 값에는 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.

Boxing 변환은 값의 복사본을 boxed로 만드는 것을 의미 합니다.A boxing conversion implies making a copy of the value being boxed. 이는 reference_typeobject형식으로 변환 하는 것과 다릅니다 .이 값은 계속 해 서 동일한 인스턴스를 참조 하 고 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);

box에 대 한 p 할당에서 발생 하는 암시적 boxing 작업으로 인해 p 값이 복사 되기 때문에 콘솔에서 값 10을 출력 합니다.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. class를 대신 Point 선언 했습니다. pbox는 동일한 인스턴스를 참조 하기 때문에 20 값이 출력 됩니다.Had Point been declared a class instead, the value 20 would be output because p and box would reference the same instance.

Unboxing 변환Unboxing conversions

Unboxing 변환을 사용 하면 reference_typevalue_type로 명시적으로 변환할 수 있습니다.An unboxing conversion permits a reference_type to be explicitly converted to a value_type. 다음 unboxing 변환이 있습니다.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 에서 interface_type를 구현 하는 non_nullable_value_typeFrom any interface_type to any non_nullable_value_type that implements the interface_type.
  • 모든 interface_type 에서 내부 형식이 interface_type를 구현 하는 nullable_typeFrom 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 형식에서 기본 enum_type를 사용 하는 모든 nullable_type .From the type System.Enum to any nullable_type with an underlying enum_type.
  • 형식 매개 변수로의 명시적 변환은 런타임에 참조 형식에서 값 형식으로의 변환 (명시적 동적 변환)을 종료 하는 경우 unboxing 변환으로 실행 됩니다.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 에 대 한 unboxing 작업은 먼저 개체 인스턴스가 지정 된 non_nullable_value_type의 boxing 된 값 인지 확인 한 다음 인스턴스 외부에서 값을 복사 하는 것으로 구성 됩니다.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 에 대 한 Unboxing은 소스 피연산자가 null경우 nullable_type 의 null 값을 생성 하 고, 그렇지 않은 경우에는 개체 인스턴스를 nullable_type 의 기본 형식에 unboxing 하는 래핑된 결과를 생성 합니다.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.

이전 섹션에 설명 된 허수 boxing 클래스를 참조 하는 경우 개체를 value_type T box 하는 unboxing 변환은 식 ((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. 따라서 문이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 에 대 한 unboxing 변환이 런타임에 성공 하려면 소스 피연산자의 값이 해당 non_nullable_value_type의 boxed 값에 대 한 참조 여야 합니다.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. 소스 피연산자가 null이면 System.NullReferenceException throw 됩니다.If the source operand is null, a System.NullReferenceException is thrown. 소스 피연산자가 호환 되지 않는 개체에 대 한 참조 인 경우 System.InvalidCastException이 throw 됩니다.If the source operand is a reference to an incompatible object, a System.InvalidCastException is thrown.

지정 된 nullable_type 에 대 한 unboxing 변환이 런타임에 성공 하려면 소스 피연산자의 값이 null 이거나 nullable_type의 기본 non_nullable_value_type boxed 값에 대 한 참조 여야 합니다.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이 throw 됩니다.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. 하나 이상의 형식 인수를 포함 하는 형식을 생성 된 형식이라고 합니다.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
    }
}

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 및 closed 형식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.
  • 생성 된 형식은 해당 형식 인수 중 하나 이상이 개방형 형식인 경우에만 개방형 형식입니다.A constructed type is an open type if and only if one or more of its type arguments is an open type. 생성 된 중첩 형식은 해당 형식 인수 중 하나 이상이 나 포함 하는 형식의 형식 인수가 개방형 형식인 경우에만 개방형 형식입니다.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. 두 폐쇄형 생성 형식은 동일한 바인딩되지 않은 제네릭 형식에서 생성 된 경우 동일한 형식이 고 해당 형식 인수는 동일한 형식입니다.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. 제약 조건을 충족 하기 위해 다음 중 하나를 C 형식 A 형식으로 변환할 수 있어야 합니다.To satisfy the constraint, it must be the case that type A is convertible to type C by one of the following:
    • Id 변환 (id 변환)An identity conversion (Identity conversion)
    • 암시적 참조 변환 (암시적 참조 변환)An implicit reference conversion (Implicit reference conversions)
    • 형식 A가 null을 허용 하지 않는 값 형식인 경우 boxing 변환 (boxing 변환)입니다.A boxing conversion (Boxing conversions), provided that type A is a non-nullable value type.
    • 형식 매개 변수에서 C로의 암시적 참조, boxing 또는 형식 매개 변수 변환이 A.An implicit reference, boxing or type parameter conversion from a type parameter A to C.
  • 제약 조건이 참조 형식 제약 조건 (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 구조체 형식 또는 열거형 형식 이지만 nullable 형식이 아닙니다.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 되지 않아야 하며 매개 변수가 없는 public 생성자가 있어야 합니다.If the constraint is the constructor constraint new(), the type A must not be abstract and must have a public parameterless constructor. 다음 조건 중 하나에 해당 하는 경우이 문제가 충족 됩니다.This is satisfied if one of the following is true:
    • 모든 값 형식에는 공용 기본 생성자 (기본생성자)가 있기 때문에 A은 값 형식입니다.A is a value type, since all value types have a public default constructor (Default constructors).
    • A는 생성자 제약 조건 (형식 매개 변수 제약 조건)을 포함 하는 형식 매개 변수입니다.A is a type parameter having the constructor constraint (Type parameter constraints).
    • A는 값 형식 제약 조건이 있는 형식 매개 변수 (형식 매개 변수 제약조건)입니다.A is a type parameter having the value type constraint (Type parameter constraints).
    • Aabstract 되지 않으며 매개 변수 없이 명시적으로 선언 된 public 생성자를 포함 하는 클래스입니다.A is a class that is not abstract and contains an explicitly declared public constructor with no parameters.
    • A abstract 없으며 기본 생성자 (기본생성자)가 있습니다.A is not abstract and has a default constructor (Default constructors).

지정 된 형식 인수에서 하나 이상의 형식 매개 변수 제약 조건이 충족 되지 않으면 컴파일 시간 오류가 발생 합니다.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>. 반면, List<T>T에 대 한 IEnumerable을 구현 하기 때문에 클래스 E 제약 조건을 지정할 필요가 없습니다.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:

  • 형식 매개 변수를 직접 사용 하 여 기본 클래스 (기본 클래스) 또는 인터페이스 (Variant 형식 매개 변수 목록)를 선언할 수 없습니다.A type parameter cannot be used directly to declare a base class (Base class) or interface (Variant type parameter lists).
  • 형식 매개 변수에 대 한 멤버 조회 규칙은 형식 매개 변수에 적용 되는 제약 조건 (있는 경우)에 따라 달라 집니다.The rules for member lookup on type parameters depend on the constraints, if any, applied to the type parameter. 멤버 조회에 자세히 설명 되어 있습니다.They are detailed in Member lookup.
  • 형식 매개 변수에 사용 가능한 변환은 형식 매개 변수에 적용 되는 제약 조건 (있는 경우)에 따라 달라 집니다.The available conversions for a type parameter depend on the constraints, if any, applied to the type parameter. 형식 매개 변수명시적 동적 변환과관련 된 암시적 변환에 자세히 설명 되어 있습니다.They are detailed in Implicit conversions involving type parameters and Explicit dynamic conversions.
  • 형식 매개 변수가 참조 형식 (형식 매개 변수를 포함 하는 암시적 변환)이 라고도 하는 경우를 제외 하 고는 리터럴 null를 형식 매개 변수에 지정 된 형식으로 변환할 수 없습니다.The literal null cannot be converted to a type given by a type parameter, except if the type parameter is known to be a reference type (Implicit conversions involving type parameters). 그러나 default 식 (기본값 식)을 대신 사용할 수 있습니다.However, a default expression (Default value expressions) can be used instead. 또한 형식 매개 변수에서 값 형식 제약 조건이 있는 경우를 제외 하 고는 형식 매개 변수에 지정 된 형식의 값을 ==!= (참조 형식 같음 연산자)를 사용 하 여 null 비교할 수 있습니다.In addition, a value with a type given by a type parameter can be compared with null using == and != (Reference type equality operators) unless the type parameter has the value type constraint.
  • new 식 (개체 생성 식)은 형식 매개 변수가 constructor_constraint 또는 값 형식 제약 조건 (형식 매개 변수 제약조건)에 의해 제한 되는 경우에만 형식 매개 변수와 함께 사용할 수 있습니다.A new expression (Object creation expressions) can only be used with a type parameter if the type parameter is constrained by a constructor_constraint or the value type constraint (Type parameter constraints).
  • 특성 내에서 형식 매개 변수를 사용할 수 없습니다.A type parameter cannot be used anywhere within an attribute.
  • 멤버 액세스 (멤버 액세스) 또는 형식 이름 (네임 스페이스 및 형식 이름)에서 형식 매개 변수를 사용 하 여 정적 멤버나 중첩 형식을 식별할 수 없습니다.A type parameter cannot be used in a member access (Member access) or type name (Namespace and type names) to identify a static member or a nested type.
  • 안전 하지 않은 코드에서 형식 매개 변수는 unmanaged_type (포인터 형식)로 사용할 수 없습니다.In unsafe code, a type parameter cannot be used as an unmanaged_type (Pointer types).

형식으로 형식 매개 변수는 순수 컴파일 시간 구문입니다.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.

대리자 형식 D와 마찬가지로 Expression<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

이러한 할당을 수행 하는 대리자 delx + 1를 반환 하는 메서드를 참조 하 고 식 트리 expx => 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.

람다 식이 식 트리 형식으로 변환 될 때 식 트리를 생성 하는 정확한 규칙 뿐만 아니라 제네릭 형식 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.

명시적으로 수행 하는 두 가지 중요 한 사항은 다음과 같습니다.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>D형식의 대리자를 생성 하는 인스턴스 메서드 Compile를 제공 합니다.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는 동일 하 고 다음 두 문은 동일한 결과를 발생 시킬 수 있습니다.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);
    

    이 코드를 실행 한 후 i1i22값이 모두 포함 됩니다.After executing this code, i1 and i2 will both have the value 2.