System.String 생성자

아티클
01/31/2024

이 문서에서는 이 API에 대한 참조 설명서에 대한 추가 설명서를 제공합니다.

오버로드된 생성자 구문

문자열 생성자는 포인터 매개 변수가 없는 범주와 포인터 매개 변수가 있는 범주의 두 가지 범주로 구분됩니다. 포인터를 사용하는 생성자는 CLS 규격이 아닙니다. 또한 Visual Basic은 포인터 사용을 지원하지 않으며 C#에는 안전하지 않은 컨텍스트에서 실행하기 위해 포인터를 사용하는 코드가 필요합니다. 자세한 내용은 unsafe를 참조하세요.

오버로드를 선택하는 방법에 대한 추가 지침은 어떤 메서드를 호출하나요?를 참조하세요.

String(Char[] value)
유니코드 문자 배열로 표시되는 값으로 새 인스턴스를 초기화합니다. 이 생성자는 유니코드 문자를 복사합니다(예제 2: 문자 배열 사용).

String(Char[] value, Int32 startIndex, Int32 length)
유니코드 문자 배열, 해당 배열 내의 시작 문자 위치 및 길이로 표시된 값으로 새 인스턴스를 초기화합니다(예 3: 문자 배열의 일부를 사용하고 단일 문자를 반복).

String(Char c, Int32 count)
지정된 유니코드 문자가 지정된 횟수만큼 반복되는 값으로 새 인스턴스를 초기화합니다(예 3: 문자 배열의 일부 사용 및 단일 문자 반복).

String(char* value)
(CLS 규격 아님) null 문자(U+0000 또는 '\0')로 종료되는 유니코드 문자 배열에 대한 포인터로 표시되는 값으로 새 인스턴스를 초기화합니다. (예제 4: 문자 배열에 대한 포인터 사용).

권한: SecurityCriticalAttribute즉시 호출자에 대한 완전 신뢰가 필요합니다. 이 멤버는 부분적으로 신뢰할 수 있는 또는 투명 코드에서 사용할 수 없습니다.

String(char* value, Int32 startIndex, Int32 length)
(CLS 규격 아님) 유니코드 문자 배열, 해당 배열 내의 시작 문자 위치 및 길이에 대한 포인터로 표시되는 값으로 새 인스턴스를 초기화합니다. 생성자는 인덱스에서 시작하여 인덱length + startIndexstartIndex스 - 1에서 value 끝나는 유니코드 문자를 복사합니다(예 5: 포인터 및 배열 범위에서 문자열 인스턴스화).

권한: SecurityCriticalAttribute즉시 호출자에 대한 완전 신뢰가 필요합니다. 이 멤버는 부분적으로 신뢰할 수 있는 또는 투명 코드에서 사용할 수 없습니다.

String(SByte* value)
(CLS 규격 아님) 새 인스턴스를 8비트 부가 정수 배열에 대한 포인터로 표시된 값으로 초기화합니다. 배열은 현재 시스템 코드 페이지(즉, 지정된 인코딩)를 사용하여 인코딩된 Encoding.Default문자열을 나타내는 것으로 간주됩니다. 생성자는 포인터가 value 지정한 위치에서 시작하여 null 문자(0x00)에 도달할 때까지 문자를 처리합니다(예 6: 포인터에서 부호 있는 바이트 배열로 문자열 인스턴스화).

권한: SecurityCriticalAttribute즉시 호출자에 대한 완전 신뢰가 필요합니다. 이 멤버는 부분적으로 신뢰할 수 있는 또는 투명 코드에서 사용할 수 없습니다.

String(SByte* value, Int32 startIndex, Int32 length)
(CLS 규격 아님) 새 인스턴스를 8비트 부가 정수의 배열, 해당 배열 내의 시작 위치 및 길이에 대한 포인터로 표시된 값으로 초기화합니다. 배열은 현재 시스템 코드 페이지(즉, 지정된 인코딩)를 사용하여 인코딩된 Encoding.Default문자열을 나타내는 것으로 간주됩니다. 생성자는 -1에서 startIndex 시작하여 끝나는 startIndexlength + 값의 문자를 처리합니다(예 6: 포인터에서 부호 있는 바이트 배열로 문자열 인스턴스화).

