[C#] 정수 숫자 형식

https://docs.microsoft.com/ko-kr/dotnet/csharp/language-reference/builtin-types/integral-numeric-types

정수 숫자 형식 - C# 참조

https://docs.microsoft.com/ko-kr/dotnet/csharp/language-reference/language-specification/types#836-integral-types

Types - C# language specification

 

정수 숫자 형식은 정수를 표현합니다. 모든 정수 숫자 형식은 값 형식입니다. 이것은 기본 형식이기도 하며, 리터럴로 초기화할 수 있습니다. 모든 정수 숫자 형식은 산술, 비트 논리, 비교 및 같음 연산자를 지원합니다.

정수 형식의 특성

C#은 다음과 같은 미리 정의된 정수 형식을 지원합니다.

 

byte 1바이트 0~255

short 2바이트 -3만~3만

int 4바이트 -21억~21억

long 8바이트

 

여기서 s가 붙으면 음수

 

sbyte 1바이트 -128~127

ushort 2바이트 0~6만

uint 4바이트 0~43억

ulong 8바이트

C# 형식/키워드범위크기.NET 형식

sbyte	-128 ~ 127	부호 있는 8비트 정수	System.SByte
byte	0 ~ 255	부호 없는 8비트 정수	System.Byte
short	–32,768 ~ 32,767	부호 있는 16비트 정수	System.Int16
ushort	0 ~ 65,535	부호 없는 16비트 정수	System.UInt16
int	–2,147,483,648 ~ 2,147,483,647	부호 있는 32비트 정수	System.Int32
uint	0 ~ 4,294,967,295	부호 없는 32비트 정수	System.UInt32
long	–9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807	부호 있는 64비트 정수	System.Int64
ulong	0 ~ 18,446,744,073,709,551,615	부호 없는 64비트 정수	System.UInt64
nint	플랫폼에 따라 다름	부호 있는 32비트 또는 64비트 정수	System.IntPtr
nuint	플랫폼에 따라 다름	부호 없는 32비트 또는 64비트 정수	System.UIntPtr

마지막 두 개를 제외한 모든 테이블 행에서 맨 왼쪽 열의 각 C# 형식 키워드는 해당하는 .NET 형식의 별칭입니다. 키워드와 .NET 형식 이름은 서로 바꿔 사용할 수 있습니다. 예를 들어 다음 선언은 동일한 형식의 변수를 선언합니다.

C#복사

 

int a = 123;
System.Int32 b = 123;

표의 마지막 두 행에 있는 nint 및 nuint 형식은 기본 크기 정수입니다. 이들은 지정된 .NET 형식에 의해 내부적으로 표시되지만, 각 경우에 키워드와 .NET 형식을 서로 바꿔 사용할 수 없습니다. 컴파일러는 nint 및 nuint에 대한 작업 및 변환을 포인터 형식 System.IntPtr 및 System.UIntPtr에 대해 제공하지 않는 정수 형식으로 제공합니다. 자세한 내용은 nint 및 nuint형식을 참조하세요.

각 정수 형식의 기본값은 0입니다. 기본 크기 형식을 제외한 각 정수 형식에는 해당 형식의 최소값과 최대값을 제공하는 MinValue 및 MaxValue 상수가 있습니다.

System.Numerics.BigInteger 구조체를 사용하여 상한 또는 하한이 없는 부호 있는 정수를 나타냅니다.

정수 리터럴

정수 리터럴은 다음 형식일 수 있습니다.

• 10진: 접두사가 없음
• 16진수: 0x 또는 0X 접두사 사용
• 이진: 0b 또는 0B 접두사 사용(C# 7.0 및 이후 버전에서 가능)

다음 코드에서는 각 예제를 보여 줍니다.

C#복사

 

var decimalLiteral = 42;
var hexLiteral = 0x2A;
var binaryLiteral = 0b_0010_1010;

앞의 예제에서는 C# 7.0부터 지원되는 숫자 구분 기호인 _를 사용하는 방법도 보여 줍니다. 모든 종류의 숫자 리터럴에서 숫자 구분 기호를 사용할 수 있습니다.

정수 리터럴의 형식은 접미사로 다음과 같이 결정됩니다.

• 리터럴에 접미사가 없는 경우 해당 형식은 값이 표현될 수 있는 int, uint, long, ulong 형식 중 첫 번째 형식입니다.
•  참고
• 리터럴은 양수 값으로 해석됩니다. 예를 들어 리터럴 0xFF_FF_FF_FF는 uint 형식의 숫자 4294967295를 나타내지만, int 형식의 숫자 -1과 같은 비트를 표현합니다. 특정 형식의 값이 필요한 경우 리터럴을 해당 형식으로 캐스팅합니다. 리터럴 값을 대상 유형으로 표현할 수 없는 경우 unchecked 연산자를 사용합니다. 예를 들어 unchecked((int)0xFF_FF_FF_FF)는 -1을 생성합니다.
• 리터럴에 접미사가 U 또는 u인 경우 해당 형식은 값이 표현될 수 있는 uint, ulong 형식 중 첫 번째 형식입니다.
• 리터럴에 접미사가 L 또는 l인 경우 해당 형식은 값이 표현될 수 있는 long, ulong 형식 중 첫 번째 형식입니다.
•  참고
• 소문자 l를 접미사로 사용할 수 있습니다. 그러나 이렇게 하면 문자 l 및 숫자 1을 혼동하기 쉬우므로 컴파일러 경고가 생성됩니다. 쉽게 구별할 수 있도록 L을 사용합니다.
• 리터럴의 접미사가 UL, Ul, uL, ul, LU, Lu, lU 또는 lu이면 해당 형식은 ulong입니다.

정수 리터럴로 표시되는 값이 UInt64.MaxValue를 초과하면 컴파일 오류 CS1021이 발생합니다.

결정된 정수 리터럴 형식이 int이고 리터럴이 나타내는 값이 대상 형식의 범위 내에 있는 경우, 해당 값이 암시적으로 sbyte, byte, short, ushort, uint, ulong, nint 또는 nuint으로 변환될 수 있습니다.

C#복사

 

byte a = 17;
byte b = 300;   // CS0031: Constant value '300' cannot be converted to a 'byte'

앞의 예제에서 볼 수 있듯이 리터럴 값이 대상 형식의 범위 내에 있지 않으면 컴파일러 오류 CS0031이 발생합니다.

캐스트를 사용하여 정수 리터럴로 표시되는 값을 결정된 리터럴 형식 이외의 형식으로 변환할 수도 있습니다.

C#복사

 

var signedByte = (sbyte)42;
var longVariable = (long)42;

변환

모든 정수 숫자 형식을 다른 정수 숫자 형식으로 변환할 수 있습니다. 대상 형식이 소스 형식의 모든 값을 저장할 수 있는 경우 변환은 암시적입니다. 저장할 수 없는 경우에는 캐스트 식를 사용하여 명시적 변환을 수행해야 합니다. 자세한 내용은 기본 제공 숫자 변환을 참조하세요.

 

C # 언어의 형식은 value types _ 및 _참조 형식*_ 이라는 두 가지 주요 범주로 구분 됩니다. 값 형식과 참조 형식은 모두 하나 이상의 _ 형식 매개 변수 를 사용 하는 _제네릭 형식일* 수 있습니다. 형식 매개 변수는 값 형식과 참조 형식을 모두 지정할 수 있습니다.

antlr복사

 

type
    : value_type
    | reference_type
    | type_parameter
    | type_unsafe
    ;

형식, 포인터의 최종 범주는 안전 하지 않은 코드 에서만 사용할 수 있습니다. 이에 대해서는 포인터 형식에 자세히 설명 되어 있습니다.

값 형식은 해당 데이터를 직접 포함 하는 반면, 참조 형식의 변수는 데이터에 *참조 _를 저장 하 고, 후자는 _ *개체* *로 알려진의 참조 형식과 다릅니다. 참조 형식을 사용 하는 경우 두 변수가 같은 개체를 참조할 수 있으므로 한 변수에 대 한 작업이 다른 변수에서 참조 하는 개체에 영향을 줄 수 있습니다. 값 형식을 사용 하는 경우 변수에는 각각 고유한 데이터 사본이 있으며 한 변수에 대 한 작업이 다른 변수에 영향을 줄 수 없습니다.

C #의 형식 시스템은 모든 형식의 값을 개체로 처리할 수 있도록 통합 되었습니다. C#의 모든 형식은 object 클래스 형식에서 직접 또는 간접적으로 파생되고 object는 모든 형식의 기본 클래스입니다. 참조 형식의 값은 object로 인식함으로써 간단히 개체로 처리됩니다. 값 형식의 값은 boxing 및 unboxing 작업 (boxing 및 unboxing)을 수행 하 여 개체로 처리 됩니다.

값 형식

값 형식은 구조체 형식 또는 열거형 형식입니다. C #에서는 단순 형식 이라는 미리 정의 된 구조체 형식의 집합을 제공 합니다. 단순 형식은 예약어를 통해 식별 됩니다.

antlr복사

 

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 형식이 nullable 형식인 경우에만 값을 포함할 수 있습니다. Null을 허용 하지 않는 모든 값 형식에 대해 값과 값의 동일한 집합을 나타내는 해당 nullable 값 형식이 있습니다 null .

값 형식의 변수에 할당 하면 할당 되는 값의 복사본이 생성 됩니다. 이는 참조를 복사 하지만 참조로 식별 되는 개체가 아닌 참조 형식의 변수에 대 한 할당과 다릅니다.

System.object 형식

모든 값 형식은 클래스에서 암시적으로 상속 System.ValueType 되며,이는 클래스에서 상속 object 됩니다. 모든 형식이 값 형식에서 파생 될 수 있는 것은 아닙니다. 따라서 값 형식은 암시적으로 봉인 됩니다 (봉인 된 클래스).

는 System.ValueType 자체 value_type 이 아닙니다. 대신 모든 value_type s가 자동으로 파생 되는 class_type 입니다.

기본 생성자

모든 값 형식은 *기본 생성자 _ 라고 하는 매개 변수가 없는 public 인스턴스 생성자를 암시적으로 선언 합니다. 기본 생성자는 값 형식에 대해 _ 기본값* 이라는 0으로 초기화 된 인스턴스를 반환 합니다.

• 모든 simple_type s의 경우 기본값은 비트 패턴에 의해 생성 된 모든 0의 값입니다.
  • ,,,,,, 및의 경우 sbyte byte 기본값은 short ushort int uint long ulong 0 입니다.
  • 의 경우 char 기본값은 '\x0000' 입니다.
  • 의 경우 float 기본값은 0.0f 입니다.
  • 의 경우 double 기본값은 0.0d 입니다.
  • 의 경우 decimal 기본값은 0.0m 입니다.
  • 의 경우 bool 기본값은 false 입니다.
• Enum_type 에 대 한 E 기본값은 0 형식으로 변환 된입니다 E .
• Struct_type 의 경우 기본값은 모든 값 형식 필드를 기본값으로 설정 하 고 모든 참조 형식 필드를로 설정 하 여 생성 되는 값입니다 null .
• Nullable_type 의 경우 기본값은 HasValue 속성이 false이 고 Value 속성이 정의 되어 있지 않은 인스턴스입니다. 기본값은 nullable 형식의 null 값 이 라고도 합니다.

다른 인스턴스 생성자와 마찬가지로 값 형식의 기본 생성자는 연산자를 사용 하 여 호출 됩니다 new . 효율성을 위해이 요구 사항은 실제로 구현에서 생성자 호출을 생성 하지 않도록 하기 위한 것입니다. 아래 예제에서 i 및 변수 j 는 모두 0으로 초기화 됩니다.

C#복사

 

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

모든 값 형식에는 매개 변수가 없는 public 인스턴스 생성자가 암시적으로 있으므로 구조체 형식에 매개 변수가 없는 생성자의 명시적 선언이 포함 될 수 없습니다. 그러나 구조체 형식은 매개 변수가 있는 인스턴스 생성자 (생성자)를 선언할 수 있습니다.

구조체 형식

구조체 형식은 상수, 필드, 메서드, 속성, 인덱서, 연산자, 인스턴스 생성자, 정적 생성자 및 중첩 형식을 선언할 수 있는 값 형식입니다. 구조체 형식 선언은 구조체 선언에 설명 되어 있습니다.

단순 형식

C #에서는 단순 형식 이라는 미리 정의 된 구조체 형식의 집합을 제공 합니다. 단순 형식은 예약어를 통해 식별 되지만 이러한 예약어는 System 아래 표에 설명 된 대로 네임 스페이스의 미리 정의 된 구조체 형식에 대 한 별칭입니다.

예약어별칭이 지정 되는 형식

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

단순 형식에서 구조체 형식의 별칭을 하므로 모든 단순 형식에는 멤버가 있습니다. 예를 들어에는 int 에 선언 된 멤버 System.Int32 와에서 상속 된 멤버 System.Object 와 다음 문이 허용 됩니다.

C#복사

 

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

단순 형식은 특정 추가 작업을 허용한다는 점에서 다른 구조체 형식과는 다릅니다.

• 가장 간단한 형식은 리터럴 (리터럴)을 작성 하 여 값을 만들 수 있도록 합니다. 예를 들어, 123 는 형식의 리터럴이 int 며 'a' 은 형식의 리터럴입니다 char . C #은 일반적으로 구조체 형식의 리터럴을 프로 비전 하지 않으며 다른 구조체 형식의 기본값이 아닌 값은 궁극적으로 항상 이러한 구조체 형식의 인스턴스 생성자를 통해 생성 됩니다.
• 식의 피연산자가 모두 단순 형식 상수인 경우 컴파일러가 컴파일 시간에 식을 계산할 수 있습니다. 이러한 식을 constant_expression (상수 식) 이라고 합니다. 다른 구조체 형식에 의해 정의 된 연산자를 포함 하는 식은 상수 식으로 간주 되지 않습니다.
• const선언을 통해 단순 형식 (상수)의 상수를 선언할 수 있습니다. 다른 구조체 형식의 상수는 있을 수 없지만 필드에서 비슷한 효과를 제공 static readonly 합니다.
• 단순 형식을 포함 하는 변환은 다른 구조체 형식에 의해 정의 된 변환 연산자의 평가에 참여할 수 있지만 사용자 정의 변환 연산자는 다른 사용자 정의 연산자의 평가에 참여할 수 없습니다 (사용자 정의 변환 평가).

정수 계열 형식 표

C #은,,,,,,, 및의 9 가지 정수 형식을 지원 sbyte byte short ushort int uint long ulong char 합니다. 정수 계열 형식은 다음 크기와 범위의 값을 갖습니다.

• sbyte형식은-128과 127 사이의 값을 가진 부호 있는 8 비트 정수를 나타냅니다.
• byte형식은 0에서 255 사이의 값을 가진 부호 없는 8 비트 정수를 나타냅니다.
• short형식은-32768과 32767 사이의 값을 가진 부호 있는 16 비트 정수를 나타냅니다.
• ushort형식은 0에서 65535 사이의 값을 가진 부호 없는 16 비트 정수를 나타냅니다.
• int형식은-2147483648에서 2147483647 사이의 값을 가진 부호 있는 32 비트 정수를 나타냅니다.
• uint형식은 0과 4294967295 사이의 값을 가진 부호 없는 32 비트 정수를 나타냅니다.
• long형식은-9223372036854775808과 9223372036854775807 사이의 값을 가진 부호 있는 64 비트 정수를 나타냅니다.
• ulong형식은 0에서 18446744073709551615 사이의 값을 가진 부호 없는 64 비트 정수를 나타냅니다.
• char형식은 0에서 65535 사이의 값을 가진 부호 없는 16 비트 정수를 나타냅니다. char 형식에 사용할 수 있는 값 집합은 유니코드 문자 집합과 일치합니다. char에는와 동일한 표현이 있지만 ushort 한 형식에서 허용 되는 모든 작업이 다른 형식에서 허용 되는 것은 아닙니다.

정수 계열 형식 단항 및 이항 연산자는 항상 부호 있는 32 비트 전체 자릿수, 부호 없는 32 비트 전체 자릿수, 부호 있는 64 비트 전체 자릿수 또는 부호 없는 64 비트 전체 자릿수를 사용 하 여 작동 합니다.

• 단항 + 및 연산자의 경우 ~ 피연산자는 형식으로 변환 됩니다 T . 여기서 T 는 int uint long ulong 피연산자의 모든 가능한 값을 완전히 나타낼 수 있는,, 및의 첫 번째입니다. 그런 다음 형식의 전체 자릿수를 사용 하 여 작업을 수행 T 하 고 결과의 형식은 T 입니다.
• 단항 연산자의 경우 - 피연산자는 형식으로 변환 되 T 고, 여기서 T 는 int long 피연산자의 모든 가능한 값을 완전히 표현할 수 있는 및의 첫 번째입니다. 그런 다음 형식의 전체 자릿수를 사용 하 여 작업을 수행 T 하 고 결과의 형식은 T 입니다. 단항 - 연산자는 형식의 피연산자에 적용할 수 없습니다 ulong .
• Binary,,,,,,,,,,,, + - * / % & ^ | 및 연산자의 경우 == != > < >= <= 피연산자는 형식으로 변환 됩니다 T T . 여기서는 int uint long ulong 두 피연산자의 모든 가능한 값을 완전히 나타낼 수 있는,, 및의 첫 번째입니다. 그런 다음 형식의 전체 자릿수를 사용 하 여 작업을 수행 T 하 고 결과의 형식은 T (또는 bool 관계형 연산자의 경우)입니다. 한 피연산자가 형식이 long 고 다른 피연산자는 이진 연산자를 사용 하 여 형식이 되도록 허용 되지 않습니다 ulong .
• 이항 << 및 연산자의 경우 >> 왼쪽 피연산자가 형식으로 변환 됩니다 T . 여기서 T 는 int uint long ulong 피연산자의 모든 가능한 값을 완전히 나타낼 수 있는,, 및의 첫 번째 피연산자입니다. 그런 다음 형식의 전체 자릿수를 사용 하 여 작업을 수행 T 하 고 결과의 형식은 T 입니다.

char형식은 정수 계열 형식으로 분류 되지만 두 가지 방법으로 다른 정수 계열 형식과 다릅니다.

• 다른 형식에서 char 형식으로의 암시적 변환은 없습니다. 특히, 및 형식에는 sbyte byte ushort 형식을 사용 하 여 완전히 표현할 수 있는 값 범위가 있지만 char , 또는에서로의 암시적 변환이 sbyte byte ushort char 없습니다.
• char형식의 상수는 character_literal s로 작성 하거나 형식에 대 한 캐스트와 함께 integer_literal 로 작성 되어야 합니다 char . 예를 들어 (char)10은 '\x000A'과 같습니다.

checked및 unchecked 연산자와 문은 정수 계열 형식 산술 연산 및 변환 (checked 및 unchecked 연산자)에 대 한 오버플로 검사를 제어 하는 데 사용 됩니다. checked컨텍스트에서 오버플로가 발생 하면 컴파일 시간 오류가 발생 하거나이 System.OverflowException throw 됩니다. unchecked컨텍스트에서 오버플로는 무시 되 고 대상 형식에 맞지 않는 상위 비트는 무시 됩니다.

부동 소수점 형식

C #에서는 두 개의 부동 소수점 형식 float 및을 지원 double 합니다. float및 double 형식은 다음 값 집합을 제공 하는 32 비트 단 정밀도 및 64 비트 배정밀도 IEEE 754 형식을 사용 하 여 표현 됩니다.

• 양의 0 및 음의 0. 대부분의 경우 양의 0과 음수 0은 단순 값 0과 동일 하 게 작동 하지만 특정 연산은 두 (나누기 연산자)를 구분 합니다.
• 양의 무한대 및 음의 무한대 무한대는 0이 아닌 숫자를 0으로 나누는 연산에 의해 생성됩니다. 예를 들어 1.0 / 0.0은 양의 무한대를 생성하고 -1.0 / 0.0은 음의 무한대를 생성합니다.
• 숫자가 아닌 값 (종종 약어 NaN)입니다. NaN은 0으로 0 나누기와 같은 잘못된 부동 소수점 연산에 의해 생성됩니다.
• 형식에 대 한 0이 아닌 유한 값 집합입니다 s * m * 2^e . 여기서 s 는 1 또는-1이 고,은 m e 특정 부동 소수점 형식 (,, 및 float 0 < m < 2^24 -149 <= e <= 104 의 double 0 < m < 2^53 -1075 <= e <= 970 경우)에 의해 결정 됩니다. 비 정규화 된 부동 소수점 숫자는 0이 아닌 유효한 값으로 간주 됩니다.

float형식은 대략에서 1.5 * 10^-45 3.4 * 10^38 7 자리의 전체 자릿수를 갖는 값을 나타낼 수 있습니다.

double형식은 대략에서 5.0 * 10^-324 1.7 × 10^308 15-16 자리의 전체 자릿수를 갖는 값을 나타낼 수 있습니다.

이항 연산자의 피연산자 중 하나가 부동 소수점 형식인 경우 다른 피연산자는 정수 형식 또는 부동 소수점 형식 이어야 하며 연산은 다음과 같이 계산 됩니다.

• 피연산자 중 하나가 정수 형식이 면 해당 피연산자는 다른 피연산자의 부동 소수점 형식으로 변환 됩니다.
• 그런 다음 피연산자 중 하나가 형식인 경우 double 다른 피연산자가로 변환 되 고 double , 최소 double 범위와 전체 자릿수를 사용 하 여 연산이 수행 되며, 결과의 형식이 double (또는 bool 관계형 연산자의 경우)입니다.
• 그렇지 않으면 최소 범위와 전체 자릿수를 사용 하 여 작업을 수행 하 float 고, 결과의 형식은 float (또는 bool 관계형 연산자의 경우)입니다.

할당 연산자를 포함 하는 부동 소수점 연산자는 예외를 생성 하지 않습니다. 대신, 예외 상황에서 부동 소수점 연산은 아래에 설명 된 대로 0, 무한대 또는 NaN을 생성 합니다.

• 부동 소수점 연산의 결과가 대상 형식에 비해 너무 작은 경우 연산 결과가 양의 0 또는 음수 0이 됩니다.
• 부동 소수점 연산의 결과가 대상 형식에 비해 너무 큰 경우 연산의 결과는 양의 무한대 또는 음의 무한대가 됩니다.
• 부동 소수점 연산이 잘못 된 경우 작업의 결과는 NaN이 됩니다.
• 부동 소수점 연산의 피연산자 중 하나 또는 둘 다가 NaN이면 연산 결과가 NaN이 됩니다.

부동 소수점 연산은 작업의 결과 형식 보다 높은 정밀도로 수행할 수 있습니다. 예를 들어 일부 하드웨어 아키텍처는 형식 보다 더 크고 전체 자릿수를 포함 하는 "확장" 또는 "long double" 부동 소수점 형식을 지원 double 하 고이 높은 전체 자릿수 형식을 사용 하 여 모든 부동 소수점 연산을 암시적으로 수행 합니다. 성능이 과도 하 게 증가 하는 경우에만 이러한 하드웨어 아키텍처를 사용 하 여 정밀도가 낮은 부동 소수점 작업을 수행할 수 있으며, 성능과 전체 자릿수를 모두 상실 구현 해야 하는 것은 아닙니다. c #에서는 모든 부동 소수점 연산에 더 높은 정밀도 형식을 사용할 수 있습니다. 보다 정확한 결과를 제공 하는 것 외에도이로 인해 측정 가능한 영향이 거의 없습니다. 그러나 곱하기에서 범위를 벗어나는 결과를 생성 하는 폼의 식에서 x * y / z double 이후 나누기는 임시 결과를 범위에 다시 표시 하지만 double 식이 더 높은 범위 형식으로 계산 되 면 무한대 대신 유한 결과가 생성 될 수 있습니다.

10진 형식

decimal 형식은 재무 및 통화 계산에 적합한 128비트 데이터 형식입니다. 이 decimal 형식은에서 1.0 * 10^-28 7.9 * 10^28 28-29 자리의 유효 자릿수로 범위가 높은 값을 나타낼 수 있습니다.

형식에 대 한 유한 값 집합은 형식 decimal 입니다 (-1)^s * c * 10^-e . 여기에서 부호는 s 0 또는 1이 고 계수는에 c 의해 지정 되며 0 <= *c* < 2^96 소수 자릿수입니다 e 0 <= e <= 28 . decimal 형식이 signed 0, 무한대 또는 NaN을 지원 하지 않습니다. 는 decimal 10의 거듭제곱으로 크기가 조정 된 96 비트 정수로 표시 됩니다. 가 decimal 보다 작은 절대값을 사용 하는 경우 1.0m 값은 28 번째 소수 자릿수와 동일 하지만 더 이상 필요 하지 않습니다. 가 decimal 보다 크거나 같은 절대값을 사용 하는 경우 1.0m 값은 28 또는 29 자리 숫자와 동일 합니다. float및 double 데이터 형식과 달리 0.1와 같은 소수 소수 자릿수는 표현에서 정확 하 게 표현할 수 있습니다 decimal . float및 표현에서 double 이러한 숫자는 종종 무한 분수로 표시 되므로 이러한 표현은 반올림 오류가 발생 하기 쉽습니다.

이항 연산자의 피연산자 중 하나가 형식인 경우 decimal 다른 피연산자는 정수 형식 또는 형식 이어야 합니다 decimal . 정수 계열 형식 피연산자가 있는 경우 decimal 작업을 수행 하기 전에로 변환 됩니다.

형식의 값에 대 한 연산의 결과는 decimal 각 연산자에 대해 정의 된 대로 정확한 결과 (소수 자릿수 유지)를 계산한 다음 표현에 맞게 반올림 한 결과입니다. 결과는 가장 가까운 표현 가능한 값으로 반올림 되 고, 결과는 두 개의 표현할 수 있는 값과 동일 하 게 비슷한 경우 ("은행원의 반올림" 이라고 함) 0 인 결과는 항상 부호가 0이 고 소수 자릿수가 0입니다.

Decimal 산술 연산이 절대 값 보다 작거나 같은 값을 생성 하는 경우 5 * 10^-29 연산의 결과는 0이 됩니다. decimal산술 연산에서 형식에 대해 너무 많은 결과를 생성 하는 경우 decimal System.OverflowException 이 throw 됩니다.

decimal형식이 부동 소수점 형식 보다 정밀도는 크지만 범위가 작습니다. 따라서 부동 소수점 형식에서로 변환 하면 decimal 오버플로 예외가 발생할 수 있으며에서 decimal 부동 소수점 형식으로 변환 하면 전체 자릿수가 손실 될 수 있습니다. 이러한 이유로, 부동 소수점 형식과, 명시적 캐스트가 없는 암시적 변환은 존재 하지 않습니다 decimal decimal . 동일한 식에서 부동 소수점과 피연산자를 혼합할 수 없습니다.

Bool 형식

bool형식은 부울 논리 수량을 나타냅니다. 형식에 사용할 수 있는 값은 bool true 및 false 입니다.

과 다른 형식 사이에는 표준 변환이 없습니다 bool . 특히 bool 형식은 고유 하며 정수 계열 형식과 구분 되며, bool 값은 정수 계열 값 대신 사용할 수 없으며 그 반대의 경우도 마찬가지입니다.

C 및 c + + 언어에서 0 개의 정수 계열 또는 부동 소수점 값 또는 null 포인터를 부울 값으로 변환 하거나 false 0이 아닌 정수 계열 또는 부동 소수점 값으로 변환 하거나 null이 아닌 포인터를 부울 값으로 변환할 수 있습니다 true . C #에서 이러한 변환은 정수 계열 또는 부동 소수점 값을 0으로 명시적으로 비교 하거나 개체 참조를에 명시적으로 비교 하 여 수행 됩니다 null .

열거형 형식

열거형 형식은 명명 된 상수가 있는 고유한 형식입니다. 모든 열거형 형식에는,,,,, 또는 여야 하는 기본 형식이 있습니다 byte sbyte short ushort int uint long ulong . 열거형 형식의 값 집합은 내부 형식의 값 집합과 동일 합니다. 열거형 형식의 값은 명명 된 상수 값으로 제한 되지 않습니다. 열거형 형식은 열거형 선언 (열거형선언)을 통해 정의 됩니다.

Nullable 유형

Nullable 형식은 해당 기본 형식 및 추가 null 값의 모든 값을 나타낼 수 있습니다. Nullable 형식이 작성 됩니다 T? T . 여기서은 기본 형식입니다. 이 구문은의 축약형 이며 System.Nullable<T> 두 가지 형태를 서로 바꿔 사용할 수 있습니다.

Null을 허용 하지 않는 값 형식 반대로는 System.Nullable<T> 및 해당 약어 T? (의 경우) 및 null을 T 허용 하지 않는 값 형식 (제약 조건이 있는 모든 형식 매개 변수)으로 제한 되는 모든 형식 매개 변수에 대 한 값 형식입니다 struct . System.Nullable<T>형식은 T (형식 매개 변수 제약 조건)에 대 한 값 형식 제약 조건을 지정 합니다. 즉, nullable 형식의 기본 형식이 null을 허용 하지 않는 값 형식일 수 있습니다. Nullable 형식의 기본 형식은 nullable 형식 또는 참조 형식일 수 없습니다. 예를 들어 int?? 및 string? 은 잘못 된 형식입니다.

Nullable 형식의 인스턴스는 T? 다음과 같은 두 개의 public 읽기 전용 속성을 포함 합니다.

• HasValue형식의 속성bool
• Value형식의 속성T

이 true 인 인스턴스는 HasValue null이 아닌 것으로 간주 됩니다. Null이 아닌 인스턴스는 알려진 값을 포함 하 고 Value 해당 값을 반환 합니다.

가 false 인 인스턴스는 HasValue null 이라고 합니다. Null 인스턴스에 정의 되지 않은 값이 있습니다. Null 인스턴스의를 읽으려고 하면이 Value System.InvalidOperationException throw 됩니다. Nullable 인스턴스의 속성에 액세스 하는 프로세스를 Value 래핑 해제 라고 합니다.

기본 생성자 외에도 모든 nullable 형식에는 T? 형식의 단일 인수를 사용 하는 public 생성자가 있습니다 T . x형식의 값이 지정 된 T 경우 폼의 생성자 호출입니다.

C#복사

 

new T?(x)

속성이 인의 null이 아닌 인스턴스를 만듭니다 T? Value x . 지정 된 값에 대해 null을 허용 하지 않는 형식의 인스턴스를 만드는 프로세스를 래핑 이라고 합니다.

암시적 변환은 null 리터럴에서 T? (Null 리터럴 변환) 및에서 T T? (암시적 nullable 변환)로 사용할 수 있습니다.

참조 형식

참조 형식은 클래스 형식, 인터페이스 형식, 배열 형식 또는 대리자 형식입니다.

antlr복사

 

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
    ;

참조 형식 값은 형식의 *instance _에 대 한 참조 이며, 후자는 _ *개체* *로 알려져 있습니다. 특수 값은 null 모든 참조 형식과 호환 되며 인스턴스가 없음을 나타냅니다.

클래스 형식

클래스 형식은 데이터 멤버 (상수 및 필드), 함수 멤버 (메서드, 속성, 이벤트, 인덱서, 연산자, 인스턴스 생성자, 소멸자 및 정적 생성자) 및 중첩 형식을 포함 하는 데이터 구조를 정의 합니다. 클래스 형식은 파생 클래스에서 기본 클래스를 확장 하 고 특수화할 수 있는 메커니즘인 상속을 지원 합니다. 클래스 형식의 인스턴스는 object_creation_expression s (개체 생성 식)를 사용 하 여 생성 됩니다.

클래스 형식은 클래스에서 설명합니다.

미리 정의 된 특정 클래스 형식은 아래 표에 설명 된 대로 c # 언어에서 특별 한 의미를 갖습니다.

클래스 형식설명

System.Object	다른 모든 형식의 궁극적인 기본 클래스입니다. 개체 형식을참조 하세요.
System.String	C # 언어의 문자열 형식입니다. 문자열 형식을참조 하십시오.
System.ValueType	모든 값 형식의 기본 클래스입니다. System.object 형식을참조 하십시오.
System.Enum	모든 열거형 형식의 기본 클래스입니다. 열거형을 참조 하세요.
System.Array	모든 배열 형식의 기본 클래스입니다. 배열을 참조하세요.
System.Delegate	모든 대리자 형식의 기본 클래스입니다. 대리자를 참조 하세요.
System.Exception	모든 예외 형식의 기본 클래스입니다. 예외를 참조 하세요.

개체 유형

object클래스 형식은 다른 모든 형식의 궁극적인 기본 클래스입니다. C #의 모든 형식이 직접 또는 간접적으로 object 클래스 형식에서 파생 됩니다.

키워드는 object 단순히 미리 정의 된 클래스에 대 한 별칭입니다 System.Object .

동적 형식

dynamic과 같은 형식은 object 개체를 참조할 수 있습니다. 연산자가 형식의 식에 적용 되 면 dynamic 프로그램이 실행 될 때까지 해당 확인이 지연 됩니다. 따라서 연산자를 참조 된 개체에 합법적으로 적용할 수 없는 경우 컴파일하는 동안 오류가 제공 되지 않습니다. 대신 런타임에 연산자의 확인이 실패 하면 예외가 throw 됩니다.

이는 동적 바인딩을 허용 하는 것입니다 .이는 동적바인딩에 자세히 설명 되어 있습니다.

dynamic 는 object 다음과 같은 측면에서를 제외 하 고 동일 하 게 간주 됩니다.

• 형식의 식에 대 한 작업 dynamic 은 동적으로 바인딩될 수 있습니다 (동적 바인딩).
• dynamic object 두 후보 모두에 해당 하는 경우 형식 유추 (형식 유추)를 사용 하는 것이 좋습니다.

이러한 동등성 때문에 다음이 포함 됩니다.

• 및 사이에는와 object dynamic 를 바꿀 때 동일 하 게 생성 된 형식 간에 암시적 id 변환이 있습니다 dynamic . object
• 및에서로의 암시적 변환과 명시적 변환은 object 에도 적용 dynamic 됩니다.
• 로 바꿀 때 동일 하 게 사용 되는 메서드 시그니처 dynamic object 는 동일한 서명으로 간주 됩니다.
• 런타임에서는 형식을 dynamic 구분할 수 없습니다 object .
• 형식의 식을 dynamic 동적 식 이라고 합니다.

문자열 유형

string형식은에서 직접 상속 되는 봉인 된 클래스 형식입니다 object . 클래스의 인스턴스는 string 유니코드 문자열을 나타냅니다.

형식의 값은 string 문자열 리터럴 (문자열 리터럴)로 작성할 수 있습니다.

키워드는 string 단순히 미리 정의 된 클래스에 대 한 별칭입니다 System.String .

인터페이스 형식

인터페이스는 계약을 정의합니다. 인터페이스를 구현 하는 클래스 또는 구조체는 해당 계약을 따라야 합니다. 인터페이스는 여러 기본 인터페이스에서 상속할 수 있으며, 클래스 또는 구조체는 여러 인터페이스를 구현할 수 있습니다.

인터페이스 형식은 인터페이스에 설명 되어 있습니다.

배열 형식

배열은 계산 된 인덱스를 통해 액세스 되는 0 개 이상의 변수를 포함 하는 데이터 구조입니다. 배열에 포함된 변수, 즉 배열의 요소라고도 하는 배열은 모두 같은 형식이며, 이 형식을 배열의 요소 형식이라고 합니다.

배열 형식은 배열에설명 되어 있습니다.

대리자 형식

대리자는 하나 이상의 메서드를 참조 하는 데이터 구조입니다. 인스턴스 메서드는 해당 개체 인스턴스도 참조 합니다.

C 또는 c + +에서 대리자와 가장 유사한 것은 함수 포인터 이지만 함수 포인터는 정적 함수만 참조할 수 있지만 대리자는 정적 메서드와 인스턴스 메서드를 모두 참조할 수 있습니다. 후자의 경우 대리자는 메서드 진입점에 대 한 참조 뿐만 아니라 메서드를 호출할 개체 인스턴스에 대 한 참조를 저장 합니다.

대리자 형식은 대리자에 설명 되어 있습니다.

boxing 및 unboxing

Boxing 및 unboxing의 개념은 c # 형식 시스템의 핵심입니다. Value_type 의 모든 값을 형식으로 변환할 수 있도록 허용 하 여 value_type s와 reference_type 간의 브리지를 제공 object 합니다. Boxing 및 unboxing을 사용 하면 모든 형식의 값을 궁극적으로 개체로 처리할 수 있는 형식 시스템의 통합 뷰를 사용할 수 있습니다.

Boxing 변환

Boxing 변환을 사용 하면 value_type 를 reference_type 으로 암시적으로 변환할 수 있습니다. 다음 boxing 변환이 있습니다.

• 모든 value_type object 에서 형식으로
• 모든 value_type System.ValueType 에서 형식으로
• 모든 non_nullable_value_type 에서 value_type 에 의해 구현 되는 모든 interface_type .
• 모든 nullable_type 에서 nullable_type 의 기본 형식에 의해 구현 되는 모든 interface_type .
• 모든 enum_type System.Enum 에서 형식으로
• 기본 enum_type 를 사용 하는 모든 nullable_type System.Enum 에서 형식으로
• 런타임에 형식 매개 변수에서의 암시적 변환은 값 형식에서 참조 형식으로의 변환 (형식 매개 변수를 포함 하는 암시적 변환)을 종료 하는 경우 boxing 변환으로 실행 됩니다.

Non_nullable_value_type 값을 Boxing 하는 것은 개체 인스턴스를 할당 하 고 non_nullable_value_type 값을 해당 인스턴스에 복사 하는 것으로 구성 됩니다.

Nullable_type 의 값을 Boxing 하면 null 참조 null ( HasValue 가 인 경우 false )가 반환 되 고, 그렇지 않은 경우에는 래핑 해제의 결과가 반환 되 고, 그렇지 않은 경우에는 기본 값이 boxing 됩니다.

Non_nullable_value_type 값을 boxing 하는 실제 프로세스는 다음과 같이 선언 된 것 처럼 동작 하는 일반 boxing 클래스 의 존재를 발견 하 여 설명 하는 것이 가장 좋습니다.

C#복사

 

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

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

이제 형식의 값에 대 한 Boxing은 v T 식을 실행 new Box<T>(v) 하 고 결과 인스턴스를 형식의 값으로 반환 하는 것으로 구성 됩니다 object . 따라서 문이

C#복사

 

int i = 123;
object box = i;

개념적으로 다음에 해당 합니다.

C#복사

 

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

위와 같은 boxing 클래스는 Box<T> 실제로 존재 하지 않으며 boxed 값의 동적 형식은 실제로 클래스 형식이 아닙니다. 대신 형식의 boxed 값에는 T 동적 형식이 있으며 T 연산자를 사용 하는 동적 형식 검사는 is 단순히 형식을 참조할 수 있습니다 T . 예제:

C#복사

 

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

는 콘솔에 "" 문자열을 출력 합니다 Box contains an int .

Boxing 변환은 값의 복사본을 boxed로 만드는 것을 의미 합니다. 이는 reference_type 를 형식으로 변환 하는 것과 다릅니다 object .이 값은 계속 해 서 동일한 인스턴스를 참조 하 고 간단히 파생 된 형식으로 간주 됩니다 object . 예를 들어 선언이 지정 된 경우

C#복사

 

struct Point
{
    public int x, y;

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

다음 문

C#복사

 

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

는의 할당에서 발생 하는 암시적 boxing 작업으로 인해의 값이 복사 되기 때문에는 콘솔에서 값 10을 출력 p box p 합니다. Point가 대신로 선언 된 class 경우 p 및 box 가 같은 인스턴스를 참조 하기 때문에 20 값이 출력 됩니다.

Unboxing 변환

Unboxing 변환을 사용 하면 reference_type 를 value_type 로 명시적으로 변환할 수 있습니다. 다음 unboxing 변환이 있습니다.

• 형식에서 object value_type 합니다.
• 형식에서 System.ValueType value_type 합니다.
• 모든 interface_type 에서 interface_type 를 구현 하는 non_nullable_value_type 합니다.
• 모든 interface_type 에서 내부 형식이 interface_type 를 구현 하는 모든 nullable_type .
• 형식에서 System.Enum enum_type 합니다.
• 형식에서 System.Enum 내부 enum_type 있는 모든 nullable_type 로
• 형식 매개 변수로의 명시적 변환은 런타임에 참조 형식에서 값 형식으로의 변환 (명시적 동적 변환)을 종료 하는 경우 unboxing 변환으로 실행 됩니다.

Non_nullable_value_type 에 대 한 unboxing 작업은 먼저 개체 인스턴스가 지정 된 non_nullable_value_type 의 boxing 된 값 인지 확인 한 다음 인스턴스 외부에서 값을 복사 하는 것으로 구성 됩니다.

Nullable_type 에 대 한 Unboxing은 소스 피연산자가 인 경우 nullable_type 의 null 값을 생성 하 고, 그렇지 않은 경우에는 null 개체 인스턴스를 nullable_type 의 내부 형식으로 unboxing 합니다.

이전 섹션에 설명 된 허수 boxing 클래스를 참조 하는 경우 개체를 value_type로 unboxing 변환 하는 것은 식을 실행 하는 것으로 box T 구성 됩니다 ((Box<T>)box).value . 따라서 문이

C#복사

 

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

개념적으로 다음에 해당 합니다.

C#복사

 

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

지정 된 non_nullable_value_type 에 대 한 unboxing 변환이 런타임에 성공 하려면 소스 피연산자의 값이 non_nullable_value_type boxed 값에 대 한 참조 여야 합니다. 소스 피연산자가 인 경우 null System.NullReferenceException 이 throw 됩니다. 소스 피연산자가 호환 되지 않는 개체에 대 한 참조 이면 System.InvalidCastException 이 throw 됩니다.

지정 된 nullable_type 에 대 한 unboxing 변환이 런타임에 성공 하려면 소스 피연산자의 값이 null nullable_type 의 기본 non_nullable_value_type boxed 값에 대 한 참조 여야 합니다. 소스 피연산자가 호환 되지 않는 개체에 대 한 참조 이면 System.InvalidCastException 이 throw 됩니다.

생성 된 형식

제네릭 형식 선언은 *형식 인수* 를 적용 하 여 다양 한 형식을 형성 하는 "청사진"으로 사용 되는 *바인딩되지 않은 제네릭 형식 를 나타냅니다.. 형식 인수는 < > 제네릭 형식의 이름 바로 뒤에 오는 꺾쇠 괄호 (및) 내에 기록 됩니다. 하나 이상의 형식 인수를 포함 하는 형식을 *생성 된 형식* 이라고 합니다. 생성 된 형식은 형식 이름이 표시 될 수 있는 언어의 대부분의 위치에서 사용할 수 있습니다. 바인딩되지 않은 제네릭 형식은 _typeof_expression * (typeof 연산자) 내 에서만 사용할 수 있습니다.

생성 된 형식은 식에서단순한 이름으로사용 되거나 멤버 (멤버 액세스)에 액세스할 때 사용 될 수도 있습니다.

Namespace_or_type_name 를 평가 하는 경우 올바른 수의 형식 매개 변수가 있는 제네릭 형식만 고려 됩니다. 따라서 형식이 다른 형식의 매개 변수를 사용 하는 경우 동일한 식별자를 사용 하 여 서로 다른 형식을 식별할 수 있습니다. 이는 동일한 프로그램에서 제네릭 및 비 제네릭 클래스를 혼합할 때 유용 합니다.

C#복사

 

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 는 형식 매개 변수를 직접 지정 하지 않더라도 생성 된 형식을 식별할 수 있습니다. 이는 제네릭 클래스 선언 내에서 형식이 중첩 되 고 포함 선언의 인스턴스 형식이 이름 조회에 암시적으로 사용 되는 경우 (제네릭 클래스의 중첩 형식) 발생할 수 있습니다.

C#복사

 

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

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

안전 하지 않은 코드에서는 생성 된 형식을 unmanaged_type (포인터 형식)로 사용할 수 없습니다.

형식 인수

형식 인수 목록의 각 인수는 단순한 형식 입니다.

antlr복사

 

type_argument_list
    : '<' type_arguments '>'
    ;

type_arguments
    : type_argument (',' type_argument)*
    ;

type_argument
    : type
    ;

안전 하지 않은 코드 (안전 하지 않은 코드)에서는 type_argument 포인터 형식이 될 수 없습니다. 각 형식 인수는 해당 형식 매개 변수 (형식 매개 변수 제약 조건)에 대 한 제약 조건을 충족 해야 합니다.

Open 및 closed 형식

모든 형식은 *open types _ 또는 _ 폐쇄형 유형 *으로 분류 될 수 있습니다. 개방형 형식은 형식 매개 변수를 포함 하는 형식입니다. 더 구체적으로 살펴보면 다음과 같습니다.

• 형식 매개 변수는 개방형 형식을 정의 합니다.
• 배열 형식은 요소 형식이 개방형 형식인 경우에만 개방형 형식입니다.
• 생성 된 형식은 해당 형식 인수 중 하나 이상이 개방형 형식인 경우에만 개방형 형식입니다. 생성 된 중첩 형식은 해당 형식 인수 중 하나 이상이 나 포함 하는 형식의 형식 인수가 개방형 형식인 경우에만 개방형 형식입니다.

폐쇄형 형식은 개방형 형식이 아닌 형식입니다.

런타임에 제네릭 형식 선언 내의 모든 코드는 제네릭 선언에 형식 인수를 적용 하 여 만든 폐쇄형 생성 형식의 컨텍스트에서 실행 됩니다. 제네릭 형식 내의 각 형식 매개 변수는 특정 런타임 형식에 바인딩됩니다. 모든 문과 식의 런타임 처리는 항상 폐쇄형 형식으로 발생 하며, 개방형 형식은 컴파일 시간 처리 중에만 발생 합니다.

폐쇄형 생성 된 각 형식에는 다른 폐쇄형 생성 형식과 공유 되지 않는 고유한 정적 변수 집합이 있습니다. 런타임에는 개방형 형식이 없으므로 개방형 형식과 연결 된 정적 변수는 없습니다. 두 폐쇄형 생성 형식은 동일한 바인딩되지 않은 제네릭 형식에서 생성 된 경우 동일한 형식이 고 해당 형식 인수는 동일한 형식입니다.

바인딩된 형식 및 바인딩되지 않은 형식

* 바인딩되지 않은 형식 _ 이란 용어는 제네릭이 아닌 형식이 나 바인딩되지 않은 제네릭 형식을 참조 합니다. _ Bound 형식* 이라는 용어는 제네릭이 아닌 형식이 나 생성 된 형식을 나타냅니다.

바인딩되지 않은 형식은 형식 선언에 의해 선언 된 엔터티를 참조 합니다. 바인딩되지 않은 제네릭 형식은 자체가 형식이 아니므로 변수, 인수 또는 반환 값의 형식 또는 기본 형식으로 사용할 수 없습니다. 바인딩되지 않은 제네릭 형식을 참조할 수 있는 유일한 구문은 typeof 식 (typeof 연산자)입니다.

만족 제약 조건

생성 된 형식 또는 제네릭 메서드가 참조 될 때마다 제공 된 형식 인수는 제네릭 형식 또는 메서드 (형식 매개 변수 제약 조건)에 선언 된 형식 매개 변수 제약 조건에 대해 검사 됩니다. 각 절에 대해 where A 명명 된 형식 매개 변수에 해당 하는 형식 인수는 각 제약 조건에 대해 다음과 같이 확인 됩니다.

• 제약 조건이 클래스 형식, 인터페이스 형식 또는 형식 매개 변수인 경우 제공 된 형식 인수를 사용 하 여 제약 조건 C 에 표시 되는 형식 매개 변수에 대해 대체 된 제약 조건을 나타냅니다. 제약 조건을 충족 하려면 형식이 A 다음 중 하나를 통해 형식으로 변환 될 수 있어야 합니다 C .
  • Id 변환 (id 변환)
  • 암시적 참조 변환 (암시적 참조 변환)
  • 형식 A가 null을 허용 하지 않는 값 형식인 경우 boxing 변환 (boxing 변환)입니다.
  • 형식 매개 변수에서로의 암시적 참조, boxing 또는 형식 매개 변수 변환 A C 입니다.
• 제약 조건이 참조 형식 제약 조건 () 이면 class 형식은 A 다음 중 하나를 충족 해야 합니다.
  • A 는 인터페이스 형식, 클래스 형식, 대리자 형식 또는 배열 형식입니다. 및는 System.ValueType System.Enum 이 제약 조건을 충족 하는 참조 형식입니다.
  • A 는 참조 형식 (형식 매개 변수 제약 조건)으로 알려진 형식 매개 변수입니다.
• 제약 조건이 값 형식 제약 조건 () 이면 struct 형식은 A 다음 중 하나를 충족 해야 합니다.
  • A 는 구조체 형식 또는 열거형 형식 이지만 nullable 형식이 아닙니다. 및는 System.ValueType System.Enum 이 제약 조건을 충족 하지 않는 참조 형식입니다.
  • A 값 형식 제약 조건 (형식 매개 변수 제약조건)을 포함 하는 형식 매개 변수입니다.
• 제약 조건이 생성자 제약 조건이 면 형식은이 아니어야 new() A abstract 하며 매개 변수가 없는 public 생성자가 있어야 합니다. 다음 조건 중 하나에 해당 하는 경우이 문제가 충족 됩니다.
  • A 모든 값 형식에는 공용 기본 생성자 (기본 생성자)가 있기 때문에은 값 형식입니다.
  • A 생성자 제약 조건 (형식 매개 변수 제약 조건)을 포함 하는 형식 매개 변수입니다.
  • A 값 형식 제약 조건 (형식 매개 변수 제약조건)을 포함 하는 형식 매개 변수입니다.
  • A 가이 아니고 abstract 매개 변수 없이 명시적으로 선언 된 생성자를 포함 하는 클래스입니다 public .
  • A 가이 아니고 abstract 기본 생성자 (기본생성자)가 있는 경우

지정 된 형식 인수에서 하나 이상의 형식 매개 변수 제약 조건이 충족 되지 않으면 컴파일 시간 오류가 발생 합니다.

형식 매개 변수는 상속 되지 않으므로 제약 조건은 상속 되지 않습니다. 아래 예제에서는가 D T T 기본 클래스에서 적용 되는 제약 조건을 충족 하도록 해당 형식 매개 변수에 대 한 제약 조건을 지정 해야 B<T> 합니다. 반면, 클래스는 E 에 대해를 구현 하므로 제약 조건을 지정할 필요가 없습니다 List<T> IEnumerable T .

C#복사

 

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

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

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

형식 매개 변수

형식 매개 변수는 런타임에 매개 변수가 바인딩되는 값 형식 또는 참조 형식을 지정 하는 식별자입니다.

antlr복사

 

type_parameter
    : identifier
    ;

형식 매개 변수는 다양 한 실제 형식 인수를 사용 하 여 인스턴스화할 수 있으므로 형식 매개 변수에는 다른 형식과는 약간 다른 작업과 제한이 있습니다. 여기에는 다음이 포함됩니다.

• 형식 매개 변수를 직접 사용 하 여 기본 클래스 (기본 클래스) 또는 인터페이스 (Variant 형식 매개 변수 목록)를 선언할 수 없습니다.
• 형식 매개 변수에 대 한 멤버 조회 규칙은 형식 매개 변수에 적용 되는 제약 조건 (있는 경우)에 따라 달라 집니다. 멤버 조회에 자세히 설명 되어 있습니다.
• 형식 매개 변수에 사용 가능한 변환은 형식 매개 변수에 적용 되는 제약 조건 (있는 경우)에 따라 달라 집니다. 형식 매개 변수 및 명시적 동적 변환과관련 된 암시적 변환에 자세히 설명 되어 있습니다.
• 형식 매개 변수가 null 참조 형식 (형식 매개 변수와 관련 된 암시적 변환) 이라고 알려진 경우를 제외 하 고는 형식 매개 변수에 지정 된 형식으로 리터럴을 변환할 수 없습니다. 그러나 default 식 (기본값 식)을 대신 사용할 수 있습니다. 또한 형식 매개 변수에서 값 형식 제약 조건을 사용 하지 않는 한, 형식 매개 변수에 지정 된 형식의 값을 null == 및 != (참조 형식 같음 연산자)를 사용 하 여 비교할 수 있습니다.
• new형식 매개 변수가 constructor_constraint 또는 값 형식 제약 조건 (형식 매개 변수 제약조건)에 의해 제한 되는 경우에만 식 (개체 생성 식)을 형식 매개 변수와 함께 사용할 수 있습니다.
• 특성 내에서 형식 매개 변수를 사용할 수 없습니다.
• 멤버 액세스 (멤버 액세스) 또는 형식 이름 (네임 스페이스 및 형식 이름)에서 형식 매개 변수를 사용 하 여 정적 멤버나 중첩 형식을 식별할 수 없습니다.
• 안전 하지 않은 코드에서 형식 매개 변수는 unmanaged_type (포인터 형식)로 사용할 수 없습니다.

형식으로 형식 매개 변수는 순수 컴파일 시간 구문입니다. 런타임에 각 형식 매개 변수는 제네릭 형식 선언에 형식 인수를 제공 하 여 지정 된 런타임 형식에 바인딩됩니다. 따라서 형식 매개 변수를 사용 하 여 선언 된 변수의 형식은 런타임에 폐쇄형 생성 형식 (개방형 및 폐쇄형 형식)이 됩니다. 형식 매개 변수를 포함 하는 모든 문과 식의 런타임 실행에서는 해당 매개 변수에 대 한 형식 인수로 제공 된 실제 형식을 사용 합니다.

식 트리 형식

*식 트리 _는 람다 식을 실행 코드 대신 데이터 구조로 표현할 수 있도록 허용 합니다. 식 트리는 형식의 _ 식 트리 형식* 값입니다 System.Linq.Expressions.Expression<D> D . 여기서는 대리자 형식입니다. 이 사양의 나머지 부분에서는 약어를 사용 하 여 이러한 형식을 참조 합니다 Expression<D> .

람다 식에서 대리자 형식으로의 변환이 있는 경우 D 식 트리 형식에 대 한 변환도 있습니다 Expression<D> . 람다 식을 대리자 형식으로 변환 하는 경우 람다 식의 실행 코드를 참조 하는 대리자를 생성 합니다. 식 트리 형식으로 변환 하면 람다 식의 식 트리 표현이 생성 됩니다.

식 트리는 람다 식의 효율적인 메모리 내 데이터 표현 이며 람다 식의 구조를 투명 하 고 명시적으로 만듭니다.

대리자 형식과 마찬가지로에는 D 와 Expression<D> 동일한 매개 변수 및 반환 형식이 있다고 D 합니다.

다음 예제에서는 람다 식을 실행 코드와 식 트리로 나타냅니다. 에 대 한 변환이 존재 하기 때문에 Func<int,int> 다음과 같은 변환도 있습니다 Expression<Func<int,int>> .

C#복사

 

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

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

이러한 할당을 수행 하면 대리자는 del 을 반환 하는 메서드를 참조 x + 1 하 고 식 트리는 exp 식을 설명 하는 데이터 구조를 참조 합니다 x => x + 1 .

Expression<D>람다 식이 식 트리 형식으로 변환 될 때 식 트리를 생성 하는 정확한 규칙 뿐만 아니라 제네릭 형식의 정확한 정의는 모두이 사양의 범위를 벗어납니다.

명시적으로 수행 하는 두 가지 중요 한 사항은 다음과 같습니다.

• 모든 람다 식을 식 트리로 변환할 수 있는 것은 아닙니다. 예를 들어, 문 본문이 있는 람다 식과 대입 식을 포함 하는 람다 식은 표현할 수 없습니다. 이러한 경우 변환은 여전히 존재 하지만 컴파일 시간에는 실패 합니다. 이러한 예외는 익명 함수 변환에 자세히 설명 되어 있습니다.
• Expression<D>``Compile형식의 대리자를 생성 하는 인스턴스 메서드를 제공 합니다 D .

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

  이 대리자를 호출 하면 식 트리로 표시 되는 코드가 실행 됩니다. 따라서 위의 정의를 사용할 경우 del과 del2는 동일 하 고 다음 두 문은 동일한 결과를 발생 시킬 수 있습니다.

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

  이 코드를 실행 한 후 및에는 i1 i2 모두 값이 2 있습니다.
• C#복사
   
• C#복사