SortKey SortKey SortKey SortKey Class

정의

문자열을 해당 정렬 키에 매핑한 결과를 나타냅니다.Represents the result of mapping a string to its sort key.

public ref class SortKey
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class SortKey
type SortKey = class
Public Class SortKey
상속
SortKeySortKeySortKeySortKey
특성

예제

다음 예제에서는 llama"문자열" "EN-US" 및 "ES-ES" 문화권 "EN-US" 및 "ES-ES" 기존의 문화권을 사용 하 여 비교 합니다.The following example compares the string "llama" using the "en-US" and "es-ES" cultures, and the "en-US" and "es-ES" traditional cultures.

using namespace System;
using namespace System::Globalization;
int main()
{
   
   // Creates a SortKey using the en-US culture.
   CultureInfo^ MyCI = gcnew CultureInfo( "en-US",false );
   CompareInfo^ myComp_enUS = MyCI->CompareInfo;
   SortKey^ mySK1 = myComp_enUS->GetSortKey( "llama" );
   
   // Creates a SortKey using the es-ES culture with international sort.
   MyCI = gcnew CultureInfo( "es-ES",false );
   CompareInfo^ myComp_esES = MyCI->CompareInfo;
   SortKey^ mySK2 = myComp_esES->GetSortKey( "llama" );
   
   // Creates a SortKey using the es-ES culture with traditional sort.
   MyCI = gcnew CultureInfo( 0x040A,false );
   CompareInfo^ myComp_es = MyCI->CompareInfo;
   SortKey^ mySK3 = myComp_es->GetSortKey( "llama" );
   
   // Compares the en-US SortKey with each of the es-ES SortKey objects.
   Console::WriteLine( "Comparing \"llama\" in en-US and in es-ES with international sort : {0}", SortKey::Compare( mySK1, mySK2 ) );
   Console::WriteLine( "Comparing \"llama\" in en-US and in es-ES with traditional sort   : {0}", SortKey::Compare( mySK1, mySK3 ) );
}

/*
This code produces the following output.

Comparing S"llama" in en-US and in es-ES with international sort : 0
Comparing S"llama" in en-US and in es-ES with traditional sort   : -1
*/
using System;
using System.Globalization;

public class SamplesSortKey  {

   public static void Main()  {

      // Creates a SortKey using the en-US culture.
      CompareInfo myComp_enUS = new CultureInfo("en-US",false).CompareInfo;
      SortKey mySK1 = myComp_enUS.GetSortKey( "llama" );

      // Creates a SortKey using the es-ES culture with international sort.
      CompareInfo myComp_esES = new CultureInfo("es-ES",false).CompareInfo;
      SortKey mySK2 = myComp_esES.GetSortKey( "llama" );

      // Creates a SortKey using the es-ES culture with traditional sort.
      CompareInfo myComp_es   = new CultureInfo(0x040A,false).CompareInfo;
      SortKey mySK3 = myComp_es.GetSortKey( "llama" );

      // Compares the en-US SortKey with each of the es-ES SortKey objects.
      Console.WriteLine( "Comparing \"llama\" in en-US and in es-ES with international sort : {0}", SortKey.Compare( mySK1, mySK2 ) );
      Console.WriteLine( "Comparing \"llama\" in en-US and in es-ES with traditional sort   : {0}", SortKey.Compare( mySK1, mySK3 ) );

   }

}

/*
This code produces the following output.

Comparing "llama" in en-US and in es-ES with international sort : 0
Comparing "llama" in en-US and in es-ES with traditional sort   : -1
*/

Imports System.Globalization

Public Class SamplesSortKey

   Public Shared Sub Main()

      ' Creates a SortKey using the en-US culture.
      Dim myComp_enUS As CompareInfo = New CultureInfo("en-US", False).CompareInfo
      Dim mySK1 As SortKey = myComp_enUS.GetSortKey("llama")

      ' Creates a SortKey using the es-ES culture with international sort.
      Dim myComp_esES As CompareInfo = New CultureInfo("es-ES", False).CompareInfo
      Dim mySK2 As SortKey = myComp_esES.GetSortKey("llama")

      ' Creates a SortKey using the es-ES culture with traditional sort.
      Dim myComp_es As CompareInfo = New CultureInfo(&H40A, False).CompareInfo
      Dim mySK3 As SortKey = myComp_es.GetSortKey("llama")

      ' Compares the en-US SortKey with each of the es-ES SortKey objects.
      Console.WriteLine("Comparing ""llama"" in en-US and in es-ES with international sort : {0}", SortKey.Compare(mySK1, mySK2))
      Console.WriteLine("Comparing ""llama"" in en-US and in es-ES with traditional sort   : {0}", SortKey.Compare(mySK1, mySK3))

   End Sub