권한: SecurityCriticalAttribute즉시 호출자에 대한 완전 신뢰가 필요합니다. 이 멤버는 부분적으로 신뢰할 수 있는 또는 투명 코드에서 사용할 수 없습니다.

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(CLS 규격 아님) 새 인스턴스를 8비트 부가 정수의 배열, 해당 배열 내의 시작 위치, 길이 및 Encoding 개체에 대한 포인터로 표시된 값으로 초기화합니다.

권한: SecurityCriticalAttribute즉시 호출자에 대한 완전 신뢰가 필요합니다. 이 멤버는 부분적으로 신뢰할 수 있는 또는 투명 코드에서 사용할 수 없습니다.

매개 변수

다음은 포인터 매개 변수를 포함하지 않는 생성자가 사용하는 String 매개 변수의 전체 목록입니다. 각 오버로드에서 사용되는 매개 변수는 위의 오버로드 구문을 참조하세요.

매개 변수	형식	설명
`value`	Char[]	유니코드 문자 배열입니다.
`c`	Char	유니코드 문자입니다.
`startIndex`	Int32	새 문자열의 `value` 첫 번째 문자에서 시작 위치입니다. 기본값: 0
`length`	Int32	새 문자열에 `value` 포함할 문자 수입니다. 기본값: Array.Length
`count`	Int32	새 문자열에서 문자 `c` 가 반복되는 횟수입니다. 0이면 `count` 새 개체의 값은 .입니다 String.Empty.

다음은 포인터 매개 변수를 포함하는 생성자가 사용하는 String 매개 변수의 전체 목록입니다. 각 오버로드에서 사용되는 매개 변수는 위의 오버로드 구문을 참조하세요.

매개 변수	형식	설명
`value`	Char* 또는 SByte*	Null로 끝나는 유니코드 문자 배열 또는 부호 있는 8비트 정수 배열에 대한 포인터입니다. 배열이거나 `null` 빈 배열인 경우 `value` 새 문자열의 값은 .입니다String.Empty.
`startIndex`	Int32	새 문자열의 첫 번째 문자를 정의하는 배열 요소의 인덱스입니다. 기본값: 0
`length`	Int32	새 문자열을 만드는 데 사용할 배열 요소의 수입니다. 길이가 0이면 생성자는 값 String.Empty이 .인 문자열을 만듭니다. 기본값: Array.Length
`enc`	Encoding	배열을 인코딩하는 방법을 `value` 지정하는 개체입니다. 기본값: Encoding.Default또는 시스템의 현재 ANSI 코드 페이지

예외

다음은 포인터 매개 변수를 포함하지 않는 생성자가 throw한 예외 목록입니다.

예외	조건	throw자:
ArgumentNullException	`value`은 `null`입니다.	String(Char[], Int32, Int32)
ArgumentOutOfRangeException	`startIndex`,`length`, 또는 `count` 0보다 작습니다. 또는 `startIndex`와 `length`의 합계가 `value`의 요소 수보다 큽니다. 또는 `count`가 0보다 작습니다.	String(Char, Int32) String(Char[], Int32, Int32)

다음은 포인터 매개 변수를 포함하는 생성자가 throw한 예외 목록입니다.

