String String String String Class

정의

텍스트를 UTF-16 코드 단위의 시퀀스로 나타냅니다.Represents text as a sequence of UTF-16 code units.

public ref class String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IEnumerable
    interface IComparable<string>
    interface seq<char>
    interface IEquatable<string>
Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)
상속
StringStringStringString
특성
구현

설명

문자열은 텍스트를 나타내는 데 사용 되는 문자의 순차적인 컬렉션입니다.A string is a sequential collection of characters that is used to represent text. A String 개체의 순차 컬렉션이 System.Char 있으며 문자열을 나타내는 개체를 개체 System.Char utf-16 코드 단위에 해당 하는 개체입니다.A String object is a sequential collection of System.Char objects that represent a string; a System.Char object corresponds to a UTF-16 code unit. 값을 String 개체의 순차 컬렉션의 콘텐츠가 System.Char 개체 및 값은 변경할 수 없습니다 (즉,이 읽기 전용).The value of the String object is the content of the sequential collection of System.Char objects, and that value is immutable (that is, it is read-only). 문자열의 불변성에 대 한 자세한 내용은 참조는 불변성 및 StringBuilder 클래스 이 항목의 뒷부분에 나오는 섹션입니다.For more information about the immutability of strings, see the Immutability and the StringBuilder class section later in this topic. 최대 크기는 String 메모리에서 개체는 약 1 십억 자 2GB입니다.The maximum size of a String object in memory is 2GB, or about 1 billion characters.

섹션 내용In this section:

문자열 개체 인스턴스화 Instantiating a String object
개체 및 유니코드 문자를 문자 Char objects and Unicode characters
문자열과 유니코드 표준 Strings and The Unicode Standard
문자열 및 포함 된 null 문자 Strings and embedded null characters
문자열 및 인덱스 Strings and indexes
Null 문자열 및 빈 문자열 Null strings and empty strings
불변성 및 StringBuilder 클래스 Immutability and the StringBuilder class
문화권 구분 작업 및 서 수 Ordinal vs. culture-sensitive operations
정규화 Normalization
범주별 문자열 작업String operations by category

문자열 개체 인스턴스화Instantiating a String object

인스턴스화할 수 있습니다는 String 다음과 같은 방법으로 개체:You can instantiate a String object in the following ways:

  • 문자열 리터럴을 할당 하 여를 String 변수입니다.By assigning a string literal to a String variable. 이 방법은 문자열을 만들기 위해 가장 일반적으로 사용 합니다.This is the most commonly used method for creating a string. 다음 예제에서는 할당을 사용 하 여 여러 문자열을 만들 수 있습니다.The following example uses assignment to create several strings. 때문에 C#에서 유의 백슬래시 (\)는 이스케이프 문자, 문자열에서 리터럴 백슬래시를 이스케이프 해야 합니다 또는 전체 문자열 이어야 합니다 @-quoted합니다.Note that in C#, because the backslash (\) is an escape character, literal backslashes in a string must be escaped or the entire string must be @-quoted.

    using namespace System;
    
    void main()
    {
       String^ string1 = "This is a string created by assignment.";
       Console::WriteLine(string1);
       String^ string2a = "The path is C:\\PublicDocuments\\Report1.doc";
       Console::WriteLine(string2a);
    }
    // The example displays the following output: 
    //       This is a string created by assignment. 
    //       The path is C:\PublicDocuments\Report1.doc 
    
    string string1 = "This is a string created by assignment.";
    Console.WriteLine(string1);
    string string2a = "The path is C:\\PublicDocuments\\Report1.doc";
    Console.WriteLine(string2a);
    string string2b = @"The path is C:\PublicDocuments\Report1.doc";
    Console.WriteLine(string2b);
    // The example displays the following output:
    //       This is a string created by assignment.
    //       The path is C:\PublicDocuments\Report1.doc
    //       The path is C:\PublicDocuments\Report1.doc      
    
    Dim string1 As String = "This is a string created by assignment."
    Console.WriteLine(string1)
    Dim string2 As String = "The path is C:\PublicDocuments\Report1.doc"
    Console.WriteLine(string2)
    ' The example displays the following output:
    '       This is a string created by assignment.
    '       The path is C:\PublicDocuments\Report1.doc      
    
  • 호출 하 여를 String 클래스 생성자입니다.By calling a String class constructor. 다음 예제에서는 몇 가지 클래스 생성자를 호출 하 여 문자열을 인스턴스화합니다.The following example instantiates strings by calling several class constructors. 문자 배열 또는 매개 변수 사용 되는 부호 있는 바이트 배열에 대 한 포인터를 포함 하는 생성자 중 일부를 note 합니다.Note that some of the constructors include pointers to character arrays or signed byte arrays as parameters. Visual Basic에서 이러한 생성자에 대 한 호출을 지원 하지 않습니다.Visual Basic does not support calls to these constructors. 에 대 한 자세한 내용은 String 생성자를 참조 합니다 String 생성자 요약 합니다.For detailed information about String constructors, see the String constructor summary.

    using namespace System;
    
    void main()
    {
       wchar_t chars[5] = L"word";
       char bytes[6] = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
       // Create a string from a character array. 
       String^ string1 = gcnew String(chars);
       Console::WriteLine(string1);
    
       // Create a string that consists of a character repeated 20 times. 
       String^ string2 = gcnew String('c', 20);
       Console::WriteLine(string2);
    
       String^ stringFromBytes = nullptr;
       String^ stringFromChars = nullptr;
    
       char * pbytes = &bytes[0];
       // Create a string from a pointer to a signed byte array.
       stringFromBytes = gcnew String(pbytes);
    
       wchar_t* pchars =  &chars[0];
       // Create a string from a pointer to a character array.
       stringFromChars = gcnew String(pchars);
    
       Console::WriteLine(stringFromBytes);
       Console::WriteLine(stringFromChars);
       Console::ReadLine();
    }
    // The example displays the following output: 
    //       word 
    //       cccccccccccccccccccc 
    //       ABCDE 
    //       word  
    
    char[] chars = { 'w', 'o', 'r', 'd' };
    sbyte[] bytes = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
    // Create a string from a character array.
    string string1 = new string(chars);
    Console.WriteLine(string1);
    
    // Create a string that consists of a character repeated 20 times.
    string string2 = new string('c', 20);
    Console.WriteLine(string2);
    
    string stringFromBytes = null;
    string stringFromChars = null;
    unsafe
    {
       fixed (sbyte* pbytes = bytes)
       {
          // Create a string from a pointer to a signed byte array.
          stringFromBytes = new string(pbytes);
       }
       fixed (char* pchars = chars)
       {
          // Create a string from a pointer to a character array.
          stringFromChars = new string(pchars);
       }
    }
    Console.WriteLine(stringFromBytes);
    Console.WriteLine(stringFromChars);
    // The example displays the following output:
    //       word
    //       cccccccccccccccccccc
    //       ABCDE
    //       word  
    
    Dim chars() As Char = { "w"c, "o"c, "r"c, "d"c }
    
    ' Create a string from a character array.
    Dim string1 As New String(chars)
    Console.WriteLine(string1)
    
    ' Create a string that consists of a character repeated 20 times.
    Dim string2 As New String("c"c, 20)
    Console.WriteLine(string2)
    ' The example displays the following output:
    '       word
    '       cccccccccccccccccccc      
    
  • 문자열 연결 연산자를 사용 하 여 (+, C# 및 & 또는 + Visual Basic의) 단일 문자열로 조합 중에서 만들려는 String 인스턴스 및 문자열 리터럴.By using the string concatenation operator (+ in C# and & or + in Visual Basic) to create a single string from any combination of String instances and string literals. 다음 예제에서는 문자열 연결 연산자를 사용을 하는 방법을 보여 줍니다.The following example illustrates the use of the string concatenation operator.

    String^ string1 = "Today is " + DateTime::Now.ToString("D") + ".";
    Console::WriteLine(string1);
    
    String^ string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console::WriteLine(string2);
    // The example displays output like the following: 
    //    Today is Tuesday, July 06, 2011. 
    //    This is one sentence. This is a second. This is a third sentence.
    
    string string1 = "Today is " + DateTime.Now.ToString("D") + ".";
    Console.WriteLine(string1);
    
    string string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console.WriteLine(string2);
    // The example displays output like the following:
    //    Today is Tuesday, July 06, 2011.
    //    This is one sentence. This is a second. This is a third sentence.
    
    Dim string1 As String = "Today is " + Date.Now.ToString("D") + "."  
    Console.WriteLine(string1)
    Dim string2 As String = "This is one sentence. " + "This is a second. "
    string2 += "This is a third sentence."
    Console.WriteLine(string2)      
    ' The example displays output like the following:
    '    Today is Tuesday, July 06, 2011.
    '    This is one sentence. This is a second. This is a third sentence.
    
  • 속성을 검색 하거나 메서드를 호출 하 여 문자열을 반환 하는 합니다.By retrieving a property or calling a method that returns a string. 메서드를 사용 하는 다음 예제는 String 클래스를 더 큰 문자열에서 부분 문자열을 추출 합니다.The following example uses the methods of the String class to extract a substring from a larger string.

    String^ sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence->IndexOf(" ") + 1;
    String^ word2 = sentence->Substring(startPosition, 
                                        sentence->IndexOf(" ", startPosition) - startPosition);
    Console::WriteLine("Second word: " + word2);
    
    string sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence.IndexOf(" ") + 1;
    string word2 = sentence.Substring(startPosition,
                                      sentence.IndexOf(" ", startPosition) - startPosition);
    Console.WriteLine("Second word: " + word2);
    // The example displays the following output:
    //       Second word: sentence
    
    Dim sentence As String = "This sentence has five words."
    ' Extract the second word.
    Dim startPosition As Integer = sentence.IndexOf(" ") + 1
    Dim word2 As String = sentence.Substring(startPosition, 
                                             sentence.IndexOf(" ", startPosition) - startPosition) 
    Console.WriteLine("Second word: " + word2)
    ' The example displays the following output:
    '       Second word: sentence
    
  • 값 또는 개체를 문자열 표현으로 변환 하는 형식 지정 메서드를 호출 합니다.By calling a formatting method to convert a value or object to its string representation. 다음 예제에서는 합니다 복합 서식 지정 문자열로 두 개체의 문자열 표현을 포함 하는 기능입니다.The following example uses the composite formatting feature to embed the string representation of two objects into a string.

    DateTime^ dateAndTime = gcnew DateTime(2011, 7, 6, 7, 32, 0);
    Double temperature = 68.3;
    String^ result = String::Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                   dateAndTime, temperature);
    Console::WriteLine(result);
    // The example displays the following output: 
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    
    DateTime dateAndTime = new DateTime(2011, 7, 6, 7, 32, 0);
    double temperature = 68.3;
    string result = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                  dateAndTime, temperature);
    Console.WriteLine(result);
    // The example displays the following output:
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    
    Dim dateAndTime As DateTime = #07/06/2011 7:32:00AM#
    Dim temperature As Double = 68.3
    Dim result As String = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                         dateAndTime, temperature)
    Console.WriteLine(result)
    ' The example displays the following output:
    '       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    

개체 및 유니코드 문자를 문자Char objects and Unicode characters

문자열의 각 문자는 유니코드 코드 포인트 또는 유니코드 문자의 서 수 (숫자) 값을 유니코드 스칼라 값으로 정의 됩니다.Each character in a string is defined by a Unicode scalar value, also called a Unicode code point or the ordinal (numeric) value of the Unicode character. Utf-16 인코딩을 사용 하 여 각 코드 포인트를 인코딩하고 인코딩을의 각 요소 숫자 값은 표현 된 Char 개체입니다.Each code point is encoded by using UTF-16 encoding, and the numeric value of each element of the encoding is represented by a Char object.

참고

때문에 String utf-16 코드 단위 순차 컬렉션의 인스턴스 구성, 만들 수 있기를 String 개체는 올바른된 유니코드 문자열입니다.Note that, because a String instance consists of a sequential collection of UTF-16 code units, it is possible to create a String object that is not a well-formed Unicode string. 예를 들어, 해당 상위 서로게이트 없이 하위 서로게이트 된 문자열을 만들 수입니다.For example, it is possible to create a string that has a low surrogate without a corresponding high surrogate. 하지만 인코딩 및 디코딩에서 개체의 메서드와 같은 일부 메서드는 System.Text 네임 스페이스 문자열이 제대로 구성 되어 있는지 확인 하는 검사를 수행 될 수 있습니다 String 문자열은 올바른 형식의 클래스 멤버 보장할 수 없습니다.Although some methods, such as the methods of encoding and decoding objects in the System.Text namespace, may performs checks to ensure that strings are well-formed, String class members don't ensure that a string is well-formed.

단일 Char 개체에는 일반적으로 단일 나타냅니다 코드 포인트의 숫자 값, 즉는 Char 코드 포인트와 같습니다.A single Char object usually represents a single code point; that is, the numeric value of the Char equals the code point. 예를 들어, 코드 포인트를 "문자에 대 한 a"가 단어로 합니다.For example, the code point for the character "a" is U+0061. 그러나 코드 포인트를 인코딩된 요소가 둘 이상 필요할 수도 있습니다 (둘 이상의 Char 개체).However, a code point might require more than one encoded element (more than one Char object). 유니코드 표준은 여러 문자에 해당 하는 두 가지 유형의 정의 Char 개체: 제자, 및에서 유니코드 보조 평면 문자에 해당 하는 유니코드 보충 코드 포인트입니다.The Unicode standard defines two types of characters that correspond to multiple Char objects: graphemes, and Unicode supplementary code points that correspond to characters in the Unicode supplementary planes.

  • 기본 문자 뒤에 하나 이상의 조합 문자는 문자 소 표시 됩니다.A grapheme is represented by a base character followed by one or more combining characters. 문자 ä는 표현 예를 들어 Char 단어로 뒤에 해당 코드 포인트 개체 Char 해당 코드 포인트 + 0308 개체입니다.For example, the character ä is represented by a Char object whose code point is U+0061 followed by a Char object whose code point is U+0308. 이 문자는 단일 정의할 수도 있습니다 Char 00 e U + 4 인 코드 포인트를 가진 개체입니다.This character can also be defined by a single Char object that has a code point of U+00E4. 다음 예제와 같이 일반 서 수 비교 하지 않습니다 하지만 이러한 두 표현은 같음, 같음에 대 한 문화권 구분 비교를 나타냅니다.As the following example shows, a culture-sensitive comparison for equality indicates that these two representations are equal, although an ordinary ordinal comparison does not. 그러나 두 문자열 정규화 되는 경우 서 수 비교를 나타내기도 같은지 합니다.However, if the two strings are normalized, an ordinal comparison also indicates that they are equal. (문자열 정규화에 대 한 자세한 내용은 참조는 정규화 섹션입니다.)(For more information on normalizing strings, see the Normalization section.)

    using namespace System;
    using namespace System::Globalization;
    using namespace System::IO;
    
    void main()
    {
       StreamWriter^ sw = gcnew StreamWriter(".\\graphemes.txt");
       String^ grapheme = L"a" + L"\u0308";
       sw->WriteLine(grapheme);
    
       String^ singleChar = "\u00e4";
       sw->WriteLine(singleChar);
    
       sw->WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                      String::Equals(grapheme, singleChar, 
                                  StringComparison::CurrentCulture));
       sw->WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                      String::Equals(grapheme, singleChar, 
                                  StringComparison::Ordinal));
       sw->WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                      String::Equals(grapheme->Normalize(), 
                                  singleChar->Normalize(), 
                                  StringComparison::Ordinal));
       sw->Close(); 
    }
    // The example produces the following output: 
    //       ä 
    //       ä 
    //       ä = ä (Culture-sensitive): True 
    //       ä = ä (Ordinal): False 
    //       ä = ä (Normalized Ordinal): True
    
    using System;
    using System.Globalization;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\graphemes.txt");
          string grapheme = "\u0061\u0308";
          sw.WriteLine(grapheme);
          
          string singleChar = "\u00e4";
          sw.WriteLine(singleChar);
                
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture));
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal));
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal));
          sw.Close(); 
       }
    }
    // The example produces the following output:
    //       ä
    //       ä
    //       ä = ä (Culture-sensitive): True
    //       ä = ä (Ordinal): False
    //       ä = ä (Normalized Ordinal): True
    
    Imports System.Globalization
    Imports System.IO
    
    Module Example
       Public Sub Main()
          Dim sw As New StreamWriter(".\graphemes.txt")
          Dim grapheme As String = ChrW(&H0061) + ChrW(&h0308)
          sw.WriteLine(grapheme)
          
          Dim singleChar As String = ChrW(&h00e4)
          sw.WriteLine(singleChar)
                
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture))
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal))
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal))
          sw.Close() 
       End Sub
    End Module
    ' The example produces the following output:
    '       ä
    '       ä
    '       ä = ä (Culture-sensitive): True
    '       ä = ä (Ordinal): False
    '       ä = ä (Normalized Ordinal): True
    
  • 보조 코드 포인트 (서로게이트 쌍)가 나타내는 유니코드를 Char 뒤에 상위 서로게이트 코드 포인트가 개체는 Char 하위 서로게이트 코드 포인트가 개체입니다.A Unicode supplementary code point (a surrogate pair) is represented by a Char object whose code point is a high surrogate followed by a Char object whose code point is a low surrogate. U+d800부터 U + dbff 사이의 높은 서로게이트가 범위의 코드 단위입니다.The code units of high surrogates range from U+D800 to U+DBFF. 이 U+dc00부터 U + dfff 낮은 서로게이트가 범위의 코드 단위입니다.The code units of low surrogates range from U+DC00 to U+DFFF. 서로게이트 쌍에 16 유니코드 보조 평면 문자를 나타내기 위해 사용 됩니다.Surrogate pairs are used to represent characters in the 16 Unicode supplementary planes. 다음 예제에서는 서로게이트 문자를 만들어 전달 된 Char.IsSurrogatePair(Char, Char) 이 서로게이트 쌍인지 여부를 결정 하는 방법입니다.The following example creates a surrogate character and passes it to the Char.IsSurrogatePair(Char, Char) method to determine whether it is a surrogate pair.

    using namespace System;
    
    void main()
    {
       String^ surrogate =  L"\xD800\xDC03" ;
       for (int ctr = 0; ctr < surrogate->Length; ctr++)
          Console::Write("U+{0:X4} ", Convert::ToUInt16(surrogate[ctr]));
    
       Console::WriteLine();
       Console::WriteLine("   Is Surrogate Pair: {0}", 
                          Char::IsSurrogatePair(surrogate[0], surrogate[1]));
       Console::ReadLine();
    }
    // The example displays the following output: 
    //       U+D800 U+DC03 
    //          Is Surrogate Pair: True
    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          string surrogate = "\uD800\uDC03";
          for (int ctr = 0; ctr < surrogate.Length; ctr++) 
             Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate[ctr]));
    
          Console.WriteLine();
          Console.WriteLine("   Is Surrogate Pair: {0}", 
                            Char.IsSurrogatePair(surrogate[0], surrogate[1]));
       }
    }
    // The example displays the following output:
    //       U+D800 U+DC03
    //          Is Surrogate Pair: True
    
    Module Example
       Public Sub Main()
          Dim surrogate As String = ChrW(&hD800) + ChrW(&hDC03)
          For ctr As Integer = 0 To surrogate.Length - 1
             Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate(ctr)))
          Next   
          Console.WriteLine()
          Console.WriteLine("   Is Surrogate Pair: {0}", 
                            Char.IsSurrogatePair(surrogate(0), surrogate(1)))
       End Sub
    End Module
    
    ' The example displays the following output:
    '       U+D800 U+DC03
    '          Is Surrogate Pair: True
    

문자열과 유니코드 표준Strings and the Unicode Standard

문자열의 문자는 해당 하는 u t F-16으로 인코딩된 코드 단위를 나타내는 Char 값입니다.Characters in a string are represented by UTF-16 encoded code units, which correspond to Char values.

문자열의 각 문자에 하 여.NET에서 표현 되는 연결 된 유니코드 문자 범주는 UnicodeCategory 열거형입니다.Each character in a string has an associated Unicode character category, which is represented in .NET by the UnicodeCategory enumeration. 호출 하 여 문자 또는 서로게이트 쌍의 범주를 확인할 수 있습니다는 CharUnicodeInfo.GetUnicodeCategory 메서드.The category of a character or a surrogate pair can be determined by calling the CharUnicodeInfo.GetUnicodeCategory method.

.NET에서는 문자 및 해당 범주의 고유한 테이블을 유지 관리합니다. 그러면 다른 플랫폼에서 실행되는 특정 버전의 .NET 구현이 동일한 문자 범주 정보를 반환하게 됩니다..NET maintains its own table of characters and their corresponding categories, which ensures that a specific version of a .NET implementation running on different platforms returns identical character category information. Linux 및 macOS에서 실행 중인 .NET Core의 문자 범주 정보는 유니코드에 대한 국가별 구성 요소 라이브러리에서 제공합니다.On .NET Core running on Linux and macOS, character category information is provided by International Components for Unicode libraries.

다음 표에서는 해당 문자 범주의 기반이 되는 .NET 버전 및 유니코드 표준 버전을 나열합니다.The following table lists .NET versions and the versions of the Unicode Standard on which their character categories are based.

.NET 버전.NET version 유니코드 표준 버전Version of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 유니코드 표준, 버전 4.0.0The Unicode Standard, Version 4.0.0
.NET Framework 2.0.NET Framework 2.0 유니코드 표준, 버전 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 3.5.NET Framework 3.5 유니코드 표준, 버전 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.NET Framework 4 유니코드 표준, 버전 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5 유니코드 표준, 버전 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.51.NET Framework 4.51 유니코드 표준, 버전 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.52.NET Framework 4.52 유니코드 표준, 버전 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.6.NET Framework 4.6 유니코드 표준, 버전 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.61.NET Framework 4.61 유니코드 표준, 버전 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.6.2 이전 버전.NET Framework 4.6.2 and later versions 유니코드 표준, 버전 8.0.0The Unicode Standard, Version 8.0.0
.NET Core(모든 버전).NET Core (all versions) 유니코드 표준, 버전 8.0.0The Unicode Standard, Version 8.0.0

또한.NET 문자열 비교를 지원 하 고 유니코드 표준에 따라 정렬 합니다.In addition, .NET supports string comparison and sorting based on the Unicode standard. 통해.NET Framework의 버전에서을 .NET Framework 4.NET Framework 4,.NET Framework에 문자열 데이터의 자체 테이블 유지 관리 합니다.In versions of the .NET Framework through the .NET Framework 4.NET Framework 4, the .NET Framework maintains its own table of string data. 부터.NET Framework의 버전도 마찬가지 여 .NET Framework 4.5.NET Framework 4.5 Windows 7을 실행 합니다.This is also true of versions of the .NET Framework starting with the .NET Framework 4.5.NET Framework 4.5 running on Windows 7. 부터 .NET Framework 4.5.NET Framework 4.5 Window 8 및 이후 버전의 Windows 운영 체제를 실행, 런타임 대리자 문자열 비교 및 정렬 작업의 운영 체제입니다.Starting with the .NET Framework 4.5.NET Framework 4.5 running on Window 8 and later versions of the Windows operating system, the runtime delegates string comparison and sorting operations to the operating system. .NET Core에서 문자열 비교 및 정렬 정보가 제공한 유니코드에 대 한 구성 요소 International 라이브러리입니다. 다음 표에서.NET 버전 및 문자 비교 및 정렬 기반으로 하는 유니코드 표준의 버전을 나열 합니다.On .NET Core, string comparison and sorting information is provided by International Components for Unicode libraries.The following table lists the versions of .NET and the versions of the Unicode Standard on which character comparison and sorting are based.

.NET 버전.NET version 유니코드 표준 버전Version of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 유니코드 표준, 버전 4.0.0The Unicode Standard, Version 4.0.0
.NET Framework 2.0The .NET Framework 2.0 유니코드 표준, 버전 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 3.5.NET Framework 3.5 유니코드 표준, 버전 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.NET Framework 4 유니코드 표준, 버전 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5 Windows 7 이상and later on Windows 7 유니코드 표준, 버전 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5 나중에 Windows 8 및 이후 Windows 운영 체제and later on Windows 8 and later Windows operating systems 유니코드 표준, 버전 6.3.0The Unicode Standard, Version 6.3.0
.NET Core(모든 버전).NET Core (all versions) 기본 운영 체제에서 지원 되는 유니코드 표준의 버전에 따라 달라 집니다.Depends on the version of the Unicode Standard supported by the underlying operating system.

문자열 및 포함 된 null 문자Strings and embedded null characters

.NET에서는 String 개체 계산에 포함 된 문자열의 길이 포함 된 null 문자를 포함할 수 있습니다.In .NET, a String object can include embedded null characters, which count as a part of the string's length. 그러나 C 및 c + +와 같은 일부 언어에서 null 문자를 끝을 나타내는 문자열입니다. 문자열의 일부로 간주 되지 않습니다 하 고 문자열의 길이의 일부로 계산 되지 않습니다.However, in some languages such as C and C++, a null character indicates the end of a string; it is not considered a part of the string and is not counted as part of the string's length. 즉, 문자열에 대 한 C 및 c + + 프로그래머 또는 C 또는 c + +로 작성 된 라이브러리 적합할 수 있는 다음과 같은 일반적인 가정을 유효 하지 않음을 반드시 적용할 때 String 개체:This means that the following common assumptions that C and C++ programmers or libraries written in C or C++ might make about strings are not necessarily valid when applied to String objects:

  • 값을 반환 합니다 strlen 또는 wcslen 함수를 반드시 같지 않습니다 String.Length합니다.The value returned by the strlen or wcslen functions does not necessarily equal String.Length.

  • 만든 문자열을 strcpy_s 또는 wcscpy_s 함수에서 생성 된 문자열을 반드시 동일 하지 않습니다는 String.Copy 메서드.The string created by the strcpy_s or wcscpy_s functions is not necessarily identical to the string created by the String.Copy method.

인스턴스화하는 네이티브 C 및 c + + 코드를 확인 해야 String 개체 및 전달 되는 코드 String 플랫폼을 통해 개체 호출, 포함 된 null 문자는 문자열의 끝을 표시는 가정 하지 마십시오.You should ensure that native C and C++ code that instantiates String objects, and code that is passed String objects through platform invoke, don't assume that an embedded null character marks the end of the string.

또한 문자열에 포함 된 null 문자 및 문자열 정렬 (또는 비교) 하는 경우 문자열을 검색할 때 다르게 처리 됩니다.Embedded null characters in a string are also treated differently when a string is sorted (or compared) and when a string is searched. Null 문자는 두 문자열을 고정 문화권을 사용한 비교를 포함 하 여 문화권 구분 비교를 수행 하는 경우 무시 됩니다.Null characters are ignored when performing culture-sensitive comparisons between two strings, including comparisons using the invariant culture. 서 수 비교를 서 수 또는 대/소문자에 대해서만 간주 됩니다.They are considered only for ordinal or case-insensitive ordinal comparisons. 반면에 포함 된 null 문자를 항상 고려와 같은 메서드를 사용 하 여 문자열을 검색 하는 경우 Contains하십시오 StartsWith, 및 IndexOf합니다.On the other hand, embedded null characters are always considered when searching a string with methods such as Contains, StartsWith, and IndexOf.

문자열 및 인덱스Strings and indexes

