CompareOptions CompareOptions CompareOptions CompareOptions Enum

Определение

Определяет параметры сравнения строк для использования с классом CompareInfo.Defines the string comparison options to use with CompareInfo.

Это перечисление имеет атрибут FlagsAttribute, который разрешает побитовое сочетание значений его элементов.

public enum class CompareOptions
[System.Flags]
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum CompareOptions
type CompareOptions = 
Public Enum CompareOptions
Наследование
CompareOptionsCompareOptionsCompareOptionsCompareOptions
Атрибуты

Поля

IgnoreCase IgnoreCase IgnoreCase IgnoreCase 1

Указывает, что сравнение строк не должно учитывать регистр.Indicates that the string comparison must ignore case.

IgnoreKanaType IgnoreKanaType IgnoreKanaType IgnoreKanaType 8

Указывает, что при сравнении строк необходимо игнорировать тип "Кана".Indicates that the string comparison must ignore the Kana type. Типы японской азбуки Каны обозначают символы хираганы и катаканы, представляющие звуки японского языка.Kana type refers to Japanese hiragana and katakana characters, which represent phonetic sounds in the Japanese language. Хирагана используется для японских выражений и слов, а катакана — для слов, заимствованных из других языков, например "компьютер" и "Интернет".Hiragana is used for native Japanese expressions and words, while katakana is used for words borrowed from other languages, such as "computer" or "Internet". Для обозначения любого звука может быть использована как хирагана, так и катакана.A phonetic sound can be expressed in both hiragana and katakana. Если выбрано это значение, знаки хирагана и катакана для одного и того же звука считаются равными.If this value is selected, the hiragana character for one sound is considered equal to the katakana character for the same sound.

IgnoreNonSpace IgnoreNonSpace IgnoreNonSpace IgnoreNonSpace 2

Указывает, что при сравнении строк необходимо игнорировать не занимающие место несамостоятельные знаки, например, диакритические.Indicates that the string comparison must ignore nonspacing combining characters, such as diacritics. В стандарте Юникода комбинированные символы определяются как символы, объединяемые с базовыми символами для получения нового символа.The Unicode Standard defines combining characters as characters that are combined with base characters to produce a new character. Непробельные составные символы в своем представлении не требуют дополнительного пространства.Nonspacing combining characters do not occupy a spacing position by themselves when rendered.

IgnoreSymbols IgnoreSymbols IgnoreSymbols IgnoreSymbols 4

Указывает, что при сравнении строк необходимо игнорировать такие символы, как разделители, знаки препинания, знаки денежных единиц, знак процента, математические символы, амперсанд и т. д.Indicates that the string comparison must ignore symbols, such as white-space characters, punctuation, currency symbols, the percent sign, mathematical symbols, the ampersand, and so on.

IgnoreWidth IgnoreWidth IgnoreWidth IgnoreWidth 16

Указывает, что при сравнении строк необходимо игнорировать ширину символа.Indicates that the string comparison must ignore the character width. Например, символы японской катаканы могут быть написаны в полную ширину или в половину ширины.For example, Japanese katakana characters can be written as full-width or half-width. Если выбрано это значение, знаки катаканы, написанные в полную ширину, считаются равными тем же знакам, написанным в половину ширины.If this value is selected, the katakana characters written as full-width are considered equal to the same characters written as half-width.

None None None None 0

Указывает настройки параметров по умолчанию для сравнения строк.Indicates the default option settings for string comparisons.

Ordinal Ordinal Ordinal Ordinal 1073741824

Указывает, что при сравнении строк должны использоваться последовательные значения строки в кодировке Юникода UTF-16 (последовательное сравнение единиц кода). Это позволяет быстро выполнить сравнение, которое, однако, не учитывает особенностей, связанных с языком и региональными параметрами.Indicates that the string comparison must use successive Unicode UTF-16 encoded values of the string (code unit by code unit comparison), leading to a fast comparison but one that is culture-insensitive. Строка, начинающаяся с единицы кода XXXX16, отображается перед строкой, начинающейся с YYYY16, если XXXX16 меньше YYYY16.A string starting with a code unit XXXX16 comes before a string starting with YYYY16, if XXXX16 is less than YYYY16. Это значение не может быть объединено с другими значениями CompareOptions и должно использоваться обособленно.This value cannot be combined with other CompareOptions values and must be used alone.