예외	조건	throw자:
ArgumentException	`value` 은 잘못된 유니코드 문자를 포함하는 배열을 지정합니다. 또는 `value` 또는 `value` + `startIndex` 64K 미만의 주소를 지정합니다. 또는 기본 코드 페이지 인코딩을 `value` 사용하지 않으므로 바이트 배열 `value` 에서 새 String 인스턴스를 초기화할 수 없습니다.	포인터가 있는 모든 생성자입니다.
ArgumentNullException	`value`가 null입니다.	String(SByte) String(SByte, Int32, Int32) String(SByte*, Int32, Int32, Encoding)
ArgumentOutOfRangeException	현재 프로세스에 주소가 지정된 모든 문자에 대한 읽기 액세스 권한이 있는 것은 아닙니다. 또는 `startIndex` 또는 `length`가 0보다 작거나 `value` + `startIndex`로 인해 포인터 오버플로가 발생하거나, 현재 프로세스에서 주소가 지정된 모든 문자에 대한 읽기 액세스 권한을 갖지는 않습니다. 또는 새 문자열의 길이가 너무 커서 할당할 수 없습니다.	포인터가 있는 모든 생성자입니다.
AccessViolationException	`value`또는 `value` + + `startIndexlength` - 1은 잘못된 주소를 지정합니다.	String(SByte) String(SByte, Int32, Int32) String(SByte*, Int32, Int32, Encoding)

어떤 메서드를 호출합니까?

To	통화 또는 사용
문자열을 만듭니다.	문자열 리터럴 또는 기존 문자열에서 할당(예제 1: 문자열 할당 사용)
전체 문자 배열에서 문자열을 만듭니다.	String(Char[]) (예제 2: 문자 배열 사용)
문자 배열의 일부에서 문자열을 만듭니다.	String(Char[], Int32, Int32) (예제 3: 문자 배열의 일부를 사용하고 단일 문자를 반복)
동일한 문자를 여러 번 반복하는 문자열을 만듭니다.	String(Char, Int32) (예제 3: 문자 배열의 일부를 사용하고 단일 문자를 반복)
포인터에서 유니코드 또는 와이드 문자 배열에 대한 문자열을 만듭니다.	String(Char*)
포인터를 사용하여 유니코드 또는 와이드 문자 배열의 일부에서 문자열을 만듭니다.	String(Char*, Int32, Int32)
C++ `char` 배열에서 문자열을 만듭니다.	String(SByte), String(SByte, Int32, Int32) 또는 String(SByte*, Int32, Int32, Encoding)
ASCII 문자에서 문자열을 만듭니다.	ASCIIEncoding.GetString

문자열 만들기

프로그래밍 방식으로 문자열을 만드는 데 가장 일반적으로 사용되는 기술은 예제 1에 설명된 것처럼 간단한 할당입니다. 클래스에는 String 다음 값에서 문자열을 만들 수 있는 4가지 유형의 생성자 오버로드도 포함됩니다.

문자 배열에서(UTF-16으로 인코딩된 문자의 배열) 전체 배열의 문자 또는 일부에서 새 String 개체를 만들 수 있습니다. String(Char[]) 생성자는 배열의 모든 문자를 새 문자열에 복사합니다. String(Char[], Int32, Int32) 생성자는 인덱스에서 인덱 + startIndexstartIndexlength 스로 문자를 복사합니다. - 1을 새 문자열로 복사합니다. 0이면 length 새 문자열의 값은 .입니다 String.Empty.

코드 반복적으로 동일한 값이 있는 문자열을 인스턴스화하는 경우 문자열을 작성 하는 대체 방법을 사용 하 여 애플리케이션 성능을 개선할 수 있습니다. 자세한 내용은 반복 문자열 처리를 참조 하세요.
생성자를 사용하여 0, 1회 이상 중복된 단일 문자에서 String(Char, Int32) 0이면 count 새 문자열의 값은 .입니다 String.Empty.
포인터에서 null로 끝나는 문자 배열에 대한 포인터에서 또는 String(Char*, Int32, Int32) 생성자를 사용합니다String(Char*). 전체 배열 또는 지정된 범위를 사용하여 문자열을 초기화할 수 있습니다. 생성자는 지정한 포인터 또는 지정한 포인터에서 startIndex 시작하여 배열의 끝이나 length 문자에 대한 유니코드 문자 시퀀스를 복사합니다. null 포인터이거나 length 0인 경우 value 생성자는 값String.Empty이 .인 문자열을 만듭니다. 복사 작업이 배열의 끝으로 진행되고 배열이 null로 종료되지 않은 경우 생성자 동작은 시스템에 종속됩니다. 이러한 조건으로 인해 액세스 위반이 발생할 수 있습니다.