인덱스의 위치를는 Char (유니코드 문자가 아님)에서 개체를 String입니다.An index is the position of a Char object (not a Unicode character) in a String. 인덱스는 인덱스 위치 0에 해당 하는 문자열의 첫 번째 위치에서 시작 하는 음수가 아닌 숫자 0부터 시작 합니다.An index is a zero-based, nonnegative number that starts from the first position in the string, which is index position zero. 검색 방법의 수와 같은 IndexOfLastIndexOf, 문자의 인덱스를 반환 하거나 문자열 인스턴스에서 문자열입니다.A number of search methods, such as IndexOf and LastIndexOf, return the index of a character or substring in the string instance.

합니다 Chars[Int32] 속성에 액세스할 수 있게 개별 Char 문자열의 인덱스 위치에 의해 개체입니다.The Chars[Int32] property lets you access individual Char objects by their index position in the string. 때문에 합니다 Chars[Int32] 속성이 (Visual Basic)의 기본 속성 또는 인덱서 (C#), 개별에 액세스할 수 있습니다 Char 다음과 같은 코드를 사용 하 여 문자열에서 개체입니다.Because the Chars[Int32] property is the default property (in Visual Basic) or the indexer (in C#), you can access the individual Char objects in a string by using code such as the following. 이 코드에서는 공백이 나 문장 부호 문자 문자열이 단어의 개수를 결정 하는 문자열에서 찾습니다.This code looks for white space or punctuation characters in a string to determine how many words the string contains.

using namespace System;

void main()
{
   String^ s1 = "This string consists of a single short sentence.";
   int nWords = 0;

   s1 = s1->Trim();      
   for (int ctr = 0; ctr < s1->Length; ctr++) {
         if (Char::IsPunctuation(s1[ctr]) | Char::IsWhiteSpace(s1[ctr]))
            nWords++;              
   }
   Console::WriteLine("The sentence\n   {0}\nhas {1} words.",
                     s1, nWords);           
}
// The example displays the following output: 
//       The sentence 
//          This string consists of a single short sentence. 
//       has 8 words.
using System;

public class Example
{
   public static void Main()
   {
      string s1 = "This string consists of a single short sentence.";
      int nWords = 0;

      s1 = s1.Trim();      
      for (int ctr = 0; ctr < s1.Length; ctr++) {
         if (Char.IsPunctuation(s1[ctr]) | Char.IsWhiteSpace(s1[ctr]))
            nWords++;              
      }
      Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                        s1, nWords);                                                                     
   }
}
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.
Module Example
   Public Sub Main()
      Dim s1 As String = "This string consists of a single short sentence."
      Dim nWords As Integer = 0

      s1 = s1.Trim()      
      For ctr As Integer = 0 To s1.Length - 1
         If Char.IsPunctuation(s1(ctr)) Or Char.IsWhiteSpace(s1(ctr)) 
            nWords += 1              
         End If   
      Next
      Console.WriteLine("The sentence{2}   {0}{2}has {1} words.",
                        s1, nWords, vbCrLf)                                                                     
   End Sub
End Module
' The example displays the following output:
'       The sentence
'          This string consists of a single short sentence.
'       has 8 words.

때문에 String 구현 클래스를 IEnumerable 인터페이스를 반복할 수 있습니다도 Char 를 사용 하 여 문자열에서 개체를 foreach 다음 예제와 같이 구문.Because the String class implements the IEnumerable interface, you can also iterate through the Char objects in a string by using a foreach construct, as the following example shows.

using namespace System;

void main()
{
   String^ s1 = "This string consists of a single short sentence.";
   int nWords = 0;

   s1 = s1->Trim();      
   for each (Char ch in s1)
   {
      if (Char::IsPunctuation(ch) | Char::IsWhiteSpace(ch))
         nWords++;              
   }
   Console::WriteLine("The sentence\n   {0}\nhas {1} words.",
                      s1, nWords);  
   Console::ReadLine();
}
// The example displays the following output: 
//       The sentence 
//          This string consists of a single short sentence. 
//       has 8 words.
using System;

public class Example
{
   public static void Main()
   {
      string s1 = "This string consists of a single short sentence.";
      int nWords = 0;

      s1 = s1.Trim();      
      foreach (var ch in s1) {
         if (Char.IsPunctuation(ch) | Char.IsWhiteSpace(ch))
            nWords++;              
      }
      Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                        s1, nWords);                                                                     
   }
}
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.
Module Example
   Public Sub Main()
      Dim s1 As String = "This string consists of a single short sentence."
      Dim nWords As Integer = 0

      s1 = s1.Trim()      
      For Each ch In s1
         If Char.IsPunctuation(ch) Or Char.IsWhiteSpace(ch) Then 
            nWords += 1              
         End If   
      Next
      Console.WriteLine("The sentence{2}   {0}{2}has {1} words.",
                        s1, nWords, vbCrLf)                                                                     
   End Sub
End Module
' The example displays the following output:
'       The sentence
'          This string consists of a single short sentence.
'       has 8 words.

연속 되는 인덱스 값 서로 다를 수 연속 유니코드 문자를 유니코드 문자 수 인코딩된 개 이상의 있으므로 Char 개체입니다.Consecutive index values might not correspond to consecutive Unicode characters, because a Unicode character might be encoded as more than one Char object. 특히, 문자열에 기본 문자 뒤에 하나 이상의 조합 문자 또는 서로게이트 쌍에 의해 형성 된 텍스트 단위의 여러 문자를 포함할 수 있습니다.In particular, a string may contain multi-character units of text that are formed by a base character followed by one or more combining characters or by surrogate pairs. 대신 유니코드 문자로 작업 해야 Char 개체를 사용 합니다 System.Globalization.StringInfoTextElementEnumerator 클래스입니다.To work with Unicode characters instead of Char objects, use the System.Globalization.StringInfo and TextElementEnumerator classes. 다음 예제에서는 작동 하는 코드 간의 차이점을 보여 줍니다. Char 개체 및 유니코드 문자를 사용 하 여 작동 하는 코드입니다.The following example illustrates the difference between code that works with Char objects and code that works with Unicode characters. 문자 또는 문장의 각 단어의 텍스트 요소 수를 비교합니다.It compares the number of characters or text elements in each word of a sentence. 문자열 기본 문자와 조합 문자 뒤에 두 개의 시퀀스를 포함 합니다.The string includes two sequences of a base character followed by a combining character.

using namespace System;
using namespace System::Collections::Generic;
using namespace System::Globalization;

void main()
{
   // First sentence of The Mystery of the Yellow Room, by Leroux. 
   String^ opening = L"Ce n'est pas sans une certaine émotion que "+
                     L"je commence à raconter ici les aventures " +
                     L"extraordinaires de Joseph Rouletabille."; 
  
   // Character counters. 
   int nChars = 0;
   // Objects to store word count.
   List<int>^ chars = gcnew List<int>();
   List<int>^ elements = gcnew List<int>();

   for each (Char ch in opening) {
      // Skip the ' character. 
      if (ch == '\x0027') continue;

      if (Char::IsWhiteSpace(ch) | (Char::IsPunctuation(ch))) {
         chars->Add(nChars);
         nChars = 0;
      }
      else {
         nChars++;
      }
   }

   TextElementEnumerator^ te = StringInfo::GetTextElementEnumerator(opening);
   while (te->MoveNext()) {
      String^ s = te->GetTextElement();   
      // Skip the ' character. 
      if (s == "\x0027") continue;
      if ( String::IsNullOrEmpty(s->Trim()) | (s->Length == 1 && Char::IsPunctuation(Convert::ToChar(s)))) {
         elements->Add(nChars);         
         nChars = 0;
      }
      else {
         nChars++;
      }
   }

   // Display character counts.
   Console::WriteLine("{0,6} {1,20} {2,20}",
                      "Word #", "Char Objects", "Characters"); 
   for (int ctr = 0; ctr < chars->Count; ctr++) 
      Console::WriteLine("{0,6} {1,20} {2,20}",
                         ctr, chars[ctr], elements[ctr]); 
   Console::ReadLine();
}
// The example displays the following output:
//      Word #         Char Objects           Characters
//           0                    2                    2
//           1                    4                    4
//           2                    3                    3
//           3                    4                    4
//           4                    3                    3
//           5                    8                    8
//           6                    8                    7
//           7                    3                    3
//           8                    2                    2
//           9                    8                    8
//          10                    2                    1
//          11                    8                    8
//          12                    3                    3
//          13                    3                    3
//          14                    9                    9
//          15                   15                   15
//          16                    2                    2
//          17                    6                    6
//          18                   12                   12
using System;
using System.Collections.Generic;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // First sentence of The Mystery of the Yellow Room, by Leroux.
      string opening = "Ce n'est pas sans une certaine émotion que "+
                       "je commence à raconter ici les aventures " +
                       "extraordinaires de Joseph Rouletabille."; 
      // Character counters.
      int nChars = 0;
      // Objects to store word count.
      List<int> chars = new List<int>();
      List<int> elements = new List<int>();
      
      foreach (var ch in opening) {
         // Skip the ' character.
         if (ch == '\u0027') continue;
              
         if (Char.IsWhiteSpace(ch) | (Char.IsPunctuation(ch))) {
            chars.Add(nChars);
            nChars = 0;
         }
         else {
            nChars++;
         }
      }

      TextElementEnumerator te = StringInfo.GetTextElementEnumerator(opening);
      while (te.MoveNext()) {
         string s = te.GetTextElement();   
         // Skip the ' character.
         if (s == "\u0027") continue;
         if ( String.IsNullOrEmpty(s.Trim()) | (s.Length == 1 && Char.IsPunctuation(Convert.ToChar(s)))) {
            elements.Add(nChars);         
            nChars = 0;
         }
         else {
            nChars++;
         }
      }

      // Display character counts.
      Console.WriteLine("{0,6} {1,20} {2,20}",
                        "Word #", "Char Objects", "Characters"); 
      for (int ctr = 0; ctr < chars.Count; ctr++) 
         Console.WriteLine("{0,6} {1,20} {2,20}",
                           ctr, chars[ctr], elements[ctr]); 
   }
}
// The example displays the following output:
//       Word #         Char Objects           Characters
//            0                    2                    2
//            1                    4                    4
//            2                    3                    3
//            3                    4                    4
//            4                    3                    3
//            5                    8                    8
//            6                    8                    7
//            7                    3                    3
//            8                    2                    2
//            9                    8                    8
//           10                    2                    1
//           11                    8                    8
//           12                    3                    3
//           13                    3                    3
//           14                    9                    9
//           15                   15                   15
//           16                    2                    2
//           17                    6                    6
//           18                   12                   12
Imports System.Collections.Generic
Imports System.Globalization

Module Example
   Public Sub Main()
      ' First sentence of The Mystery of the Yellow Room, by Leroux.
      Dim opening As String = "Ce n'est pas sans une certaine émotion que "+
                              "je commence à raconter ici les aventures " +
                              "extraordinaires de Joseph Rouletabille." 
      ' Character counters.
      Dim nChars As Integer = 0
      ' Objects to store word count.
      Dim chars As New List(Of Integer)()
      Dim elements As New List(Of Integer)()
      
      For Each ch In opening
         ' Skip the ' character.
         If ch = ChrW(&h0027) Then Continue For
              
         If Char.IsWhiteSpace(ch) Or Char.IsPunctuation(ch) Then
            chars.Add(nChars)
            nChars = 0
         Else 
            nChars += 1
         End If
      Next

      Dim te As TextElementEnumerator = StringInfo.GetTextElementEnumerator(opening)
      Do While te.MoveNext()
         Dim s As String = te.GetTextElement()   
         ' Skip the ' character.
         If s = ChrW(&h0027) Then Continue Do
         If String.IsNullOrEmpty(s.Trim()) Or (s.Length = 1 AndAlso Char.IsPunctuation(Convert.ToChar(s))) 
            elements.Add(nChars)         
            nChars = 0
         Else 
            nChars += 1
         End If
      Loop

      ' Display character counts.
      Console.WriteLine("{0,6} {1,20} {2,20}",
                        "Word #", "Char Objects", "Characters") 
      For ctr As Integer = 0 To chars.Count - 1 
         Console.WriteLine("{0,6} {1,20} {2,20}",
                           ctr, chars(ctr), elements(ctr)) 
      Next                        
   End Sub
End Module
' The example displays the following output:
'    Word #         Char Objects           Characters
'         0                    2                    2
'         1                    4                    4
'         2                    3                    3
'         3                    4                    4
'         4                    3                    3
'         5                    8                    8
'         6                    8                    7
'         7                    3                    3
'         8                    2                    2
'         9                    8                    8
'        10                    2                    1
'        11                    8                    8
'        12                    3                    3
'        13                    3                    3
'        14                    9                    9
'        15                   15                   15
'        16                    2                    2
'        17                    6                    6
'        18                   12                   12

이 예제를 사용 하 여 텍스트 요소를 사용 하 여 작동 합니다 StringInfo.GetTextElementEnumerator 메서드 및 TextElementEnumerator 문자열의 모든 텍스트 요소를 열거 하는 클래스입니다.This example works with text elements by using the StringInfo.GetTextElementEnumerator method and the TextElementEnumerator class to enumerate all the text elements in a string. 호출 하 여 각 텍스트 요소의 시작 하는 인덱스를 포함 하는 배열을 검색할 수도 있습니다는 StringInfo.ParseCombiningCharacters 메서드.You can also retrieve an array that contains the starting index of each text element by calling the StringInfo.ParseCombiningCharacters method.

개별이 아닌 텍스트의 단위를 사용 하는 방법에 대 한 자세한 내용은 Char 값, 참조는 StringInfo 클래스입니다.For more information about working with units of text rather than individual Char values, see the StringInfo class.

Null 문자열 및 빈 문자열Null strings and empty strings

선언 되었지만 값 할당 되지 않았습니다 하는 문자열은 null합니다.A string that has been declared but has not been assigned a value is null. 문자열에서 메서드를 호출 하는 동안 throw 된 NullReferenceException합니다.Attempting to call methods on that string throws a NullReferenceException. Null 문자열을 문자열 값이 빈 문자열인 경우와 다릅니다. "" 또는 String.Empty합니다.A null string is different from an empty string, which is a string whose value is "" or String.Empty. 일부 경우에는 예외를 throw 메서드 호출에서 인수로 null 문자열 또는 빈 문자열을 전달 합니다.In some cases, passing either a null string or an empty string as an argument in a method call throws an exception. 예를 들어, null 문자열을 전달 합니다 Int32.Parse 메서드가 throw를 ArgumentNullException, throw 빈 문자열을 전달 하는 FormatException합니다.For example, passing a null string to the Int32.Parse method throws an ArgumentNullException, and passing an empty string throws a FormatException. 다른 경우에는 null 문자열 또는 빈 문자열 메서드 인수 수 있습니다.In other cases, a method argument can be either a null string or an empty string. 예를 들어, 제공 하는 경우는 IFormattable 일반 ("G") 서식 지정자를 사용 하 여 null 문자열 및 빈 문자열을 모두 같게 하려는 클래스의 구현입니다.For example, if you are providing an IFormattable implementation for a class, you want to equate both a null string and an empty string with the general ("G") format specifier.

합니다 String 문자열 인지 여부를 테스트할 수 있도록 하는 다음 두 가지 편의 메서드를 포함 하는 클래스 null 또는 빈:The String class includes the following two convenience methods that enable you to test whether a string is null or empty:

  • IsNullOrEmpty를 문자열 중 하나 인지를 나타내는 null 와 같은지를 String.Empty입니다.IsNullOrEmpty, which indicates whether a string is either null or is equal to String.Empty. 이 메서드는 다음과 같은 코드를 사용할 필요를 제거 합니다.This method eliminates the need to use code such as the following:

    if (str == nullptr || str->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty))
    
    If str Is Nothing OrElse str.Equals(String.Empty) Then
    
  • IsNullOrWhiteSpace를 문자열 인지 여부를 나타내는 null, 같음 String.Empty, 모두 공백 문자로 구성 되어 또는 합니다.IsNullOrWhiteSpace, which indicates whether a string is null, equals String.Empty, or consists exclusively of white-space characters. 이 메서드는 다음과 같은 코드를 사용할 필요를 제거 합니다.This method eliminates the need to use code such as the following:

    if (str == nullptr || str->Equals(String::Empty) || str->Trim()->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty) || str.Trim().Equals(String.Empty))
    
    If str Is Nothing OrElse str.Equals(String.Empty) OrElse str.Trim().Equals(String.Empty)
    

다음 예제에서는 합니다 IsNullOrEmpty 의 메서드를 IFormattable.ToString 사용자 지정 구현의 Temperature 클래스입니다.The following example uses the IsNullOrEmpty method in the IFormattable.ToString implementation of a custom Temperature class. 메서드는 "G", "C", "F" 및 "K" 형식 문자열을 지원합니다.The method supports the "G", "C", "F", and "K" format strings. 형식 문자열이 비어 또는 형식 문자열 값인 경우 null 전달 되는 메서드를 "G" 형식 문자열에 해당 값을 변경 합니다.If an empty format string or a format string whose value is null is passed to the method, its value is changed to the "G" format string.

public:
   virtual String^ ToString(String^ format, IFormatProvider^ provider) 
   {
      if (String::IsNullOrEmpty(format)) format = "G";  
      if (provider == nullptr) provider = CultureInfo::CurrentCulture;
      
      switch (Convert::ToUInt16(format->ToUpperInvariant()))
      {
         // Return degrees in Celsius.    
         case 'G':
         case 'C':
            return temp.ToString("F2", provider) + L"�C";
         // Return degrees in Fahrenheit.
         case 'F': 
            return (temp * 9 / 5 + 32).ToString("F2", provider) + L"�F";
         // Return degrees in Kelvin.
         case 'K':   
            return (temp + 273.15).ToString();
         default:
            throw gcnew FormatException(
                  String::Format("The {0} format string is not supported.", 
                                 format));
      }                                   
   }
public string ToString(string format, IFormatProvider provider) 
{
   if (String.IsNullOrEmpty(format)) format = "G";  
   if (provider == null) provider = CultureInfo.CurrentCulture;
   
   switch (format.ToUpperInvariant())
   {
      // Return degrees in Celsius.    
      case "G":
      case "C":
         return temp.ToString("F2", provider) + "°C";
      // Return degrees in Fahrenheit.
      case "F": 
         return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F";
      // Return degrees in Kelvin.
      case "K":   
         return (temp + 273.15).ToString();
      default:
         throw new FormatException(
               String.Format("The {0} format string is not supported.", 
                             format));
   }                                   
}
Public Overloads Function ToString(fmt As String, provider As IFormatProvider) As String _
                Implements IFormattable.ToString
   If String.IsNullOrEmpty(fmt) Then fmt = "G"  
   If provider Is Nothing Then provider = CultureInfo.CurrentCulture
   
   Select Case fmt.ToUpperInvariant()
      ' Return degrees in Celsius.    
      Case "G", "C"
         Return temp.ToString("F2", provider) + "°C"
      ' Return degrees in Fahrenheit.
      Case "F" 
         Return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F"
      ' Return degrees in Kelvin.
      Case "K"   
         Return (temp + 273.15).ToString()
      Case Else
         Throw New FormatException(
               String.Format("The {0} format string is not supported.", 
                             fmt))
    End Select                                   
End Function

불변성 및 StringBuilder 클래스Immutability and the StringBuilder class

String 개체를 변경할 수 없는 호출 (읽기 전용)를 만든 후 값을 수정할 수 없습니다.A String object is called immutable (read-only), because its value cannot be modified after it has been created. 수정 하는 메서드를 String 개체는 실제로 새 반환 String 수정을 포함 하는 개체입니다.Methods that appear to modify a String object actually return a new String object that contains the modification.

문자열을 변경할 수 없기 때문에 추가 또는 단일 문자열에는 성능이 크게 저하 정확한 수를 표시 하는 삭제를 수행 하는 문자열 조작 루틴 반복 합니다.Because strings are immutable, string manipulation routines that perform repeated additions or deletions to what appears to be a single string can exact a significant performance penalty. 예를 들어, 다음 코드는 1000 ~ 0x052F 0x0001 범위의 문자를 사용 하 여 문자열을 만들려면 난수 생성기를 사용 합니다.For example, the following code uses a random number generator to create a string with 1000 characters in the range 0x0001 to 0x052F. 문자열 연결 이라는 기존 문자열에 새 문자를 추가 하는 데 코드 보이지만 str를 실제로 만드는 새 String 각 연결 작업에 대 한 개체입니다.Although the code appears to use string concatenation to append a new character to the existing string named str, it actually creates a new String object for each concatenation operation.

using namespace System;
using namespace System::IO;
using namespace System::Text;

void main()
{
   Random^ rnd = gcnew Random();

   String^ str = String::Empty;
   StreamWriter^ sw = gcnew StreamWriter(".\\StringFile.txt", 
                        false, Encoding::Unicode);

   for (int ctr = 0; ctr <= 1000; ctr++) {
      str += Convert::ToChar(rnd->Next(1, 0x0530)); 
      if (str->Length % 60 == 0)
         str += Environment::NewLine;          
   }                    
   sw->Write(str);
   sw->Close();
}
using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      
      string str = String.Empty;
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                           false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         str += Convert.ToChar(rnd.Next(1, 0x0530)); 
         if (str.Length % 60 == 0)
            str += Environment.NewLine;          
      }                    
      sw.Write(str);
      sw.Close();
   }
}
Imports System.IO
Imports System.Text

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      
      Dim str As String = String.Empty
      Dim sw As New StreamWriter(".\StringFile.txt", 
                           False, Encoding.Unicode)

      For ctr As Integer = 0 To 1000
         str += ChrW(rnd.Next(1, &h0530)) 
         If str.Length Mod 60 = 0 Then str += vbCrLf          
      Next                    
      sw.Write(str)
      sw.Close()
   End Sub
End Module

사용할 수는 StringBuilder 대신 클래스는 String 문자열의 값에 대 한 여러 변경 하는 작업에 대 한 클래스입니다.You can use the StringBuilder class instead of the String class for operations that make multiple changes to the value of a string. 인스턴스와 달리 합니다 String 클래스 StringBuilder 개체는 변경할 수, 연결, 추가 또는 문자열에서 부분 문자열을 삭제 작업을 단일 문자열에 대해 수행 됩니다.Unlike instances of the String class, StringBuilder objects are mutable; when you concatenate, append, or delete substrings from a string, the operations are performed on a single string. 값을 수정 했으면 하는 경우는 StringBuilder 개체를 호출할 수 있습니다 해당 StringBuilder.ToString 를 문자열로 변환 하는 방법입니다.When you have finished modifying the value of a StringBuilder object, you can call its StringBuilder.ToString method to convert it to a string. 다음 예제에서는 대체 합니다 String 0x052F 0x0001로 범위에서 임의의 문자 1000을 연결 하려면 이전 예제에서 사용을 StringBuilder 개체입니다.The following example replaces the String used in the previous example to concatenate 1000 random characters in the range to 0x0001 to 0x052F with a StringBuilder object.

using namespace System;
using namespace System::IO;
using namespace System::Text;

void main()
{
   Random^ rnd = gcnew Random();

   StringBuilder^ sb = gcnew StringBuilder();
   StreamWriter^ sw = gcnew StreamWriter(".\\StringFile.txt", 
                        false, Encoding::Unicode);

   for (int ctr = 0; ctr <= 1000; ctr++) {
      sb->Append(Convert::ToChar(rnd->Next(1, 0x0530))); 
      if (sb->Length % 60 == 0)
         sb->AppendLine();          
   }                    
   sw->Write(sb->ToString());
   sw->Close();
}
using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      StringBuilder sb = new StringBuilder();
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                                         false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         sb.Append(Convert.ToChar(rnd.Next(1, 0x0530))); 
         if (sb.Length % 60 == 0)
            sb.AppendLine();          
      }                    
      sw.Write(sb.ToString());
      sw.Close();
   }
}
Imports System.IO
Imports System.Text

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim sb As New StringBuilder()
      Dim sw As New StreamWriter(".\StringFile.txt", 
                                 False, Encoding.Unicode)

      For ctr As Integer = 0 To 1000
         sb.Append(ChrW(rnd.Next(1, &h0530))) 
         If sb.Length Mod 60 = 0 Then sb.AppendLine()          
      Next                    
      sw.Write(sb.ToString())
      sw.Close()
   End Sub
End Module

문화권 구분 작업 및 서 수Ordinal vs. culture-sensitive operations

멤버는 String 서 수 또는 문화권 (언어) 작업을 수행 하는 클래스를 String 개체입니다.Members of the String class perform either ordinal or culture-sensitive (linguistic) operations on a String object. 각각의 숫자 값에는 서 수이 연산은 Char 개체입니다.An ordinal operation acts on the numeric value of each Char object. 값에 문화권 구분 작업을 수행 합니다 String 개체 및는 문화권별 대/소문자 구분, 정렬, 형식 및 계정에 규칙을 구문 분석 합니다.A culture-sensitive operation acts on the value of the String object, and takes culture-specific casing, sorting, formatting, and parsing rules into account. 문화권 구분 작업을 명시적으로 선언 된 문화권 이나 암시적 현재 문화권의 컨텍스트에서 실행합니다.Culture-sensitive operations execute in the context of an explicitly declared culture or the implicit current culture. 동일한 문자열에 수행 하는 경우 두 종류의 작업에서 매우 다른 결과 생성할 수 있습니다.The two kinds of operations can produce very different results when they are performed on the same string.

.NET 고정 문화권을 사용 하 여 문화권을 구분 하지 않는 언어적 문자열 작업도 지원 (CultureInfo.InvariantCulture), 영어 영역의 독립의 culture 설정을 기준으로 하는 느슨하게 합니다..NET also supports culture-insensitive linguistic string operations by using the invariant culture (CultureInfo.InvariantCulture), which is loosely based on the culture settings of the English language independent of region. 달리 System.Globalization.CultureInfo 설정, 고정 문화권의 설정 시스템에.net 버전 간에 시스템에서 단일 컴퓨터에서 일관성을 유지 하도록 보장 합니다.Unlike other System.Globalization.CultureInfo settings, the settings of the invariant culture are guaranteed to remain consistent on a single computer, from system to system, and across versions of .NET. 고정 문화권은 대기 모든 문화권에서 문자열 비교의 안정성을 보장 하는 블랙 박스 형태의 표시 및 순서 지정 수 있습니다.The invariant culture can be seen as a kind of black box that ensures stability of string comparisons and ordering across all cultures.

중요

응용 프로그램 파일 이름과 같은 기호 식별자에 대 한 보안 결정을 내리는 또는 명명 된 파이프 하는 경우, XML 파일에 텍스트 기반 데이터와 같은 지속형된 데이터에 대 한 작업 대신 문화권 구분 비교는 서 수 비교를 사용 해야 합니다.If your application makes a security decision about a symbolic identifier such as a file name or named pipe, or about persisted data such as the text-based data in an XML file, the operation should use an ordinal comparison instead of a culture-sensitive comparison. 서 수 비교를 문자를 비교의 이진 값에 따라서만 달라 집니다 하지만 문화권 구분 비교를 문화권에 따라 다른 결과 실제로 생성 수 때문입니다.This is because a culture-sensitive comparison can yield different results depending on the culture in effect, whereas an ordinal comparison depends solely on the binary value of the compared characters.

중요

형식의 매개 변수가 있는 오버 로드를 포함 하는 문자열 작업을 수행 하는 대부분의 메서드가 StringComparison, 메서드는 서 수 또는 문화권 구분 작업을 수행 하는지 여부를 지정할 수 있습니다.Most methods that perform string operations include an overload that has a parameter of type StringComparison, which enables you to specify whether the method performs an ordinal or culture-sensitive operation. 일반적으로 지우기 호출 메서드의 의도 확인 합니다.이 오버 로드를 호출 해야 합니다.In general, you should call this overload to make the intent of your method call clear. 모범 사례 및 문자열의 서 수 및 문화권 구분 작업을 사용 하기 위한 지침을 참조 하세요 를 사용 하 여 문자열에 대 한 모범 사례합니다.For best practices and guidance for using ordinal and culture-sensitive operations on strings, see Best Practices for Using Strings.