End Class


'This code produces the following output.
'
'Comparing "llama" in en-US and in es-ES with international sort : 0
'Comparing "llama" in en-US and in es-ES with traditional sort   : -1

다음 예제에서는 사용 하는 방법을 보여 줍니다는 SortKey 큰 배열의 검색 및 정렬을 광범위 하 게 의존 하는 애플리케이션의 성능을 향상 시키는 클래스입니다.The following example shows how you can use the SortKey class to improve performance in an application that relies extensively on sorting and searching a large array. 이 예제에는 경우 13 개 요소가 있는 이름의 순서가 지정 되지 않은 배열을 만듭니다.The example creates an unordered array of names, which in this case has 13 elements. 그런 다음 각 이름의 정렬 키를 전달 하는 병렬 배열에 저장 된 Array.Sort(Array, Array) 메서드.It then stores the sort key of each name in a parallel array, which it passes to the Array.Sort(Array, Array) method. 결과 정렬 된 배열입니다.The result is a sorted array. 예제에서는 세 문자열 배열을 검색합니다.The example then searches the array for three strings. 각 검색 문자열에 대 한 호출을 CompareInfo.GetSortKey(String, CompareOptions) 검색 문자열의 정렬 키를 차례로 호출 하는 메서드는 Array.FindIndex 정렬 키의 배열에서 해당 정렬 키의 인덱스를 검색 하는 방법.For each search string, it calls the CompareInfo.GetSortKey(String, CompareOptions) method to retrieve the string's sort key, and then calls the Array.FindIndex method to retrieve the index of that sort key in the array of sort keys. 이름 및 정렬 키 배열 병렬 이기 때문에 반환 된 인덱스에 있는 이름의 인덱스 이기도 합니다 names 배열입니다.Because the name and sort key arrays are parallel, the returned index is also the index of the name in the names array.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Define names.
      String[] names= { "Adam", "Ignatius", "Batholomew", "Gregory", 
                        "Clement", "Frances", "Harold", "Dalmatius", 
                        "Edgar", "John", "Benedict", "Paul", "George" }; 
      SortKey[] sortKeys = new SortKey[names.Length];
      CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;

      for (int ctr = 0; ctr < names.Length; ctr++)
         sortKeys[ctr] = ci.GetSortKey(names[ctr], CompareOptions.IgnoreCase);         
      
      // Sort array based on value of sort keys.
      Array.Sort(names, sortKeys);
      
      Console.WriteLine("Sorted array: ");
      foreach (var name in names)
         Console.WriteLine(name);

      Console.WriteLine();
      
      String[] namesToFind = { "Paul", "PAUL", "Wilberforce" };
      
      Console.WriteLine("Searching an array:");
      foreach (var nameToFind in namesToFind) {
         SortKey searchKey = ci.GetSortKey(nameToFind, CompareOptions.IgnoreCase);
         int index = Array.FindIndex(sortKeys, (x) => x.Equals(searchKey)); 
         if (index >= 0)
            Console.WriteLine("{0} found at index {1}: {2}", nameToFind,
                              index, names[index]);
         else
            Console.WriteLine("{0} not found", nameToFind);
      } 
   }
}
// The example displays the following output:
//       Sorted array:
//       Adam
//       Batholomew
//       Benedict
//       Clement
//       Dalmatius
//       Edgar
//       Frances
//       George
//       Gregory
//       Harold
//       Ignatius
//       John
//       Paul
//       
//       Searching an array:
//       Paul found at index 12: Paul
//       PAUL found at index 12: Paul
//       Wilberforce not found
Imports System.Globalization