배열에 포함된 null 문자(U+0000 또는 '\0')가 포함되어 있고 String(Char*, Int32, Int32) 오버로드가 호출되는 경우 문자열 인스턴스에는 포함된 null을 length 포함한 문자가 포함됩니다. 다음 예제에서는 두 개의 null 문자를 포함하는 10개 요소의 배열에 대한 포인터가 메서드에 String(Char*, Int32, Int32) 전달될 때 발생하는 작업을 보여줍니다. 주소는 배열의 시작 부분이며 배열의 모든 요소를 문자열에 추가해야 하므로 생성자는 포함된 null 2개를 포함하여 10자로 문자열을 인스턴스화합니다. 반면, 동일한 배열이 생성자에 전달 String(Char*) 되는 경우 결과는 첫 번째 null 문자를 포함하지 않는 4자 문자열입니다.
```
using System;

public class Example2
{
   public unsafe static void Main()
   {
      char[] chars = { 'a', 'b', 'c', 'd', '\0', 'A', 'B', 'C', 'D', '\0' };
      string s = null;
      
      fixed(char* chPtr = chars) {
         s = new string(chPtr, 0, chars.Length);            
      } 

      foreach (var ch in s)
         Console.Write($"{(ushort)ch:X4} ");
      Console.WriteLine();
      
      fixed(char* chPtr = chars) {
         s = new string(chPtr);         
      }
      
      foreach (var ch in s)
         Console.Write($"{(ushort)ch:X4} ");
      Console.WriteLine();    
   }
}
// The example displays the following output:
//       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
//       0061 0062 0063 0064
```
```
#nowarn "9"
open System

let chars = [| 'a'; 'b'; 'c'; 'd'; '\000'; 'A'; 'B'; 'C'; 'D'; '\000' |]
let s =
    use chPtr = fixed chars
    String(chPtr, 0, chars.Length)

for ch in s do
    printf $"{uint16 ch:X4} "
printfn ""

let s2 = 
    use chPtr = fixed chars
    String chPtr    

for ch in s2 do
    printf $"{uint16 ch:X4} "
printfn ""  
// The example displays the following output:
//       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
//       0061 0062 0063 0064
```
배열에는 유니코드 문자가 포함되어야 합니다. C++에서는 문자 배열을 관리 Char되는 [] 형식 또는 관리wchar_t되지 않는[] 형식으로 정의해야 합니다.

오버로드가 String(Char*) 호출되고 배열이 null로 종료되지 않거나 오버로드가 호출되고 startIndex + length-1에 문자 시퀀스에 할당된 메모리 외부의 범위가 포함된 경우 String(Char*, Int32, Int32) 생성자의 동작은 시스템에 따라 달라지며 액세스 위반이 발생할 수 있습니다.
포인터에서 서명된 바이트 배열에 대한 포인터입니다. 전체 배열 또는 지정된 범위를 사용하여 문자열을 초기화할 수 있습니다. 기본 코드 페이지 인코딩을 사용하여 바이트 시퀀스를 해석하거나 생성자 호출에서 인코딩을 지정할 수 있습니다. 생성자가 null로 종료되지 않은 전체 배열에서 문자열을 인스턴스화하려고 하거나 배열 범위가 -1에서 value + startIndex -1까지 + value + startIndexlength의 범위가 배열에 할당된 메모리 외부에 있는 경우 이 생성자의 동작은 시스템에 종속되며 액세스 위반이 발생할 수 있습니다.