에 대 한 작업 대/소문자 구분구문 분석 및 서식 지정비교 및 정렬, 및 같은지 테스트 수 두 서 수 또는 문화권을 구분 합니다.Operations for casing, parsing and formatting, comparison and sorting, and testing for equality can be either ordinal or culture-sensitive. 다음 섹션에서는 각 범주의 작업을 설명합니다.The following sections discuss each category of operation.

지우기 호출 메서드의 의도 메서드 오버 로드를 호출 해야 합니다.You should always call a method overload that makes the intent of your method call clear. 호출 하는 대신에 예를 들어, 합니다 Compare(String, String) 현재 문화권의 규칙을 사용 하 여 두 문자열의 문화권 구분 비교를 수행 하는 방법 호출 해야 합니다 Compare(String, String, StringComparison) 값을 사용 하 여 메서드 StringComparison.CurrentCulture 에 대 한는 comparisonType 인수입니다.For example, instead of calling the Compare(String, String) method to perform a culture-sensitive comparison of two strings by using the conventions of the current culture, you should call the Compare(String, String, StringComparison) method with a value of StringComparison.CurrentCulture for the comparisonType argument. 자세한 내용은 문자열 사용에 대한 모범 사례를 참조하세요.For more information, see Best Practices for Using Strings.

Windows 운영 체제에 대한 정렬 및 비교 작업에 사용되는 문자 가중치에 대한 정보를 포함하는 텍스트 파일의 집합, 가중치 테이블 정렬 및 Linux 및 macOS의 정렬 가중치 테이블 기본 유니코드 데이터 정렬 요소 테이블을 다운로드할 수 있습니다.You can download the Sorting Weight Tables, a set of text files that contain information on the character weights used in sorting and comparison operations for Windows operating systems, and the Default Unicode Collation Element Table, the sort weight table for Linux and macOS.

대/소문자 구분Casing

대/소문자 규칙 확인 된 유니코드 문자의 대/소문자를 변경 하는 방법 예를 들어 대문자 소문자입니다.Casing rules determine how to change the capitalization of a Unicode character; for example, from lowercase to uppercase. 종종 작업을 대/소문자 구분 문자열 비교 전에 수행 됩니다.Often, a casing operation is performed before a string comparison. 예를 들어, 다른 대문자 문자열을 사용 하 여 비교할 수 있도록 하는 문자열을 대문자로 변환 될 수 있습니다.For example, a string might be converted to uppercase so that it can be compared with another uppercase string. 호출 하 여 소문자로 문자열의 문자를 변환할 수 있습니다는 ToLowerToLowerInvariant 메서드를 호출 하 여 대문자로으로 변환할 수는 ToUpper 또는 ToUpperInvariant 메서드.You can convert the characters in a string to lowercase by calling the ToLower or ToLowerInvariant method, and you can convert them to uppercase by calling the ToUpper or ToUpperInvariant method. 또한 사용할 수 있습니다는 TextInfo.ToTitleCase 문자열 첫 글자를 대문자로 변환 하는 방법입니다.In addition, you can use the TextInfo.ToTitleCase method to convert a string to title case.

대/소문자 구분 작업은 현재 문화권, 지정된 된 문화권 이나 고정 문화권의 규칙에 기반 할 수 있습니다.Casing operations can be based on the rules of the current culture, a specified culture, or the invariant culture. 대/소문자 매핑 사용 하는 문화권에 따라 달라질 수 있으므로 대/소문자 구분 작업의 결과 문화권에 따라 달라질 수 있습니다.Because case mappings can vary depending on the culture used, the result of casing operations can vary based on culture. 실제 대/소문자 차이 세 가지 종류입니다.The actual differences in casing are of three kinds:

  • LATIN CAPITAL LETTER I의 대/소문자 매핑에의 차이점 (U + 0049), 라틴 문자 작은 문자 I (라는)를 LATIN CAPITAL LETTER I (U + 0130), 위에서 점 및 라틴 작은 문자 점 없는 I를 사용 하 여 (U + 0131).Differences in the case mapping of LATIN CAPITAL LETTER I (U+0049), LATIN SMALL LETTER I (U+0069), LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130), and LATIN SMALL LETTER DOTLESS I (U+0131). TR-TR (터키어 (터키)) 및 Latn-AZ-AZ (아제르바이잔, 라틴 문자) 문화권 및 tr, az, az Latn 중립 문화권에 해당 하는 라틴어 대문자 I의 소문자 라틴어 작은 문자 점 없는 I, 이며 라틴어 작은 문자 I의 대문자에 해당 라틴어 대문자 I 점 위를 사용 하 여 합니다.In the tr-TR (Turkish (Turkey)) and az-Latn-AZ (Azerbaijan, Latin) cultures, and in the tr, az, and az-Latn neutral cultures, the lowercase equivalent of LATIN CAPITAL LETTER I is LATIN SMALL LETTER DOTLESS I, and the uppercase equivalent of LATIN SMALL LETTER I is LATIN CAPITAL LETTER I WITH DOT ABOVE. 다른 모든 문화권에서 라틴 문자 작은 문자 I 및 LATIN CAPITAL LETTER 필자는 대 / 소문자 해당 하는 고정 문화권을 포함 합니다.In all other cultures, including the invariant culture, LATIN SMALL LETTER I and LATIN CAPITAL LETTER I are lowercase and uppercase equivalents.

    다음 예제에서는 어떻게 설계 하는 문자열 비교를 파일 시스템 액세스를 방지 하기 위해는 대/소문자 문화권 구분 비교를 사용 하는 경우 실패할 수 있습니다.The following example demonstrates how a string comparison designed to prevent file system access can fail if it relies on a culture-sensitive casing comparison. (고정 문화권의 대/소문자 규칙을 사용 합니다.)(The casing conventions of the invariant culture should have been used.)

    using System;
    using System.Globalization;
    using System.Threading;
    
    public class Example
    {
       const string disallowed = "file";
       
       public static void Main()
       {
          IsAccessAllowed(@"FILE:\\\c:\users\user001\documents\FinancialInfo.txt");
       }
    
       private static void IsAccessAllowed(String resource)
       {
          CultureInfo[] cultures = { CultureInfo.CreateSpecificCulture("en-US"),
                                     CultureInfo.CreateSpecificCulture("tr-TR") };
          String scheme = null;
          int index = resource.IndexOfAny( new Char[] { '\\', '/' } );
          if (index > 0) 
             scheme = resource.Substring(0, index - 1);
    
          // Change the current culture and perform the comparison.
          foreach (var culture in cultures) {
             Thread.CurrentThread.CurrentCulture = culture;
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
             Console.WriteLine(resource);
             Console.WriteLine("Access allowed: {0}", 
                               ! String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase));      
             Console.WriteLine();
          }   
       }
    }
    // The example displays the following output:
    //       Culture: English (United States)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: False
    //       
    //       Culture: Turkish (Turkey)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: True
    
    Imports System.Globalization
    Imports System.Threading
    
    Module Example
       Const disallowed = "file"
       
       Public Sub Main()
          IsAccessAllowed("FILE:\\\c:\users\user001\documents\FinancialInfo.txt")
       End Sub
    
       Private Sub IsAccessAllowed(resource As String)
          Dim cultures() As CultureInfo = { CultureInfo.CreateSpecificCulture("en-US"),
                                            CultureInfo.CreateSpecificCulture("tr-TR") }
          Dim scheme As String = Nothing
          Dim index As Integer = resource.IndexOfAny( {"\"c, "/"c })
          If index > 0 Then scheme = resource.Substring(0, index - 1)
    
          ' Change the current culture and perform the comparison.
          For Each culture In cultures
             Thread.CurrentThread.CurrentCulture = culture
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName)
             Console.WriteLine(resource)
             Console.WriteLine("Access allowed: {0}", 
                               Not String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase))      
             Console.WriteLine()
          Next   
       End Sub      
    End Module
    ' The example displays the following output:
    '       Culture: English (United States)
    '       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    '       Access allowed: False
    '       
    '       Culture: Turkish (Turkey)
    '       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    '       Access allowed: True
    
  • 대/소문자 매핑 고정 문화권 및 다른 모든 문화권 간의 차이점입니다.Differences in case mappings between the invariant culture and all other cultures. 이러한 경우 고정 문화권의 대/소문자 규칙을 사용 하 여 문자를 대문자 또는 소문자를 변경 하려면 같은 문자를 반환 합니다.In these cases, using the casing rules of the invariant culture to change a character to uppercase or lowercase returns the same character. 다른 모든 문화권에 다른 문자를 반환합니다.For all other cultures, it returns a different character. 일부 영향을 받는 문자는 다음 표에 나열 됩니다.Some of the affected characters are listed in the following table.

    문자Character 로 변경 하는 경우If changed to 반환 값Returns
    미크론 기호 (U + 00B5)MICRON SIGN (U+00B5) 대문자Uppercase 그리스어 대문자 MU (U +-39 C)GREEK CAPITAL LETTER MU (U+-39C)
    라틴어 대문자 I 점이 (U + 0130) 위에LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130) 소문자Lowercase 작은 라틴 문자 I (라는)LATIN SMALL LETTER I (U+0069)
    라틴어 소문자 점 없는 I (U + 0131)LATIN SMALL LETTER DOTLESS I (U+0131) 대문자Uppercase 라틴어 대문자 I (U + 0049)LATIN CAPITAL LETTER I (U+0049)
    영문 소문자 긴 S (U + 017F)LATIN SMALL LETTER LONG S (U+017F) 대문자Uppercase 라틴어 대문자 S (U + 0053)LATIN CAPITAL LETTER S (U+0053)
    파이프 기호 있는 작은 문자 Z로 영문 대문자 D (U + 01C 5)LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON (U+01C5) 소문자Lowercase 파이프 기호 있는 DZ 영문 소문자 (U + 01C 6)LATIN SMALL LETTER DZ WITH CARON (U+01C6)
    그리스어 YPOGEGRAMMENI 결합 (U + 0345)COMBINING GREEK YPOGEGRAMMENI (U+0345) 대문자Uppercase 그리스어 대문자 IOTA (U + 0399)GREEK CAPITAL LETTER IOTA (U+0399)
  • ASCII 문자 범위에서 두 문자의 소문자가 혼합 쌍의 대/소문자 매핑 차이입니다.Differences in case mappings of two-letter mixed-case pairs in the ASCII character range. 대부분의 문화권에서 두 문자의 소문자가 혼합 쌍은 해당 두 문자의 대문자 또는 소문자 쌍과 같습니다.In most cultures, a two-letter mixed-case pair is equal to the equivalent two-letter uppercase or lowercase pair. 이 아니므로 다음 문화에 다음 두 문자 쌍에 대 한 true 각각의 경우에서에 digraph 비교 됩니다.This is not true for the following two-letter pairs in the following cultures, because in each case they are compared to a digraph:

    • "lJ" 및 "nJ" HR-HR (크로아티아어 (크로아티아)) 문화권에 있습니다."lJ" and "nJ" in the hr-HR (Croatian (Croatia)) culture.

    • "cH" sk-SK (슬로바키아어 (슬로바키아)) 문화권에 CS-CZ (체코어 (체코 공화국))."cH" in the cs-CZ (Czech (Czech Republic)) and sk-SK (Slovak (Slovakia)) cultures.

    • "aA" DA-DK (덴마크어 (덴마크)) 문화권에서."aA" in the da-DK (Danish (Denmark)) culture.

    • "cS", "dZ", "dZS", "nY", "sZ", "tY" 및 "zS" HU-HU (헝가리어 (헝가리)) 문화권에서"cS", "dZ", "dZS", "nY", "sZ", "tY", and "zS" in the hu-HU (Hungarian (Hungary)) culture.

    • "cH" 및 "lL" es-es_tradnl (스페인어 (스페인, 전통 정렬)) 문화권에서."cH" and "lL" in the es-ES_tradnl (Spanish (Spain, Traditional Sort)) culture.

    • "cH", "gI", "kH", "nG" "nH", "pH", "qU',"tH"및"tR"vi-VN (베트남어 (베트남)) 문화권에서."cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH", and "tR" in the vi-VN (Vietnamese (Vietnam)) culture.

    그러나 이러한 쌍 고정된 문자열 또는 식별자에서 일반적으로 없기 때문에 이러한 쌍의 문화권 구분 비교를 만드는 문제의 상황이 발생 하는 데 평소 아닙니다.However, it is unusual to encounter a situation in which a culture-sensitive comparison of these pairs creates problems, because these pairs are uncommon in fixed strings or identifiers.

다음 예제에서는 대/소문자 규칙의 문화권 문자열을 대문자로 변환 하는 경우 간의 차이점 중 일부를 보여 줍니다.The following example illustrates some of the differences in casing rules between cultures when converting strings to uppercase.

using namespace System;
using namespace System::Globalization;
using namespace System::IO;

String^ ShowHexValue(String^ s);

void main()
{
   StreamWriter^ sw = gcnew StreamWriter(".\\case.txt");   
   array<String^>^ words = gcnew array<String^> { L"file", L"sıfır", L"Dženana" };
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               gcnew CultureInfo("en-US"),  
                                                               gcnew CultureInfo("tr-TR") };

   for each (String^ word in words) {
      sw->WriteLine("{0}:", word);
      for each (CultureInfo^ culture in cultures) {
         String^ name = String::IsNullOrEmpty(culture->Name) ? 
                              "Invariant" : culture->Name;
         String^ upperWord = word->ToUpper(culture);
         sw->WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                        upperWord, ShowHexValue(upperWord));

      }
      sw->WriteLine();  
   }
   sw->Close();
}

String^ ShowHexValue(String^ s)
{
   String^ retval = nullptr;
   for each (Char ch in s) {
      array<Byte>^ bytes = BitConverter::GetBytes(ch);
      retval += String::Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
   }
   return retval;
} 
// The example displays the following output: 
//    file: 
//        Invariant:    FILE               00 46 00 49 00 4C 00 45  
//            en-US:    FILE               00 46 00 49 00 4C 00 45  
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45  
//     
//    sıfır: 
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52  
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52  
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52  
//     
//    Dženana: 
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41  
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41  
//            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\case.txt");   
      string[] words = { "file", "sıfır", "Dženana" };
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"),  
                                 new CultureInfo("tr-TR") };

      foreach (var word in words) {
         sw.WriteLine("{0}:", word);
         foreach (var culture in cultures) {
            string name = String.IsNullOrEmpty(culture.Name) ? 
                                 "Invariant" : culture.Name;
            string upperWord = word.ToUpper(culture);
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord));
     
         }
         sw.WriteLine();  
      }
      sw.Close();
   }

   private static string ShowHexValue(string s)
   {
      string retval = null;
      foreach (var ch in s) {
         byte[] bytes = BitConverter.GetBytes(ch);
         retval += String.Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
      }
      return retval;
   } 
}
// The example displays the following output:
//    file:
//        Invariant:    FILE               00 46 00 49 00 4C 00 45 
//            en-US:    FILE               00 46 00 49 00 4C 00 45 
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
//    
//    sıfır:
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//    
//    Dženana:
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
//            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
Imports System.Globalization
Imports System.IO

Module Example
   Public Sub Main()
      Dim sw As New StreamWriter(".\case.txt")   
      Dim words As String() = { "file", "sıfır", "Dženana" }
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        New CultureInfo("en-US"),  
                                        New CultureInfo("tr-TR") }

      For Each word In words
         sw.WriteLine("{0}:", word)
         For Each culture In cultures
            Dim name As String = If(String.IsNullOrEmpty(culture.Name),  
                                 "Invariant", culture.Name)
            Dim upperWord As String = word.ToUpper(culture)
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord))
     
         Next
         sw.WriteLine()  
      Next
      sw.Close()
   End Sub

   Private Function ShowHexValue(s As String) As String
      Dim retval As String = Nothing
      For Each ch In s
         Dim bytes() As Byte = BitConverter.GetBytes(ch)
         retval += String.Format("{0:X2} {1:X2} ", bytes(1), bytes(0))     
      Next
      Return retval
   End Function
End Module
' The example displays the following output:
'    file:
'        Invariant:    FILE               00 46 00 49 00 4C 00 45 
'            en-US:    FILE               00 46 00 49 00 4C 00 45 
'            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
'    
'    sıfır:
'        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
'            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
'            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
'    
'    Dženana:
'        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
'            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
'            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41  

구문 분석 및 서식 지정Parsing and formatting

서식 지정 및 구문 분석은 역 작업입니다.Formatting and parsing are inverse operations. 서식 설정 규칙 구문 분석 규칙에는 날짜 및 시간과 같은 값으로 문자열 표현을 변환 하는 방법을 결정 하는 반면 같은 날짜 및 시간 또는 숫자 값을 문자열 표현으로 변환 하는 방법을 결정 합니다.Formatting rules determine how to convert a value, such as a date and time or a number, to its string representation, whereas parsing rules determine how to convert a string representation to a value such as a date and time. 서식 지정 및 구문 분석 규칙에는 문화권 규칙에 따라 다릅니다.Both formatting and parsing rules are dependent on cultural conventions. 다음 예에서는 culture 별 날짜 문자열을 해석할 때 발생할 수 있는 모호성을 보여 줍니다.The following example illustrates the ambiguity that can arise when interpreting a culture-specific date string. 날짜 문자열을 생성 하는 데 사용 된 문화권의 규칙을 알고 있으면 없이 불가능 2011 년 03 월 01, 2011 년 3 월 1/및 2011/01/03 2011 년 1 월 3 일 또는 2011 년 3 월 1 표현 하는지 여부를 알아야 합니다.Without knowing the conventions of the culture that was used to produce a date string, it is not possible to know whether 03/01/2011, 3/1/2011, and 01/03/2011 represent January 3, 2011 or March 1, 2011.

using namespace System;
using namespace System::Globalization;

void main()
{
   DateTime^ date = gcnew DateTime(2011, 3, 1);
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               gcnew CultureInfo("en-US"), 
                                                               gcnew CultureInfo("fr-FR") };

   for each (CultureInfo^ culture in cultures)
      Console::WriteLine("{0,-12} {1}", String::IsNullOrEmpty(culture->Name) ?
                        "Invariant" : culture->Name, 
                        date->ToString("d", culture));                                    
}
// The example displays the following output: 
//       Invariant    03/01/2011 
//       en-US        3/1/2011 
//       fr-FR        01/03/2011
using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date = new DateTime(2011, 3, 1);
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"), 
                                 new CultureInfo("fr-FR") };

      foreach (var culture in cultures)
         Console.WriteLine("{0,-12} {1}", String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.ToString("d", culture));                                    
   }
}
// The example displays the following output:
//       Invariant    03/01/2011
//       en-US        3/1/2011
//       fr-FR        01/03/2011
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dat As Date = #3/1/2011#
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        New CultureInfo("en-US"), 
                                        New CultureInfo("fr-FR") }

      For Each culture In cultures
         Console.WriteLine("{0,-12} {1}", If(String.IsNullOrEmpty(culture.Name), 
                           "Invariant", culture.Name), 
                           dat.ToString("d", culture))
      Next                                                         
   End Sub
End Module
' The example displays the following output:
'       Invariant    03/01/2011
'       en-US        3/1/2011
'       fr-FR        01/03/2011

마찬가지로, 다음 예제와 같이 단일 문자열을 구문 분석 작업에서 규칙이 포함 되는 문화권에 따라 서로 다른 날짜를 생성할 수 있습니다.Similarly, as the following example shows, a single string can produce different dates depending on the culture whose conventions are used in the parsing operation.

using namespace System;
using namespace System::Globalization;

void main()
{
   String^ dateString = "07/10/2011";
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               CultureInfo::CreateSpecificCulture("en-GB"), 
                                                               CultureInfo::CreateSpecificCulture("en-US") };
   Console::WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                "Month", "Day");
   for each (CultureInfo^ culture in cultures) {
      DateTime date = DateTime::Parse(dateString, culture);
      Console::WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                        String::IsNullOrEmpty(culture->Name) ?
                        "Invariant" : culture->Name, 
                        date.Month, date.Day);
   }                      
}
// The example displays the following output: 
//       Date String     Culture    Month      Day 
//        
//       07/10/2011    Invariant        7       10 
//       07/10/2011        en-GB       10        7 
//       07/10/2011        en-US        7       10

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString = "07/10/2011";
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 CultureInfo.CreateSpecificCulture("en-GB"), 
                                 CultureInfo.CreateSpecificCulture("en-US") };
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                 "Month", "Day");
      foreach (var culture in cultures) {
         DateTime date = DateTime.Parse(dateString, culture);
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.Month, date.Day);
      }                      
   }
}
// The example displays the following output:
//       Date String     Culture    Month      Day
//       
//       07/10/2011    Invariant        7       10
//       07/10/2011        en-GB       10        7
//       07/10/2011        en-US        7       10
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateString As String = "07/10/2011"
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        CultureInfo.CreateSpecificCulture("en-GB"), 
                                        CultureInfo.CreateSpecificCulture("en-US") }
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", "Date String", "Culture", 
                                                 "Month", "Day")
      Console.WriteLine()                                                 
      For Each culture In cultures
         Dim dat As Date = DateTime.Parse(dateString, culture)
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           If(String.IsNullOrEmpty(culture.Name), 
                           "Invariant", culture.Name), 
                           dat.Month, dat.Day)
      Next
   End Sub
End Module
' The example displays the following output:
'       Date String     Culture    Month      Day
'       
'       07/10/2011    Invariant        7       10
'       07/10/2011        en-GB       10        7
'       07/10/2011        en-US        7       10

문자열 비교 및 정렬String comparison and sorting

문자열 정렬 및 비교에 대 한 규칙에는 문화권 달라 집니다.Conventions for comparing and sorting strings vary from culture to culture. 예를 들어, 정렬 순서 음성 또는 문자의 시각적 표현을 기반 수 있습니다.For example, the sort order may be based on phonetics or on the visual representation of characters. 동아시아 언어에서는 표의 문자의 부수와 획에 따라 문자가 정렬됩니다.In East Asian languages, characters are sorted by the stroke and radical of ideographs. 언어와 문화권이 알파벳에 사용하는 순서에 따라 정렬 순서가 달라지기도 합니다.Sorting also depends on the order languages and cultures use for the alphabet. 예를 들어 덴마크어 알파벳의 "Æ" 문자는 "Z" 다음에 옵니다.For example, the Danish language has an "Æ" character that it sorts after "Z" in the alphabet. 또한 대/소문자 구분 또는 대/소문자를 비교 될 수 있습니다 및 일부 경우에서 대/소문자 규칙에 따라서도 문화권입니다.In addition, comparisons can be case-sensitive or case-insensitive, and in some cases casing rules also differ by culture. 반면에 서 수 비교를 비교 하 고 문자열을 정렬 하는 경우 문자열에서 개별 문자의 유니코드 코드 포인트를 사용 합니다.Ordinal comparison, on the other hand, uses the Unicode code points of individual characters in a string when comparing and sorting strings.

정렬 규칙을 서로 비교 하는 알파벳이 유니코드 문자 순서와 두 문자열을 결정 합니다.Sort rules determine the alphabetic order of Unicode characters and how two strings compare to each other. 예를 들어 합니다 String.Compare(String, String, StringComparison) 기반으로 하는 두 문자열을 비교 하는 메서드는 StringComparison 매개 변수입니다.For example, the String.Compare(String, String, StringComparison) method compares two strings based on the StringComparison parameter. 매개 변수 값이 StringComparison.CurrentCulture, 메서드 매개 변수 값이 현재 문화권의 규칙을 사용 하는 언어 비교를 수행 StringComparison.Ordinal, 메서드는 서 수 비교를 수행 합니다.If the parameter value is StringComparison.CurrentCulture, the method performs a linguistic comparison that uses the conventions of the current culture; if the parameter value is StringComparison.Ordinal, the method performs an ordinal comparison. 따라서 다음 예와 같이, 현재 문화권이 미국 영어, 첫 번째 호출은 String.Compare(String, String, StringComparison) 메서드 (문화권 구분 비교 사용) "A", "a" 작음 되었지만 두 번째 호출 (서 수 비교 사용) 같은 방법으로 간주 "a" "A" 보다 큰 합니다.Consequently, as the following example shows, if the current culture is U.S. English, the first call to the String.Compare(String, String, StringComparison) method (using culture-sensitive comparison) considers "a" less than "A", but the second call to the same method (using ordinal comparison) considers "a" greater than "A".

using namespace System;
using namespace System::Globalization;
using namespace System::Threading;

void main()
{
   Thread::CurrentThread->CurrentCulture = CultureInfo::CreateSpecificCulture("en-US");
   Console::WriteLine(String::Compare("A", "a", StringComparison::CurrentCulture));
   Console::WriteLine(String::Compare("A", "a", StringComparison::Ordinal));
}
// The example displays the following output: 
//       1 
//       -32
using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture));
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       1
//       -32
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture))
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal))
   End Sub
End Module
' The example displays the following output:
'       1                                                                                     
'       -32

.NET에서는 단어, 문자열 및 서 수 정렬 규칙을 지원합니다..NET supports word, string, and ordinal sort rules:

  • 단어 정렬 특정 영숫자가 아닌 유니코드 문자에 특별 한 가중치가 할당 해야 할 수 있는 문자열의 문화권 구분 비교를 수행 합니다.A word sort performs a culture-sensitive comparison of strings in which certain nonalphanumeric Unicode characters might have special weights assigned to them. 예를 들어, 하이픈 (-)는 매우 작은 가중치가 할당 "coop" 및 "co-op" 정렬된 된 목록에 나란히 표시 되도록 있을 수 있습니다.For example, the hyphen (-) might have a very small weight assigned to it so that "coop" and "co-op" appear next to each other in a sorted list. 목록은 String 단어 정렬 규칙을 사용 하 여 두 문자열을 비교 하는 메서드를 참조 합니다 범주별 문자열 작업 섹션입니다.For a list of the String methods that compare two strings using word sort rules, see the String operations by category section.

  • 또한 문자열 정렬 문화권 구분 비교를 수행합니다.A string sort also performs a culture-sensitive comparison. 이 특수 한 사례가 없습니다, 모든 영숫자 유니코드 문자를 앞으로 모든 영숫자가 아닌 기호가 있다는 점을 제외 하면에 단어 정렬 비슷합니다.It is similar to a word sort, except that there are no special cases, and all nonalphanumeric symbols come before all alphanumeric Unicode characters. 문자열 정렬 규칙을 사용 하 여 호출 하 여 두 문자열을 비교할 수는 CompareInfo.Compare 메서드 오버 로드의 경우는 options 의 값이 제공 되는 매개 변수가 CompareOptions.StringSort합니다.Two strings can be compared using string sort rules by calling the CompareInfo.Compare method overloads that have an options parameter that is supplied a value of CompareOptions.StringSort. 이.NET 문자열 정렬 규칙을 사용 하 여 두 문자열을 비교를 제공 하는 유일한 방법은 note 합니다.Note that this is the only method that .NET provides to compare two strings using string sort rules.

  • 각각의 숫자 값을 기반으로 하는 문자열을 비교 하는 서 수 정렬 Char 문자열에는 개체입니다.An ordinal sort compares strings based on the numeric value of each Char object in the string. 서 수 비교는 대 / 소문자 버전의 문자는 점이 다른 코드 때문에 자동으로 대/소문자 구분입니다.An ordinal comparison is automatically case-sensitive because the lowercase and uppercase versions of a character have different code points. 그러나 대/소문자는 중요 하지 않습니다, 경우에 대/소문자를 구분 하지 않는 서 수 비교를 지정할 수 있습니다.However, if case is not important, you can specify an ordinal comparison that ignores case. 문자열을 고정 문화권을 사용 하 고 다음 결과에 서 수 비교를 수행 하 여 대문자로 변환 하는 것과 같습니다.This is equivalent to converting the string to uppercase by using the invariant culture and then performing an ordinal comparison on the result. 목록은 String 서 수 정렬 규칙을 사용 하 여 두 문자열을 비교 하는 메서드를 참조 합니다 범주별 문자열 작업 섹션입니다.For a list of the String methods that compare two strings using ordinal sort rules, see the String operations by category section.