OrdinalIgnoreCase OrdinalIgnoreCase OrdinalIgnoreCase OrdinalIgnoreCase 268435456

При сравнении строк не должен учитываться регистр. После этого выполняется обычное сравнение.String comparison must ignore case, then perform an ordinal comparison. Этот способ аналогичен преобразованию строки в верхний регистр с помощью инвариантного языка и региональных параметров и выполнению порядкового сравнения результатов.This technique is equivalent to converting the string to uppercase using the invariant culture and then performing an ordinal comparison on the result.

StringSort StringSort StringSort StringSort 536870912

Указывает, что при сравнении строк следует использовать алгоритм сортировки строк.Indicates that the string comparison must use the string sort algorithm. В строке сортировки дефис, апостроф, а также другие знаки, не являющиеся буквенно-цифровыми, предшествуют буквенно-цифровым знакам.In a string sort, the hyphen and the apostrophe, as well as other nonalphanumeric symbols, come before alphanumeric characters.

Примеры

В следующем примере кода показано, как сортировка с помощью Стрингсорт отличается от сортировки без Стрингсорт.The following code example shows how sorting with StringSort differs from sorting without StringSort.

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

// __gc public class SamplesCompareOptions {
ref class MyStringComparer: public IComparer
{
public:

   // Constructs a comparer using the specified CompareOptions.
   CompareInfo^ myComp;
   CompareOptions myOptions;
   MyStringComparer( CompareInfo^ cmpi, CompareOptions options )
      : myComp( cmpi ), myOptions( options )
   {}

   // Compares strings with the CompareOptions specified in the constructor.
   virtual int Compare( Object^ a, Object^ b )
   {
      if ( a == b )
            return 0;

      if ( a == nullptr )
            return  -1;

      if ( b == nullptr )
            return 1;

      String^ sa = dynamic_cast<String^>(a);
      String^ sb = dynamic_cast<String^>(b);
      if ( sa != nullptr && sb != nullptr )
            return myComp->Compare( sa, sb, myOptions );

      throw gcnew ArgumentException( "a and b should be strings." );
   }
};

int main()
{
   
   // Creates and initializes an array of strings to sort.
   array<String^>^myArr = {"cant","bill's","coop","cannot","billet","can't","con","bills","co-op"};
   Console::WriteLine( "\nInitially, " );
   IEnumerator^ myEnum = myArr->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ myStr = safe_cast<String^>(myEnum->Current);
      Console::WriteLine( myStr );
   }

   
   // Creates and initializes a Comparer to use.
   //CultureInfo* myCI = new CultureInfo(S"en-US", false);
   MyStringComparer^ myComp = gcnew MyStringComparer( CompareInfo::GetCompareInfo( "en-US" ),CompareOptions::None );
   
   // Sorts the array without StringSort.
   Array::Sort( myArr, myComp );
   Console::WriteLine( "\nAfter sorting without CompareOptions::StringSort:" );
   myEnum = myArr->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ myStr = safe_cast<String^>(myEnum->Current);
      Console::WriteLine( myStr );
   }

   
   // Sorts the array with StringSort.
   myComp = gcnew MyStringComparer( CompareInfo::GetCompareInfo( "en-US" ),CompareOptions::StringSort );
   Array::Sort( myArr, myComp );
   Console::WriteLine( "\nAfter sorting with CompareOptions::StringSort:" );
   myEnum = myArr->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ myStr = safe_cast<String^>(myEnum->Current);
      Console::WriteLine( myStr );
   }
}

/*
This code produces the following output.

Initially,
cant
bill's
coop
cannot
billet
can't
con
bills
co-op

After sorting without CompareOptions::StringSort:
billet
bills
bill's
cannot
cant
can't
con
coop
co-op

After sorting with CompareOptions::StringSort:
bill's
billet
bills
can't
cannot
cant
co-op
con
coop
*/
using System;
using System.Collections;
using System.Globalization;


public class SamplesCompareOptions  {

   private class MyStringComparer: IComparer {
      private CompareInfo myComp;   
      private CompareOptions myOptions = CompareOptions.None;

      // Constructs a comparer using the specified CompareOptions.
      public MyStringComparer( CompareInfo cmpi, CompareOptions options )  {
         myComp = cmpi;
         this.myOptions = options;
      }

