CompareOptions CompareOptions CompareOptions CompareOptions Enum

Definizione

Definisce le opzioni per il confronto tra stringhe da utilizzare con CompareInfo.Defines the string comparison options to use with CompareInfo.

Questa enumerazione ha un attributo FlagsAttribute che consente una combinazione bit per bit dei valori del relativo membro.

public enum class CompareOptions
[System.Flags]
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum CompareOptions
type CompareOptions = 
Public Enum CompareOptions
Ereditarietà
CompareOptionsCompareOptionsCompareOptionsCompareOptions
Attributi

Campi

IgnoreCase IgnoreCase IgnoreCase IgnoreCase 1

Indica che nel confronto tra stringhe non deve essere fatta distinzione tra maiuscole e minuscole.Indicates that the string comparison must ignore case.

IgnoreKanaType IgnoreKanaType IgnoreKanaType IgnoreKanaType 8

Indica che nel confronto tra stringhe deve essere ignorato il tipo di carattere Kana.Indicates that the string comparison must ignore the Kana type. Il tipo Kana fa riferimento ai caratteri giapponesi hiragana e katakana che rappresentano i fonemi della lingua giapponese.Kana type refers to Japanese hiragana and katakana characters, which represent phonetic sounds in the Japanese language. L'hiragana è utilizzato per le espressioni e le parole giapponesi native, mentre il katakana è utilizzato per le parole mutuate da altre lingue, come "computer" o "Internet".Hiragana is used for native Japanese expressions and words, while katakana is used for words borrowed from other languages, such as "computer" or "Internet". Un fonema può essere espresso sia in hiragana sia in katakana.A phonetic sound can be expressed in both hiragana and katakana. Se questo valore è selezionato, il carattere hiragana per un fonema è considerato equivalente al carattere katakana per lo stesso fonema.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

Indica che nel confronto tra stringhe devono essere ignorati i caratteri di combinazione di non spaziatura, come i segni diacritici.Indicates that the string comparison must ignore nonspacing combining characters, such as diacritics. Lo standard Unicode definisce le combinazioni di caratteri come caratteri combinati con caratteri di base per produrre un nuovo carattere.The Unicode Standard defines combining characters as characters that are combined with base characters to produce a new character. I caratteri di combinazione di non spaziatura non occupano uno spazio quando vengono visualizzati.Nonspacing combining characters do not occupy a spacing position by themselves when rendered.

IgnoreSymbols IgnoreSymbols IgnoreSymbols IgnoreSymbols 4

Indica che il confronto di stringhe deve ignorare i simboli, ad esempio gli spazi vuoti, i segni di punteggiatura, i simboli di valuta, il segno di percentuale, i simboli matematici, la e commerciale e così via.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

Indica che nel confronto tra stringhe deve essere ignorata la larghezza dei caratteri.Indicates that the string comparison must ignore the character width. Ad esempio, i caratteri katakana giapponesi possono essere scritti a larghezza massima o parziale (ridotta della metà).For example, Japanese katakana characters can be written as full-width or half-width. Se viene selezionato questo valore, i caratteri katakana scritti a larghezza massima sono considerati uguali agli stessi caratteri scritti a metà larghezza.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

Indica le impostazioni predefinite delle opzioni per il confronto tra stringhe.Indicates the default option settings for string comparisons.

Ordinal Ordinal Ordinal Ordinal 1073741824

Indica che per il confronto di stringhe devono essere utilizzati valori della stringa codificati in formato successivo a Unicode UTF-16 (confronto tra singole unità di codice), ottenendo un confronto veloce ma indipendente dalle impostazioni cultura.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. Una stringa che inizia con un'unità di codice XXXX16 precede una stringa che inizia con YYYY16, se XXXX16 è minore di YYYY16.A string starting with a code unit XXXX16 comes before a string starting with YYYY16, if XXXX16 is less than YYYY16. Poiché non è possibile combinare questo valore con altri valori CompareOptions, è necessario utilizzarlo da solo.This value cannot be combined with other CompareOptions values and must be used alone.

OrdinalIgnoreCase OrdinalIgnoreCase OrdinalIgnoreCase OrdinalIgnoreCase 268435456

Nel confronto tra stringhe non deve essere fatta distinzione tra maiuscole e minuscole e deve essere effettuato un confronto ordinale.String comparison must ignore case, then perform an ordinal comparison. Questa tecnica equivale alla conversione della stringa in lettere maiuscole tramite le impostazioni cultura non associate alla lingua inglese e alla successiva esecuzione di un confronto ordinale sul risultato.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