문화권 구분 비교는 명시적 또는 암시적으로 사용 하는 모든 비교는 CultureInfo 에 지정 된 고정 문화권을 포함 하 여 개체를 CultureInfo.InvariantCulture 속성.A culture-sensitive comparison is any comparison that explicitly or implicitly uses a CultureInfo object, including the invariant culture that is specified by the CultureInfo.InvariantCulture property. 암시적 문화권은 현재 문화권으로 지정 되는 Thread.CurrentCultureCultureInfo.CurrentCulture 속성입니다.The implicit culture is the current culture, which is specified by the Thread.CurrentCulture and CultureInfo.CurrentCulture properties. 영문자의 정렬 순서에서 상당한 변화는 (는 문자, 합니다 Char.IsLetter 속성이 반환 true) 문화권에 걸쳐 합니다.There is considerable variation in the sort order of alphabetic characters (that is, characters for which the Char.IsLetter property returns true) across cultures. 제공 하 여 특정 문화권의 규칙을 사용 하는 문화권 구분 비교를 지정할 수 있습니다는 CultureInfo 와 같은 개체는 문자열 비교 메서드를 Compare(String, String, CultureInfo, CompareOptions)입니다.You can specify a culture-sensitive comparison that uses the conventions of a specific culture by supplying a CultureInfo object to a string comparison method such as Compare(String, String, CultureInfo, CompareOptions). 제공 하 여 현재 문화권의 규칙을 사용 하는 문화권 구분 비교를 지정할 수 있습니다 StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase, 또는의 모든 멤버는 CompareOptions 이외의 열거형 CompareOptions.Ordinal 또는 CompareOptions.OrdinalIgnoreCase 를 적절 한 오버 로드는 Compare 메서드.You can specify a culture-sensitive comparison that uses the conventions of the current culture by supplying StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase, or any member of the CompareOptions enumeration other than CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase to an appropriate overload of the Compare method. 문화권 구분 비교는 서 수 비교 하는 반면 정렬에 대 한 일반적으로 적합 합니다.A culture-sensitive comparison is generally appropriate for sorting whereas an ordinal comparison is not. 서 수 비교는 두 문자열이 같은지 여부를 결정 하는 데 일반적으로 적절 한 (즉, id 확인에 대 한) 문화권 구분 비교는 없습니다.An ordinal comparison is generally appropriate for determining whether two strings are equal (that is, for determining identity) whereas a culture-sensitive comparison is not.

다음 예제에서는 문화권 구분 및 서 수 비교 간의 차이점을 보여 줍니다.The following example illustrates the difference between culture-sensitive and ordinal comparison. 이 예제에서는 세 문자열, "Apple", "æ b l e" 및 "AEble", 서 수 비교 및 DA-DK 및 EN-US 문화권의 규칙을 사용 하 여 평가 (시 기본 문화권은 각각는 Compare 메서드는).The example evaluates three strings, "Apple", "Æble", and "AEble", using ordinal comparison and the conventions of the da-DK and en-US cultures (each of which is the default culture at the time the Compare method is called). 덴마크어 "→" 문자는 개별 문자를 처리 하 고 문자에서 "Z" 뒤에 정렬 하기 때문에 문자열 "æ b l e"는 "Apple" 보다 큽니다.Because the Danish language treats the character "Æ" as an individual letter and sorts it after "Z" in the alphabet, the string "Æble" is greater than "Apple". 그러나 "æ b l e" 간주 되지 않습니다 "AEble" 같음 "æ b l e"를 "AEble" 보다 큰 이기도 하므로.However, "Æble" is not considered equivalent to "AEble", so "Æble" is also greater than "AEble". EN-US 문화권 "→" 문자를 포함 하지 않습니다 하지만 동일한 "AE" 이유 "æ b l e"는 "Apple" 보다 작지만 "AEble" 같은 설명 하는 것으로 처리 합니다.The en-US culture doesn't include the letter"Æ" but treats it as equivalent to "AE", which explains why "Æble" is less than "Apple" but equal to "AEble". 서 수 비교는 반면에 "Apple" "AEble" 보다 큰 값으로 "æ b l e" 및 "æ b l e" 보다 작아야를 고려 합니다.Ordinal comparison, on the other hand, considers "Apple" to be less than "Æble", and "Æble" to be greater than "AEble".

using System;
using System.Globalization;
using System.Threading;

public class CompareStringSample
{
   public static void Main()
   {
      string str1 = "Apple";
      string str2 = "Æble"; 
      string str3 = "AEble";
      
      // Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));
      
      // Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));
      
      // Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison");
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal));
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       Current culture: da-DK
//       Comparison of Apple with Æble: -1
//       Comparison of Æble with AEble: 1
//       
//       Current culture: en-US
//       Comparison of Apple with Æble: 1
//       Comparison of Æble with AEble: 0
//       
//       Ordinal comparison
//       Comparison of Apple with Æble: -133
//       Comparison of Æble with AEble: 133
Imports System.Globalization
Imports System.Threading

Public Module Example
   Public Sub Main()
      Dim str1 As String = "Apple"
      Dim str2 As String = "Æble"
      Dim str3 As String = "AEble"
      
      ' Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, String.Compare(str2, str3))
      Console.WriteLine()
      
      ' Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, String.Compare(str2, str3))
      Console.WriteLine()
      
      ' Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison")
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal))
   End Sub
End Module
' The example displays the following output:
'       Current culture: da-DK
'       Comparison of Apple with Æble: -1
'       Comparison of Æble with AEble: 1
'       
'       Current culture: en-US
'       Comparison of Apple with Æble: 1
'       Comparison of Æble with AEble: 0
'       
'       Ordinal comparison
'       Comparison of Apple with Æble: -133
'       Comparison of Æble with AEble: 133

적절 한 정렬 또는 문자열 비교 방법을 선택 하려면 다음 일반 지침을 사용 합니다.Use the following general guidelines to choose an appropriate sorting or string comparison method:

  • 문자열을 정렬할 수를 지정 하지 않고 사용자의 문화권을 기반으로 하려는 경우 현재 문화권의 규칙을 기반으로 주문할 해야 있습니다.If you want the strings to be ordered based on the user's culture, you should order them based on the conventions of the current culture. 사용자의 문화권 변경 되 면 정렬 된 문자열의 순서도 그에 따라 변경 됩니다.If the user's culture changes, the order of sorted strings will also change accordingly. 예를 들어 동의어 사전 응용 프로그램을 사용자의 문화권을 기준으로 단어를 항상 정렬 해야 합니다.For example, a thesaurus application should always sort words based on the user's culture.

  • 문자열을 정렬할 수를 지정 하지 않고 특정 문화권의 규칙에 따라 하려는 경우 제공에 따라 정렬 해야 하는 CultureInfo 비교 메서드에 해당 문화권을 나타내는 개체입니다.If you want the strings to be ordered based on the conventions of a specific culture, you should order them by supplying a CultureInfo object that represents that culture to a comparison method. 예를 들어, 학생에 게 특정 언어를 설명 하도록 응용 프로그램에서 원하는 문자열을 정렬할 익히면 해당 하는 문화권 중 하나로의 규칙에 따라 합니다.For example, in an application designed to teach students a particular language, you want strings to be ordered based on the conventions of one of the cultures that speaks that language.

  • 문화권에 걸쳐 그대로 문자열의 순서를 하려는 경우에 고정 문화권의 규칙을 기준으로 정렬 하거나 서 수 비교를 사용 해야 합니다.If you want the order of strings to remain unchanged across cultures, you should order them based on the conventions of the invariant culture or use an ordinal comparison. 예를 들어, 파일, 프로세스, 뮤텍스 이름을 구성 하는 서 수 정렬 사용 또는 명명 된 파이프 합니다.For example, you would use an ordinal sort to organize the names of files, processes, mutexes, or named pipes.

  • 보안 의사 결정 (예: 사용자가 유효한 지 여부)를 포함 하는 비교를 항상 수행 해야 같음에 대 한 서 수는 테스트의 오버 로드를 호출 하 여는 Equals 메서드.For a comparison that involves a security decision (such as whether a username is valid), you should always perform an ordinal test for equality by calling an overload of the Equals method.

참고

문화권 구분 정렬 및 문자열 비교에 사용 되는 규칙을 대/소문자 버전의.NET에 따라 달라 집니다.The culture-sensitive sorting and casing rules used in string comparison depend on the version of the .NET. 이상 버전에서 실행 되 고.NET Framework 4.5는 Windows 8Windows 8 유니코드 6.0 표준을 따르는 운영 체제, 정렬, 대/소문자 구분, 정규화 및 유니코드 문자 정보입니다.In the .NET Framework 4.5 and later versions running on the Windows 8Windows 8 operating system, sorting, casing, normalization, and Unicode character information conforms to the Unicode 6.0 standard. 다른 Windows 운영 체제에서 표준 유니코드 5.0에 맞습니다.On other Windows operating systems, it conforms to the Unicode 5.0 standard. .NET Core에서 기본 운영 체제에서 지원 되는 유니코드 표준의 버전에 따라 다릅니다.On .NET Core, it depends on the version of the Unicode Standard supported by the underlying operating system.

Word, 문자열 및 서 수 정렬 규칙에 대 한 자세한 내용은 참조는 System.Globalization.CompareOptions 항목입니다.For more information about word, string, and ordinal sort rules, see the System.Globalization.CompareOptions topic. 각 규칙을 사용 하는 경우에 추가 권장 사항을 참조 하세요 를 사용 하 여 문자열에 대 한 모범 사례합니다.For additional recommendations on when to use each rule, see Best Practices for Using Strings.

일반적으로 호출 하지 않으면 문자열 비교와 같은 메서드와 Compare 문자열의 정렬 순서를 결정 하려면 직접.Ordinarily, you don't call string comparison methods such as Compare directly to determine the sort order of strings. 와 같은 메서드를 정렬 하 여 비교 메서드는 호출 하는 대신 Array.Sort 또는 List<T>.Sort합니다.Instead, comparison methods are called by sorting methods such as Array.Sort or List<T>.Sort. 다음 예제에서는 명시적으로 문자열 비교 메서드를 호출 하지 않고 네 가지 정렬 작업 (현재 문화권, 고정 문화권을 사용 하 여 단어 정렬, 서 수 정렬 및 고정 문화권을 사용 하 여 문자열 정렬을 사용 하 여 단어 정렬) 수행 사용할 비교 형식을 지정지 않습니다 하지만.The following example performs four different sorting operations (word sort using the current culture, word sort using the invariant culture, ordinal sort, and string sort using the invariant culture) without explicitly calling a string comparison method, although they do specify the type of comparison to use. 각 유형의 정렬 배열에서 문자열의 고유한 순서를 생성 하는 참고 합니다.Note that each type of sort produces a unique ordering of strings in its array.

using namespace System;
using namespace System::Collections;
using namespace System::Collections::Generic;
using namespace System::Globalization;

// IComparer<String> implementation to perform string sort. 
ref class SCompare : System::Collections::Generic::IComparer<String^>
{
public:
   SCompare() {};

   virtual int Compare(String^ x, String^ y)
   {
      return CultureInfo::CurrentCulture->CompareInfo->Compare(x, y, CompareOptions::StringSort);
   }
};

void main()
{
   array<String^>^ strings = gcnew array<String^> { "coop", "co-op", "cooperative", 
                                                    L"co\x00ADoperative", L"c�ur", "coeur" };

   // Perform a word sort using the current (en-US) culture. 
   array<String^>^ current = gcnew array<String^>(strings->Length); 
   strings->CopyTo(current, 0); 
   Array::Sort(current, StringComparer::CurrentCulture);

   // Perform a word sort using the invariant culture. 
   array<String^>^ invariant = gcnew array<String^>(strings->Length);
   strings->CopyTo(invariant, 0); 
   Array::Sort(invariant, StringComparer::InvariantCulture);

   // Perform an ordinal sort. 
   array<String^>^ ordinal = gcnew array<String^>(strings->Length);
   strings->CopyTo(ordinal, 0); 
   Array::Sort(ordinal, StringComparer::Ordinal);

   // Perform a string sort using the current culture. 
   array<String^>^ stringSort = gcnew array<String^>(strings->Length);
   strings->CopyTo(stringSort, 0); 
   Array::Sort(stringSort, gcnew SCompare());

   // Display array values
   Console::WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                     "Original", "Word Sort", "Invariant Word", 
                     "Ordinal Sort", "String Sort");
   for (int ctr = 0; ctr < strings->Length; ctr++)
      Console::WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                         strings[ctr], current[ctr], invariant[ctr], 
                         ordinal[ctr], stringSort[ctr] );          
}
// The example displays the following output: 
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort 
//     
//             coop          c�ur            c�ur         co-op         co-op 
//            co-op         coeur           coeur         coeur          c�ur 
//      cooperative          coop            coop          coop         coeur 
//      co�operative         co-op           co-op   cooperative          coop 
//             c�ur   cooperative     cooperative   co�operative   cooperative 
//            coeur   co�operative     co�operative          c�ur   co�operative
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
 
public class Example
{
   public static void Main()
   {
      string[] strings = { "coop", "co-op", "cooperative", 
                           "co\u00ADoperative", "cœur", "coeur" };

      // Perform a word sort using the current (en-US) culture.
      string[] current = new string[strings.Length]; 
      strings.CopyTo(current, 0); 
      Array.Sort(current, StringComparer.CurrentCulture);

      // Perform a word sort using the invariant culture.
      string[] invariant = new string[strings.Length];
      strings.CopyTo(invariant, 0); 
      Array.Sort(invariant, StringComparer.InvariantCulture);

      // Perform an ordinal sort.
      string[] ordinal = new string[strings.Length];
      strings.CopyTo(ordinal, 0); 
      Array.Sort(ordinal, StringComparer.Ordinal);

      // Perform a string sort using the current culture.
      string[] stringSort = new string[strings.Length];
      strings.CopyTo(stringSort, 0); 
      Array.Sort(stringSort, new SCompare());

      // Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort");
      for (int ctr = 0; ctr < strings.Length; ctr++)
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings[ctr], current[ctr], invariant[ctr], 
                           ordinal[ctr], stringSort[ctr] );          
   }
}

// IComparer<String> implementation to perform string sort.
internal class SCompare : IComparer<String>
{
   public int Compare(string x, string y)
   {
      return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort);
   }
}
// The example displays the following output:
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
//    
//             coop          cœur            cœur         co-op         co-op
//            co-op         coeur           coeur         coeur          cœur
//      cooperative          coop            coop          coop         coeur
//     co­operative         co-op           co-op   cooperative          coop
//             cœur   cooperative     cooperative  co­operative   cooperative
//            coeur  co­operative    co­operative          cœur  co­operative
Imports System.Collections
Imports System.Collections.Generic
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim strings() As String = { "coop", "co-op", "cooperative", 
                                  "co" + ChrW(&h00AD) + "operative", 
                                  "cœur", "coeur" }

      ' Perform a word sort using the current (en-US) culture.
      Dim current(strings.Length - 1) As String  
      strings.CopyTo(current, 0) 
      Array.Sort(current, StringComparer.CurrentCulture)

      ' Perform a word sort using the invariant culture.
      Dim invariant(strings.Length - 1) As String
      strings.CopyTo(invariant, 0) 
      Array.Sort(invariant, StringComparer.InvariantCulture)

      ' Perform an ordinal sort.
      Dim ordinal(strings.Length - 1) As String
      strings.CopyTo(ordinal, 0) 
      Array.Sort(ordinal, StringComparer.Ordinal)

      ' Perform a string sort using the current culture.
      Dim stringSort(strings.Length - 1) As String
      strings.CopyTo(stringSort, 0) 
      Array.Sort(stringSort, new SCompare())

      ' Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort")
      Console.WriteLine()
                                                      
      For ctr As Integer = 0 To strings.Length - 1
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings(ctr), current(ctr), invariant(ctr), 
                           ordinal(ctr), stringSort(ctr))   
      Next                                  
   End Sub
End Module

' IComparer<String> implementation to perform string sort.
Friend Class SCompare : Implements IComparer(Of String)
   Public Function Compare(x As String, y As String) As Integer _
                   Implements IComparer(Of String).Compare
      Return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort)
   End Function
End Class
' The example displays the following output:
'         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
'    
'             coop          cœur            cœur         co-op         co-op
'            co-op         coeur           coeur         coeur          cœur
'      cooperative          coop            coop          coop         coeur
'     co­operative         co-op           co-op   cooperative          coop
'             cœur   cooperative     cooperative  co­operative   cooperative
'            coeur  co­operative    co­operative          cœur  co­operative

내부적으로.NET 정렬 키를 사용 하 여 문화권 구분 문자열 비교를 지원 합니다.Internally, .NET uses sort keys to support culturally sensitive string comparison. 문자열의 각 문자에는 사전순, 대/소문자 및 분음 부호를 포함하여 여러 범주의 정렬 가중치가 적용됩니다.Each character in a string is given several categories of sort weights, including alphabetic, case, and diacritic. 정렬 키를 나타내는 SortKey 클래스, 특정 문자열에 대 한 이러한 가중치의 리포지토리를 제공 합니다.A sort key, represented by the SortKey class, provides a repository of these weights for a particular string. 앱을 많은 수의 검색 또는 정렬 문자열의 동일한 집합에 대 한 작업을 수행 하는 경우 생성 하 고 사용 되는 모든 문자열에 대 한 정렬 키를 저장 하 여 성능을 개선할 수 있습니다.If your app performs a large number of searching or sorting operations on the same set of strings, you can improve its performance by generating and storing sort keys for all the strings that it uses. 정렬 또는 비교 작업이 필요한 경우에 문자열 대신 정렬 키를 사용 합니다.When a sort or comparison operation is required, you use the sort keys instead of the strings. 자세한 내용은 SortKey 클래스를 참조하세요.For more information, see the SortKey class.

문자열 비교 규칙을 지정 하지 않으면, 메서드 같은 정렬 Array.Sort(Array) 문자열에서 문화권 구분 및 대/소문자 구분 정렬을 수행 합니다.If you don't specify a string comparison convention, sorting methods such as Array.Sort(Array) perform a culture-sensitive, case-sensitive sort on strings. 다음 예제에서는 배열에서 정렬 된 문자열의 순서에 미치는 현재 문화권을 변경 하는 방법을 보여 줍니다.The following example illustrates how changing the current culture affects the order of sorted strings in an array. 세 문자열의 배열을 만듭니다.It creates an array of three strings. 우선 System.Threading.Thread.CurrentThread.CurrentCulture 속성을 "en-US"로 설정하고 Array.Sort(Array) 메서드를 호출합니다.First, it sets the System.Threading.Thread.CurrentThread.CurrentCulture property to en-US and calls the Array.Sort(Array) method. 결과 정렬 순서는 정렬 규칙 영어 (미국) 문화권을 기반으로 합니다.The resulting sort order is based on sorting conventions for the English (United States) culture. 다음으로 예제에서는 System.Threading.Thread.CurrentThread.CurrentCulture 속성을 da-DK로 설정하고 Array.Sort 메서드를 다시 호출합니다.Next, the example sets the System.Threading.Thread.CurrentThread.CurrentCulture property to da-DK and calls the Array.Sort method again. 덴마크어(덴마크)의 정렬 규칙을 사용하는 경우 결과 정렬 순서가 en-US 결과와 어떻게 다른지 확인해 봅니다.Notice how the resulting sort order differs from the en-US results because it uses the sorting conventions for Danish (Denmark).

using System;
using System.Globalization;
using System.Threading;

public class ArraySort 
{
   public static void Main(String[] args) 
   {
      // Create and initialize a new array to store the strings.
      string[] stringArray = { "Apple", "Æble", "Zebra"};

      // Display the values of the array.
      Console.WriteLine( "The original string array:");
      PrintIndexAndValues(stringArray);

      // Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      // Sort the values of the array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"en-US\":");
      PrintIndexAndValues(stringArray); 

      // Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      // Sort the values of the Array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"da-DK\":");
      PrintIndexAndValues(stringArray); 
   }
   public static void PrintIndexAndValues(string[] myArray)  
   {
      for (int i = myArray.GetLowerBound(0); i <= 
            myArray.GetUpperBound(0); i++ )
         Console.WriteLine("[{0}]: {1}", i, myArray[i]);
      Console.WriteLine();      
   }
}
// The example displays the following output:
//       The original string array:
//       [0]: Apple
//       [1]: Æble
//       [2]: Zebra
//       
//       After sorting for the "en-US" culture:
//       [0]: Æble
//       [1]: Apple
//       [2]: Zebra
//       
//       After sorting for the culture "da-DK":
//       [0]: Apple
//       [1]: Zebra
//       [2]: Æble
Imports System.Globalization
Imports System.IO
Imports System.Threading

Public Class TextToFile   
   Public Shared Sub Main()
      ' Creates and initializes a new array to store 
      ' these date/time objects.
      Dim stringArray() As String = { "Apple", "Æble", "Zebra"}
      
      ' Displays the values of the array.
      Console.WriteLine("The original string array:")
      PrintIndexAndValues(stringArray)
      
      ' Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
      ' Sort the values of the Array.
      Array.Sort(stringArray)
      
      ' Display the values of the array.
      Console.WriteLine("After sorting for the ""en-US"" culture:")
      PrintIndexAndValues(stringArray)
      
      ' Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
      ' Sort the values of the Array.
      Array.Sort(stringArray)
      
      ' Displays the values of the Array.
      Console.WriteLine("After sorting for the culture ""da-DK"":")
      PrintIndexAndValues(stringArray)
   End Sub

   Public Shared Sub PrintIndexAndValues(myArray() As String)
      For i As Integer = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
         Console.WriteLine("[{0}]: {1}", i, myArray(i))
      Next
      Console.WriteLine()
   End Sub 
End Class
' The example displays the following output:
'       The original string array:
'       [0]: Apple
'       [1]: Æble
'       [2]: Zebra
'       
'       After sorting for the "en-US" culture:
'       [0]: Æble
'       [1]: Apple
'       [2]: Zebra
'       
'       After sorting for the culture "da-DK":
'       [0]: Apple
'       [1]: Zebra
'       [2]: Æble

경고

기본 문자열 비교의 목적이 호출 해야 해당 값이 같은지 여부를 결정 하는 경우는 String.Equals 메서드.If your primary purpose in comparing strings is to determine whether they are equal, you should call the String.Equals method. 일반적으로 사용 해야 Equals 는 서 수 비교를 수행 합니다.Typically, you should use Equals to perform an ordinal comparison. String.Compare 메서드가 기본적으로 문자열을 정렬 하기에 적합 합니다.The String.Compare method is intended primarily to sort strings.

와 같은 문자열 검색 메서드를 String.StartsWithString.IndexOf, 또한 문화권 구분 또는 서 수 문자열 비교를 수행할 수 있습니다.String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons. 다음 예제에서는 서 수 및 문화권 구분 비교를 사용 하 여 차이 보여 줍니다.는 IndexOf 메서드.The following example illustrates the differences between ordinal and culture-sensitive comparisons using the IndexOf method. 현재 문화권의 영어 (미국) 문화권 구분 검색을 부분 문자열 "oe" 합자 "œ"와 일치 하도록 고려 합니다.A culture-sensitive search in which the current culture is English (United States) considers the substring "oe" to match the ligature "œ". 검색에서 동등 하 게 사용자 지정 하이픈을 처리 하는 하이픈이 (U + 00AD)는 너비가 0 인 문자 이므로 Empty 문자열의 시작 부분에서 일치 하는 항목을 찾습니다.Because a soft hyphen (U+00AD) is a zero-width character, the search treats the soft hyphen as equivalent to Empty and finds a match at the beginning of the string. 서 수 검색, 다른 한편으로 찾지 일치 하는 두 경우 모두.An ordinal search, on the other hand, does not find a match in either case.

using namespace System;

void FindInString(String^ s, String^ substring, StringComparison options);

void main()
{
   // Search for "oe" and "�u" in "�ufs" and "oeufs".
   String^ s1 = L"�ufs";
   String^ s2 = L"oeufs";
   FindInString(s1, "oe", StringComparison::CurrentCulture);
   FindInString(s1, "oe", StringComparison::Ordinal);
   FindInString(s2, "�u", StringComparison::CurrentCulture);
   FindInString(s2, "�u", StringComparison::Ordinal);
   Console::WriteLine();

   String^ s3 = L"co\x00ADoperative";
   FindInString(s3, L"\x00AD", StringComparison::CurrentCulture);
   FindInString(s3, L"\x00AD", StringComparison::Ordinal);
}

void FindInString(String^ s, String^ substring, StringComparison options)
{
   int result = s->IndexOf(substring, options);
   if (result != -1)
      Console::WriteLine("'{0}' found in {1} at position {2}", 
                        substring, s, result);
   else
      Console::WriteLine("'{0}' not found in {1}", 
                        substring, s);                                                  
}
// The example displays the following output:
//      'oe' found in oufs at position 0
//      'oe' not found in oufs
//      'ou' found in oeufs at position 0
//      'ou' not found in oeufs
//
//      '-' found in co-operative at position 0
//      '-' found in co-operative at position 2
using System;

public class Example
{
   public static void Main()
   {
      // Search for "oe" and "œu" in "œufs" and "oeufs".
      string s1 = "œufs";
      string s2 = "oeufs";
      FindInString(s1, "oe", StringComparison.CurrentCulture);
      FindInString(s1, "oe", StringComparison.Ordinal);
      FindInString(s2, "œu", StringComparison.CurrentCulture);
      FindInString(s2, "œu", StringComparison.Ordinal);
      Console.WriteLine();
      
      string s3 = "co\u00ADoperative";
      FindInString(s3, "\u00AD", StringComparison.CurrentCulture);
      FindInString(s3, "\u00AD", StringComparison.Ordinal);
   }

   private static void FindInString(string s, string substring, StringComparison options)
   {
      int result = s.IndexOf(substring, options);
      if (result != -1)
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result);
      else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s);                                                  
   }
}
// The example displays the following output:
//       'oe' found in œufs at position 0
//       'oe' not found in œufs
//       'œu' found in oeufs at position 0
//       'œu' not found in oeufs
//       
//       '­' found in co­operative at position 0
//       '­' found in co­operative at position 2
Module Example
   Public Sub Main()
      ' Search for "oe" and "œu" in "œufs" and "oeufs".
      Dim s1 As String = "œufs"
      Dim s2 As String = "oeufs"
      FindInString(s1, "oe", StringComparison.CurrentCulture)
      FindInString(s1, "oe", StringComparison.Ordinal)
      FindInString(s2, "œu", StringComparison.CurrentCulture)
      FindInString(s2, "œu", StringComparison.Ordinal)
      Console.WriteLine()
      
      Dim softHyphen As String = ChrW(&h00AD)
      Dim s3 As String = "co" + softHyphen + "operative"
      FindInString(s3, softHyphen, StringComparison.CurrentCulture)
      FindInString(s3, softHyphen, StringComparison.Ordinal)
   End Sub

   Private Sub FindInString(s As String, substring As String, 
                            options As StringComparison)
      Dim result As Integer = s.IndexOf(substring, options)
      If result <> -1
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result)
      Else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s)
      End If                                                                          
   End Sub