      // Compares strings with the CompareOptions specified in the constructor.
      public int Compare(Object a, Object b) {
         if (a == b) return 0;
         if (a == null) return -1;
         if (b == null) return 1;

         String sa = a as String;
         String sb = b as String;
         if (sa != null && sb != null)
            return myComp.Compare(sa, sb, myOptions);
         throw new ArgumentException("a and b should be strings.");

      }
   }
   
   public static void Main()  {

      // Creates and initializes an array of strings to sort.
      String[] myArr = new String[9] { "cant", "bill's", "coop", "cannot", "billet", "can't", "con", "bills", "co-op" };
      Console.WriteLine( "\nInitially," );
      foreach ( String myStr in myArr )
         Console.WriteLine( myStr );

      // Creates and initializes a Comparer to use.
      //CultureInfo myCI = new CultureInfo( "en-US", false );
      MyStringComparer myComp = new MyStringComparer(CompareInfo.GetCompareInfo("en-US"), CompareOptions.None);

      // Sorts the array without StringSort.
      Array.Sort( myArr, myComp );
      Console.WriteLine( "\nAfter sorting without CompareOptions.StringSort:" );
      foreach ( String myStr in myArr )
         Console.WriteLine( myStr );

      // Sorts the array with StringSort.
      myComp = new MyStringComparer(CompareInfo.GetCompareInfo("en-US"), CompareOptions.StringSort);
      Array.Sort( myArr, myComp );
      Console.WriteLine( "\nAfter sorting with CompareOptions.StringSort:" );
      foreach ( String myStr in myArr )
         Console.WriteLine( myStr );

   }

}

/*
This code produces the following output.

Initially,
cant
bill's
coop
cannot
billet
can't
con
bills
co-op

After sorting without CompareOptions.StringSort:
billet
bills
bill's
cannot
cant
can't
con
coop
co-op

After sorting with CompareOptions.StringSort:
bill's
billet
bills
can't
cannot
cant
co-op
con
coop

*/
Imports System.Collections
Imports System.Globalization

Public Class SamplesCompareOptions

   Private Class MyStringComparer
      Implements IComparer

      Private myComp As CompareInfo
      Private myOptions As CompareOptions = CompareOptions.None
      
      ' Constructs a comparer using the specified CompareOptions.
      Public Sub New(cmpi As CompareInfo, options As CompareOptions)
         myComp = cmpi
         Me.myOptions = options
      End Sub
      
      ' Compares strings with the CompareOptions specified in the constructor.
      Public Function Compare(a As [Object], b As [Object]) As Integer Implements IComparer.Compare
         If a = b Then
            Return 0
         End If
         If a Is Nothing Then
            Return - 1
         End If
         If b Is Nothing Then
            Return 1
         End If 

         Dim sa As [String] = a
         Dim sb As [String] = b
         If Not (sa Is Nothing) And Not (sb Is Nothing) Then
            Return myComp.Compare(sa, sb, myOptions)
         End If
         Throw New ArgumentException("a and b should be strings.")

      End Function 'Compare 

   End Class


   Public Shared Sub Main()
      
      ' Creates and initializes an array of strings to sort.
      Dim myArr() As [String] = {"cant", "bill's", "coop", "cannot", "billet", "can't", "con", "bills", "co-op"}
      Console.WriteLine()
      Console.WriteLine("Initially,")
      Dim myStr As [String]
      For Each myStr In  myArr
         Console.WriteLine(myStr)
      Next myStr 

      ' Creates and initializes a Comparer to use.
      'CultureInfo myCI = new CultureInfo( "en-US", false );
      Dim myComp As New MyStringComparer(CompareInfo.GetCompareInfo("en-US"), CompareOptions.None)
      
      ' Sorts the array without StringSort.
      Array.Sort(myArr, myComp)
      Console.WriteLine()
      Console.WriteLine("After sorting without CompareOptions.StringSort:")
      For Each myStr In  myArr
         Console.WriteLine(myStr)
      Next myStr 

      ' Sorts the array with StringSort.
      myComp = New MyStringComparer(CompareInfo.GetCompareInfo("en-US"), CompareOptions.StringSort)
      Array.Sort(myArr, myComp)
      Console.WriteLine()
      Console.WriteLine("After sorting with CompareOptions.StringSort:")
      For Each myStr In  myArr
         Console.WriteLine(myStr)
      Next myStr 

   End Sub

End Class


