CompareOptions 列挙体

.NET Framework クラス ライブラリ リファレンス

CompareOptions 列挙体

CompareInfo と共に使用する文字列比較オプションを定義します。

この列挙体には、メンバ値のビットごとの組み合わせを可能にする FlagsAttribute 属性が含まれています。

名前空間: System.Globalization
アセンブリ: mscorlib (mscorlib.dll 内)
構文

Visual Basic (宣言)

<SerializableAttribute> _
<ComVisibleAttribute(True)> _
<FlagsAttribute> _
Public Enumeration CompareOptions

Visual Basic (使用法)

Dim instance As CompareOptions

C#

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
[FlagsAttribute] 
public enum CompareOptions

C++

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
[FlagsAttribute] 
public enum class CompareOptions

J#

/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
/** @attribute FlagsAttribute() */ 
public enum CompareOptions

JScript

SerializableAttribute 
ComVisibleAttribute(true) 
FlagsAttribute 
public enum CompareOptions

メンバ

	メンバ名	説明
	IgnoreCase	文字列比較で大文字と小文字の区別を無視することを示します。
	IgnoreKanaType	文字列比較でカナ型を無視することを示します。カナ型とは、日本語の発音を表すひらがなとカタカナの文字を指します。ひらがなは、本来の日本語の表現と単語に使用し、カタカナは "コンピュータ" または "インターネット" などの外来語に使用します。発音は、ひらがなとカタカナのどちらでも表現できます。この値が選択されている場合、ある発音を示すひらがなは、同じ発音を示すカタカナと同一であると見なされます。
	IgnoreNonSpace	文字列比較で、発音区別符など、非スペーシング組み合わせ文字を無視するように指定します。Unicode 標準は、基本文字を組み合わせて生成される新しい文字を組み合わせ文字として定義しています。非スペーシング組み合わせ文字は、表示されるときに文字間隔用の領域は確保しません。非スペーシング組み合わせ文字の詳細については、http://www.unicode.org の「The Unicode Standard」を参照してください。
	IgnoreSymbols	文字列比較において、空白文字、句読点、通貨記号、パーセント記号、算術記号、アンパサンドなどの記号を無視することを示します。
	IgnoreWidth	文字列比較において、半角と全角の区別を無視することを示します。たとえば、日本語のカタカナ文字は、全角または半角で記述できます。この値を選択した場合、全角で記述されたカタカナ文字は、半角で記述されたカタカナ文字と同一であると見なされます。
	None	文字列比較の既定のオプション設定を示します。
	Ordinal	各文字の Unicode 値を使用して、文字列を比較することを示します。この比較は処理速度は速いですが、カルチャに応じた処理は行いません。xxxx が yyyy よりも小さい場合、"U+xxxx" で始まる文字列は "U+yyyy" で始まる文字列よりも前になります。このフラグを他のフラグと組み合わせることはできません。このフラグは、単独で使用してください。
	OrdinalIgnoreCase	文字列の比較で大文字と小文字の違いを無視するように指定し、通常の比較を実行します。これは、インバリアント カルチャを使用して文字列を大文字に変換した後、その結果に対して通常の比較を実行する操作と同じです。
	StringSort	文字列の比較時に、ハイフン、アポストロフィ、およびその他の英数字以外の記号が英数字よりも前になる文字列並べ替えアルゴリズムを使用することを示します。

解説

これらのオプションは、大文字と小文字を区別するかどうか、または文字の型を無視するかどうかを示します。

.NET Framework は、単語での並べ替え、文字列での並べ替え、序数での並べ替えの異なる 3 種類の並べ替えの方法を使用します。単語での並べ替えでは、カルチャを考慮した文字列比較が実行されます。英数字以外の特定の文字に特殊な重み付けが行われる場合があります。たとえば、ハイフン ("-") に非常に低い重み付けが行われ、並べ替えられた一覧に "coop" と "co-op" が並んで現れる場合があります。文字列での並べ替えは、単語での並べ替えと似ていますが、特殊な場合が存在しません。このため、英数字以外のすべての記号がどの英数字よりも前に来ます。序数での並べ替えでは、文字列の各要素の Unicode 値を元に文字列が比較されます。

StringSort 値は、CompareInfo.Compare と CompareInfo.GetSortKey だけで使用できます。StringSort 値を CompareInfo.IsPrefix、CompareInfo.IsSuffix、CompareInfo.IndexOf、または CompareInfo.LastIndexOf で使用すると、ArgumentException がスローされます。

使用例

StringSort を指定した並べ替えと StringSort なしでの並べ替えがどのように異なるかを次のコード例で示します。

Visual Basic

Imports System
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 'New
      
      ' 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 'Main

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

C#

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

*/

C++

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
*/

J#

import System.* ;
import System.Collections.* ;
import System.Globalization.* ;

public class SamplesCompareOptions
{
    private class MyStringComparer implements
 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;
        } //MyStringComparer

        // 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 =(String) a;
            String sb = (String)b;
            if (sa  != null && sb 
 != null) {
                return myComp.Compare(sa, sb, myOptions);
            }
            throw new ArgumentException("a and b should be
 strings.");
        } //Compare 
    } //MyStringComparer
   
    public static void main(String[]
 args)
    {
        // Creates and initializes an array of strings to sort.
        String myArr[] = new String[]{"cant", "bill's",
 "coop", "cannot", 
            "billet", "can't", "con", "bills",
 "co-op"};
        Console.WriteLine("\nInitially,");
            SamplesCompareOptions mySamplesCompareOptions = 
                new SamplesCompareOptions();    
        
        for(int i=0 ; i < myArr.length ;i++)
 {
            String myStr = myArr[i];
            Console.WriteLine(myStr);
        }
        // Creates and initializes a Comparer to use.
        //CultureInfo myCI = new CultureInfo( "en-US", false
 );
        MyStringComparer myComp = mySamplesCompareOptions.new
 MyStringComparer(
            CompareInfo.GetCompareInfo("en-US"), CompareOptions.None);
            
        // Sorts the array without StringSort.
        Array.Sort(myArr, myComp);
        Console.WriteLine("\nAfter sorting without CompareOptions.StringSort:");
        
        for(int i=0; i< myArr.length ;i++)
 {
            String myStr = myArr[i];
            Console.WriteLine(myStr);
        }
            
        // Sorts the array with StringSort.
        myComp = mySamplesCompareOptions.new MyStringComparer(
            CompareInfo.GetCompareInfo("en-US"), CompareOptions.StringSort);
        Array.Sort(myArr, myComp);
        Console.WriteLine("\nAfter sorting with CompareOptions.StringSort:");
        
        for(int i=0; i< myArr.length ;i++)
 {
            String myStr = myArr[i];
            Console.WriteLine(myStr);
        }
    } //main 
} //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
*/

プラットフォーム

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報

.NET Framework
サポート対象 : 2.0、1.1、1.0
.NET Compact Framework
サポート対象 : 2.0、1.0

参照

関連項目
System.Globalization 名前空間
その他の技術情報
基本的な文字列操作