End Module
' The example displays the following output:
'       'oe' found in œufs at position 0
'       'oe' not found in œufs
'       'œu' found in oeufs at position 0
'       'œu' not found in oeufs
'       
'       '­' found in co­operative at position 0
'       '­' found in co­operative at position 2

문자열 검색Searching Strings

와 같은 문자열 검색 메서드를 String.StartsWithString.IndexOf, 또한 문화권별으로 수행할 수 있습니다 또는 지정된 된 문자열의 서 수 문자열 비교 문자나 부분 문자열을 여부를 확인 하려면가 있습니다.String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons to determine whether a character or substring is found in a specified string.

에 검색 메서드는 String 와 같은 개별 문자를 검색 하는 클래스를 IndexOf 메서드 또는 문자 집합 중 하나 같은 IndexOfAny 메서드를 모든 서 수 검색을 수행 합니다.The search methods in the String class that search for an individual character, such as the IndexOf method, or one of a set of characters, such as the IndexOfAny method, all perform an ordinal search. 호출 된 문자에 대 한 문화권 구분 검색을 수행 해야 합니다는 CompareInfo 메서드와 같은 CompareInfo.IndexOf(String, Char) 또는 CompareInfo.LastIndexOf(String, Char)합니다.To perform a culture-sensitive search for a character, you must call a CompareInfo method such as CompareInfo.IndexOf(String, Char) or CompareInfo.LastIndexOf(String, Char). 참고 서 수 및 문화권 구분 비교를 사용 하 여 문자에 대 한 검색 결과 매우 달라질 수 있습니다.Note that the results of searching for a character using ordinal and culture-sensitive comparison can be very different. 예를 들어 합자 "→"와 같은 미리 구성 된 유니코드 문자에 대 한 검색 (U + 00 C 6) 수 찾습니다 모든 "AE"와 같은 올바른 순서로 구성 요소 (U + 041U + 0045) 문화권에 따라 합니다.For example, a search for a precomposed Unicode character such as the ligature "Æ" (U+00C6) might match any occurrence of its components in the correct sequence, such as "AE" (U+041U+0045), depending on the culture. 다음 예제에서는 차이점을 보여 줍니다.는 String.IndexOf(Char)CompareInfo.IndexOf(String, Char) 개별 문자를 검색할 때 메서드.The following example illustrates the difference between the String.IndexOf(Char) and CompareInfo.IndexOf(String, Char) methods when searching for an individual character. 합자 "→" (U + 00E6)가 문자열에 "항공" EN-US 문화권의 규칙을 사용 하는 경우 있지만 DA-DK 문화권의 규칙을 사용 하 여 때가 아니라 또는 서 수 비교를 수행 하는 경우.The ligature "æ" (U+00E6) is found in the string "aerial" when using the conventions of the en-US culture, but not when using the conventions of the da-DK culture or when performing an ordinal comparison.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "da-DK", "en-US" };
      CompareInfo ci;
      String str = "aerial";
      Char ch = 'æ';  // U+00E6
      
      Console.Write("Ordinal comparison -- ");
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch));
      
      foreach (var cultureName in cultureNames) {
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo;
         Console.Write("{0} cultural comparison -- ", cultureName);
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch));
      }
   }
}
// The example displays the following output:
//       Ordinal comparison -- Position of 'æ' in aerial: -1
//       da-DK cultural comparison -- Position of 'æ' in aerial: -1
//       en-US cultural comparison -- Position of 'æ' in aerial: 0
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "da-DK", "en-US" }
      Dim ci As CompareInfo
      Dim str As String = "aerial"
      Dim ch As Char = "æ"c  ' U+00E6
      
      Console.Write("Ordinal comparison -- ")
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch))
      
      For Each cultureName In cultureNames
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo
         Console.Write("{0} cultural comparison -- ", cultureName)
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch))
      Next
   End Sub
End Module
' The example displays the following output:
'       Ordinal comparison -- Position of 'æ' in aerial: -1
'       da-DK cultural comparison -- Position of 'æ' in aerial: -1
'       en-US cultural comparison -- Position of 'æ' in aerial: 0

다른 한편 String 검색할 문자가 아니라 문자열 검색 옵션 형식의 매개 변수를 통해 명시적으로 지정 되지 않은 경우 문화권 구분 검색을 수행 하는 메서드를 클래스 StringComparison합니다.On the other hand, String class methods that search for a string rather than a character perform a culture-sensitive search if search options are not explicitly specified by a parameter of type StringComparison. 한 가지 예외는 Contains, 서 수 검색을 수행 합니다.The sole exception is Contains, which performs an ordinal search.

같음에 대 한 테스트Testing for equality

사용 된 String.Compare 정렬 순서에서 두 문자열의 관계를 결정 하는 방법입니다.Use the String.Compare method to determine the relationship of two strings in the sort order. 일반적으로 문화권 구분 작업입니다.Typically, this is a culture-sensitive operation. 반면, 호출 된 String.Equals 같은지 테스트 하는 방법입니다.In contrast, call the String.Equals method to test for equality. 같음 테스트는 일반적으로 파일 시스템 경로 올바른 사용자 이름, 암호 등의 몇 가지 알려진된 문자열을 사용 하 여 사용자 입력을 비교 하기 때문에 일반적으로 서 수에 연산입니다.Because the test for equality usually compares user input with some known string, such as a valid user name, a password, or a file system path, it is typically an ordinal operation.

경고

호출 하 여 같은지 테스트 하는 것이 불가능 합니다 String.Compare 메서드와 반환 값이 0 인지 여부를 결정 합니다.It is possible to test for equality by calling the String.Compare method and determining whether the return value is zero. 그러나이 방법은 권장 되지 않습니다.However, this practice is not recommended. 두 문자열이 같은지를 확인 하려면 호출 해야 오버 로드 중 하나는 String.Equals 메서드.To determine whether two strings are equal, you should call one of the overloads of the String.Equals method. 기본 오버 로드를 호출 되는 인스턴스 Equals(String, StringComparison) 메서드 또는 정적 Equals(String, String, StringComparison) 메서드를 두 방법 모두 포함 되므로 System.StringComparison 비교의 형식을 명시적으로 지정 하는 매개 변수입니다.The preferred overload to call is either the instance Equals(String, StringComparison) method or the static Equals(String, String, StringComparison) method, because both methods include a System.StringComparison parameter that explicitly specifies the type of comparison.

다음 예제에서는 같음 경우 하나를 대신 사용 해야 하는 서 수에 대 한 문화권 구분 비교를 수행 하는 위험을 보여 줍니다.The following example illustrates the danger of performing a culture-sensitive comparison for equality when an ordinal one should be used instead. 이 경우 코드의 의도 "FILE://" 문자열을 사용 하 여 URL 부분에 대 한 대/소문자 구분 비교를 수행 하 여 "FILE://" 또는 "file://"로 시작 하는 Url에서 파일 시스템 액세스를 금지 하는 것입니다.In this case, the intent of the code is to prohibit file system access from URLs that begin with "FILE://" or "file://" by performing a case-insensitive comparison of the beginning of a URL with the string "FILE://". 그러나 터키어 (터키) 문화권 "file://"로 시작 하는 URL에서 사용 하 여 문화권 구분 비교를 수행 하는 경우 같음 비교가 실패할 Turkish 대문자 소문자 "i"은 "i" 대신 "I" 합니다.However, if a culture-sensitive comparison is performed using the Turkish (Turkey) culture on a URL that begins with "file://", the comparison for equality fails, because the Turkish uppercase equivalent of the lowercase "i" is "İ" instead of "I". 결과적으로, 파일 시스템 액세스 실수로 허용 됩니다.As a result, file system access is inadvertently permitted. 반면에 서 수 비교를 수행 하는 경우 같음 비교가 성공 하 고 파일 시스템 액세스가 거부 됩니다.On the other hand, if an ordinal comparison is performed, the comparison for equality succeeds, and file system access is denied.

using namespace System;
using namespace System::Globalization;
using namespace System::Threading;

bool TestForEquality(String^ str, StringComparison cmp);

void main()
{
   Thread::CurrentThread->CurrentCulture = CultureInfo::CreateSpecificCulture("tr-TR");      

   String^ filePath = "file://c:/notes.txt";

   Console::WriteLine("Culture-sensitive test for equality:");
   if (! TestForEquality(filePath, StringComparison::CurrentCultureIgnoreCase))
      Console::WriteLine("Access to {0} is allowed.", filePath);
   else
      Console::WriteLine("Access to {0} is not allowed.", filePath);

   Console::WriteLine("\nOrdinal test for equality:");
   if (! TestForEquality(filePath, StringComparison::OrdinalIgnoreCase))
      Console::WriteLine("Access to {0} is allowed.", filePath);
   else
      Console::WriteLine("Access to {0} is not allowed.", filePath);
}

bool TestForEquality(String^ str, StringComparison cmp)
{
      int position = str->IndexOf("://");
      if (position < 0) return false;

      String^ substring = str->Substring(0, position);  
      return substring->Equals("FILE", cmp);
}
// The example displays the following output: 
//       Culture-sensitive test for equality: 
//       Access to file://c:/notes.txt is allowed. 
//        
//       Ordinal test for equality: 
//       Access to file://c:/notes.txt is not allowed.
using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR");      

      string filePath = "file://c:/notes.txt";
      
      Console.WriteLine("Culture-sensitive test for equality:");
      if (! TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
      
      Console.WriteLine("\nOrdinal test for equality:");
      if (! TestForEquality(filePath, StringComparison.OrdinalIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
   }

   private static bool TestForEquality(string str, StringComparison cmp)
   {
      int position = str.IndexOf("://");
      if (position < 0) return false;

      string substring = str.Substring(0, position);  
      return substring.Equals("FILE", cmp);
   }
}
// The example displays the following output:
//       Culture-sensitive test for equality:
//       Access to file://c:/notes.txt is allowed.
//       
//       Ordinal test for equality:
//       Access to file://c:/notes.txt is not allowed.
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR")      

      Dim filePath As String = "file://c:/notes.txt"
      
      Console.WriteLine("Culture-sensitive test for equality:")
      If Not TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase) Then
         Console.WriteLine("Access to {0} is allowed.", filePath)
      Else
         Console.WriteLine("Access to {0} is not allowed.", filePath)
      End If       
      Console.WriteLine()
      
      Console.WriteLine("Ordinal test for equality:")
      If Not TestForEquality(filePath, StringComparison.OrdinalIgnoreCase) Then
         Console.WriteLine("Access to {0} is allowed.", filePath)
      Else
         Console.WriteLine("Access to {0} is not allowed.", filePath)
      End If       
   End Sub
   
   Private Function TestForEquality(str As String, cmp As StringComparison) As Boolean
      Dim position As Integer = str.IndexOf("://")
      If position < 0 Then Return False

      Dim substring As String = str.Substring(0, position)  
      Return substring.Equals("FILE", cmp)
   End Function
End Module
' The example displays the following output:
'       Culture-sensitive test for equality:
'       Access to file://c:/notes.txt is allowed.
'       
'       Ordinal test for equality:
'       Access to file://c:/notes.txt is not allowed.

표준화Normalization

일부 유니코드 문자에 여러 표현이 있습니다.Some Unicode characters have multiple representations. 예를 들어, 다음 코드 지점 중 하나는 문자 "ắ"을 나타낼 수 있습니다.For example, any of the following code points can represent the letter "ắ":

  • U + 1EAFU+1EAF

  • U + 0103 U + 0301U+0103 U+0301

  • U + 0061 U + 0306 U + 0301U+0061 U+0306 U+0301

단일 문자에 대 한 여러 표현을 검색, 정렬, 일치 및 기타 작업이 복잡해 집니다.Multiple representations for a single character complicate searching, sorting, matching, and other string operations.

유니코드 표준 라는 해당 하는 이진 표현에 대 한 유니코드 문자에 대 한 이진 표현을 반환 하는 정규화 프로세스를 정의 합니다.The Unicode standard defines a process called normalization that returns one binary representation of a Unicode character for any of its equivalent binary representations. 정규화에는 다양 한 규칙을 따르는 정규화 형식 이라는 다양 한 알고리즘을 사용 합니다.Normalization can use several algorithms, called normalization forms, that follow different rules. .NET에는 유니코드 정규화 형식 C, D, KC 및 KD 지원합니다..NET supports Unicode normalization forms C, D, KC, and KD. 문자열 같은 정규화로 표준화 되었으므로, 경우 서 수 비교를 사용 하 여 비교할 수 있습니다.When strings have been normalized to the same normalization form, they can be compared by using ordinal comparison.

서 수 비교는 해당 유니코드 스칼라 값에 대 한 이진 비교 Char 각 문자열에서 개체입니다.An ordinal comparison is a binary comparison of the Unicode scalar value of corresponding Char objects in each string. String 클래스는 다양 한 다음을 비롯 한 서 수 비교를 수행할 수 있는 메서드를 포함 합니다.The String class includes a number of methods that can perform an ordinal comparison, including the following:

호출 하 여 정규화 형식 C 문자열이 정규화 되는지 여부를 확인할 수 있습니다 합니다 String.IsNormalized() 하거나 메서드를 호출할 수는 String.IsNormalized(NormalizationForm) 문자열에 지정 된 정규화 형식인 정규화 되는지 여부를 결정 하는 방법입니다.You can determine whether a string is normalized to normalization form C by calling the String.IsNormalized() method, or you can call the String.IsNormalized(NormalizationForm) method to determine whether a string is normalized to a specified normalization form. 호출할 수도 있습니다는 String.Normalize() 정규화 형식 C에 문자열을 변환 하는 메서드를 호출할 수는 String.Normalize(NormalizationForm) 지정한 정규화 형식을 문자열로 변환 하는 방법입니다.You can also call the String.Normalize() method to convert a string to normalization form C, or you can call the String.Normalize(NormalizationForm) method to convert a string to a specified normalization form. 정규화 및 문자열 비교에 대 한 단계별 정보를 참조 하세요. 합니다 Normalize()Normalize(NormalizationForm) 메서드.For step-by-step information about normalizing and comparing strings, see the Normalize() and Normalize(NormalizationForm) methods.

다음의 간단한 예제에서는 문자열 정규화를 보여 줍니다.The following simple example illustrates string normalization. 세 개의 다른 문자열의 세 가지 방법으로 "ố" 문자를 정의 하 고 같음에 대 한 서 수 비교를 사용 하 여 각 문자열에서 다른 두 문자열이 다른 것을 결정 합니다.It defines the letter "ố" in three different ways in three different strings, and uses an ordinal comparison for equality to determine that each string differs from the other two strings. 그런 다음 지원 되는 정규화 폼, 각 문자열을 변환 하 고 다시 지정 된 정규화 형식인 각 문자열의 서 수 비교를 수행 합니다.It then converts each string to the supported normalization forms, and again performs an ordinal comparison of each string in a specified normalization form. 각각의 경우에서 같음에 대 한 두 번째 테스트에서는 문자열이 같은지를 보여 줍니다.In each case, the second test for equality shows that the strings are equal.

using namespace System;
using namespace System::Globalization;
using namespace System::IO;
using namespace System::Text;

public ref class Example
{
private:
   StreamWriter^ sw;

   void TestForEquality(... array<String^>^  words)
   {
      for (int ctr = 0; ctr <= words->Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words->Length - 1; ctr2++) 
            sw->WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr]->Equals(words[ctr2], StringComparison::Ordinal));
   }

   String^ ShowBytes(String^ str)
   {
      String^ result = nullptr;
      for each (Char ch in str)
         result += String::Format("{0} ", Convert::ToUInt16(ch).ToString("X4")); 
      return result->Trim();            
   } 

   array<String^>^ NormalizeStrings(NormalizationForm nf, ... array<String^>^ words)
   {
      for (int ctr = 0; ctr < words->Length; ctr++)
         if (! words[ctr]->IsNormalized(nf))
            words[ctr] = words[ctr]->Normalize(nf); 
      return words;   
   }

public: 
   void Execute()
   {
      sw = gcnew StreamWriter(".\\TestNorm1.txt");

      // Define three versions of the same word.  
      String^ s1 = L"sống";        // create word with U+1ED1 
      String^ s2 = L"s\x00F4\x0301ng";
      String^ s3 = L"so\x0302\x0301ng";

      TestForEquality(s1, s2, s3);      
      sw->WriteLine();

      // Normalize and compare strings using each normalization form. 
      for each (String^ formName in Enum::GetNames(NormalizationForm::typeid))
      {
         sw->WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum::Parse(NormalizationForm::typeid, formName);
         array<String^>^ sn = NormalizeStrings(nf, s1, s2, s3 );
         TestForEquality(sn);           
         sw->WriteLine("\n");                                        
      }

      sw->Close(); 
   }
};

void main()
{
   Example^ ex = gcnew Example();
   ex->Execute();
}
// The example produces the following output:
// The example displays the following output: 
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False 
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False 
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False 
//        
//       Normalization FormC: 
//        
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//        
//        
//       Normalization FormD: 
//        
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//        
//        
//       Normalization FormKC: 
//        
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//        
//        
//       Normalization FormKD: 
//        
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
using System;
using System.Globalization;
using System.IO;
using System.Text;

public class Example
{
   private static StreamWriter sw;
   
   public static void Main()
   {
      sw = new StreamWriter(@".\TestNorm1.txt");

      // Define three versions of the same word. 
      string s1 = "sống";        // create word with U+1ED1
      string s2 = "s\u00F4\u0301ng";
      string s3 = "so\u0302\u0301ng";

      TestForEquality(s1, s2, s3);      
      sw.WriteLine();

      // Normalize and compare strings using each normalization form.
      foreach (string formName in Enum.GetNames(typeof(NormalizationForm)))
      {
         sw.WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum.Parse(typeof(NormalizationForm), formName);
         string[] sn = NormalizeStrings(nf, s1, s2, s3);
         TestForEquality(sn);           
         sw.WriteLine("\n");                                        
      }
      
      sw.Close();   
   }

   private static void TestForEquality(params string[] words)
   {
      for (int ctr = 0; ctr <= words.Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words.Length - 1; ctr2++) 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr].Equals(words[ctr2], StringComparison.Ordinal));
   }

   private static string ShowBytes(string str)
   {
      string result = null;
      foreach (var ch in str)
         result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4")); 
      return result.Trim();            
   } 
   
   private static string[] NormalizeStrings(NormalizationForm nf, params string[] words)
   {
      for (int ctr = 0; ctr < words.Length; ctr++)
         if (! words[ctr].IsNormalized(nf))
            words[ctr] = words[ctr].Normalize(nf); 
      return words;   
   }
}
// The example displays the following output:
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       
//       Normalization FormC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       
//       
//       Normalization FormKC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormKD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
Imports System.Globalization
Imports System.IO
Imports System.Text

Module Example
   Private sw As StreamWriter
       
   Public Sub Main()
      sw = New StreamWriter(".\TestNorm1.txt")

      ' Define three versions of the same word. 
      Dim s1 As String = "sống"        ' create word with U+1ED1
      Dim s2 AS String = "s" + ChrW(&h00F4) + ChrW(&h0301) + "ng"
      Dim s3 As String = "so" + ChrW(&h0302) + ChrW(&h0301) + "ng"

      TestForEquality(s1, s2, s3)      
      sw.WriteLine()

      ' Normalize and compare strings using each normalization form.
      For Each formName In [Enum].GetNames(GetType(NormalizationForm))
         sw.WriteLine("Normalization {0}:", formName) 
         Dim nf As NormalizationForm = CType([Enum].Parse(GetType(NormalizationForm), formName),  
                                             NormalizationForm)
         Dim sn() As String = NormalizeStrings(nf, s1, s2, s3)
         TestForEquality(sn)           
         sw.WriteLine(vbCrLf)                                        
      Next
      
      sw.Close()   
   End Sub

   Private Sub TestForEquality(ParamArray words As String())
      For ctr As Integer = 0 To words.Length - 2
         For ctr2 As Integer = ctr + 1 To words.Length - 1 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words(ctr), ShowBytes(words(ctr)),
                         words(ctr2), ShowBytes(words(ctr2)),
                         words(ctr).Equals(words(ctr2), StringComparison.Ordinal))
         Next                
      Next   
   End Sub

   Private Function ShowBytes(str As String) As String
      Dim result As String = Nothing
      For Each ch In str
         result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4")) 
      Next
      Return result.Trim()            
   End Function  
   
   Private Function NormalizeStrings(nf As NormalizationForm, ParamArray words() As String) As String()
      For ctr As Integer = 0 To words.Length - 1
         If Not words(ctr).IsNormalized(nf) Then
            words(ctr) = words(ctr).Normalize(nf)
         End If    
      Next
      Return words   
   End Function
End Module
' The example displays the following output:
'       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
'       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
'       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
'       
'       Normalization FormC:
'       
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       
'       
'       Normalization FormD:
'       
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       
'       
'       Normalization FormKC:
'       
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       
'       
'       Normalization FormKD:
'       
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True

정규화 및 정규화 형식에 대 한 자세한 내용은 참조 하세요. System.Text.NormalizationForm, 뿐만 Unicode Standard Annex #15: Unicode Normalization Forms 하며 정규화 FAQ 에 unicode.org 웹 사이트입니다.For more information about normalization and normalization forms, see System.Text.NormalizationForm, as well as Unicode Standard Annex #15: Unicode Normalization Forms and the Normalization FAQ on the unicode.org website.

범주별 문자열 작업String operations by category

합니다 String 클래스는 같음, 문자 또는 형식을 지정 하는 문자열을 복사 하는 값을 문자열을 결합 하는 문자열에서 부분 문자열을 추출 하는 문자열을 수정 하는 문자열의 부분 문자열 찾기에 대 한 문자열을 테스트 하는 문자열 비교에 대 한 멤버를 제공 하 고 문자열을 정규화 합니다.The String class provides members for comparing strings, testing strings for equality, finding characters or substrings in a string, modifying a string, extracting substrings from a string, combining strings, formatting values, copying a string, and normalizing a string.

문자열 비교Comparing strings

다음을 사용 하 여 정렬 순서에서 상대 위치를 결정 하는 문자열을 비교할 수 있습니다 String 메서드:You can compare strings to determine their relative position in the sort order by using the following String methods:

  • Compare 정렬 순서에서 두 번째 문자열을 하나의 문자열로의 관계를 나타내는 정수를 반환 합니다.Compare returns an integer that indicates the relationship of one string to a second string in the sort order.

  • CompareOrdinal 두 번째 문자열의 코드 포인트 비교를 기반으로 하는 문자열 하나의 관계를 나타내는 정수를 반환 합니다.CompareOrdinal returns an integer that indicates the relationship of one string to a second string based on a comparison of their code points.

  • CompareTo 정렬 순서에서 두 번째 문자열에는 현재 문자열 인스턴스가의 관계를 나타내는 정수를 반환 합니다.CompareTo returns an integer that indicates the relationship of the current string instance to a second string in the sort order. CompareTo(String) 메서드를 제공 합니다 IComparableIComparable<T> 에 대 한 구현을 String 클래스입니다.The CompareTo(String) method provides the IComparable and IComparable<T> implementations for the String class.

문자열이 같은지를 테스트합니다.Testing strings for equality

호출 하 여 Equals 두 문자열이 같은지 여부를 확인 하는 방법입니다.You call the Equals method to determine whether two strings are equal. 인스턴스 Equals(String, String, StringComparison) 및 정적 Equals(String, StringComparison) 오버 로드를 통해 문화권 구분 또는 서 수 비교 인지 및 대/소문자가 고려 되거나 무시 하는지 여부를 지정 합니다.The instance Equals(String, String, StringComparison) and the static Equals(String, StringComparison) overloads let you specify whether the comparison is culture-sensitive or ordinal, and whether case is considered or ignored. 같음에 대 한 대부분의 테스트는 서 수 및 시스템 리소스 (예: 파일 시스템 개체)에 대 한 액세스를 결정 하는 같음 비교 항상 서 수 여야 합니다.Most tests for equality are ordinal, and comparisons for equality that determine access to a system resource (such as a file system object) should always be ordinal.

문자열의 문자를 찾기Finding characters in a string

String 클래스는 두 가지 검색 메서드를 포함 합니다.The String class includes two kinds of search methods:

경고

특정 부분 문자열 보다는 특정 패턴에 대 한 문자열을 검색 하려는 경우 정규식을 사용 해야 합니다.If you want to search a string for a particular pattern rather than a specific substring, you should use regular expressions. 자세한 내용은 .NET 정규식합니다.For more information, see .NET Regular Expressions.

문자열을 수정합니다.Modifying a string

String 클래스는 문자열의 값을 수정 하는 다음 메서드를 포함 합니다.The String class includes the following methods that appear to modify the value of a string:

  • Insert 현재 문자열 삽입 String 인스턴스.Insert inserts a string into the current String instance.

  • PadLeft 문자열의 시작 부분에는 지정 된 문자 하나 이상의 항목을 삽입합니다.PadLeft inserts one or more occurrences of a specified character at the beginning of a string.

  • PadRight 문자열의 끝에 지정 된 문자의 하나 이상의 항목을 삽입합니다.PadRight inserts one or more occurrences of a specified character at the end of a string.

  • Remove 부분 문자열을 현재에서 삭제 String 인스턴스.Remove deletes a substring from the current String instance.

  • Replace 현재에서 다른 부분 문자열을 사용 하 여 부분 문자열을 대체 String 인스턴스.Replace replaces a substring with another substring in the current String instance.

  • ToLowerToLowerInvariant 문자열의 모든 문자를 소문자로 변환 합니다.ToLower and ToLowerInvariant convert all the characters in a string to lowercase.

  • ToUpperToUpperInvariant 문자열의 모든 문자를 대문자로 변환 합니다.ToUpper and ToUpperInvariant convert all the characters in a string to uppercase.

  • Trim 문자열의 시작과 끝에서 모든 문자를 제거합니다.Trim removes all occurrences of a character from the beginning and end of a string.

  • TrimEnd 문자열의 끝에서 모든 문자를 제거합니다.TrimEnd removes all occurrences of a character from the end of a string.

  • TrimStart 문자열의 시작 부분에서 모든 문자를 제거합니다.TrimStart removes all occurrences of a character from the beginning of a string.

중요

모든 문자열 수정 메서드 반환 새 String 개체입니다.All string modification methods return a new String object. 현재 인스턴스의 값을 수정 하지 마세요.They don't modify the value of the current instance.

문자열에서 부분 문자열을 추출합니다.Extracting substrings from a string

String.Split 메서드는 여러 문자열으로 단일 문자열을 구분 합니다.The String.Split method separates a single string into multiple strings. 메서드의 오버 로드를 사용 하면 메서드를 추출 하는 부분 문자열의 최대 수를 확인 하려면 및 빈 문자열 (발생 하는 구분 기호 옆에 있는 경우) 반환 된 문자열 중 포함 되는지 여부를 확인 하려면 여러 개의 구분 기호를 지정할 수 있습니다.Overloads of the method allow you to specify multiple delimiters, to determine the maximum number of substrings that the method extracts, and to determine whether empty strings (which occur when delimiters are adjacent) are included among the returned strings.

결합 문자열Combining strings

다음 String 문자열 연결에 대 한 메서드를 사용할 수 있습니다.The following String methods can be used for string concatenation:

  • Concat 하나 이상의 부분 문자열을 단일 문자열로 결합합니다.Concat combines one or more substrings into a single string.

  • Join 단일 요소에 하나 이상의 부분 문자열을 연결 하 고 각 부분 문자열 사이의 구분 기호를 추가 합니다.Join concatenates one or more substrings into a single element and adds a separator between each substring.