'This code produces the following output.
'
'Initially,
'cant
'bill's
'coop
'cannot
'billet
'can't
'con
'bills
'co-op
'
'After sorting without CompareOptions.StringSort:
'billet
'bills
'bill's
'cannot
'cant
'can't
'con
'coop
'co-op
'
'After sorting with CompareOptions.StringSort:
'bill's
'billet
'bills
'can't
'cannot
'cant
'co-op
'con
'coop

Комментарии

Эти параметры обозначают чувствительность к регистру или возможность пропуска типов символов.These options denote case sensitivity or necessity to ignore types of characters.

В .NET используются три различных способа сортировки: Сортировка по словам, сортировка строк и сортировка по порядковым номерам..NET uses three distinct ways of sorting: word sort, string sort, and ordinal sort. Сортировка по словам выполняет сравнение строк с учетом языка и региональных параметров.Word sort performs a culture-sensitive comparison of strings. Некоторым небуквенно-цифровым символам могут быть назначены специальные весовые коэффициенты.Certain nonalphanumeric 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 sort is similar to word sort, except that there are no special cases. Поэтому все символы, не являющиеся буквенно-цифровыми, предшествуют всем буквенно-цифровым символам.Therefore, all nonalphanumeric symbols come before all alphanumeric characters. Сортировка по порядковому номеру сравнивает строки на основе значений Юникода для каждого элемента строки.Ordinal sort compares strings based on the Unicode values of each element of the string. Сведения о загружаемом наборе текстовых файлов, содержащих информацию о весах символов, используемых в операциях сортировки и сравнения для операционных систем Windows, см. в разделе Сортировка таблиц веса.For a downloadable set of text files that contain information on the character weights used in sorting and comparison operations for Windows operating systems, see Sorting Weight Tables. Сведения о таблице веса сортировки для Linux и macOS см. в таблице элементов параметров сортировки Юникода по умолчанию.For the sort weight table for Linux and macOS, see the Default Unicode Collation Element Table. Конкретная версия таблицы коэффициентов сортировки в Linux и macOS зависит от установленной в системе версии библиотек International Components for Unicode (ICU).The specific version of the sort weight table on Linux and macOS depends on the version of the International Components for Unicode libraries installed on the system. Сведения о версиях ICU и реализуемых в них версиях Юникода см. на странице Downloading ICU (Скачивание ICU).For information on ICU versions and the Unicode versions that they implement, see Downloading ICU.

Значение может использоваться только с CompareInfo.Compare и CompareInfo.GetSortKey. StringSortThe StringSort value can only be used with CompareInfo.Compare and CompareInfo.GetSortKey. ArgumentExceptionвызывается, если значение стрингсорт используется CompareInfo.IsPrefixс, CompareInfo.IsSuffix, CompareInfo.IndexOfили CompareInfo.LastIndexOf.ArgumentException is thrown if the StringSort value is used with CompareInfo.IsPrefix, CompareInfo.IsSuffix, CompareInfo.IndexOf, or CompareInfo.LastIndexOf.

Примечание

По возможности следует использовать методы сравнения строк, которые принимают CompareOptions значение, чтобы указать тип ожидаемого сравнения.When possible, you should use string comparison methods that accept a CompareOptions value to specify the kind of comparison expected. Как правило, для сравнения пользователей лучше использовать лингвистические параметры (с использованием текущего языка и региональных параметров), тогда как в сравнениях безопасности должно быть указано Ordinal или. OrdinalIgnoreCaseAs a general rule, user-facing comparisons are best served by the use of linguistic options (using the current culture), while security comparisons should specify Ordinal or OrdinalIgnoreCase.

Примечания по сортировке с учетом языка и региональных параметровNotes on culture-sensitive sorts

Примечание

Выполнение .NET Core в только в системах Linux и macOS: При использовании параметров сортировки для языков и региональных параметров C и Posix всегда учитывается регистр, так как в этом случае Юникод не поддерживается..NET Core running on Linux and macOS systems only: The collation behavior for the C and Posix cultures is always case-sensitive because these cultures do not use the expected Unicode collation order. Мы не рекомендуем использовать язык и региональные параметры, выбранные для C или Posix, для выполнения операций сортировки с учетом языка и региональных параметров, но без учета регистра.We recommend that you use a culture other than C or Posix for performing culture-sensitive, case-insensitive sorting operations.

Применяется к

Дополнительно