Module Example
   Public Sub Main()
      ' Define names.
      Dim names() As String = { "Adam", "Ignatius", "Batholomew", 
                                "Gregory", "Clement", "Frances",  
                                "Harold", "Dalmatius", "Edgar",    
                                "John", "Benedict", "Paul", "George" } 
      Dim sortKeys(names.Length - 1) As SortKey
      Dim ci As CompareInfo = CultureInfo.CurrentCulture.CompareInfo

      For ctr As Integer = 0 To names.Length - 1
         sortKeys(ctr) = ci.GetSortKey(names(ctr), CompareOptions.IgnoreCase)         
      Next   
      
      ' Sort array based on value of sort keys.
      Array.Sort(names, sortKeys)
      
      Console.WriteLine("Sorted array: ")
      For Each name In names
         Console.WriteLine(name)
      Next          
      Console.WriteLine()
      
      Dim namesToFind() As String = { "Paul", "PAUL", "Wilberforce" }
      
      Console.WriteLine("Searching an array:")
      For Each nameToFind In namesToFind
         Dim searchKey As SortKey = ci.GetSortKey(nameToFind, CompareOptions.IgnoreCase)
         Dim index As Integer = Array.FindIndex(sortKeys, 
                                                Function(x) x.Equals(searchKey)) 
         If index >= 0 Then
            Console.WriteLine("{0} found at index {1}: {2}", nameToFind,
                              index, names(index))
         Else
            Console.WriteLine("{0} not found", nameToFind)
         End If                     
      Next                     
   End Sub
End Module
' The example displays the following output:
'       Sorted array:
'       Adam
'       Batholomew
'       Benedict
'       Clement
'       Dalmatius
'       Edgar
'       Frances
'       George
'       Gregory
'       Harold
'       Ignatius
'       John
'       Paul
'       
'       Searching an array:
'       Paul found at index 12: Paul
'       PAUL found at index 12: Paul
'       Wilberforce not found

설명

두 문자열의 문화권 구분 비교는 대/소문자 및 분음 부호 가중치 여러 범주의 정렬 가중치가, 스크립트, 사전순, 포함 된 문자열의 각 문자에 따라 다릅니다.A culture-sensitive comparison of two strings depends on each character in the strings having several categories of sort weights, including script, alphabetic, case, and diacritic weights. 정렬 키는 특정 문자열에 대 한 이러한 가중치의 리포지토리 역할도합니다.A sort key serves as the repository of these weights for a particular string.

합니다 CompareInfo.GetSortKey 의 인스턴스를 반환 하는 메서드는 SortKey 문화권 구분 매핑이 지정된 된 문자열의 문자를 반영 하는 클래스입니다.The CompareInfo.GetSortKey method returns an instance of the SortKey class that reflects the culture-sensitive mapping of characters in a specified string. 값을 SortKey 개체가 반환한 키 데이터는 KeyData 속성.The value of a SortKey object is its key data, which is returned by the KeyData property. 이 주요 데이터 일련의 문자열, 문화권별 정렬 규칙 및 사용자 지정 비교 옵션을 인코딩할 바이트로 이루어져 있습니다.This key data consists of a series of bytes that encode the string, culture-specific sorting rules, and user-specified comparison options. 각 정렬 키의 해당 키 데이터 비트 비교의 정렬 키를 사용 하는 비교 구성 됩니다.A comparison using sort keys consists of a bitwise comparison of the corresponding key data in each sort key. 예를 들어 정렬 키를 호출 하 여 만든 합니다 GetSortKey(String, CompareOptions) 값을 사용 하 여 메서드 CompareOptions.IgnoreCase, 정렬 키를 사용 하는 문자열 비교 작업은 대/소문자입니다.For example, if you create a sort key by calling the GetSortKey(String, CompareOptions) method with a value of CompareOptions.IgnoreCase, a string comparison operation that uses the sort key is case-insensitive.

정적 호출 하 여 정렬 키를 비교 하는 문자열에 대 한 정렬 키를 만든 후 SortKey.Compare 메서드.After you create a sort key for a string, you compare sort keys by calling the static SortKey.Compare method. 보다 훨씬 빠르게 수행 되므로이 메서드는 간단한 바이트 단위로 비교를 수행 합니다 String.Compare 또는 CompareInfo.Compare 메서드.This method performs a simple byte-by-byte comparison, so it is much faster than the String.Compare or CompareInfo.Compare method.