값의 서식 지정Formatting values

String.Format 메서드 복합 서식 지정 기능을 사용 하 여 문자열에서 하나 이상의 자리 표시자 일부 개체 또는 값의 문자열 표현으로 바꿉니다.The String.Format method uses the composite formatting feature to replace one or more placeholders in a string with the string representation of some object or value. Format 메서드는 종종 다음을 수행 하는 데 사용 됩니다.The Format method is often used to do the following:

  • 문자열에서 숫자 값의 문자열 표현을 포함 합니다.To embed the string representation of a numeric value in a string.

  • 문자열에서 날짜 및 시간 값의 문자열 표현을 포함 합니다.To embed the string representation of a date and time value in a string.

  • 문자열에서 열거형 값의 문자열 표현을 포함 합니다.To embed the string representation of an enumeration value in a string.

  • 지 원하는 일부 개체의 문자열 표현을 포함 하는 IFormattable 문자열에 대 한 인터페이스입니다.To embed the string representation of some object that supports the IFormattable interface in a string.

  • 오른쪽 맞춤 또는 더 큰 문자열 내에서 필드의 부분 문자열을 왼쪽에 맞춥니다.To right-justify or left-justify a substring in a field within a larger string.

작업 및 예 형식에 대 한 자세한 내용은 참조는 Format 요약 오버 로드 합니다.For detailed information about formatting operations and examples, see the Format overload summary.

문자열 복사Copying a string

다음을 호출할 수 있습니다 String 문자열의 복사본을 확인 하는 방법.You can call the following String methods to make a copy of a string:

  • Clone 기존에 대 한 참조를 반환 합니다. String 개체입니다.Clone returns a reference to an existing String object.

  • Copy 기존 문자열의 복사본을 만듭니다.Copy creates a copy of an existing string.

  • CopyTo 문자 배열에 있는 문자열 부분을 복사합니다.CopyTo copies a portion of a string to a character array.

문자열 정규화Normalizing a string

유니코드, 단일 문자 코드 포인트를 여러 개 있을 수 있습니다.In Unicode, a single character can have multiple code points. 정규화 같은 이진 표현으로 이러한 동등한 문자로 변환합니다.Normalization converts these equivalent characters into the same binary representation. 합니다 String.Normalize 정규화를 수행 하는 메서드 및 String.IsNormalized 메서드 문자열이 정규화 되는지 여부를 결정 합니다.The String.Normalize method performs the normalization, and the String.IsNormalized method determines whether a string is normalized.

자세한 내용 및 예제에 대 한 참조를 정규화 이 항목의 앞부분에 나오는 섹션입니다.For more information and an example, see the Normalization section earlier in this topic.

생성자

String(Char*) String(Char*) String(Char*) String(Char*)

유니코드 문자 배열에 대한 지정된 포인터가 가리키는 값으로 String 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters.

String(Char*, Int32, Int32) String(Char*, Int32, Int32) String(Char*, Int32, Int32) String(Char*, Int32, Int32)

유니코드 문자 배열에 대한 지정된 포인터가 나타내는 값, 해당 배열 내의 시작 문자 위치 및 길이로 String 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters, a starting character position within that array, and a length.

String(Char, Int32) String(Char, Int32) String(Char, Int32) String(Char, Int32)

지정한 횟수만큼 반복되는 지정된 유니코드 문자가 나타내는 값으로 String 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the String class to the value indicated by a specified Unicode character repeated a specified number of times.

String(Char[]) String(Char[]) String(Char[]) String(Char[])

유니코드 문자 배열에서 나타내는 값으로 String 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the String class to the value indicated by an array of Unicode characters.

String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32)

유니코드 문자 배열에서 나타내는 값, 해당 배열 내의 시작 문자 위치 및 길이로 String 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the String class to the value indicated by an array of Unicode characters, a starting character position within that array, and a length.

String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>)
String(SByte*) String(SByte*) String(SByte*) String(SByte*)

8비트 부호 있는 정수 배열에 대한 포인터가 나타내는 값으로 String 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the String class to the value indicated by a pointer to an array of 8-bit signed integers.

String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32)

8비트 부호 있는 정수 배열에 대한 지정된 포인터가 나타내는 값, 해당 배열 내의 시작 위치 및 길이로 String 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, and a length.

String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding)

8비트 부호 있는 정수 배열에 대한 지정된 포인터가 나타내는 값, 해당 배열 내의 시작 문자 위치, 길이 및 String 개체로 Encoding 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an Encoding object.

필드

Empty Empty Empty Empty

빈 문자열을 나타냅니다.Represents the empty string. 이 필드는 읽기 전용입니다.This field is read-only.

속성

Chars[Int32] Chars[Int32] Chars[Int32] Chars[Int32]

현재 Char 개체에서 지정된 문자 위치에 있는 String 개체를 가져옵니다.Gets the Char object at a specified position in the current String object.

Length Length Length Length

현재 String 개체의 문자 수를 가져옵니다.Gets the number of characters in the current String object.

메서드

Clone() Clone() Clone() Clone()

String의 이 인스턴스에 대한 참조를 반환합니다.Returns a reference to this instance of String.

Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32)

지정된 두 String 개체의 부분 문자열을 비교하고 정렬 순서에서 두 개체의 상대 위치를 나타내는 정수를 반환합니다.Compares substrings of two specified String objects and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean)

대/소문자를 구분하거나 구분하지 않고 지정된 두 String 개체의 부분 문자열을 비교하여 정렬 순서에서 두 개체의 상대 위치를 나타내는 정수를 반환합니다.Compares substrings of two specified String objects, ignoring or honoring their case, and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)

대/소문자를 구분하거나 구분하지 않고 지정된 두 String 개체의 부분 문자열을 비교하여 정렬 순서에서 두 개체의 상대 위치를 나타내는 정수를 반환합니다. 문화권별 정보가 비교에 영향을 줍니다.Compares substrings of two specified String objects, ignoring or honoring their case and using culture-specific information to influence the comparison, and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)

지정된 두 String 개체의 부분 문자열을 비교하고 정렬 순서에서 두 부분 문자열 간의 관계를 나타내는 정수를 반환합니다. 지정된 비교 옵션 및 문화권별 정보가 비교에 영향을 줍니다.Compares substrings of two specified String objects using the specified comparison options and culture-specific information to influence the comparison, and returns an integer that indicates the relationship of the two substrings to each other in the sort order.

Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison)

지정된 규칙을 사용하여 지정된 두 String 개체의 부분 문자열을 비교하고 정렬 순서에서 두 개체의 상대 위치를 나타내는 정수를 반환합니다.Compares substrings of two specified String objects using the specified rules, and returns an integer that indicates their relative position in the sort order.

Compare(String, String) Compare(String, String) Compare(String, String) Compare(String, String)

지정된 두 String 개체를 비교하고 정렬 순서에서 두 개체의 상대 위치를 나타내는 정수를 반환합니다.Compares two specified String objects and returns an integer that indicates their relative position in the sort order.

Compare(String, String, Boolean) Compare(String, String, Boolean) Compare(String, String, Boolean) Compare(String, String, Boolean)

대/소문자를 구분하거나 구분하지 않고 지정된 두 String 개체를 비교하여 정렬 순서에서 두 개체의 상대 위치를 나타내는 정수를 반환합니다.Compares two specified String objects, ignoring or honoring their case, and returns an integer that indicates their relative position in the sort order.

Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo)

대/소문자를 구분하거나 구분하지 않고 지정된 두 String 개체를 비교하여 정렬 순서에서 두 개체의 상대 위치를 나타내는 정수를 반환합니다. 문화권별 정보가 비교에 영향을 줍니다.Compares two specified String objects, ignoring or honoring their case, and using culture-specific information to influence the comparison, and returns an integer that indicates their relative position in the sort order.

Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions)

지정된 두 String 개체를 비교하고 정렬 순서에서 두 문자열 간의 관계를 나타내는 정수를 반환합니다. 지정된 비교 옵션 및 문화권별 정보가 비교에 영향을 줍니다.Compares two specified String objects using the specified comparison options and culture-specific information to influence the comparison, and returns an integer that indicates the relationship of the two strings to each other in the sort order.

Compare(String, String, StringComparison) Compare(String, String, StringComparison) Compare(String, String, StringComparison) Compare(String, String, StringComparison)

지정된 규칙을 사용하여 지정된 두 String 개체를 비교하고 정렬 순서에서 두 개체의 상대 위치를 나타내는 정수를 반환합니다.Compares two specified String objects using the specified rules, and returns an integer that indicates their relative position in the sort order.

CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32)

각 부분 문자열에서 해당하는 String 개체의 숫자 값을 계산하여 지정된 두 Char 개체의 부분 문자열을 비교합니다.Compares substrings of two specified String objects by evaluating the numeric values of the corresponding Char objects in each substring.

CompareOrdinal(String, String) CompareOrdinal(String, String) CompareOrdinal(String, String) CompareOrdinal(String, String)

각 문자열에서 해당하는 String 개체의 숫자 값을 계산해서 두 지정된 Char 개체를 비교합니다.Compares two specified String objects by evaluating the numeric values of the corresponding Char objects in each string.

CompareTo(Object) CompareTo(Object) CompareTo(Object) CompareTo(Object)

이 인스턴스를 지정된 Object와 비교하고 정렬 순서에서 이 인스턴스의 위치가 지정된 Object보다 앞인지, 뒤인지 또는 동일한지를 나타냅니다.Compares this instance with a specified Object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified Object.

CompareTo(String) CompareTo(String) CompareTo(String) CompareTo(String)

이 인스턴스를 지정된 String 개체와 비교하고 정렬 순서에서 이 인스턴스의 위치가 지정된 문자열보다 앞인지, 뒤인지 또는 동일한지를 나타냅니다.Compares this instance with a specified String object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified string.

Concat(IEnumerable<String>) Concat(IEnumerable<String>) Concat(IEnumerable<String>) Concat(IEnumerable<String>)

IEnumerable<T> 형식의 생성된 String 컬렉션의 멤버를 연결합니다.Concatenates the members of a constructed IEnumerable<T> collection of type String.

Concat(Object) Concat(Object) Concat(Object) Concat(Object)

지정된 개체의 문자열 표현을 만듭니다.Creates the string representation of a specified object.

Concat(Object, Object) Concat(Object, Object) Concat(Object, Object) Concat(Object, Object)

지정된 두 개체의 문자열 표현을 연결합니다.Concatenates the string representations of two specified objects.

Concat(Object, Object, Object) Concat(Object, Object, Object) Concat(Object, Object, Object) Concat(Object, Object, Object)

지정된 세 개체의 문자열 표현을 연결합니다.Concatenates the string representations of three specified objects.

Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object)

지정된 네 개체의 문자열 표현과 선택적 변수 길이 매개 변수 목록에 지정된 개체를 연결합니다.Concatenates the string representations of four specified objects and any objects specified in an optional variable length parameter list.

Concat(Object[]) Concat(Object[]) Concat(Object[]) Concat(Object[])

지정된 Object 배열에 있는 요소의 문자열 표현을 연결합니다.Concatenates the string representations of the elements in a specified Object array.

Concat(String, String) Concat(String, String) Concat(String, String) Concat(String, String)

String의 지정된 두 인스턴스를 연결합니다.Concatenates two specified instances of String.

Concat(String, String, String) Concat(String, String, String) Concat(String, String, String) Concat(String, String, String)

String의 지정된 세 인스턴스를 연결합니다.Concatenates three specified instances of String.

Concat(String, String, String, String) Concat(String, String, String, String) Concat(String, String, String, String) Concat(String, String, String, String)

String의 지정된 네 인스턴스를 연결합니다.Concatenates four specified instances of String.

Concat(String[]) Concat(String[]) Concat(String[]) Concat(String[])

지정된 String 배열의 요소를 연결합니다.Concatenates the elements of a specified String array.

Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>)

IEnumerable<T> 구현의 멤버를 연결합니다.Concatenates the members of an IEnumerable<T> implementation.

Contains(Char) Contains(Char) Contains(Char) Contains(Char)
Contains(Char, StringComparison) Contains(Char, StringComparison) Contains(Char, StringComparison) Contains(Char, StringComparison)
Contains(String) Contains(String) Contains(String) Contains(String)

이 문자열 내에서 지정한 하위 문자열이 발생하는지를 나타내는 값을 반환합니다.Returns a value indicating whether a specified substring occurs within this string.

Contains(String, StringComparison) Contains(String, StringComparison) Contains(String, StringComparison) Contains(String, StringComparison)
Copy(String) Copy(String) Copy(String) Copy(String)

지정된 String과 동일한 값을 갖는 String의 새 인스턴스를 만듭니다.Creates a new instance of String with the same value as a specified String.

CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32)

이 인스턴스의 지정한 위치에 있는 지정한 수의 문자를 유니코드 문자 배열의 특정 위치에 복사합니다.Copies a specified number of characters from a specified position in this instance to a specified position in an array of Unicode characters.

Create<TState>(Int32, TState, SpanAction<Char,TState>) Create<TState>(Int32, TState, SpanAction<Char,TState>) Create<TState>(Int32, TState, SpanAction<Char,TState>) Create<TState>(Int32, TState, SpanAction<Char,TState>)
EndsWith(Char) EndsWith(Char) EndsWith(Char) EndsWith(Char)
EndsWith(String) EndsWith(String) EndsWith(String) EndsWith(String)

이 문자열 인스턴스의 끝 부분과 지정한 문자열이 일치하는지를 확인합니다.Determines whether the end of this string instance matches the specified string.

EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo)

지정한 문화권을 사용하여 비교할 때 이 문자열 인스턴스의 끝 부분과 지정한 문자열이 일치하는지를 확인합니다.Determines whether the end of this string instance matches the specified string when compared using the specified culture.

EndsWith(String, StringComparison) EndsWith(String, StringComparison) EndsWith(String, StringComparison) EndsWith(String, StringComparison)

지정한 비교 옵션을 사용하여 비교할 때 지정한 문자열과 이 문자열 인스턴스의 끝 부분이 일치하는지를 확인합니다.Determines whether the end of this string instance matches the specified string when compared using the specified comparison option.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

이 인스턴스와 지정한 개체의 값이 같은지를 확인합니다. 이 개체도 String 개체여야 합니다.Determines whether this instance and a specified object, which must also be a String object, have the same value.

Equals(String) Equals(String) Equals(String) Equals(String)

이 인스턴스와 지정한 다른 String 개체의 값이 같은지를 확인합니다.Determines whether this instance and another specified String object have the same value.

Equals(String, String) Equals(String, String) Equals(String, String) Equals(String, String)

지정된 두 String 개체의 값이 같은지를 확인합니다.Determines whether two specified String objects have the same value.

Equals(String, String, StringComparison) Equals(String, String, StringComparison) Equals(String, String, StringComparison) Equals(String, String, StringComparison)

지정된 두 String 개체의 값이 같은지를 확인합니다.Determines whether two specified String objects have the same value. 매개 변수는 비교에 사용되는 문화권, 대/소문자 및 정렬 규칙을 지정합니다.A parameter specifies the culture, case, and sort rules used in the comparison.

Equals(String, StringComparison) Equals(String, StringComparison) Equals(String, StringComparison) Equals(String, StringComparison)

이 문자열과 지정한 String 개체의 값이 같은지를 확인합니다.Determines whether this string and a specified String object have the same value. 매개 변수는 비교에 사용되는 문화권, 대/소문자 및 정렬 규칙을 지정합니다.A parameter specifies the culture, case, and sort rules used in the comparison.

Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object)

지정된 문자열에 있는 하나의 형식 항목 또는 여러 개의 형식 항목을 해당하는 개체의 문자열 표현으로 바꿉니다.Replaces the format item or items in a specified string with the string representation of the corresponding object. 매개 변수에서 문화권별 서식 지정 정보를 제공합니다.A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object)

문자열에 있는 서식 지정 항목을 지정된 두 개체의 문자열 표현으로 바꿉니다.Replaces the format items in a string with the string representation of two specified objects. 매개 변수에서 문화권별 서식 지정 정보를 제공합니다.A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object)

문자열에 있는 서식 지정 항목을 지정된 세 개체의 문자열 표현으로 바꿉니다.Replaces the format items in a string with the string representation of three specified objects. 매개 변수에서 문화권별 형식 지정 정보를 제공합니다.An parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[])

문자열의 형식 항목을 지정된 배열에 있는 해당 개체의 문자열 표현으로 바꿉니다.Replaces the format items in a string with the string representations of corresponding objects in a specified array. 매개 변수에서 문화권별 서식 지정 정보를 제공합니다.A parameter supplies culture-specific formatting information.

Format(String, Object) Format(String, Object) Format(String, Object) Format(String, Object)

문자열에 있는 하나 이상의 형식 항목을 지정된 개체의 문자열 표현으로 바꿉니다.Replaces one or more format items in a string with the string representation of a specified object.

Format(String, Object, Object) Format(String, Object, Object) Format(String, Object, Object) Format(String, Object, Object)

문자열에 있는 서식 지정 항목을 지정된 두 개체의 문자열 표현으로 바꿉니다.Replaces the format items in a string with the string representation of two specified objects.

Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object)

문자열에 있는 서식 지정 항목을 지정된 세 개체의 문자열 표현으로 바꿉니다.Replaces the format items in a string with the string representation of three specified objects.

Format(String, Object[]) Format(String, Object[]) Format(String, Object[]) Format(String, Object[])

지정된 문자열의 형식 항목을 지정된 배열에 있는 해당 개체의 문자열 표현으로 바꿉니다.Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

이 문자열의 개별 문자에서 반복될 수 있는 개체를 검색합니다.Retrieves an object that can iterate through the individual characters in this string.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

해당 문자열에 대한 해시 코드를 반환합니다.Returns the hash code for this string.

GetHashCode(StringComparison) GetHashCode(StringComparison) GetHashCode(StringComparison) GetHashCode(StringComparison)
GetType() GetType() GetType() GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(Inherited from Object)
GetTypeCode() GetTypeCode() GetTypeCode() GetTypeCode()

TypeCode 클래스에 대한 String를 반환합니다.Returns the TypeCode for class String.

IndexOf(Char) IndexOf(Char) IndexOf(Char) IndexOf(Char)

이 문자열에서 맨 처음 발견되는 지정된 유니코드 문자의 0부터 시작하는 인덱스를 보고합니다.Reports the zero-based index of the first occurrence of the specified Unicode character in this string.

IndexOf(Char, Int32) IndexOf(Char, Int32) IndexOf(Char, Int32) IndexOf(Char, Int32)

이 문자열에서 맨 처음 발견되는 지정된 유니코드 문자의 0부터 시작하는 인덱스를 보고합니다.Reports the zero-based index of the first occurrence of the specified Unicode character in this string. 검색은 지정된 문자 위치에서 시작됩니다.The search starts at a specified character position.

IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32)

이 인스턴스에서 맨 처음 발견되는 지정된 문자의 0부터 시작하는 인덱스를 보고합니다.Reports the zero-based index of the first occurrence of the specified character in this instance. 검색은 지정된 문자 위치에서 시작하여 지정된 수의 문자 위치를 검사합니다.The search starts at a specified character position and examines a specified number of character positions.

IndexOf(Char, StringComparison) IndexOf(Char, StringComparison) IndexOf(Char, StringComparison) IndexOf(Char, StringComparison)

이 문자열에서 맨 처음 발견되는 지정된 유니코드 문자의 인덱스(0부터 시작)를 보고합니다.Reports the zero-based index of the first occurrrence of the specxified Unicode character in this string. 매개 변수는 지정된 문자에 사용할 검색 형식을 지정합니다.A parameter specifies the type of search to use for the specified character.

IndexOf(String) IndexOf(String) IndexOf(String) IndexOf(String)

이 인스턴스에서 맨 처음 발견되는 지정된 문자열의 0부터 시작하는 인덱스를 보고합니다.Reports the zero-based index of the first occurrence of the specified string in this instance.

IndexOf(String, Int32) IndexOf(String, Int32) IndexOf(String, Int32) IndexOf(String, Int32)

이 인스턴스에서 맨 처음 발견되는 지정된 문자열의 0부터 시작하는 인덱스를 보고합니다.Reports the zero-based index of the first occurrence of the specified string in this instance. 검색은 지정된 문자 위치에서 시작됩니다.The search starts at a specified character position.

IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32)

이 인스턴스에서 맨 처음 발견되는 지정된 문자열의 0부터 시작하는 인덱스를 보고합니다.Reports the zero-based index of the first occurrence of the specified string in this instance. 검색은 지정된 문자 위치에서 시작하여 지정된 수의 문자 위치를 검사합니다.The search starts at a specified character position and examines a specified number of character positions.

IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison)

현재 String 개체에서 맨 처음 발견되는 지정된 문자열의 0부터 시작하는 인덱스를 보고합니다.Reports the zero-based index of the first occurrence of the specified string in the current String object. 매개 변수는 현재 문자열의 검색 시작 위치, 검색할 현재 문자열의 문자 수 및 지정된 문자열에 사용할 검색 유형을 지정합니다.Parameters specify the starting search position in the current string, the number of characters in the current string to search, and the type of search to use for the specified string.

IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison)

현재 String 개체에서 맨 처음 발견되는 지정된 문자열의 0부터 시작하는 인덱스를 보고합니다.Reports the zero-based index of the first occurrence of the specified string in the current String object. 매개 변수는 현재 문자열의 검색 시작 위치와 지정된 문자열에 사용할 검색 유형을 지정합니다.Parameters specify the starting search position in the current string and the type of search to use for the specified string.

IndexOf(String, StringComparison) IndexOf(String, StringComparison) IndexOf(String, StringComparison) IndexOf(String, StringComparison)

현재 String 개체에서 맨 처음 발견되는 지정된 문자열의 0부터 시작하는 인덱스를 보고합니다.Reports the zero-based index of the first occurrence of the specified string in the current String object. 매개 변수는 지정된 문자열에 사용할 검색 유형을 지정합니다.A parameter specifies the type of search to use for the specified string.

IndexOfAny(Char[]) IndexOfAny(Char[]) IndexOfAny(Char[]) IndexOfAny(Char[])

지정된 유니코드 문자 배열에 있는 문자 중에 이 인스턴스에서 맨 처음 발견되는 문자의 0부터 시작하는 인덱스를 보고합니다.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters.

IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32)

지정된 유니코드 문자 배열에 있는 문자 중에 이 인스턴스에서 맨 처음 발견되는 문자의 0부터 시작하는 인덱스를 보고합니다.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. 검색은 지정된 문자 위치에서 시작됩니다.The search starts at a specified character position.

IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32)

지정된 유니코드 문자 배열에 있는 문자 중에 이 인스턴스에서 맨 처음 발견되는 문자의 0부터 시작하는 인덱스를 보고합니다.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. 검색은 지정된 문자 위치에서 시작하여 지정된 수의 문자 위치를 검사합니다.The search starts at a specified character position and examines a specified number of character positions.

Insert(Int32, String) Insert(Int32, String) Insert(Int32, String) Insert(Int32, String)

이 인스턴스의 지정된 인덱스 위치에 지정한 문자열이 삽입되는 새 문자열을 반환합니다.Returns a new string in which a specified string is inserted at a specified index position in this instance.

Intern(String) Intern(String) Intern(String) Intern(String)

지정된 String에 대한 시스템의 참조를 검색합니다.Retrieves the system's reference to the specified String.

IsInterned(String) IsInterned(String) IsInterned(String) IsInterned(String)

지정된 String에 대한 참조를 검색합니다.Retrieves a reference to a specified String.

IsNormalized() IsNormalized() IsNormalized() IsNormalized()

이 문자열의 형식이 유니코드 정규화 형식 C인지를 나타냅니다.Indicates whether this string is in Unicode normalization form C.

IsNormalized(NormalizationForm) IsNormalized(NormalizationForm) IsNormalized(NormalizationForm) IsNormalized(NormalizationForm)

이 문자열의 형식이 지정한 유니코드 정규화 형식인지를 나타냅니다.Indicates whether this string is in the specified Unicode normalization form.

IsNullOrEmpty(String) IsNullOrEmpty(String) IsNullOrEmpty(String) IsNullOrEmpty(String)

지정된 문자열이 null이거나 빈 문자열("")인지를 나타냅니다.Indicates whether the specified string is null or an empty string ("").

IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String)

지정된 문자열이 null이거나 비어 있거나 공백 문자로만 구성되어 있는지를 나타냅니다.Indicates whether a specified string is null, empty, or consists only of white-space characters.

Join(Char, Object[]) Join(Char, Object[]) Join(Char, Object[]) Join(Char, Object[])
Join(Char, String[]) Join(Char, String[]) Join(Char, String[]) Join(Char, String[])
Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32)
Join(String, IEnumerable<String>) Join(String, IEnumerable<String>) Join(String, IEnumerable<String>) Join(String, IEnumerable<String>)

각 멤버 사이에 지정된 구분 기호를 사용하여 IEnumerable<T> 형식의 생성된 String 컬렉션의 멤버를 연결합니다.Concatenates the members of a constructed IEnumerable<T> collection of type String, using the specified separator between each member.

Join(String, Object[]) Join(String, Object[]) Join(String, Object[]) Join(String, Object[])

각 요소 사이에 지정된 구분 기호를 사용하여 개체 배열의 요소를 연결합니다.Concatenates the elements of an object array, using the specified separator between each element.

Join(String, String[]) Join(String, String[]) Join(String, String[]) Join(String, String[])

각 요소 사이에 지정된 구분 기호를 사용하여 문자열 배열의 모든 요소를 연결합니다.Concatenates all the elements of a string array, using the specified separator between each element.

Join(String, String[], Int32, Int32) Join(String, String[], Int32, Int32) Join(String, String[], Int32, Int32) Join(String, String[], Int32, Int32)

각 요소 사이에 지정된 구분 기호를 사용하여 문자열 배열의 지정된 요소를 연결합니다.Concatenates the specified elements of a string array, using the specified separator between each element.

Join<T>(Char, IEnumerable<T>) Join<T>(Char, IEnumerable<T>) Join<T>(Char, IEnumerable<T>) Join<T>(Char, IEnumerable<T>)
Join<T>(String, IEnumerable<T>) Join<T>(String, IEnumerable<T>) Join<T>(String, IEnumerable<T>) Join<T>(String, IEnumerable<T>)

각 멤버 사이에 지정된 구분 기호를 사용하여 컬렉션의 멤버를 연결합니다.Concatenates the members of a collection, using the specified separator between each member.

LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char)

이 인스턴스에서 마지막으로 발견되는 지정된 유니코드 문자의 0부터 시작하는 인덱스 위치를 보고합니다.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance.

LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32)

이 인스턴스에서 마지막으로 발견되는 지정된 유니코드 문자의 0부터 시작하는 인덱스 위치를 보고합니다.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. 지정된 문자 위치에서 시작하고 문자열의 시작 부분을 향해 뒤로 검색이 진행됩니다.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32)

이 인스턴스의 부분 문자열에서 마지막으로 발견되는 지정된 유니코드 문자의 0부터 시작하는 인덱스 위치를 보고합니다.Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. 지정된 문자 위치에서 검색을 시작하여 지정된 수의 문자 위치에 대한 문자열의 시작 부분 쪽으로 뒤로 검색합니다.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(String) LastIndexOf(String) LastIndexOf(String) LastIndexOf(String)

이 인스턴스에서 마지막으로 발견되는 지정된 문자열의 0부터 시작하는 인덱스 위치를 보고합니다.Reports the zero-based index position of the last occurrence of a specified string within this instance.

LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32)

이 인스턴스에서 마지막으로 발견되는 지정된 문자열의 0부터 시작하는 인덱스 위치를 보고합니다.Reports the zero-based index position of the last occurrence of a specified string within this instance. 지정된 문자 위치에서 시작하고 문자열의 시작 부분을 향해 뒤로 검색이 진행됩니다.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32)

이 인스턴스에서 마지막으로 발견되는 지정된 문자열의 0부터 시작하는 인덱스 위치를 보고합니다.Reports the zero-based index position of the last occurrence of a specified string within this instance. 지정된 문자 위치에서 검색을 시작하여 지정된 수의 문자 위치에 대한 문자열의 시작 부분 쪽으로 뒤로 검색합니다.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison)

이 인스턴스에서 마지막으로 발견되는 지정된 문자열의 0부터 시작하는 인덱스 위치를 보고합니다.Reports the zero-based index position of the last occurrence of a specified string within this instance. 지정된 문자 위치에서 검색을 시작하여 지정된 수의 문자 위치에 대한 문자열의 시작 부분 쪽으로 뒤로 검색합니다.The search starts at a specified character position and proceeds backward toward the beginning of the string for the specified number of character positions. 매개 변수는 지정된 문자열을 검색할 때 수행할 비교 유형을 지정합니다.A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison)

현재 String 개체에서 마지막으로 발견되는 지정된 문자열의 0부터 시작하는 인덱스를 보고합니다.Reports the zero-based index of the last occurrence of a specified string within the current String object. 지정된 문자 위치에서 시작하고 문자열의 시작 부분을 향해 뒤로 검색이 진행됩니다.The search starts at a specified character position and proceeds backward toward the beginning of the string. 매개 변수는 지정된 문자열을 검색할 때 수행할 비교 유형을 지정합니다.A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison)

현재 String 개체에서 마지막으로 발견되는 지정된 문자열의 0부터 시작하는 인덱스를 보고합니다.Reports the zero-based index of the last occurrence of a specified string within the current String object. 매개 변수는 지정된 문자열에 사용할 검색 유형을 지정합니다.A parameter specifies the type of search to use for the specified string.

LastIndexOfAny(Char[]) LastIndexOfAny(Char[]) LastIndexOfAny(Char[]) LastIndexOfAny(Char[])

유니코드 배열에서 지정된 하나 이상의 문자 중에 이 인스턴스에서 마지막으로 발견되는 문자의 0부터 시작하는 인덱스 위치를 보고합니다.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array.

LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32)

유니코드 배열에서 지정된 하나 이상의 문자 중에 이 인스턴스에서 마지막으로 발견되는 문자의 0부터 시작하는 인덱스 위치를 보고합니다.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. 지정된 문자 위치에서 시작하고 문자열의 시작 부분을 향해 뒤로 검색이 진행됩니다.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32)

유니코드 배열에서 지정된 하나 이상의 문자 중에 이 인스턴스에서 마지막으로 발견되는 문자의 0부터 시작하는 인덱스 위치를 보고합니다.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. 지정된 문자 위치에서 검색을 시작하여 지정된 수의 문자 위치에 대한 문자열의 시작 부분 쪽으로 뒤로 검색합니다.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(Inherited from Object)
Normalize() Normalize() Normalize() Normalize()

텍스트 값이 이 문자열과 같지만 이진 표현의 형식이 유니코드 정규화 형식 C인 새 문자열을 반환합니다.Returns a new string whose textual value is the same as this string, but whose binary representation is in Unicode normalization form C.

Normalize(NormalizationForm) Normalize(NormalizationForm) Normalize(NormalizationForm) Normalize(NormalizationForm)

텍스트 값이 이 문자열과 같지만 이진 표현의 형식이 지정한 유니코드 정규화 형식인 새 문자열을 반환합니다.Returns a new string whose textual value is the same as this string, but whose binary representation is in the specified Unicode normalization form.

PadLeft(Int32) PadLeft(Int32) PadLeft(Int32) PadLeft(Int32)

지정한 길이만큼 왼쪽의 안쪽 여백을 공백으로 채워서 이 인스턴스의 문자를 오른쪽에 맞추는 새 문자열을 반환합니다.Returns a new string that right-aligns the characters in this instance by padding them with spaces on the left, for a specified total length.

PadLeft(Int32, Char) PadLeft(Int32, Char) PadLeft(Int32, Char) PadLeft(Int32, Char)

지정한 길이만큼 왼쪽의 안쪽 여백을 지정된 유니코드 문자로 채워서 이 인스턴스의 문자를 오른쪽에 맞추는 새 문자열을 반환합니다.Returns a new string that right-aligns the characters in this instance by padding them on the left with a specified Unicode character, for a specified total length.

PadRight(Int32) PadRight(Int32) PadRight(Int32) PadRight(Int32)

지정한 길이만큼 오른쪽의 안쪽 여백을 공백으로 채워서 이 문자열의 문자를 왼쪽에 맞추는 새 문자열을 반환합니다.Returns a new string that left-aligns the characters in this string by padding them with spaces on the right, for a specified total length.

PadRight(Int32, Char) PadRight(Int32, Char) PadRight(Int32, Char) PadRight(Int32, Char)

지정한 길이만큼 오른쪽의 안쪽 여백을 지정된 유니코드 문자로 채워서 이 문자열의 문자를 왼쪽에 맞추는 새 문자열을 반환합니다.Returns a new string that left-aligns the characters in this string by padding them on the right with a specified Unicode character, for a specified total length.

Remove(Int32) Remove(Int32) Remove(Int32) Remove(Int32)

지정된 위치부터 마지막 위치 사이에 현재 인스턴스의 모든 문자가 삭제되었던 새 문자열을 반환합니다.Returns a new string in which all the characters in the current instance, beginning at a specified position and continuing through the last position, have been deleted.

Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32)

현재 인스턴스의 지정된 위치에서 시작하여 지정된 수의 문자가 삭제되었던 새 문자열을 반환합니다.Returns a new string in which a specified number of characters in the current instance beginning at a specified position have been deleted.

Replace(Char, Char) Replace(Char, Char) Replace(Char, Char) Replace(Char, Char)

현재 인스턴스의 지정된 유니코드 문자가 지정된 다른 유니코드 문자로 모두 바뀌는 새 문자열을 반환합니다.Returns a new string in which all occurrences of a specified Unicode character in this instance are replaced with another specified Unicode character.

Replace(String, String) Replace(String, String) Replace(String, String) Replace(String, String)

현재 인스턴스의 지정된 문자열이 지정된 다른 문자열로 모두 바뀌는 새 문자열을 반환합니다.Returns a new string in which all occurrences of a specified string in the current instance are replaced with another specified string.

Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo)
Replace(String, String, StringComparison) Replace(String, String, StringComparison) Replace(String, String, StringComparison) Replace(String, String, StringComparison)
Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions)
Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions)
Split(Char[]) Split(Char[]) Split(Char[]) Split(Char[])

문자열을 배열 내 문자에 기초하는 하위 문자열로 분할합니다.Splits a string into substrings that are based on the characters in an array.

Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32)

배열에 있는 문자에 따라 최대 개수의 부분 문자열로 문자열을 분할합니다.Splits a string into a maximum number of substrings based on the characters in an array. 반환할 부분 문자열의 최대 수도 지정합니다.You also specify the maximum number of substrings to return.

Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions)

배열에 있는 문자에 따라 최대 개수의 부분 문자열로 문자열을 분할합니다.Splits a string into a maximum number of substrings based on the characters in an array.

Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions)

배열에 있는 문자에 따라 문자열을 부분 문자열로 분할합니다.Splits a string into substrings based on the characters in an array. 부분 문자열이 빈 배열 요소를 포함하는지 여부를 지정할 수 있습니다.You can specify whether the substrings include empty array elements.

Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions)
Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions)
Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions)

배열에 있는 문자열에 따라 최대 개수의 부분 문자열로 문자열을 분할합니다.Splits a string into a maximum number of substrings based on the strings in an array. 부분 문자열이 빈 배열 요소를 포함하는지 여부를 지정할 수 있습니다.You can specify whether the substrings include empty array elements.

Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions)

배열에 있는 문자열에 따라 문자열을 부분 문자열로 분할합니다.Splits a string into substrings based on the strings in an array. 부분 문자열이 빈 배열 요소를 포함하는지 여부를 지정할 수 있습니다.You can specify whether the substrings include empty array elements.

StartsWith(Char) StartsWith(Char) StartsWith(Char) StartsWith(Char)
StartsWith(String) StartsWith(String) StartsWith(String) StartsWith(String)

이 문자열 인스턴스의 시작 부분과 지정한 문자열이 일치하는지를 확인합니다.Determines whether the beginning of this string instance matches the specified string.

StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo)

지정한 문화권을 사용하여 비교할 때 이 문자열 인스턴스의 시작 부분과 지정한 문자열이 일치하는지를 확인합니다.Determines whether the beginning of this string instance matches the specified string when compared using the specified culture.

StartsWith(String, StringComparison) StartsWith(String, StringComparison) StartsWith(String, StringComparison) StartsWith(String, StringComparison)

지정한 비교 옵션을 사용하여 비교할 때 지정한 문자열과 이 문자열 인스턴스의 시작 부분이 일치하는지를 확인합니다.Determines whether the beginning of this string instance matches the specified string when compared using the specified comparison option.

Substring(Int32) Substring(Int32) Substring(Int32) Substring(Int32)

이 인스턴스에서 부분 문자열을 검색합니다.Retrieves a substring from this instance. 부분 문자열은 지정된 문자 위치에서 시작하고 문자열 끝까지 계속됩니다.The substring starts at a specified character position and continues to the end of the string.

Substring(Int32, Int32) Substring(Int32, Int32) Substring(Int32, Int32) Substring(Int32, Int32)

이 인스턴스에서 부분 문자열을 검색합니다.Retrieves a substring from this instance. 부분 문자열은 지정된 문자 위치에서 시작하고 길이도 지정되어 있습니다.The substring starts at a specified character position and has a specified length.

ToCharArray() ToCharArray() ToCharArray() ToCharArray()

이 인스턴스의 문자를 유니코드 문자 배열에 복사합니다.Copies the characters in this instance to a Unicode character array.

ToCharArray(Int32, Int32) ToCharArray(Int32, Int32) ToCharArray(Int32, Int32) ToCharArray(Int32, Int32)

이 인스턴스의 지정된 부분 문자열에 있는 문자를 유니코드 문자 배열에 복사합니다.Copies the characters in a specified substring in this instance to a Unicode character array.

ToLower() ToLower() ToLower() ToLower()

이 문자열의 복사본을 소문자로 변환하여 반환합니다.Returns a copy of this string converted to lowercase.

ToLower(CultureInfo) ToLower(CultureInfo) ToLower(CultureInfo) ToLower(CultureInfo)

지정한 문화권의 대/소문자 규칙을 사용하여 소문자로 변환된 이 문자열의 복사본을 반환합니다.Returns a copy of this string converted to lowercase, using the casing rules of the specified culture.

ToLowerInvariant() ToLowerInvariant() ToLowerInvariant() ToLowerInvariant()

고정 문화권의 대/소문자 규칙을 사용하여 소문자로 변환된 이 String 개체의 복사본을 반환합니다.Returns a copy of this String object converted to lowercase using the casing rules of the invariant culture.

ToString() ToString() ToString() ToString()

String의 이 인스턴스를 반환하며, 이때 실제 변환은 수행되지 않습니다.Returns this instance of String; no actual conversion is performed.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider)

String의 이 인스턴스를 반환하며, 이때 실제 변환은 수행되지 않습니다.Returns this instance of String; no actual conversion is performed.

ToUpper() ToUpper() ToUpper() ToUpper()

이 문자열의 복사본을 대문자로 변환하여 반환합니다.Returns a copy of this string converted to uppercase.

ToUpper(CultureInfo) ToUpper(CultureInfo) ToUpper(CultureInfo) ToUpper(CultureInfo)

지정한 문화권의 대/소문자 규칙을 사용하여 대문자로 변환된 이 문자열의 복사본을 반환합니다.Returns a copy of this string converted to uppercase, using the casing rules of the specified culture.

ToUpperInvariant() ToUpperInvariant() ToUpperInvariant() ToUpperInvariant()

고정 문화권의 대/소문자 규칙을 사용하여 대문자로 변환된 이 String 개체의 복사본을 반환합니다.Returns a copy of this String object converted to uppercase using the casing rules of the invariant culture.

Trim() Trim() Trim() Trim()

현재 String 개체에서 선행 공백과 후행 공백을 모두 제거합니다.Removes all leading and trailing white-space characters from the current String object.

Trim(Char) Trim(Char) Trim(Char) Trim(Char)
Trim(Char[]) Trim(Char[]) Trim(Char[]) Trim(Char[])

현재 String 개체에서 배열에 지정된 문자 집합의 선행 항목과 후행 항목을 모두 제거합니다.Removes all leading and trailing occurrences of a set of characters specified in an array from the current String object.

TrimEnd() TrimEnd() TrimEnd() TrimEnd()
TrimEnd(Char) TrimEnd(Char) TrimEnd(Char) TrimEnd(Char)
TrimEnd(Char[]) TrimEnd(Char[]) TrimEnd(Char[]) TrimEnd(Char[])

현재 String 개체에서 배열에 지정된 문자 집합의 후행 항목을 모두 제거합니다.Removes all trailing occurrences of a set of characters specified in an array from the current String object.

TrimStart() TrimStart() TrimStart() TrimStart()
TrimStart(Char) TrimStart(Char) TrimStart(Char) TrimStart(Char)
TrimStart(Char[]) TrimStart(Char[]) TrimStart(Char[]) TrimStart(Char[])

현재 String 개체에서 배열에 지정된 문자 집합의 선행 항목을 모두 제거합니다.Removes all leading occurrences of a set of characters specified in an array from the current String object.

연산자

Equality(String, String) Equality(String, String) Equality(String, String) Equality(String, String)

지정된 두 문자열의 값이 같은지를 확인합니다.Determines whether two specified strings have the same value.

Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>)
Inequality(String, String) Inequality(String, String) Inequality(String, String) Inequality(String, String)

지정된 두 문자열의 값이 다른지를 확인합니다.Determines whether two specified strings have different values.

명시적 인터페이스 구현

IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object)
IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider)

이 멤버에 대한 설명은 ToBoolean(IFormatProvider)를 참조하세요.For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider)

이 멤버에 대한 설명은 ToByte(IFormatProvider)를 참조하세요.For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider)

이 멤버에 대한 설명은 ToChar(IFormatProvider)를 참조하세요.For a description of this member, see ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider)

이 멤버에 대한 설명은 ToDateTime(IFormatProvider)를 참조하세요.For a description of this member, see ToDateTime(IFormatProvider).

IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider)

이 멤버에 대한 설명은 ToDecimal(IFormatProvider)를 참조하세요.For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider)

이 멤버에 대한 설명은 ToDouble(IFormatProvider)를 참조하세요.For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider)

이 멤버에 대한 설명은 ToInt16(IFormatProvider)를 참조하세요.For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider)

이 멤버에 대한 설명은 ToInt32(IFormatProvider)를 참조하세요.For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider)

이 멤버에 대한 설명은 ToInt64(IFormatProvider)를 참조하세요.For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider)

이 멤버에 대한 설명은 ToSByte(IFormatProvider)를 참조하세요.For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider)

이 멤버에 대한 설명은 ToSingle(IFormatProvider)를 참조하세요.For a description of this member, see ToSingle(IFormatProvider).

IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider)
IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider)

이 멤버에 대한 설명은 ToType(Type, IFormatProvider)를 참조하세요.For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider)

이 멤버에 대한 설명은 ToUInt16(IFormatProvider)를 참조하세요.For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider)

이 멤버에 대한 설명은 ToUInt32(IFormatProvider)를 참조하세요.For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider)

이 멤버에 대한 설명은 ToUInt64(IFormatProvider)를 참조하세요.For a description of this member, see ToUInt64(IFormatProvider).

IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

현재 String 개체를 반복하는 열거자를 반환합니다.Returns an enumerator that iterates through the current String object.

IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator()

현재 String 개체를 반복하는 열거자를 반환합니다.Returns an enumerator that iterates through the current String object.

Extension Methods

ToImmutableArray<TSource>(IEnumerable<TSource>) ToImmutableArray<TSource>(IEnumerable<TSource>) ToImmutableArray<TSource>(IEnumerable<TSource>) ToImmutableArray<TSource>(IEnumerable<TSource>)

지정된 컬렉션에서 변경할 수 없는 배열을 만듭니다.Creates an immutable array from the specified collection.

ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

원본 키에 변형 함수를 적용하여 기존 요소 컬렉션에서 변경할 수 없는 사전을 생성합니다.Constructs an immutable dictionary from an existing collection of elements, applying a transformation function to the source keys.

ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

시퀀스의 일부 변형에 따라 변경할 수 없는 사전을 생성합니다.Constructs an immutable dictionary based on some transformation of a sequence.

ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>) ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>) ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>) ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>)

키/값 쌍의 시퀀스를 열거하고 해당 시퀀스의 내용에 대한 변경할 수 없는 사전을 생성합니다.Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents.

ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>) ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>) ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>) ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>)

키/값 쌍의 시퀀스를 열거하고, 지정된 키 비교자를 사용하여 해당 시퀀스의 내용에 대한 변경할 수 없는 사전을 생성합니다.Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents by using the specified key comparer.

ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>, IEqualityComparer<TValue>) ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>, IEqualityComparer<TValue>) ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>, IEqualityComparer<TValue>) ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)

키/값 쌍의 시퀀스를 열거하고, 지정된 키 및 값 비교자를 사용하여 해당 시퀀스의 내용에 대한 변경할 수 없는 사전을 생성합니다.Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents by using the specified key and value comparers.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

시퀀스를 열거 및 변형하고 해당 시퀀스의 내용에 대한 변경할 수 없는 사전을 생성합니다.Enumerates and transforms a sequence, and produces an immutable dictionary of its contents.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>) ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>) ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>) ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)

시퀀스를 열거 및 변형하고, 지정된 키 비교자를 사용하여 해당 시퀀스의 내용에 대한 변경할 수 없는 사전을 생성합니다.Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key comparer.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>) ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>) ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>) ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)

시퀀스를 열거 및 변형하고, 지정된 키 및 값 비교자를 사용하여 해당 시퀀스의 내용에 대한 변경할 수 없는 사전을 생성합니다.Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key and value comparers.

ToImmutableHashSet<TSource>(IEnumerable<TSource>) ToImmutableHashSet<TSource>(IEnumerable<TSource>) ToImmutableHashSet<TSource>(IEnumerable<TSource>) ToImmutableHashSet<TSource>(IEnumerable<TSource>)

시퀀스를 열거하고 해당 시퀀스의 내용에 대한 변경할 수 없는 해시 집합을 생성합니다. Enumerates a sequence and produces an immutable hash set of its contents.

ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

시퀀스를 열거하고, 해당 시퀀스의 내용에 대한 변경할 수 없는 해시 집합을 생성하며, 형식 집합에 지정된 같음 비교자를 사용합니다. Enumerates a sequence, produces an immutable hash set of its contents, and uses the specified equality comparer for the set type.

ToImmutableList<TSource>(IEnumerable<TSource>) ToImmutableList<TSource>(IEnumerable<TSource>) ToImmutableList<TSource>(IEnumerable<TSource>) ToImmutableList<TSource>(IEnumerable<TSource>)

시퀀스를 열거하고 해당 시퀀스의 내용에 대한 변경할 수 없는 목록을 생성합니다. Enumerates a sequence and produces an immutable list of its contents.

ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>) ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>) ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>) ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>)

키/값 쌍의 시퀀스를 열거하고 해당 시퀀스의 내용에 대한 변경할 수 없는 정렬된 사전을 생성합니다.Enumerates a sequence of key/value pairs and produces an immutable sorted dictionary of its contents.

ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IComparer<TKey>) ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IComparer<TKey>) ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IComparer<TKey>) ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IComparer<TKey>)

키/값 쌍의 시퀀스를 열거하고, 지정된 키 비교자를 사용하여 해당 시퀀스의 내용에 대한 변경할 수 없는 사전을 생성합니다.Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents by using the specified key comparer.

ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IComparer<TKey>, IEqualityComparer<TValue>) ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IComparer<TKey>, IEqualityComparer<TValue>) ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IComparer<TKey>, IEqualityComparer<TValue>) ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IComparer<TKey>, IEqualityComparer<TValue>)

키/값 쌍의 시퀀스를 열거하고, 지정된 키 및 값 비교자를 사용하여 해당 시퀀스의 내용에 대한 변경할 수 없는 정렬된 사전을 생성합니다.Enumerates a sequence of key/value pairs and produces an immutable sorted dictionary of its contents by using the specified key and value comparers.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

시퀀스를 열거 및 변형하고 해당 시퀀스의 내용에 대한 변경할 수 없는 정렬된 사전을 생성합니다.Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>) ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>) ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>) ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)

시퀀스를 열거 및 변형하고, 지정된 키 비교자를 사용하여 해당 시퀀스의 내용에 대한 변경할 수 없는 정렬된 사전을 생성합니다.Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key comparer.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>) ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>) ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>) ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)

시퀀스를 열거 및 변형하고, 지정된 키 및 값 비교자를 사용하여 해당 시퀀스의 내용에 대한 변경할 수 없는 정렬된 사전을 생성합니다.Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key and value comparers.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>) ToImmutableSortedSet<TSource>(IEnumerable<TSource>) ToImmutableSortedSet<TSource>(IEnumerable<TSource>) ToImmutableSortedSet<TSource>(IEnumerable<TSource>)

시퀀스를 열거하고 해당 시퀀스의 내용에 대한 변경할 수 없는 정렬된 집합을 생성합니다.Enumerates a sequence and produces an immutable sorted set of its contents.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>) ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>) ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>) ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)

시퀀스를 열거하고, 해당 시퀀스의 내용에 대한 변경할 수 없는 정렬된 집합을 생성하며, 지정된 비교자를 사용합니다.Enumerates a sequence, produces an immutable sorted set of its contents, and uses the specified comparer.

CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>)

제네릭 매개 변수 TDataTable인 지정된 입력 DataRow 개체를 사용하여 IEnumerable<T> 개체의 복사본이 들어 있는 DataRow을 반환합니다. Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

제네릭 매개 변수 TDataRow인 지정된 입력 DataTable 개체를 사용하여 IEnumerable<T> 개체를 지정된 DataRow에 복사합니다. Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

제네릭 매개 변수 TDataRow인 지정된 입력 DataTable 개체를 사용하여 IEnumerable<T> 개체를 지정된 DataRow에 복사합니다. Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>) Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>) Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>) Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)

시퀀스에 누적기 함수를 적용합니다.Applies an accumulator function over a sequence.

Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>) Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>) Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>) Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)

시퀀스에 누적기 함수를 적용합니다.Applies an accumulator function over a sequence. 지정된 시드 값은 초기 누적기 값으로 사용됩니다.The specified seed value is used as the initial accumulator value.

Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>) Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>) Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>) Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)

시퀀스에 누적기 함수를 적용합니다.Applies an accumulator function over a sequence. 지정된 시드 값은 초기 누적기 값으로 사용되고 지정된 함수는 결과 값을 선택하는 데 사용됩니다.The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.

All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

시퀀스의 모든 요소가 특정 조건에 맞는지 확인합니다.Determines whether all elements of a sequence satisfy a condition.

Any<TSource>(IEnumerable<TSource>) Any<TSource>(IEnumerable<TSource>) Any<TSource>(IEnumerable<TSource>) Any<TSource>(IEnumerable<TSource>)

시퀀스에 요소가 하나라도 있는지 확인합니다.Determines whether a sequence contains any elements.

Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

시퀀스에 특정 조건에 맞는 요소가 있는지 확인합니다.Determines whether any element of a sequence satisfies a condition.

Append<TSource>(IEnumerable<TSource>, TSource) Append<TSource>(IEnumerable<TSource>, TSource) Append<TSource>(IEnumerable<TSource>, TSource) Append<TSource>(IEnumerable<TSource>, TSource)

시퀀스의 끝에 값을 추가합니다.Appends a value to the end of the sequence.

AsEnumerable<TSource>(IEnumerable<TSource>) AsEnumerable<TSource>(IEnumerable<TSource>) AsEnumerable<TSource>(IEnumerable<TSource>) AsEnumerable<TSource>(IEnumerable<TSource>)

IEnumerable<T>로 형식화된 입력을 반환합니다.Returns the input typed as IEnumerable<T>.

Average(IEnumerable<Decimal>) Average(IEnumerable<Decimal>) Average(IEnumerable<Decimal>) Average(IEnumerable<Decimal>)

Decimal 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of Decimal values.

Average(IEnumerable<Double>) Average(IEnumerable<Double>) Average(IEnumerable<Double>) Average(IEnumerable<Double>)

Double 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of Double values.

Average(IEnumerable<Int32>) Average(IEnumerable<Int32>) Average(IEnumerable<Int32>) Average(IEnumerable<Int32>)

Int32 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of Int32 values.

Average(IEnumerable<Int64>) Average(IEnumerable<Int64>) Average(IEnumerable<Int64>) Average(IEnumerable<Int64>)

Int64 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of Int64 values.

Average(IEnumerable<Nullable<Decimal>>) Average(IEnumerable<Nullable<Decimal>>) Average(IEnumerable<Nullable<Decimal>>) Average(IEnumerable<Nullable<Decimal>>)

nullable Decimal 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of nullable Decimal values.

Average(IEnumerable<Nullable<Double>>) Average(IEnumerable<Nullable<Double>>) Average(IEnumerable<Nullable<Double>>) Average(IEnumerable<Nullable<Double>>)

nullable Double 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of nullable Double values.

Average(IEnumerable<Nullable<Int32>>) Average(IEnumerable<Nullable<Int32>>) Average(IEnumerable<Nullable<Int32>>) Average(IEnumerable<Nullable<Int32>>)

nullable Int32 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of nullable Int32 values.

Average(IEnumerable<Nullable<Int64>>) Average(IEnumerable<Nullable<Int64>>) Average(IEnumerable<Nullable<Int64>>) Average(IEnumerable<Nullable<Int64>>)

nullable Int64 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of nullable Int64 values.

Average(IEnumerable<Nullable<Single>>) Average(IEnumerable<Nullable<Single>>) Average(IEnumerable<Nullable<Single>>) Average(IEnumerable<Nullable<Single>>)

nullable Single 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of nullable Single values.

Average(IEnumerable<Single>) Average(IEnumerable<Single>) Average(IEnumerable<Single>) Average(IEnumerable<Single>)

Single 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of Single values.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

입력 시퀀스의 각 요소에 대해 변형 함수를 호출하여 가져온 Decimal 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

입력 시퀀스의 각 요소에 대해 변형 함수를 호출하여 가져온 Double 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

입력 시퀀스의 각 요소에 대해 변형 함수를 호출하여 가져온 Int32 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

입력 시퀀스의 각 요소에 대해 변형 함수를 호출하여 가져온 Int64 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

입력 시퀀스의 각 요소에 대해 변형 함수를 호출하여 가져온 nullable Decimal 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

입력 시퀀스의 각 요소에 대해 변형 함수를 호출하여 가져온 nullable Double 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

입력 시퀀스의 각 요소에 대해 변형 함수를 호출하여 가져온 nullable Int32 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

입력 시퀀스의 각 요소에 대해 변형 함수를 호출하여 가져온 nullable Int64 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

입력 시퀀스의 각 요소에 대해 변형 함수를 호출하여 가져온 nullable Single 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