부호 있는 바이트 배열을 매개 변수로 포함하는 세 개의 생성자는 이 예제와 같이 주로 C++ char 배열을 문자열로 변환하도록 설계되었습니다.
```
using namespace System;

void main()
{
      char chars[] = { 'a', 'b', 'c', 'd', '\x00' };
      
      char* charPtr = chars;
      String^ value = gcnew String(charPtr);

      Console::WriteLine(value);
}
// The example displays the following output:
//      abcd
```
배열에 값이 0이고 String(SByte*, Int32, Int32) 오버로드가 호출되는 null 문자('\0') 또는 바이트가 포함된 경우 문자열 인스턴스에는 포함된 null이 포함된 문자가 포함 length 됩니다. 다음 예제에서는 두 개의 null 문자를 포함하는 10개 요소의 배열에 대한 포인터가 메서드에 String(SByte*, Int32, Int32) 전달될 때 발생하는 작업을 보여줍니다. 주소는 배열의 시작 부분이며 배열의 모든 요소를 문자열에 추가해야 하므로 생성자는 포함된 null 2개를 포함하여 10자로 문자열을 인스턴스화합니다. 반면, 동일한 배열이 생성자에 전달 String(SByte*) 되는 경우 결과는 첫 번째 null 문자를 포함하지 않는 4자 문자열입니다.
```
using System;

public class Example5
{
   public unsafe static void Main()
   {
      sbyte[] bytes = { 0x61, 0x62, 0x063, 0x064, 0x00, 0x41, 0x42, 0x43, 0x44, 0x00 };
      
      string s = null;
      fixed (sbyte* bytePtr = bytes) {
         s = new string(bytePtr, 0, bytes.Length);
      }
      
      foreach (var ch in s)
         Console.Write($"{(ushort)ch:X4} ");
      
      Console.WriteLine();    

      fixed(sbyte* bytePtr = bytes) {
         s = new string(bytePtr);         
      }
      
      foreach (var ch in s)
         Console.Write($"{(ushort)ch:X4} ");
      Console.WriteLine();    
   }
}
// The example displays the following output:
//       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
//       0061 0062 0063 0064
```
```
#nowarn "9"
open System

let bytes = 
    [| 0x61y; 0x62y; 0x063y; 0x064y; 0x00y; 0x41y; 0x42y; 0x43y; 0x44y; 0x00y |]

let s =
    use bytePtr = fixed bytes
    String(bytePtr, 0, bytes.Length)

for ch in s do
    printf $"{uint16 ch:X4} "
printfn ""

let s2 =
    use bytePtr = fixed bytes
    String bytePtr         

for ch in s do
    printf $"{uint16 ch:X4} "
printfn ""
// The example displays the following output:
//       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
//       0061 0062 0063 0064
```
String(SByte*) 및 String(SByte*, Int32, Int32) 생성자는 기본 ANSI 코드 페이지를 사용하여 해석 value 하기 때문에 바이트 배열이 동일한 이러한 생성자를 호출하면 다른 시스템에서 값이 다른 문자열을 만들 수 있습니다.

반복 문자열 처리

텍스트 스트림을 구문 분석하거나 디코딩하는 앱은 종종 생성자 또는 StringBuilder.Append(Char[], Int32, Int32) 메서드를 사용하여 String(Char[], Int32, Int32) 문자 시퀀스를 문자열로 변환합니다. 하나의 문자열을 만들고 다시 사용하는 대신 동일한 값으로 새 문자열을 반복적으로 만들면 메모리가 낭비됩니다. 생성자를 호출 String(Char[], Int32, Int32) 하여 동일한 문자열 값을 반복적으로 만들 가능성이 있는 경우 동일한 문자열 값이 무엇인지 미리 모르는 경우에도 대신 조회 테이블을 사용할 수 있습니다.

예를 들어 XML 태그 및 특성이 포함된 파일에서 문자 스트림을 읽고 구문 분석한다고 가정합니다. 스트림을 구문 분석할 때 특정 토큰(즉, 기호적 의미가 있는 문자 시퀀스)이 반복적으로 발생합니다. "0", "1", "true" 및 "false" 문자열에 해당하는 토큰은 XML 스트림에서 자주 발생할 수 있습니다.