참고

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, the Default Unicode Collation Element Table, the sort weight table for Linux and macOS.

성능 고려 사항Performance considerations

문자열 비교를 수행 하는 경우는 CompareCompareInfo.Compare 메서드 생성 결과 동일 하지만 해당 대상 시나리오가 서로 다릅니다.When performing a string comparison, the Compare and CompareInfo.Compare methods yield the same results, but they target different scenarios.

높은 수준에서 CompareInfo.Compare 메서드 각 문자열에 대 한 정렬 키를 생성, 비교를 수행 하 고 다음 정렬 키를 삭제 및 비교의 결과 반환 합니다.At a high level, the CompareInfo.Compare method generates the sort key for each string, performs the comparison, and then discards the sort key and returns the result of the comparison. 그러나는 CompareInfo.Compare 메서드 실제로 생성 하지 비교를 수행 하는 전체 정렬 키입니다.However, the CompareInfo.Compare method actually doesn't generate an entire sort key to perform the comparison. 대신 메서드가 각 문자열에서 각 텍스트 요소 (즉, 기본 문자, 서로게이트 쌍 또는 문자 시퀀스 결합)에 대 한 주요 데이터를 생성 합니다.Instead, the method generates the key data for each text element (that is, base character, surrogate pair, or combining character sequence) in each string. 해당 텍스트 요소에 대 한 키 데이터를 비교합니다.The method then compares the key data for the corresponding text elements. 작업 비교의 최종 결과 결정 하는 즉시 종료 합니다.The operation terminates as soon as the ultimate result of the comparison is determined. 정렬 키 정보가 계산 없는 SortKey 개체가 만들어집니다.Sort key information is computed, but no SortKey object is created. 이 전략은 한 번에 두 문자열을 비교 하는 경우 성능 측면에서 경제적 하지만 동일한 문자열이 여러 번을 비교 하는 경우 비용이 많이 드는 됩니다.This strategy is economical in terms of performance if both strings are compared once, but becomes expensive if the same strings are compared many times.

Compare 메서드를 사용 하려면 차세대는 SortKey 비교를 수행 하기 전에 각 문자열에 대 한 개체입니다.The Compare method requires generation of a SortKey object for each string before performing the comparison. 이 전략은 생성 하는 데 메모리와 시간으로 인해 첫 번째 비교에 대 한 성능 측면에서 비용이 많이 드는 SortKey 개체입니다.This strategy is expensive in terms of performance for the first comparison because of the time and memory invested to generate the SortKey objects. 동일한 정렬 키를 여러 번을 비교 하는 경우에 경제적입니다.However, it becomes economical if the same sort keys are compared many times.

예를 들어 인덱스 문자열 기반 열에 지정된 된 검색 문자열과 일치 하는 행에 대 한 데이터베이스 테이블을 검색 하는 애플리케이션을 작성 합니다.For example, suppose you write an application that searches a database table for the row in which the string-based index column matches a specified search string. 테이블에는 수천 개의 행을 포함 하 고 시간이 오래 걸리는 각 행의 인덱스 검색 문자열을 비교 합니다.The table contains thousands of rows, and comparing the search string to the index in each row will take a long time. 따라서 애플리케이션에서 행과 해당 인덱스 열에 저장 하는 경우 또한 생성 하 고 검색 성능을 향상 시키기 위한 전용된 열에서 인덱스에 대 한 정렬 키를 저장.Therefore, when the application stores a row and its index column, it also generates and stores the sort key for the index in a column dedicated to improving search performance. 애플리케이션 대상 행을 검색할 때 검색 문자열 인덱스 문자열 검색 문자열을 비교 하는 대신 인덱스 문자열을 정렬 키에 대 한 정렬 키를 비교 합니다.When the application searches for a target row, it compares the sort key for the search string to the sort key for the index string, instead of comparing the search string to the index string.

보안 고려 사항Security considerations