입력 시퀀스의 각 요소에 대해 변형 함수를 호출하여 가져온 Single 값 시퀀스의 평균을 계산합니다.Computes the average of a sequence of Single values that are obtained by invoking a transform function on each element of the input sequence.

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

IEnumerable의 요소를 지정된 형식으로 캐스팅합니다.Casts the elements of an IEnumerable to the specified type.

Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

두 시퀀스를 연결합니다.Concatenates two sequences.

Contains<TSource>(IEnumerable<TSource>, TSource) Contains<TSource>(IEnumerable<TSource>, TSource) Contains<TSource>(IEnumerable<TSource>, TSource) Contains<TSource>(IEnumerable<TSource>, TSource)

기본 같음 비교자를 사용하여 시퀀스에 지정된 요소가 들어 있는지 확인합니다.Determines whether a sequence contains a specified element by using the default equality comparer.

Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>) Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>) Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>) Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)

지정된 IEqualityComparer<T>를 사용하여 시퀀스에 지정된 요소가 들어 있는지 확인합니다.Determines whether a sequence contains a specified element by using a specified IEqualityComparer<T>.

Count<TSource>(IEnumerable<TSource>) Count<TSource>(IEnumerable<TSource>) Count<TSource>(IEnumerable<TSource>) Count<TSource>(IEnumerable<TSource>)

시퀀스의 요소 수를 반환합니다.Returns the number of elements in a sequence.

Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

지정된 시퀀스에서 특정 조건에 맞는 요소 수를 나타내는 숫자를 반환합니다.Returns a number that represents how many elements in the specified sequence satisfy a condition.

DefaultIfEmpty<TSource>(IEnumerable<TSource>) DefaultIfEmpty<TSource>(IEnumerable<TSource>) DefaultIfEmpty<TSource>(IEnumerable<TSource>) DefaultIfEmpty<TSource>(IEnumerable<TSource>)

지정된 시퀀스의 요소를 반환하거나, 시퀀스가 비어 있으면 형식 매개 변수의 기본값을 반환합니다.Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.

DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource) DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource) DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource) DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)

지정된 시퀀스의 요소를 반환하거나, 시퀀스가 비어 있으면 singleton 컬렉션의 지정된 값을 반환합니다.Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.

Distinct<TSource>(IEnumerable<TSource>) Distinct<TSource>(IEnumerable<TSource>) Distinct<TSource>(IEnumerable<TSource>) Distinct<TSource>(IEnumerable<TSource>)

기본 같음 비교자로 값을 비교하여 시퀀스에서 고유 요소를 반환합니다.Returns distinct elements from a sequence by using the default equality comparer to compare values.

Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

지정된 IEqualityComparer<T>로 값을 비교하여 시퀀스에서 고유 요소를 반환합니다.Returns distinct elements from a sequence by using a specified IEqualityComparer<T> to compare values.

ElementAt<TSource>(IEnumerable<TSource>, Int32) ElementAt<TSource>(IEnumerable<TSource>, Int32) ElementAt<TSource>(IEnumerable<TSource>, Int32) ElementAt<TSource>(IEnumerable<TSource>, Int32)

시퀀스에서 지정된 인덱스의 요소를 반환합니다.Returns the element at a specified index in a sequence.

ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32) ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32) ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32) ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)

시퀀스에서 지정된 인덱스의 요소를 반환하거나, 인덱스가 범위를 벗어나면 기본 값을 반환합니다.Returns the element at a specified index in a sequence or a default value if the index is out of range.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

기본 같음 비교자로 값을 비교하여 두 시퀀스의 차집합을 구합니다.Produces the set difference of two sequences by using the default equality comparer to compare values.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

지정된 IEqualityComparer<T>로 값을 비교하여 두 시퀀스의 차집합을 구합니다.Produces the set difference of two sequences by using the specified IEqualityComparer<T> to compare values.

First<TSource>(IEnumerable<TSource>) First<TSource>(IEnumerable<TSource>) First<TSource>(IEnumerable<TSource>) First<TSource>(IEnumerable<TSource>)

시퀀스의 첫 번째 요소를 반환합니다.Returns the first element of a sequence.

First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

시퀀스에서 지정된 조건에 맞는 첫 번째 요소를 반환합니다.Returns the first element in a sequence that satisfies a specified condition.

FirstOrDefault<TSource>(IEnumerable<TSource>) FirstOrDefault<TSource>(IEnumerable<TSource>) FirstOrDefault<TSource>(IEnumerable<TSource>) FirstOrDefault<TSource>(IEnumerable<TSource>)

시퀀스의 첫 번째 요소를 반환하거나, 시퀀스에 요소가 없으면 기본값을 반환합니다.Returns the first element of a sequence, or a default value if the sequence contains no elements.

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

시퀀스에서 특정 조건에 맞는 첫 번째 요소를 반환하거나, 이러한 요소가 없으면 기본값을 반환합니다.Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

지정된 키 선택기 함수에 따라 시퀀스의 요소를 그룹화합니다.Groups the elements of a sequence according to a specified key selector function.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

지정된 키 선택기 함수에 따라 지정된 비교자로 키를 비교하여 시퀀스의 요소를 그룹화합니다.Groups the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

지정된 키 선택기 함수에 따라 시퀀스의 요소를 그룹화하고 지정된 함수를 사용하여 각 그룹의 요소를 투영합니다.Groups the elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

키 선택기 함수에 따라 시퀀스의 요소를 그룹화합니다.Groups the elements of a sequence according to a key selector function. 키는 비교자를 통해 비교되고 각 그룹의 요소는 지정된 함수를 통해 투영됩니다.The keys are compared by using a comparer and each group's elements are projected by using a specified function.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>) GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>) GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>) GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)

지정된 키 누적기 함수에 따라 시퀀스의 요소를 그룹화하고 각 그룹의 결과 값과 해당 키를 만듭니다.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>) GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>) GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>) GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)

지정된 키 누적기 함수에 따라 시퀀스의 요소를 그룹화하고 각 그룹의 결과 값과 해당 키를 만듭니다.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. 키는 지정된 비교자를 통해 비교됩니다.The keys are compared by using a specified comparer.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>) GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>) GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>) GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)

지정된 키 누적기 함수에 따라 시퀀스의 요소를 그룹화하고 각 그룹의 결과 값과 해당 키를 만듭니다.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. 각 그룹의 요소는 지정된 함수를 통해 투영됩니다.The elements of each group are projected by using a specified function.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>, IEqualityComparer<TKey>) GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>, IEqualityComparer<TKey>) GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>, IEqualityComparer<TKey>) GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>, IEqualityComparer<TKey>)

지정된 키 누적기 함수에 따라 시퀀스의 요소를 그룹화하고 각 그룹의 결과 값과 해당 키를 만듭니다.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. 키 값은 지정된 비교자를 통해 비교되고 각 그룹의 요소는 지정된 함수를 통해 투영됩니다.Key values are compared by using a specified comparer, and the elements of each group are projected by using a specified function.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>) GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>) GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>) GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>)

키가 같은지 여부에 따라 두 시퀀스의 요소를 연관시키고 결과를 그룹화합니다.Correlates the elements of two sequences based on equality of keys and groups the results. 기본 같음 비교자를 사용하여 키를 비교합니다.The default equality comparer is used to compare keys.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>, IEqualityComparer<TKey>) GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>, IEqualityComparer<TKey>) GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>, IEqualityComparer<TKey>) GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>, IEqualityComparer<TKey>)

키가 같은지 여부에 따라 두 시퀀스의 요소를 연관시키고 결과를 그룹화합니다.Correlates the elements of two sequences based on key equality and groups the results. 지정된 IEqualityComparer<T>를 사용하여 키를 비교합니다.A specified IEqualityComparer<T> is used to compare keys.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

기본 같음 비교자로 값을 비교하여 두 시퀀스의 교집합을 구합니다.Produces the set intersection of two sequences by using the default equality comparer to compare values.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

지정된 IEqualityComparer<T>로 값을 비교하여 두 시퀀스의 교집합을 구합니다.Produces the set intersection of two sequences by using the specified IEqualityComparer<T> to compare values.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>) Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>) Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>) Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)

일치하는 키를 기준으로 두 시퀀스의 요소를 연관시킵니다.Correlates the elements of two sequences based on matching keys. 기본 같음 비교자를 사용하여 키를 비교합니다.The default equality comparer is used to compare keys.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>) Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>) Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>) Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)

일치하는 키를 기준으로 두 시퀀스의 요소를 연관시킵니다.Correlates the elements of two sequences based on matching keys. 지정된 IEqualityComparer<T>를 사용하여 키를 비교합니다.A specified IEqualityComparer<T> is used to compare keys.

Last<TSource>(IEnumerable<TSource>) Last<TSource>(IEnumerable<TSource>) Last<TSource>(IEnumerable<TSource>) Last<TSource>(IEnumerable<TSource>)

시퀀스의 마지막 요소를 반환합니다.Returns the last element of a sequence.

Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

시퀀스에서 지정된 조건에 맞는 마지막 요소를 반환합니다.Returns the last element of a sequence that satisfies a specified condition.

LastOrDefault<TSource>(IEnumerable<TSource>) LastOrDefault<TSource>(IEnumerable<TSource>) LastOrDefault<TSource>(IEnumerable<TSource>) LastOrDefault<TSource>(IEnumerable<TSource>)

시퀀스의 마지막 요소를 반환하거나, 시퀀스에 요소가 없으면 기본값을 반환합니다.Returns the last element of a sequence, or a default value if the sequence contains no elements.

LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

시퀀스에서 특정 조건에 맞는 마지막 요소를 반환하거나, 이러한 요소가 없으면 기본값을 반환합니다.Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.

LongCount<TSource>(IEnumerable<TSource>) LongCount<TSource>(IEnumerable<TSource>) LongCount<TSource>(IEnumerable<TSource>) LongCount<TSource>(IEnumerable<TSource>)

시퀀스의 총 요소 수를 나타내는 Int64를 반환합니다.Returns an Int64 that represents the total number of elements in a sequence.

LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

시퀀스에서 특정 조건에 맞는 요소 수를 나타내는 Int64를 반환합니다.Returns an Int64 that represents how many elements in a sequence satisfy a condition.

Max(IEnumerable<Decimal>) Max(IEnumerable<Decimal>) Max(IEnumerable<Decimal>) Max(IEnumerable<Decimal>)

Decimal 값 시퀀스의 최대값을 반환합니다.Returns the maximum value in a sequence of Decimal values.

Max(IEnumerable<Double>) Max(IEnumerable<Double>) Max(IEnumerable<Double>) Max(IEnumerable<Double>)

Double 값 시퀀스의 최대값을 반환합니다.Returns the maximum value in a sequence of Double values.

Max(IEnumerable<Int32>) Max(IEnumerable<Int32>) Max(IEnumerable<Int32>) Max(IEnumerable<Int32>)

Int32 값 시퀀스의 최대값을 반환합니다.Returns the maximum value in a sequence of Int32 values.

Max(IEnumerable<Int64>) Max(IEnumerable<Int64>) Max(IEnumerable<Int64>) Max(IEnumerable<Int64>)

Int64 값 시퀀스의 최대값을 반환합니다.Returns the maximum value in a sequence of Int64 values.

Max(IEnumerable<Nullable<Decimal>>) Max(IEnumerable<Nullable<Decimal>>) Max(IEnumerable<Nullable<Decimal>>) Max(IEnumerable<Nullable<Decimal>>)

nullable Decimal 값 시퀀스의 최대값을 반환합니다.Returns the maximum value in a sequence of nullable Decimal values.

Max(IEnumerable<Nullable<Double>>) Max(IEnumerable<Nullable<Double>>) Max(IEnumerable<Nullable<Double>>) Max(IEnumerable<Nullable<Double>>)

nullable Double 값 시퀀스의 최대값을 반환합니다.Returns the maximum value in a sequence of nullable Double values.

Max(IEnumerable<Nullable<Int32>>) Max(IEnumerable<Nullable<Int32>>) Max(IEnumerable<Nullable<Int32>>) Max(IEnumerable<Nullable<Int32>>)

nullable Int32 값 시퀀스의 최대값을 반환합니다.Returns the maximum value in a sequence of nullable Int32 values.

Max(IEnumerable<Nullable<Int64>>) Max(IEnumerable<Nullable<Int64>>) Max(IEnumerable<Nullable<Int64>>) Max(IEnumerable<Nullable<Int64>>)

nullable Int64 값 시퀀스의 최대값을 반환합니다.Returns the maximum value in a sequence of nullable Int64 values.

Max(IEnumerable<Nullable<Single>>) Max(IEnumerable<Nullable<Single>>) Max(IEnumerable<Nullable<Single>>) Max(IEnumerable<Nullable<Single>>)

nullable Single 값 시퀀스의 최대값을 반환합니다.Returns the maximum value in a sequence of nullable Single values.

Max(IEnumerable<Single>) Max(IEnumerable<Single>) Max(IEnumerable<Single>) Max(IEnumerable<Single>)

Single 값 시퀀스의 최대값을 반환합니다.Returns the maximum value in a sequence of Single values.

Max<TSource>(IEnumerable<TSource>) Max<TSource>(IEnumerable<TSource>) Max<TSource>(IEnumerable<TSource>) Max<TSource>(IEnumerable<TSource>)

제네릭 시퀀스의 최대값을 반환합니다.Returns the maximum value in a generic sequence.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최대 Decimal 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the maximum Decimal value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최대 Double 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the maximum Double value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최대 Int32 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the maximum Int32 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최대 Int64 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the maximum Int64 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최대 nullable Decimal 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the maximum nullable Decimal value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최대 nullable Double 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the maximum nullable Double value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최대 nullable Int32 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the maximum nullable Int32 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최대 nullable Int64 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the maximum nullable Int64 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최대 nullable Single 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the maximum nullable Single value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최대 Single 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the maximum Single value.

Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

제네릭 시퀀스의 각 요소에 대해 변형 함수를 호출하고 최대 결과 값을 반환합니다.Invokes a transform function on each element of a generic sequence and returns the maximum resulting value.

Min(IEnumerable<Decimal>) Min(IEnumerable<Decimal>) Min(IEnumerable<Decimal>) Min(IEnumerable<Decimal>)

Decimal 값 시퀀스의 최소값을 반환합니다.Returns the minimum value in a sequence of Decimal values.

Min(IEnumerable<Double>) Min(IEnumerable<Double>) Min(IEnumerable<Double>) Min(IEnumerable<Double>)

Double 값 시퀀스의 최소값을 반환합니다.Returns the minimum value in a sequence of Double values.

Min(IEnumerable<Int32>) Min(IEnumerable<Int32>) Min(IEnumerable<Int32>) Min(IEnumerable<Int32>)

Int32 값 시퀀스의 최소값을 반환합니다.Returns the minimum value in a sequence of Int32 values.

Min(IEnumerable<Int64>) Min(IEnumerable<Int64>) Min(IEnumerable<Int64>) Min(IEnumerable<Int64>)

Int64 값 시퀀스의 최소값을 반환합니다.Returns the minimum value in a sequence of Int64 values.

Min(IEnumerable<Nullable<Decimal>>) Min(IEnumerable<Nullable<Decimal>>) Min(IEnumerable<Nullable<Decimal>>) Min(IEnumerable<Nullable<Decimal>>)

nullable Decimal 값 시퀀스의 최소값을 반환합니다.Returns the minimum value in a sequence of nullable Decimal values.

Min(IEnumerable<Nullable<Double>>) Min(IEnumerable<Nullable<Double>>) Min(IEnumerable<Nullable<Double>>) Min(IEnumerable<Nullable<Double>>)

nullable Double 값 시퀀스의 최소값을 반환합니다.Returns the minimum value in a sequence of nullable Double values.

Min(IEnumerable<Nullable<Int32>>) Min(IEnumerable<Nullable<Int32>>) Min(IEnumerable<Nullable<Int32>>) Min(IEnumerable<Nullable<Int32>>)

nullable Int32 값 시퀀스의 최소값을 반환합니다.Returns the minimum value in a sequence of nullable Int32 values.

Min(IEnumerable<Nullable<Int64>>) Min(IEnumerable<Nullable<Int64>>) Min(IEnumerable<Nullable<Int64>>) Min(IEnumerable<Nullable<Int64>>)

nullable Int64 값 시퀀스의 최소값을 반환합니다.Returns the minimum value in a sequence of nullable Int64 values.

Min(IEnumerable<Nullable<Single>>) Min(IEnumerable<Nullable<Single>>) Min(IEnumerable<Nullable<Single>>) Min(IEnumerable<Nullable<Single>>)

nullable Single 값 시퀀스의 최소값을 반환합니다.Returns the minimum value in a sequence of nullable Single values.

Min(IEnumerable<Single>) Min(IEnumerable<Single>) Min(IEnumerable<Single>) Min(IEnumerable<Single>)

Single 값 시퀀스의 최소값을 반환합니다.Returns the minimum value in a sequence of Single values.

Min<TSource>(IEnumerable<TSource>) Min<TSource>(IEnumerable<TSource>) Min<TSource>(IEnumerable<TSource>) Min<TSource>(IEnumerable<TSource>)

제네릭 시퀀스의 최소값을 반환합니다.Returns the minimum value in a generic sequence.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최소 Decimal 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the minimum Decimal value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최소 Double 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the minimum Double value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최소 Int32 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the minimum Int32 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최소 Int64 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the minimum Int64 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최소 nullable Decimal 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the minimum nullable Decimal value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최소 nullable Double 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the minimum nullable Double value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최소 nullable Int32 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the minimum nullable Int32 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최소 nullable Int64 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the minimum nullable Int64 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최소 nullable Single 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the minimum nullable Single value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

시퀀스의 각 요소에 대해 변형 함수를 호출하고 최소 Single 값을 반환합니다.Invokes a transform function on each element of a sequence and returns the minimum Single value.

Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

제네릭 시퀀스의 각 요소에 대해 변형 함수를 호출하고 최소 결과 값을 반환합니다.Invokes a transform function on each element of a generic sequence and returns the minimum resulting value.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

지정된 형식에 따라 IEnumerable의 요소를 필터링합니다.Filters the elements of an IEnumerable based on a specified type.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

시퀀스의 요소를 키에 따라 오름차순으로 정렬합니다.Sorts the elements of a sequence in ascending order according to a key.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

지정된 비교자를 사용하여 시퀀스의 요소를 오름차순으로 정렬합니다.Sorts the elements of a sequence in ascending order by using a specified comparer.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

시퀀스의 요소를 키에 따라 내림차순으로 정렬합니다.Sorts the elements of a sequence in descending order according to a key.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

지정된 비교자를 사용하여 시퀀스의 요소를 내림차순으로 정렬합니다.Sorts the elements of a sequence in descending order by using a specified comparer.

Prepend<TSource>(IEnumerable<TSource>, TSource) Prepend<TSource>(IEnumerable<TSource>, TSource) Prepend<TSource>(IEnumerable<TSource>, TSource) Prepend<TSource>(IEnumerable<TSource>, TSource)

시퀀스의 시작 부분에 값을 추가합니다.Adds a value to the beginning of the sequence.

Reverse<TSource>(IEnumerable<TSource>) Reverse<TSource>(IEnumerable<TSource>) Reverse<TSource>(IEnumerable<TSource>) Reverse<TSource>(IEnumerable<TSource>)

시퀀스의 요소 순서를 반전합니다.Inverts the order of the elements in a sequence.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

시퀀스의 각 요소를 새 폼에 투영합니다.Projects each element of a sequence into a new form.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>) Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>) Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>) Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)

요소의 인덱스를 통합하여 시퀀스의 각 요소를 새 폼에 투영합니다.Projects each element of a sequence into a new form by incorporating the element's index.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)

시퀀스의 각 요소를 IEnumerable<T>에 투영하고 결과 시퀀스를 단일 시퀀스로 평면화합니다.Projects each element of a sequence to an IEnumerable<T> and flattens the resulting sequences into one sequence.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)

시퀀스의 각 요소를 IEnumerable<T>에 투영하고 결과 시퀀스를 단일 시퀀스로 평면화합니다.Projects each element of a sequence to an IEnumerable<T>, and flattens the resulting sequences into one sequence. 각 소스 요소의 인덱스는 해당 요소의 투영된 폼에 사용됩니다.The index of each source element is used in the projected form of that element.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

시퀀스의 각 요소를 IEnumerable<T>로 투영하고, 결과 시퀀스를 단일 시퀀스로 평면화한 다음 포함된 각 요소에 대해 결과 선택기 함수를 호출합니다.Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

시퀀스의 각 요소를 IEnumerable<T>로 투영하고, 결과 시퀀스를 단일 시퀀스로 평면화한 다음 포함된 각 요소에 대해 결과 선택기 함수를 호출합니다.Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. 각 소스 요소의 인덱스는 해당 요소의 투영된 중간 폼에 사용됩니다.The index of each source element is used in the intermediate projected form of that element.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

해당 형식에 대한 기본 같음 비교자를 통해 요소를 비교하여 두 시퀀스가 서로 같은지 확인합니다.Determines whether two sequences are equal by comparing the elements by using the default equality comparer for their type.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

지정된 IEqualityComparer<T>를 통해 요소를 비교하여 두 시퀀스가 서로 같은지 확인합니다.Determines whether two sequences are equal by comparing their elements by using a specified IEqualityComparer<T>.

Single<TSource>(IEnumerable<TSource>) Single<TSource>(IEnumerable<TSource>) Single<TSource>(IEnumerable<TSource>) Single<TSource>(IEnumerable<TSource>)

시퀀스의 유일한 요소를 반환하고, 시퀀스에 요소가 정확히 하나 들어 있지 않으면 예외를 throw합니다.Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.

Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

시퀀스에서 지정된 조건에 맞는 유일한 요소를 반환하고, 이러한 요소가 둘 이상 있으면 예외를 throw합니다.Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.

SingleOrDefault<TSource>(IEnumerable<TSource>) SingleOrDefault<TSource>(IEnumerable<TSource>) SingleOrDefault<TSource>(IEnumerable<TSource>) SingleOrDefault<TSource>(IEnumerable<TSource>)

시퀀스의 유일한 요소를 반환하거나 시퀀스가 비어 있으면 기본값을 반환합니다. 시퀀스에 요소가 둘 이상 있으면 예외를 throw합니다.Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.

SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

시퀀스에서 지정된 조건에 맞는 유일한 요소를 반환하거나 이러한 요소가 없으면 기본값을 반환합니다. 조건에 맞는 요소가 둘 이상 있으면 예외를 throw합니다.Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition.

Skip<TSource>(IEnumerable<TSource>, Int32) Skip<TSource>(IEnumerable<TSource>, Int32) Skip<TSource>(IEnumerable<TSource>, Int32) Skip<TSource>(IEnumerable<TSource>, Int32)

시퀀스에서 지정된 수의 요소를 건너뛴 다음 나머지 요소를 반환합니다.Bypasses a specified number of elements in a sequence and then returns the remaining elements.

SkipLast<TSource>(IEnumerable<TSource>, Int32) SkipLast<TSource>(IEnumerable<TSource>, Int32) SkipLast<TSource>(IEnumerable<TSource>, Int32) SkipLast<TSource>(IEnumerable<TSource>, Int32)
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

지정된 조건이 true이면 시퀀스에 있는 요소를 무시하고 나머지 요소를 반환합니다.Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

지정된 조건이 true이면 시퀀스에 있는 요소를 무시하고 나머지 요소를 반환합니다.Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. 조건자 함수의 논리에 요소의 인덱스가 사용됩니다.The element's index is used in the logic of the predicate function.

Sum(IEnumerable<Decimal>) Sum(IEnumerable<Decimal>) Sum(IEnumerable<Decimal>) Sum(IEnumerable<Decimal>)

Decimal 값 시퀀스의 합을 계산합니다.Computes the sum of a sequence of Decimal values.

Sum(IEnumerable<Double>) Sum(IEnumerable<Double>) Sum(IEnumerable<Double>) Sum(IEnumerable<Double>)

Double 값 시퀀스의 합을 계산합니다.Computes the sum of a sequence of Double values.

Sum(IEnumerable<Int32>) Sum(IEnumerable<Int32>) Sum(IEnumerable<Int32>) Sum(IEnumerable<Int32>)

Int32 값 시퀀스의 합을 계산합니다.Computes the sum of a sequence of Int32 values.

Sum(IEnumerable<Int64>) Sum(IEnumerable<Int64>) Sum(IEnumerable<Int64>) Sum(IEnumerable<Int64>)

Int64 값 시퀀스의 합을 계산합니다.Computes the sum of a sequence of Int64 values.

Sum(IEnumerable<Nullable<Decimal>>) Sum(IEnumerable<Nullable<Decimal>>) Sum(IEnumerable<Nullable<Decimal>>) Sum(IEnumerable<Nullable<Decimal>>)

nullable Decimal 값 시퀀스의 합을 계산합니다.Computes the sum of a sequence of nullable Decimal values.

Sum(IEnumerable<Nullable<Double>>) Sum(IEnumerable<Nullable<Double>>) Sum(IEnumerable<Nullable<Double>>) Sum(IEnumerable<Nullable<Double>>)

nullable Double 값 시퀀스의 합을 계산합니다.Computes the sum of a sequence of nullable Double values.

Sum(IEnumerable<Nullable<Int32>>) Sum(IEnumerable<Nullable<Int32>>) Sum(IEnumerable<Nullable<Int32>>) Sum(IEnumerable<Nullable<Int32>>)

nullable Int32 값 시퀀스의 합을 계산합니다.Computes the sum of a sequence of nullable Int32 values.

Sum(IEnumerable<Nullable<Int64>>) Sum(IEnumerable<Nullable<Int64>>) Sum(IEnumerable<Nullable<Int64>>) Sum(IEnumerable<Nullable<Int64>>)

nullable Int64 값 시퀀스의 합을 계산합니다.Computes the sum of a sequence of nullable Int64 values.

Sum(IEnumerable<Nullable<Single>>) Sum(IEnumerable<Nullable<Single>>) Sum(IEnumerable<Nullable<Single>>) Sum(IEnumerable<Nullable<Single>>)

nullable Single 값 시퀀스의 합을 계산합니다.Computes the sum of a sequence of nullable Single values.

Sum(IEnumerable<Single>) Sum(IEnumerable<Single>) Sum(IEnumerable<Single>) Sum(IEnumerable<Single>)

Single 값 시퀀스의 합을 계산합니다.Computes the sum of a sequence of Single values.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

입력 시퀀스의 각 요소에 대해 변형 함수를 호출하여 가져온 Decimal 값 시퀀스의 합을 계산합니다.Computes the sum of the sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

입력 시퀀스의 각 요소에 대해 변형 함수를 호출하여 가져온 Double 값 시퀀스의 합을 계산합니다.Computes the sum of the sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

입력 시퀀스의 각 요소에 대해 변형 함수를 호출하여 가져온 Int32 값 시퀀스의 합을 계산합니다.Computes the sum of the sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

입력 시퀀스의 각 요소에 대해 변형 함수를 호출하여 가져온 Int64 값 시퀀스의 합을 계산합니다.Computes the sum of the sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

입력 시퀀스의 각 요소에 대해 변형 함수를 호출하여 가져온 nullable Decimal 값 시퀀스의 합을 계산합니다.Computes the sum of the sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

입력 시퀀스의 각 요소에 대해 변형 함수를 호출하여 가져온 nullable Double 값 시퀀스의 합을 계산합니다.Computes the sum of the sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

입력 시퀀스의 각 요소에 대해 변형 함수를 호출하여 가져온 nullable Int32 값 시퀀스의 합을 계산합니다.Computes the sum of the sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Sum<TSource>(IEnumerable<TSource>,