각 토큰을 새 문자열로 변환하는 대신 일반적으로 발생하는 문자열을 System.Xml.NameTable 저장할 개체를 만들 수 있습니다. 개체는 NameTable 임시 메모리를 할당하지 않고 저장된 문자열을 검색하기 때문에 성능을 향상시킵니다. 토큰이 발견되면 메서드를 NameTable.Get(Char[], Int32, Int32) 사용하여 테이블에서 토큰을 검색합니다. 토큰이 있는 경우 메서드는 해당 문자열을 반환합니다. 토큰이 없으면 메서드를 NameTable.Add(Char[], Int32, Int32) 사용하여 테이블에 토큰을 삽입하고 해당 문자열을 가져옵니다.

예제 1: 문자열 할당 사용

다음 예제에서는 문자열 리터럴을 할당하여 새 문자열을 만듭니다. 첫 번째 문자열의 값을 할당하여 두 번째 문자열을 만듭니다. 다음은 새 String 개체를 인스턴스화하는 가장 일반적인 두 가지 방법입니다.

using System;

public class Example3
{
   public static void Main()
   {
      String value1 = "This is a string.";
      String value2 = value1;
      Console.WriteLine(value1);
      Console.WriteLine(value2);
   }
}
// The example displays the following output:
//    This is a string.
//    This is a string.

let value1 = "This is a string."
let value2 = value1
printfn "%s" value1
printfn "%s" value2
// The example displays the following output:
//    This is a string.
//    This is a string.

Module Example
   Public Sub Main()
      Dim value1 As String = "This is a string."
      Dim value2 As String = value1
      Console.WriteLine(value1)
      Console.WriteLine(value2)
   End Sub
End Module
' The example displays the following output:
'    This is a string.
'    This is a string.

예제 2: 문자 배열 사용

다음 예제에서는 문자 배열에서 새 String 개체를 만드는 방법을 보여 줍니다.

// Unicode Mathematical operators
char [] charArr1 = {'\u2200','\u2202','\u200F','\u2205'};
String szMathSymbols = new String(charArr1);

// Unicode Letterlike Symbols
char [] charArr2 = {'\u2111','\u2118','\u2122','\u2126'};
String szLetterLike = new String (charArr2);

// Compare Strings - the result is false
Console.WriteLine("The Strings are equal? " +
    (String.Compare(szMathSymbols, szLetterLike)==0?"true":"false") );

// Unicode Mathematical operators
let charArr1 = [| '\u2200'; '\u2202'; '\u200F'; '\u2205' |]
let szMathSymbols = String charArr1

// Unicode Letterlike Symbols
let charArr2 = [| '\u2111'; '\u2118'; '\u2122'; '\u2126' |]
let szLetterLike = String charArr2

// Compare Strings - the result is false
printfn $"The Strings are equal? %b{String.Compare(szMathSymbols, szLetterLike) = 0}"

' Unicode Mathematical operators
Dim charArr1() As Char = {ChrW(&H2200), ChrW(&H2202), _
                          ChrW(&H200F), ChrW(&H2205)}
Dim szMathSymbols As New String(charArr1)

' Unicode Letterlike Symbols
Dim charArr2() As Char = {ChrW(&H2111), ChrW(&H2118), _
                          ChrW(&H2122), ChrW(&H2126)}
Dim szLetterLike As New String(charArr2)

' Compare Strings - the result is false
Console.WriteLine("The strings are equal? " & _
        CStr(szMathSymbols.Equals(szLetterLike)))

예제 3: 문자 배열의 일부를 사용하고 단일 문자를 반복합니다.

다음 예제에서는 문자 배열의 일부에서 새 String 개체를 만드는 방법과 단일 문자가 여러 번 나타나는 새 String 개체를 만드는 방법을 보여 줍니다.

// Create a Unicode String with 5 Greek Alpha characters
String szGreekAlpha = new String('\u0391',5);
// Create a Unicode String with a Greek Omega character
String szGreekOmega = new String(new char [] {'\u03A9','\u03A9','\u03A9'},2,1);

String szGreekLetters = String.Concat(szGreekOmega, szGreekAlpha, szGreekOmega.Clone());

// Examine the result
Console.WriteLine(szGreekLetters);