CompareInfo.GetSortKey(String, CompareOptions) 메서드가 반환 되는 SortKey 지정 된 문자열을 기반으로 하는 값을 가진 개체가 및 CompareOptions 값 및 기본 연결 된 문화권 CompareInfo 개체입니다.The CompareInfo.GetSortKey(String, CompareOptions) method returns a SortKey object with the value based on a specified string and CompareOptions value, and the culture associated with the underlying CompareInfo object. 보안 결정은 문자열 비교 또는 대/소문자 변경에 따라 종속 하는 경우 사용 해야는 CompareInfo.GetSortKey(String, CompareOptions) 메서드의 동작 작업의 운영 체제의 문화권 설정에 관계 없이 일관 되도록 고정 문화권입니다.If a security decision depends on a string comparison or case change, you should use the CompareInfo.GetSortKey(String, CompareOptions) method of the invariant culture to ensure that the behavior of the operation is consistent, regardless of the culture settings of the operating system.

정렬 키를 얻으려면 다음 단계를 사용 합니다.Use the following steps to obtain a sort key:

  1. 고정 문화권을 검색 합니다 CultureInfo.InvariantCulture 속성입니다.Retrieve the invariant culture from the CultureInfo.InvariantCulture property.

  2. 검색을 CompareInfo 에서 고정 문화권에 대 한 개체는 CultureInfo.CompareInfo 속성입니다.Retrieve a CompareInfo object for the invariant culture from the CultureInfo.CompareInfo property.

  3. CompareInfo.GetSortKey(String, CompareOptions) 메서드를 호출합니다.Call the CompareInfo.GetSortKey(String, CompareOptions) method.

값을 사용 하 여 작업을 SortKey 개체는 Windows를 호출 하는 것은 LCMapString LCMAP_SORTKEY 값이 지정 된 메서드.Working with the value of a SortKey object is equivalent to calling the Windows LCMapString method with the LCMAP_SORTKEY value specified. 그러나는 SortKey 개체 영어 문자에 대 한 정렬 키의 정렬 키 한국어 문자를 앞에 야 합니다.However, for the SortKey object, the sort keys for English characters precede the sort keys for Korean characters.

SortKey 개체 수 serialize 된 있지만 이러한를 넘을 수 있도록 AppDomain 개체입니다.SortKey objects can be serialized, but only so that they can cross AppDomain objects. 애플리케이션을 serialize 하는 경우는 SortKey 개체를.NET Framework의 새 버전이 있는 경우 애플리케이션의 모든 정렬 키를 다시 생성 해야 합니다.If an application serializes a SortKey object, the application must regenerate all the sort keys when there is a new version of the .NET Framework.

정렬 키에 대 한 자세한 내용은 유니코드 기술 표준 #10, "유니코드 데이터 정렬 알고리즘"을 참조 합니다 유니코드 컨소시엄 웹 사이트합니다.For more information about sort keys, see Unicode Technical Standard #10, "Unicode Collation Algorithm" on the Unicode Consortium website.

속성

KeyData KeyData KeyData KeyData

현재 SortKey 개체를 나타내는 바이트 배열을 가져옵니다.Gets the byte array representing the current SortKey object.

OriginalString OriginalString OriginalString OriginalString

현재 SortKey 개체를 만드는 데 사용되는 원래 문자열을 가져옵니다.Gets the original string used to create the current SortKey object.

메서드

Compare(SortKey, SortKey) Compare(SortKey, SortKey) Compare(SortKey, SortKey) Compare(SortKey, SortKey)

두 정렬 키를 비교합니다.Compares two sort keys.

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

지정한 개체와 현재 SortKey 개체가 같은지 여부를 확인합니다.Determines whether the specified object is equal to the current SortKey object.

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

해시 알고리즘과 해시 테이블 같은 데이터 구조에 적합한 현재 SortKey 개체에 대한 해시 함수의 역할을 합니다.Serves as a hash function for the current SortKey object that is suitable for hashing algorithms and data structures such as a hash table.

GetType() GetType() GetType() GetType()

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

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

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

(Inherited from Object)
ToString() ToString() ToString() ToString()

현재 SortKey 개체를 나타내는 문자열을 반환합니다.Returns a string that represents the current SortKey object.

적용 대상

추가 정보