Indica che nel confronto tra stringhe deve essere utilizzato l'algoritmo di ordinamento delle stringhe.Indicates that the string comparison must use the string sort algorithm. In un ordinamento per stringhe, il trattino e l'apostrofo, così come altri simboli non alfanumerici, precedono i caratteri alfanumerici.In a string sort, the hyphen and the apostrophe, as well as other nonalphanumeric symbols, come before alphanumeric characters.

Esempi

Nell'esempio di codice seguente viene illustrato come l'ordinamento con StringSort differisce dall'ordinamento senza StringSort.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 'MyStringComparer


   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 'SamplesCompareOptions 


'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

Commenti

Queste opzioni denotano la distinzione tra maiuscole e minuscole o la necessità di ignorare tipi di caratteri.These options denote case sensitivity or necessity to ignore types of characters.

.NET usa tre modi distinti di ordinamento: ordinamento delle parole, ordinamento delle stringhe e ordinamento ordinale..NET uses three distinct ways of sorting: word sort, string sort, and ordinal sort. In Word Sort viene eseguito un confronto con distinzione delle impostazioni cultura delle stringhe.Word sort performs a culture-sensitive comparison of strings. Alcuni caratteri non alfanumerici possono avere pesi speciali assegnati.Certain nonalphanumeric characters might have special weights assigned to them. Ad esempio, il trattino ("-") può avere un peso molto ridotto, in modo che "Coop" e "co-op" siano visualizzati uno accanto all'altro in un elenco ordinato.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. Il tipo di ordinamento delle stringhe è simile a quello di Word, tranne per il fatto che non esistono casi particolari.String sort is similar to word sort, except that there are no special cases. Pertanto, tutti i simboli non alfanumerici vengono prima di tutti i caratteri alfanumerici.Therefore, all nonalphanumeric symbols come before all alphanumeric characters. L'ordinamento ordinale confronta le stringhe in base ai valori Unicode di ogni elemento della stringa.Ordinal sort compares strings based on the Unicode values of each element of the string. Per un set scaricabile di file di testo contenenti informazioni sui pesi dei caratteri utilizzati nelle operazioni di ordinamento e confronto per i sistemi operativi Windows, vedere ordinamento delle tabelledi ponderazione.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. Per la tabella relativa al peso di ordinamento per Linux e macOS, vedere la tabella elemento delle regole di confronto Unicode predefinito.For the sort weight table for Linux and macOS, see the Default Unicode Collation Element Table. La versione specifica della tabella di ordinamento spessore in Linux e macOS dipende dalla versione delle librerie International Components for Unicode installate nel sistema.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. Per informazioni sulle versioni ICU e sulle versioni Unicode implementate, vedere Downloading ICU (Download di ICU).For information on ICU versions and the Unicode versions that they implement, see Downloading ICU.

Il StringSort valore può essere utilizzato solo con CompareInfo.Compare e CompareInfo.GetSortKey.The StringSort value can only be used with CompareInfo.Compare and CompareInfo.GetSortKey. ArgumentExceptionviene generata se il valore StringSort viene utilizzato con CompareInfo.IsPrefix, CompareInfo.IsSuffix, CompareInfo.IndexOfo CompareInfo.LastIndexOf.ArgumentException is thrown if the StringSort value is used with CompareInfo.IsPrefix, CompareInfo.IsSuffix, CompareInfo.IndexOf, or CompareInfo.LastIndexOf.

Nota

Quando possibile, è consigliabile usare metodi di confronto tra stringhe che CompareOptions accettano un valore per specificare il tipo di confronto previsto.When possible, you should use string comparison methods that accept a CompareOptions value to specify the kind of comparison expected. Come regola generale, i confronti per gli utenti vengono serviti in modo ottimale dall'uso di opzioni linguistiche (usando le impostazioni cultura correnti), mentre i Ordinal confronti di sicurezza devono specificare o. 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.

Note sugli ordinamenti dipendenti dalle impostazioni culturaNotes on culture-sensitive sorts

Nota

.NET core in esecuzione solo in sistemi Linux e macOS: Il comportamento delle regole di confronto per le impostazioni cultura C e Posix prevede sempre la distinzione maiuscole/minuscole perché queste impostazioni cultura non usano l'ordine delle regole di confronto Unicode previsto..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. È consigliabile usare impostazioni cultura diverse da C o Posix per l'esecuzione di operazioni di ordinamento dipendenti dalle impostazioni cultura e senza distinzione tra maiuscole e minuscole.We recommend that you use a culture other than C or Posix for performing culture-sensitive, case-insensitive sorting operations.

Si applica a

Vedi anche