// The first index of Alpha
int ialpha = szGreekLetters.IndexOf('\u0391');
// The last index of Omega
int iomega = szGreekLetters.LastIndexOf('\u03A9');

Console.WriteLine("The Greek letter Alpha first appears at index " + ialpha +
    " and Omega last appears at index " + iomega + " in this String.");

// Create a Unicode String with 5 Greek Alpha characters
let szGreekAlpha = String('\u0391',5)
// Create a Unicode String with a Greek Omega character
let szGreekOmega = String([| '\u03A9'; '\u03A9'; '\u03A9' |],2,1)

let szGreekLetters = String.Concat(szGreekOmega, szGreekAlpha, szGreekOmega.Clone())

// Examine the result
printfn $"{szGreekLetters}"

// The first index of Alpha
let ialpha = szGreekLetters.IndexOf '\u0391'
// The last index of Omega
let iomega = szGreekLetters.LastIndexOf '\u03A9'

printfn $"The Greek letter Alpha first appears at index {ialpha} and Omega last appears at index {iomega} in this String."

' Create a Unicode String with 5 Greek Alpha characters
Dim szGreekAlpha As New String(ChrW(&H0391), 5)
' Create a Unicode String with a Greek Omega character
Dim szGreekOmega As New String(New Char() {ChrW(&H03A9), ChrW(&H03A9), _
                                           ChrW(&H03A9)}, 2, 1)

Dim szGreekLetters As String = String.Concat(szGreekOmega, szGreekAlpha, _
                                             szGreekOmega.Clone())

' Examine the result
Console.WriteLine(szGreekLetters)

' The first index of Alpha
Dim iAlpha As Integer = szGreekLetters.IndexOf(ChrW(&H0391))
' The last index of Omega
Dim iomega As Integer = szGreekLetters.LastIndexOf(ChrW(&H03A9))

Console.WriteLine("The Greek letter Alpha first appears at index {0}.", _ 
                  ialpha)
Console.WriteLIne("The Greek letter Omega last appears at index {0}.", _
                  iomega)

예제 4: 문자 배열에 대한 포인터 사용

다음 예제에서는 포인터에서 문자 배열에 대한 새 String 개체를 만드는 방법을 보여 줍니다. C# 예제는 컴파일러 스위치를 /unsafe 사용하여 컴파일해야 합니다.

using System;

public class Example4
{
   public static unsafe void Main()
   {
      char[] characters = { 'H', 'e', 'l', 'l', 'o', ' ', 
                            'w', 'o', 'r', 'l', 'd', '!', '\u0000' };
      string value;
      
      fixed (char* charPtr = characters) {
         value = new String(charPtr);
      }                            
      Console.WriteLine(value);
   }
}
// The example displays the following output:
//        Hello world!

#nowarn "9"
open System

let characters = 
    [| 'H'; 'e'; 'l'; 'l'; 'o'; ' ' 
       'w'; 'o'; 'r'; 'l'; 'd'; '!'; '\u0000' |]

let value =
    use charPtr = fixed characters
    String charPtr

printfn $"{value}"
// The example displays the following output:
//        Hello world!

예제 5: 포인터 및 배열 범위에서 문자열 인스턴스화

다음 예제에서는 마침표 또는 느낌표에 대한 문자 배열의 요소를 검사합니다. 문자열이 발견되면 문장 부호 앞에 오는 배열의 문자에서 문자열을 인스턴스화합니다. 그렇지 않은 경우 배열의 전체 내용으로 문자열을 인스턴스화합니다. C# 예제는 컴파일러 스위치를 /unsafe 사용하여 컴파일해야 합니다.

using System;

public class Example1
{
   public static unsafe void Main()
   {
      char[] characters = { 'H', 'e', 'l', 'l', 'o', ' ', 
                            'w', 'o', 'r', 'l', 'd', '!', '\u0000' };
      String value;
      
      fixed (char* charPtr = characters) {
         int length = 0;
         Char* iterator = charPtr;
   
         while (*iterator != '\x0000')
         {
            if (*iterator == '!' || *iterator == '.')
               break;
            iterator++;
            length++;
         }
         value = new String(charPtr, 0, length);
      }
      Console.WriteLine(value);
   }
}
// The example displays the following output:
//      Hello World

