SortKey 클래스

정의

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

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

예제

다음 예제에서는 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. 예를 들어 CompareOptions.IgnoreCase값을 사용 하 여 GetSortKey(String, CompareOptions) 메서드를 호출 하 여 정렬 키를 만드는 경우 정렬 키를 사용 하는 문자열 비교 연산은 대/소문자를 구분 하지 않습니다.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) 메서드는 지정 된 문자열과 CompareOptions 값을 기반으로 하는 값과 기본 CompareInfo 개체와 연결 된 문화권을 사용 하 여 SortKey 개체를 반환 합니다.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. CultureInfo.CompareInfo 속성에서 고정 문화권에 대 한 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 개체의 값으로 작업 하는 것은 지정 된 LCMAP_SORTKEY 값을 사용 하 여 Windows LCMapString 메서드를 호출 하는 것과 같습니다.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.

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

속성

KeyData

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

OriginalString

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

메서드

Compare(SortKey, SortKey)

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

Equals(Object)

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

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()

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

(다음에서 상속됨 Object)
MemberwiseClone()

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

(다음에서 상속됨 Object)
ToString()

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

적용 대상

추가 정보