#nowarn "9"
open System
open FSharp.NativeInterop

let characters = 
    [| 'H'; 'e'; 'l'; 'l'; 'o'; ' '
       'w'; 'o'; 'r'; 'l'; 'd'; '!'; '\u0000' |]

[<EntryPoint>]
let main _ =
    use charPtr = fixed characters
    let mutable length = 0
    let mutable iterator = charPtr
    let mutable broken = false
    while not broken && NativePtr.read iterator <> '\u0000' do
        if NativePtr.read iterator = '!' || NativePtr.read iterator = '.' then
            broken <- true
        else
            iterator <- NativePtr.add iterator 1
            length <- length + 1
    String(charPtr, 0, length)
    |> printfn "%s"
    0
// The example displays the following output:
//      Hello World

예제 6: 포인터에서 부호 있는 바이트 배열로 문자열 인스턴스화

다음 예제에서는 생성자를 사용하여 클래스 String(SByte*) 의 인스턴스를 String 만드는 방법을 보여 줍니다.

unsafe
{
    // Null terminated ASCII characters in an sbyte array
    String szAsciiUpper = null;
    sbyte[] sbArr1 = new sbyte[] { 0x41, 0x42, 0x43, 0x00 };
    // Instruct the Garbage Collector not to move the memory
    fixed(sbyte* pAsciiUpper = sbArr1)
    {
        szAsciiUpper = new String(pAsciiUpper);
    }
    String szAsciiLower = null;
    sbyte[] sbArr2 = { 0x61, 0x62, 0x63, 0x00 };
    // Instruct the Garbage Collector not to move the memory
    fixed(sbyte* pAsciiLower = sbArr2)
    {
        szAsciiLower = new String(pAsciiLower, 0, sbArr2.Length);
    }
    // Prints "ABC abc"
    Console.WriteLine(szAsciiUpper + " " + szAsciiLower);

    // Compare Strings - the result is true
    Console.WriteLine("The Strings are equal when capitalized ? " +
        (String.Compare(szAsciiUpper.ToUpper(), szAsciiLower.ToUpper())==0?"true":"false") );

    // This is the effective equivalent of another Compare method, which ignores case
    Console.WriteLine("The Strings are equal when capitalized ? " +
        (String.Compare(szAsciiUpper, szAsciiLower, true)==0?"true":"false") );
}

// Null terminated ASCII characters in an sbyte array
let szAsciiUpper =
    let sbArr1 = [| 0x41y; 0x42y; 0x43y; 0x00y |]
    // Instruct the Garbage Collector not to move the memory
    use pAsciiUpper = fixed sbArr1
    String pAsciiUpper

let szAsciiLower =
    let sbArr2 = [| 0x61y; 0x62y; 0x63y; 0x00y |]
    // Instruct the Garbage Collector not to move the memory
    use pAsciiLower = fixed sbArr2 
    String(pAsciiLower, 0, sbArr2.Length)

// Prints "ABC abc"
printfn $"{szAsciiUpper} {szAsciiLower}"

// Compare Strings - the result is true
printfn $"The Strings are equal when capitalized ? %b{String.Compare(szAsciiUpper.ToUpper(), szAsciiLower.ToUpper()) = 0}"

// This is the effective equivalent of another Compare method, which ignores case
printfn $"The Strings are equal when capitalized ? %b{String.Compare(szAsciiUpper, szAsciiLower, true) = 0}"

피드백

출시 예정: 2024년 내내 콘텐츠에 대한 피드백 메커니즘으로 GitHub 문제를 단계적으로 폐지하고 이를 새로운 피드백 시스템으로 바꿀 예정입니다. 자세한 내용은 다음을 참조하세요. https://aka.ms/ContentUserFeedback

다음에 대한 사용자 의견 제출 및 보기

이 제품 이 페이지

모든 페이지 피드백 보기