String String String String Class

定義

テキストを一連の UTF-16 コード単位として表現します。Represents text as a sequence of UTF-16 code units.

public ref class String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IEnumerable
    interface IComparable<string>
    interface seq<char>
    interface IEquatable<string>
Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)
継承
StringStringStringString
属性
実装

注釈

文字列は、テキストを表すために使用される文字のシーケンシャルコレクションです。A string is a sequential collection of characters that is used to represent text. オブジェクトは、文字列をSystem.Char表すオブジェクトSystem.Charのシーケンシャルコレクションです。オブジェクトは utf-16 コード単位に対応します。 StringA String object is a sequential collection of System.Char objects that represent a string; a System.Char object corresponds to a UTF-16 code unit. Stringオブジェクトの値はオブジェクトのSystem.Charシーケンシャルコレクションの内容であり、その値は変更できません (つまり、読み取り専用です)。The value of the String object is the content of the sequential collection of System.Char objects, and that value is immutable (that is, it is read-only). 文字列の不変性の詳細については、このトピックで後述する「不変クラスと StringBuilder クラス」を参照してください。For more information about the immutability of strings, see the Immutability and the StringBuilder class section later in this topic. メモリ内のStringオブジェクトの最大サイズは 2 gb、または約10億文字です。The maximum size of a String object in memory is 2GB, or about 1 billion characters.

注意

この記事の C# 例の一部は、Try.NET インライン コード ランナーとプレイグラウンドで実行されます。Some of the C# examples in this article run in the Try.NET inline code runner and playground. [実行] ボタンがある場合は、これを選択して対話型ウィンドウで例を実行します。When present, select the Run button to run an example in an interactive window. コードを実行したら、コードを変更し、 [実行] をもう一度選択して変更後のコードを実行できます。Once you execute the code, you can modify it and run the modified code by selecting Run again. 変更後のコードが対話型ウィンドウで実行されるか、コンパイルできなかった場合、対話型ウィンドウにすべての C# コンパイラ エラー メッセージが表示されます。The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

このセクションの内容:In this section:

String オブジェクトのインスタンス化 Instantiating a String object
Char オブジェクトと Unicode 文字 Char objects and Unicode characters
文字列と Unicode 標準 Strings and The Unicode Standard
文字列と埋め込まれた null 文字 Strings and embedded null characters
文字列とインデックス Strings and indexes
Null 文字列と空の文字列 Null strings and empty strings
不変性と StringBuilder クラス Immutability and the StringBuilder class
序数およびカルチャに依存する操作 Ordinal vs. culture-sensitive operations
非正規 Normalization
カテゴリ別の文字列操作String operations by category

String オブジェクトのインスタンス化Instantiating a String object

オブジェクトをStringインスタンス化するには、次の方法があります。You can instantiate a String object in the following ways:

  • String変数に文字列リテラルを代入する。By assigning a string literal to a String variable. これは、文字列を作成するために最もよく使用されるメソッドです。This is the most commonly used method for creating a string. 次の例では、割り当てを使用して複数の文字列を作成します。The following example uses assignment to create several strings. でC#は、円記号 (\) はエスケープ文字なので、文字列内のリテラルの円記号はエスケープする必要があり@-quotedます。また、文字列全体をにする必要があることに注意してください。Note that in C#, because the backslash (\) is an escape character, literal backslashes in a string must be escaped or the entire string must be @-quoted.

    using namespace System;
    
    void main()
    {
       String^ string1 = "This is a string created by assignment.";
       Console::WriteLine(string1);
       String^ string2a = "The path is C:\\PublicDocuments\\Report1.doc";
       Console::WriteLine(string2a);
    }
    // The example displays the following output: 
    //       This is a string created by assignment. 
    //       The path is C:\PublicDocuments\Report1.doc 
    
    string string1 = "This is a string created by assignment.";
    Console.WriteLine(string1);
    string string2a = "The path is C:\\PublicDocuments\\Report1.doc";
    Console.WriteLine(string2a);
    string string2b = @"The path is C:\PublicDocuments\Report1.doc";
    Console.WriteLine(string2b);
    // The example displays the following output:
    //       This is a string created by assignment.
    //       The path is C:\PublicDocuments\Report1.doc
    //       The path is C:\PublicDocuments\Report1.doc      
    
    Dim string1 As String = "This is a string created by assignment."
    Console.WriteLine(string1)
    Dim string2 As String = "The path is C:\PublicDocuments\Report1.doc"
    Console.WriteLine(string2)
    ' The example displays the following output:
    '       This is a string created by assignment.
    '       The path is C:\PublicDocuments\Report1.doc      
    
  • クラスコンストラクターをString呼び出す。By calling a String class constructor. 次の例では、複数のクラスコンストラクターを呼び出すことによって文字列をインスタンス化します。The following example instantiates strings by calling several class constructors. 一部のコンストラクターには、パラメーターとしての文字配列または符号付きバイト配列へのポインターが含まれていることに注意してください。Note that some of the constructors include pointers to character arrays or signed byte arrays as parameters. Visual Basic は、これらのコンストラクターの呼び出しをサポートしていません。Visual Basic does not support calls to these constructors. Stringコンストラクターの詳細については、 String 「コンストラクターの概要」を参照してください。For detailed information about String constructors, see the String constructor summary.

    using namespace System;
    
    void main()
    {
       wchar_t chars[5] = L"word";
       char bytes[6] = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
       // Create a string from a character array. 
       String^ string1 = gcnew String(chars);
       Console::WriteLine(string1);
    
       // Create a string that consists of a character repeated 20 times. 
       String^ string2 = gcnew String('c', 20);
       Console::WriteLine(string2);
    
       String^ stringFromBytes = nullptr;
       String^ stringFromChars = nullptr;
    
       char * pbytes = &bytes[0];
       // Create a string from a pointer to a signed byte array.
       stringFromBytes = gcnew String(pbytes);
    
       wchar_t* pchars =  &chars[0];
       // Create a string from a pointer to a character array.
       stringFromChars = gcnew String(pchars);
    
       Console::WriteLine(stringFromBytes);
       Console::WriteLine(stringFromChars);
       Console::ReadLine();
    }
    // The example displays the following output: 
    //       word 
    //       cccccccccccccccccccc 
    //       ABCDE 
    //       word  
    
    char[] chars = { 'w', 'o', 'r', 'd' };
    sbyte[] bytes = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
    // Create a string from a character array.
    string string1 = new string(chars);
    Console.WriteLine(string1);
    
    // Create a string that consists of a character repeated 20 times.
    string string2 = new string('c', 20);
    Console.WriteLine(string2);
    
    string stringFromBytes = null;
    string stringFromChars = null;
    unsafe
    {
       fixed (sbyte* pbytes = bytes)
       {
          // Create a string from a pointer to a signed byte array.
          stringFromBytes = new string(pbytes);
       }
       fixed (char* pchars = chars)
       {
          // Create a string from a pointer to a character array.
          stringFromChars = new string(pchars);
       }
    }
    Console.WriteLine(stringFromBytes);
    Console.WriteLine(stringFromChars);
    // The example displays the following output:
    //       word
    //       cccccccccccccccccccc
    //       ABCDE
    //       word  
    
    Dim chars() As Char = { "w"c, "o"c, "r"c, "d"c }
    
    ' Create a string from a character array.
    Dim string1 As New String(chars)
    Console.WriteLine(string1)
    
    ' Create a string that consists of a character repeated 20 times.
    Dim string2 As New String("c"c, 20)
    Console.WriteLine(string2)
    ' The example displays the following output:
    '       word
    '       cccccccccccccccccccc      
    
  • 文字列連結演算子 (+ in C#および & または + in Visual Basic) を使用して、インスタンスと文字列リテラルのString任意の組み合わせから1つの文字列を作成する。By using the string concatenation operator (+ in C# and & or + in Visual Basic) to create a single string from any combination of String instances and string literals. 次の例は、文字列連結演算子の使用方法を示しています。The following example illustrates the use of the string concatenation operator.

    String^ string1 = "Today is " + DateTime::Now.ToString("D") + ".";
    Console::WriteLine(string1);
    
    String^ string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console::WriteLine(string2);
    // The example displays output like the following: 
    //    Today is Tuesday, July 06, 2011. 
    //    This is one sentence. This is a second. This is a third sentence.
    
    string string1 = "Today is " + DateTime.Now.ToString("D") + ".";
    Console.WriteLine(string1);
    
    string string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console.WriteLine(string2);
    // The example displays output like the following:
    //    Today is Tuesday, July 06, 2011.
    //    This is one sentence. This is a second. This is a third sentence.
    
    Dim string1 As String = "Today is " + Date.Now.ToString("D") + "."  
    Console.WriteLine(string1)
    Dim string2 As String = "This is one sentence. " + "This is a second. "
    string2 += "This is a third sentence."
    Console.WriteLine(string2)      
    ' The example displays output like the following:
    '    Today is Tuesday, July 06, 2011.
    '    This is one sentence. This is a second. This is a third sentence.
    
  • プロパティを取得するか、文字列を返すメソッドを呼び出します。By retrieving a property or calling a method that returns a string. 次の例では、 Stringクラスのメソッドを使用して、より大きな文字列から部分文字列を抽出します。The following example uses the methods of the String class to extract a substring from a larger string.

    String^ sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence->IndexOf(" ") + 1;
    String^ word2 = sentence->Substring(startPosition, 
                                        sentence->IndexOf(" ", startPosition) - startPosition);
    Console::WriteLine("Second word: " + word2);
    
    string sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence.IndexOf(" ") + 1;
    string word2 = sentence.Substring(startPosition,
                                      sentence.IndexOf(" ", startPosition) - startPosition);
    Console.WriteLine("Second word: " + word2);
    // The example displays the following output:
    //       Second word: sentence
    
    Dim sentence As String = "This sentence has five words."
    ' Extract the second word.
    Dim startPosition As Integer = sentence.IndexOf(" ") + 1
    Dim word2 As String = sentence.Substring(startPosition, 
                                             sentence.IndexOf(" ", startPosition) - startPosition) 
    Console.WriteLine("Second word: " + word2)
    ' The example displays the following output:
    '       Second word: sentence
    
  • 書式指定メソッドを呼び出して、値またはオブジェクトをその文字列形式に変換する。By calling a formatting method to convert a value or object to its string representation. 次の例では、複合書式指定機能を使用して、2つのオブジェクトの文字列形式を文字列に埋め込みます。The following example uses the composite formatting feature to embed the string representation of two objects into a string.

    DateTime^ dateAndTime = gcnew DateTime(2011, 7, 6, 7, 32, 0);
    Double temperature = 68.3;
    String^ result = String::Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                   dateAndTime, temperature);
    Console::WriteLine(result);
    // The example displays the following output: 
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    
    DateTime dateAndTime = new DateTime(2011, 7, 6, 7, 32, 0);
    double temperature = 68.3;
    string result = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                  dateAndTime, temperature);
    Console.WriteLine(result);
    // The example displays the following output:
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    
    Dim dateAndTime As DateTime = #07/06/2011 7:32:00AM#
    Dim temperature As Double = 68.3
    Dim result As String = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                         dateAndTime, temperature)
    Console.WriteLine(result)
    ' The example displays the following output:
    '       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    

Char オブジェクトと Unicode 文字Char objects and Unicode characters

文字列内の各文字は、unicode スカラー値 (Unicode コードポイントまたは unicode 文字の序数 (numeric) 値) によって定義されます。Each character in a string is defined by a Unicode scalar value, also called a Unicode code point or the ordinal (numeric) value of the Unicode character. 各コードポイントは utf-16 エンコーディングを使用してエンコードされ、エンコーディングの各要素の数値はCharオブジェクトによって表されます。Each code point is encoded by using UTF-16 encoding, and the numeric value of each element of the encoding is represented by a Char object.

注意

インスタンスはString utf-16 コード単位のシーケンシャルコレクションで構成されているため、正しい形式の Unicode 文字列ではないStringオブジェクトを作成することができます。Note that, because a String instance consists of a sequential collection of UTF-16 code units, it is possible to create a String object that is not a well-formed Unicode string. たとえば、対応する上位サロゲートを持たない下位サロゲートを持つ文字列を作成できます。For example, it is possible to create a string that has a low surrogate without a corresponding high surrogate. System.Text名前空間のオブジェクトをエンコードおよびデコードするメソッドなどの一部のメソッドでは、文字列が適切な形式であることを確認するStringためのチェックが実行されますが、クラスメンバーは文字列が整形式であることを保証しません。Although some methods, such as the methods of encoding and decoding objects in the System.Text namespace, may performs checks to ensure that strings are well-formed, String class members don't ensure that a string is well-formed.

通常、 Char 1 つのオブジェクトは1つのコードポイントを表します。つまり、 Charの数値はコードポイントに相当します。A single Char object usually represents a single code point; that is, the numeric value of the Char equals the code point. たとえば、文字 "a" のコードポイントは U + 0061 です。For example, the code point for the character "a" is U+0061. ただし、コードポイントでは、複数のエンコードされた要素 ( Char複数のオブジェクト) が必要になる場合があります。However, a code point might require more than one encoded element (more than one Char object). Unicode 規格では、複数Charのオブジェクトに対応する2種類の文字 (graphemes) と、unicode 補助プレーンの文字に対応する unicode 補助コードポイントが定義されています。The Unicode standard defines two types of characters that correspond to multiple Char objects: graphemes, and Unicode supplementary code points that correspond to characters in the Unicode supplementary planes.

  • 書記素は、基本文字とそれに続く1つ以上の組み合わせ文字で表されます。A grapheme is represented by a base character followed by one or more combining characters. たとえば、äという文字は、コードポイントCharが u + 0061 で、その後Charにコードポイントが u + 0308 のオブジェクトが続くオブジェクトによって表されます。For example, the character ä is represented by a Char object whose code point is U+0061 followed by a Char object whose code point is U+0308. この文字は、コードポイントが U + Char 00E4 の1つのオブジェクトによって定義することもできます。This character can also be defined by a single Char object that has a code point of U+00E4. 次の例に示すように、カルチャに依存した等値比較では、これら2つの表現が等しいことを示していますが、通常の序数の比較は同じではありません。As the following example shows, a culture-sensitive comparison for equality indicates that these two representations are equal, although an ordinary ordinal comparison does not. ただし、2つの文字列が正規化されている場合は、序数に基づく比較でも等しいことが示されます。However, if the two strings are normalized, an ordinal comparison also indicates that they are equal. (文字列の正規化の詳細については、「正規化」セクションを参照してください)。(For more information on normalizing strings, see the Normalization section.)

    using namespace System;
    using namespace System::Globalization;
    using namespace System::IO;
    
    void main()
    {
       StreamWriter^ sw = gcnew StreamWriter(".\\graphemes.txt");
       String^ grapheme = L"a" + L"\u0308";
       sw->WriteLine(grapheme);
    
       String^ singleChar = "\u00e4";
       sw->WriteLine(singleChar);
    
       sw->WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                      String::Equals(grapheme, singleChar, 
                                  StringComparison::CurrentCulture));
       sw->WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                      String::Equals(grapheme, singleChar, 
                                  StringComparison::Ordinal));
       sw->WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                      String::Equals(grapheme->Normalize(), 
                                  singleChar->Normalize(), 
                                  StringComparison::Ordinal));
       sw->Close(); 
    }
    // The example produces the following output: 
    //       ä 
    //       ä 
    //       ä = ä (Culture-sensitive): True 
    //       ä = ä (Ordinal): False 
    //       ä = ä (Normalized Ordinal): True
    
    using System;
    using System.Globalization;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\graphemes.txt");
          string grapheme = "\u0061\u0308";
          sw.WriteLine(grapheme);
          
          string singleChar = "\u00e4";
          sw.WriteLine(singleChar);
                
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture));
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal));
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal));
          sw.Close(); 
       }
    }
    // The example produces the following output:
    //       ä
    //       ä
    //       ä = ä (Culture-sensitive): True
    //       ä = ä (Ordinal): False
    //       ä = ä (Normalized Ordinal): True
    
    Imports System.Globalization
    Imports System.IO
    
    Module Example
       Public Sub Main()
          Dim sw As New StreamWriter(".\graphemes.txt")
          Dim grapheme As String = ChrW(&H0061) + ChrW(&h0308)
          sw.WriteLine(grapheme)
          
          Dim singleChar As String = ChrW(&h00e4)
          sw.WriteLine(singleChar)
                
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture))
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal))
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal))
          sw.Close() 
       End Sub
    End Module
    ' The example produces the following output:
    '       ä
    '       ä
    '       ä = ä (Culture-sensitive): True
    '       ä = ä (Ordinal): False
    '       ä = ä (Normalized Ordinal): True
    
  • Unicode 補助コードポイント (サロゲートペア) は、コードポイントが上位Charサロゲートであるオブジェクトと、そのCharコードポイントが下位サロゲートであるオブジェクトによって表されます。A Unicode supplementary code point (a surrogate pair) is represented by a Char object whose code point is a high surrogate followed by a Char object whose code point is a low surrogate. 高いサロゲートのコード単位は、U + D800 から U + DBFF までの範囲です。The code units of high surrogates range from U+D800 to U+DBFF. 下限サロゲートのコード単位は、U + DC00 から U + DFFF までの範囲です。The code units of low surrogates range from U+DC00 to U+DFFF. サロゲートペアは、16の Unicode 補助プレーンの文字を表すために使用されます。Surrogate pairs are used to represent characters in the 16 Unicode supplementary planes. 次の例では、サロゲート文字を作成し、 Char.IsSurrogatePair(Char, Char)それをメソッドに渡して、サロゲートペアであるかどうかを判断します。The following example creates a surrogate character and passes it to the Char.IsSurrogatePair(Char, Char) method to determine whether it is a surrogate pair.

    using namespace System;
    
    void main()
    {
       String^ surrogate =  L"\xD800\xDC03" ;
       for (int ctr = 0; ctr < surrogate->Length; ctr++)
          Console::Write("U+{0:X4} ", Convert::ToUInt16(surrogate[ctr]));
    
       Console::WriteLine();
       Console::WriteLine("   Is Surrogate Pair: {0}", 
                          Char::IsSurrogatePair(surrogate[0], surrogate[1]));
       Console::ReadLine();
    }
    // The example displays the following output: 
    //       U+D800 U+DC03 
    //          Is Surrogate Pair: True
    
    string surrogate = "\uD800\uDC03";
    for (int ctr = 0; ctr < surrogate.Length; ctr++) 
       Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate[ctr]));
    
    Console.WriteLine();
    Console.WriteLine("   Is Surrogate Pair: {0}", 
                      Char.IsSurrogatePair(surrogate[0], surrogate[1]));
    // The example displays the following output:
    //       U+D800 U+DC03
    //          Is Surrogate Pair: True
    
    Module Example
       Public Sub Main()
          Dim surrogate As String = ChrW(&hD800) + ChrW(&hDC03)
          For ctr As Integer = 0 To surrogate.Length - 1
             Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate(ctr)))
          Next   
          Console.WriteLine()
          Console.WriteLine("   Is Surrogate Pair: {0}", 
                            Char.IsSurrogatePair(surrogate(0), surrogate(1)))
       End Sub
    End Module
    
    ' The example displays the following output:
    '       U+D800 U+DC03
    '          Is Surrogate Pair: True
    

文字列と Unicode 標準Strings and the Unicode Standard

文字列内の文字は、値にChar対応する utf-16 でエンコードされたコード単位で表されます。Characters in a string are represented by UTF-16 encoded code units, which correspond to Char values.

文字列内の各文字には、関連付けられた Unicode 文字カテゴリがありますUnicodeCategory 。これは、列挙体によって .net で表されます。Each character in a string has an associated Unicode character category, which is represented in .NET by the UnicodeCategory enumeration. 文字またはサロゲートペアのカテゴリは、メソッドをCharUnicodeInfo.GetUnicodeCategory呼び出すことによって決定できます。The category of a character or a surrogate pair can be determined by calling the CharUnicodeInfo.GetUnicodeCategory method.

.NET は独自の文字のテーブルとそれに対応するカテゴリを保持するため、さまざまなプラットフォームで実行されている特定のバージョンの .NET 実装で同一の文字カテゴリの情報が返されるようになります。.NET maintains its own table of characters and their corresponding categories, which ensures that a specific version of a .NET implementation running on different platforms returns identical character category information. Linux および macOS で実行されている .NET Core 上では、文字カテゴリの情報が International Components for Unicode ライブラリによって提供されます。On .NET Core running on Linux and macOS, character category information is provided by International Components for Unicode libraries.

次の表は、.NET のバージョンとその文字カテゴリが基準としている Unicode 標準のバージョンを示しています。The following table lists .NET versions and the versions of the Unicode Standard on which their character categories are based.

.NET のバージョン.NET version Unicode 標準のバージョンVersion of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 Unicode 標準、バージョン 4.0.0The Unicode Standard, Version 4.0.0
.NET Framework 2.0.NET Framework 2.0 Unicode 標準、バージョン 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 3.5.NET Framework 3.5 Unicode 標準、バージョン 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.NET Framework 4 Unicode 標準、バージョン 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5 Unicode 標準、バージョン 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.51.NET Framework 4.51 Unicode 標準、バージョン 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.52.NET Framework 4.52 Unicode 標準、バージョン 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.6.NET Framework 4.6 Unicode 標準、バージョン 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.61.NET Framework 4.61 Unicode 標準、バージョン 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.6.2 およびそれ以降のバージョン.NET Framework 4.6.2 and later versions Unicode 標準、バージョン 8.0.0The Unicode Standard, Version 8.0.0
.NET Core (すべてのバージョン).NET Core (all versions) Unicode 標準、バージョン 8.0.0The Unicode Standard, Version 8.0.0

また、.NET では、Unicode 標準に基づく文字列比較と並べ替えがサポートされています。In addition, .NET supports string comparison and sorting based on the Unicode standard. を通じて.NET Framework 4.NET Framework 4.NET Framework のバージョンでは、.NET Framework は文字列データの独自のテーブルを保持します。In versions of the .NET Framework through the .NET Framework 4.NET Framework 4, the .NET Framework maintains its own table of string data. これは、Windows 7 で実行され.NET Framework 4.5.NET Framework 4.5ている以降の .NET Framework のバージョンにも当てはまります。This is also true of versions of the .NET Framework starting with the .NET Framework 4.5.NET Framework 4.5 running on Windows 7. Windows 8 以降.NET Framework 4.5.NET Framework 4.5のバージョンの Windows オペレーティングシステムで実行されているでは、ランタイムは文字列の比較と並べ替えの操作をオペレーティングシステムに委任します。Starting with the .NET Framework 4.5.NET Framework 4.5 running on Window 8 and later versions of the Windows operating system, the runtime delegates string comparison and sorting operations to the operating system. .NET Core では、 Unicode ライブラリの国際化コンポーネントによって、文字列の比較と並べ替えの情報が提供されます。次の表に、.NET のバージョンと、文字の比較と並べ替えの基準となる Unicode 標準のバージョンを示します。On .NET Core, string comparison and sorting information is provided by International Components for Unicode libraries.The following table lists the versions of .NET and the versions of the Unicode Standard on which character comparison and sorting are based.

.NET のバージョン.NET version Unicode 標準のバージョンVersion of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 Unicode 標準、バージョン 4.0.0The Unicode Standard, Version 4.0.0
.NET Framework 2.0The .NET Framework 2.0 Unicode 標準、バージョン 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 3.5.NET Framework 3.5 Unicode 標準、バージョン 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.NET Framework 4 Unicode 標準、バージョン 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5以降 (Windows 7)and later on Windows 7 Unicode 標準、バージョン 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5Windows 8 以降の windows オペレーティングシステムand later on Windows 8 and later Windows operating systems Unicode 標準、バージョン 6.3.0The Unicode Standard, Version 6.3.0
.NET Core (すべてのバージョン).NET Core (all versions) 基になるオペレーティング システムでサポートされている Unicode 標準のバージョンによって異なります。Depends on the version of the Unicode Standard supported by the underlying operating system.

文字列と埋め込まれた null 文字Strings and embedded null characters

.Net では、 Stringオブジェクトに埋め込み null 文字を含めることができます。これは、文字列の長さの一部としてカウントされます。In .NET, a String object can include embedded null characters, which count as a part of the string's length. ただし、C やC++などの一部の言語では、null 文字は文字列の末尾を示します。文字列の一部とは見なされず、文字列の長さの一部としてカウントされません。However, in some languages such as C and C++, a null character indicates the end of a string; it is not considered a part of the string and is not counted as part of the string's length. これは、c、プログラマー、またはC++ C++ c で記述されたプログラマやライブラリが、オブジェクトにString適用するときには必ずしも有効でないという一般的な仮定を意味します。This means that the following common assumptions that C and C++ programmers or libraries written in C or C++ might make about strings are not necessarily valid when applied to String objects:

  • strlenまたString.Lengthwcslen関数によって返される値は、必ずしもと同じではありません。The value returned by the strlen or wcslen functions does not necessarily equal String.Length.

  • 関数strcpy_sまたはwcscpy_s関数によって作成された文字列は、 String.Copyメソッドによって作成された文字列と必ずしも同じであるとは限りません。The string created by the strcpy_s or wcscpy_s functions is not necessarily identical to the string created by the String.Copy method.

オブジェクトをインスタンスString化するネイティブ C C++とコード、およびプラットフォーム呼び出しを通じてオブジェクトStringを渡すコードは、埋め込まれた null 文字が文字列の末尾を示すと想定してはいけません。You should ensure that native C and C++ code that instantiates String objects, and code that is passed String objects through platform invoke, don't assume that an embedded null character marks the end of the string.

文字列の並べ替え (または比較) と文字列の検索時には、文字列の埋め込み null 文字も異なる方法で処理されます。Embedded null characters in a string are also treated differently when a string is sorted (or compared) and when a string is searched. 2つの文字列の間でカルチャに依存した比較を実行する場合、Null 文字は無視されます (インバリアントカルチャを使用した比較を含む)。Null characters are ignored when performing culture-sensitive comparisons between two strings, including comparisons using the invariant culture. 序数または大文字と小文字を区別しない序数比較の場合にのみ考慮されます。They are considered only for ordinal or case-insensitive ordinal comparisons. 一方、 ContainsStartsWithIndexOfなどのメソッドを使用して文字列を検索する場合は、埋め込み null 文字が常に考慮されます。On the other hand, embedded null characters are always considered when searching a string with methods such as Contains, StartsWith, and IndexOf.

文字列とインデックスStrings and indexes

インデックスは、 Char String内のオブジェクト (Unicode 文字ではない) の位置です。An index is the position of a Char object (not a Unicode character) in a String. インデックスは、0から始まる、負でない数値で、文字列内の最初の位置から始まります。インデックス位置は0です。An index is a zero-based, nonnegative number that starts from the first position in the string, which is index position zero. IndexOfLastIndexOfなどの多数の検索メソッドでは、文字列インスタンス内の文字または部分文字列のインデックスが返されます。A number of search methods, such as IndexOf and LastIndexOf, return the index of a character or substring in the string instance.

プロパティChars[Range]を使用すると、 Char文字列内のインデックス位置によって個々のオブジェクトにアクセスできます。The Chars[Range] property lets you access individual Char objects by their index position in the string. プロパティが既定のプロパティ (Visual Basic) またはインデクサー (でC#は) であるため、次のようなCharコードを使用して、文字列内の個々のオブジェクトにアクセスできます。 Chars[Range]Because the Chars[Range] property is the default property (in Visual Basic) or the indexer (in C#), you can access the individual Char objects in a string by using code such as the following. このコードでは、文字列内の空白文字または句読点を検索して、文字列に含まれる単語の数を確認します。This code looks for white space or punctuation characters in a string to determine how many words the string contains.

using namespace System;

void main()
{
   String^ s1 = "This string consists of a single short sentence.";
   int nWords = 0;

   s1 = s1->Trim();      
   for (int ctr = 0; ctr < s1->Length; ctr++) {
         if (Char::IsPunctuation(s1[ctr]) | Char::IsWhiteSpace(s1[ctr]))
            nWords++;              
   }
   Console::WriteLine("The sentence\n   {0}\nhas {1} words.",
                     s1, nWords);           
}
// The example displays the following output: 
//       The sentence 
//          This string consists of a single short sentence. 
//       has 8 words.
string s1 = "This string consists of a single short sentence.";
int nWords = 0;

s1 = s1.Trim();      
for (int ctr = 0; ctr < s1.Length; ctr++) {
   if (Char.IsPunctuation(s1[ctr]) | Char.IsWhiteSpace(s1[ctr]))
      nWords++;              
}
Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                  s1, nWords);                                                                     
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.
Module Example
   Public Sub Main()
      Dim s1 As String = "This string consists of a single short sentence."
      Dim nWords As Integer = 0

      s1 = s1.Trim()      
      For ctr As Integer = 0 To s1.Length - 1
         If Char.IsPunctuation(s1(ctr)) Or Char.IsWhiteSpace(s1(ctr)) 
            nWords += 1              
         End If   
      Next
      Console.WriteLine("The sentence{2}   {0}{2}has {1} words.",
                        s1, nWords, vbCrLf)                                                                     
   End Sub
End Module
' The example displays the following output:
'       The sentence
'          This string consists of a single short sentence.
'       has 8 words.

クラスはString IEnumerableインターフェイスを実装するため、次の例に示すCharように、 foreachコンストラクトを使用して文字列内のオブジェクトを反復処理することもできます。Because the String class implements the IEnumerable interface, you can also iterate through the Char objects in a string by using a foreach construct, as the following example shows.

using namespace System;

void main()
{
   String^ s1 = "This string consists of a single short sentence.";
   int nWords = 0;

   s1 = s1->Trim();      
   for each (Char ch in s1)
   {
      if (Char::IsPunctuation(ch) | Char::IsWhiteSpace(ch))
         nWords++;              
   }
   Console::WriteLine("The sentence\n   {0}\nhas {1} words.",
                      s1, nWords);  
   Console::ReadLine();
}
// The example displays the following output: 
//       The sentence 
//          This string consists of a single short sentence. 
//       has 8 words.
string s1 = "This string consists of a single short sentence.";
int nWords = 0;

s1 = s1.Trim();      
foreach (var ch in s1) {
   if (Char.IsPunctuation(ch) | Char.IsWhiteSpace(ch))
      nWords++;              
}
Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                  s1, nWords);                                                                     
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.
Module Example
   Public Sub Main()
      Dim s1 As String = "This string consists of a single short sentence."
      Dim nWords As Integer = 0

      s1 = s1.Trim()      
      For Each ch In s1
         If Char.IsPunctuation(ch) Or Char.IsWhiteSpace(ch) Then 
            nWords += 1              
         End If   
      Next
      Console.WriteLine("The sentence{2}   {0}{2}has {1} words.",
                        s1, nWords, vbCrLf)                                                                     
   End Sub
End Module
' The example displays the following output:
'       The sentence
'          This string consists of a single short sentence.
'       has 8 words.

Unicode 文字は複数のCharオブジェクトとしてエンコードされる可能性があるため、連続したインデックス値が連続する unicode 文字に対応しないことがあります。Consecutive index values might not correspond to consecutive Unicode characters, because a Unicode character might be encoded as more than one Char object. 特に、文字列には、基本文字で構成され、1つ以上の組み合わせ文字またはサロゲートペアによって形成される複数文字のテキスト単位を含めることができます。In particular, a string may contain multi-character units of text that are formed by a base character followed by one or more combining characters or by surrogate pairs. Charオブジェクトではなく Unicode 文字を操作するにはSystem.Globalization.StringInfoTextElementEnumeratorクラスおよびクラスを使用します。To work with Unicode characters instead of Char objects, use the System.Globalization.StringInfo and TextElementEnumerator classes. 次の例では、Unicode 文字で動作するCharオブジェクトとコードの違いについて説明します。The following example illustrates the difference between code that works with Char objects and code that works with Unicode characters. 文の各単語の文字数またはテキスト要素を比較します。It compares the number of characters or text elements in each word of a sentence. 文字列には、基本文字の2つのシーケンスの後に結合文字が含まれます。The string includes two sequences of a base character followed by a combining character.

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

void main()
{
   // First sentence of The Mystery of the Yellow Room, by Leroux. 
   String^ opening = L"Ce n'est pas sans une certaine émotion que "+
                     L"je commence à raconter ici les aventures " +
                     L"extraordinaires de Joseph Rouletabille."; 
  
   // Character counters. 
   int nChars = 0;
   // Objects to store word count.
   List<int>^ chars = gcnew List<int>();
   List<int>^ elements = gcnew List<int>();

   for each (Char ch in opening) {
      // Skip the ' character. 
      if (ch == '\x0027') continue;

      if (Char::IsWhiteSpace(ch) | (Char::IsPunctuation(ch))) {
         chars->Add(nChars);
         nChars = 0;
      }
      else {
         nChars++;
      }
   }

   TextElementEnumerator^ te = StringInfo::GetTextElementEnumerator(opening);
   while (te->MoveNext()) {
      String^ s = te->GetTextElement();   
      // Skip the ' character. 
      if (s == "\x0027") continue;
      if ( String::IsNullOrEmpty(s->Trim()) | (s->Length == 1 && Char::IsPunctuation(Convert::ToChar(s)))) {
         elements->Add(nChars);         
         nChars = 0;
      }
      else {
         nChars++;
      }
   }

   // Display character counts.
   Console::WriteLine("{0,6} {1,20} {2,20}",
                      "Word #", "Char Objects", "Characters"); 
   for (int ctr = 0; ctr < chars->Count; ctr++) 
      Console::WriteLine("{0,6} {1,20} {2,20}",
                         ctr, chars[ctr], elements[ctr]); 
   Console::ReadLine();
}
// The example displays the following output:
//      Word #         Char Objects           Characters
//           0                    2                    2
//           1                    4                    4
//           2                    3                    3
//           3                    4                    4
//           4                    3                    3
//           5                    8                    8
//           6                    8                    7
//           7                    3                    3
//           8                    2                    2
//           9                    8                    8
//          10                    2                    1
//          11                    8                    8
//          12                    3                    3
//          13                    3                    3
//          14                    9                    9
//          15                   15                   15
//          16                    2                    2
//          17                    6                    6
//          18                   12                   12
// First sentence of The Mystery of the Yellow Room, by Leroux.
string opening = "Ce n'est pas sans une certaine émotion que "+
                 "je commence à raconter ici les aventures " +
                 "extraordinaires de Joseph Rouletabille."; 
// Character counters.
int nChars = 0;
// Objects to store word count.
List<int> chars = new List<int>();
List<int> elements = new List<int>();

foreach (var ch in opening) {
   // Skip the ' character.
   if (ch == '\u0027') continue;
        
   if (Char.IsWhiteSpace(ch) | (Char.IsPunctuation(ch))) {
      chars.Add(nChars);
      nChars = 0;
   }
   else {
      nChars++;
   }
}

System.Globalization.TextElementEnumerator te = 
   System.Globalization.StringInfo.GetTextElementEnumerator(opening);
while (te.MoveNext()) {
   string s = te.GetTextElement();   
   // Skip the ' character.
   if (s == "\u0027") continue;
   if ( String.IsNullOrEmpty(s.Trim()) | (s.Length == 1 && Char.IsPunctuation(Convert.ToChar(s)))) {
      elements.Add(nChars);         
      nChars = 0;
   }
   else {
      nChars++;
   }
}

// Display character counts.
Console.WriteLine("{0,6} {1,20} {2,20}",
                  "Word #", "Char Objects", "Characters"); 
for (int ctr = 0; ctr < chars.Count; ctr++) 
   Console.WriteLine("{0,6} {1,20} {2,20}",
                     ctr, chars[ctr], elements[ctr]); 
// The example displays the following output:
//       Word #         Char Objects           Characters
//            0                    2                    2
//            1                    4                    4
//            2                    3                    3
//            3                    4                    4
//            4                    3                    3
//            5                    8                    8
//            6                    8                    7
//            7                    3                    3
//            8                    2                    2
//            9                    8                    8
//           10                    2                    1
//           11                    8                    8
//           12                    3                    3
//           13                    3                    3
//           14                    9                    9
//           15                   15                   15
//           16                    2                    2
//           17                    6                    6
//           18                   12                   12
Imports System.Collections.Generic
Imports System.Globalization

Module Example
   Public Sub Main()
      ' First sentence of The Mystery of the Yellow Room, by Leroux.
      Dim opening As String = "Ce n'est pas sans une certaine émotion que "+
                              "je commence à raconter ici les aventures " +
                              "extraordinaires de Joseph Rouletabille." 
      ' Character counters.
      Dim nChars As Integer = 0
      ' Objects to store word count.
      Dim chars As New List(Of Integer)()
      Dim elements As New List(Of Integer)()
      
      For Each ch In opening
         ' Skip the ' character.
         If ch = ChrW(&h0027) Then Continue For
              
         If Char.IsWhiteSpace(ch) Or Char.IsPunctuation(ch) Then
            chars.Add(nChars)
            nChars = 0
         Else 
            nChars += 1
         End If
      Next

      Dim te As TextElementEnumerator = StringInfo.GetTextElementEnumerator(opening)
      Do While te.MoveNext()
         Dim s As String = te.GetTextElement()   
         ' Skip the ' character.
         If s = ChrW(&h0027) Then Continue Do
         If String.IsNullOrEmpty(s.Trim()) Or (s.Length = 1 AndAlso Char.IsPunctuation(Convert.ToChar(s))) 
            elements.Add(nChars)         
            nChars = 0
         Else 
            nChars += 1
         End If
      Loop

      ' Display character counts.
      Console.WriteLine("{0,6} {1,20} {2,20}",
                        "Word #", "Char Objects", "Characters") 
      For ctr As Integer = 0 To chars.Count - 1 
         Console.WriteLine("{0,6} {1,20} {2,20}",
                           ctr, chars(ctr), elements(ctr)) 
      Next                        
   End Sub
End Module
' The example displays the following output:
'    Word #         Char Objects           Characters
'         0                    2                    2
'         1                    4                    4
'         2                    3                    3
'         3                    4                    4
'         4                    3                    3
'         5                    8                    8
'         6                    8                    7
'         7                    3                    3
'         8                    2                    2
'         9                    8                    8
'        10                    2                    1
'        11                    8                    8
'        12                    3                    3
'        13                    3                    3
'        14                    9                    9
'        15                   15                   15
'        16                    2                    2
'        17                    6                    6
'        18                   12                   12

この例では、 StringInfo.GetTextElementEnumeratorメソッドTextElementEnumeratorとクラスを使用して、文字列内のすべてのテキスト要素を列挙することで、テキスト要素を操作します。This example works with text elements by using the StringInfo.GetTextElementEnumerator method and the TextElementEnumerator class to enumerate all the text elements in a string. また、メソッドをStringInfo.ParseCombiningCharacters呼び出すことによって、各テキスト要素の開始インデックスを含む配列を取得することもできます。You can also retrieve an array that contains the starting index of each text element by calling the StringInfo.ParseCombiningCharacters method.

個々Charの値ではなく、テキストの単位を操作する方法の詳細StringInfoについては、クラスを参照してください。For more information about working with units of text rather than individual Char values, see the StringInfo class.

Null 文字列と空の文字列Null strings and empty strings

宣言されているが値が割り当てられていないnull文字列はです。A string that has been declared but has not been assigned a value is null. その文字列に対してメソッドを呼び出そうとNullReferenceExceptionすると、がスローされます。Attempting to call methods on that string throws a NullReferenceException. Null 文字列は、値が "" またはString.Emptyである文字列である空の文字列とは異なります。A null string is different from an empty string, which is a string whose value is "" or String.Empty. 場合によっては、メソッドの呼び出しで引数として null 文字列または空の文字列を渡すと、例外がスローされます。In some cases, passing either a null string or an empty string as an argument in a method call throws an exception. たとえば、null 文字列をInt32.Parseメソッドに渡すと、がArgumentNullExceptionスローされ、空の文字列を渡すFormatExceptionとがスローされます。For example, passing a null string to the Int32.Parse method throws an ArgumentNullException, and passing an empty string throws a FormatException. それ以外の場合、メソッドの引数には、null 文字列または空の文字列を指定できます。In other cases, a method argument can be either a null string or an empty string. たとえば、クラスのIFormattable実装を提供する場合、null 文字列と空の文字列の両方を通常の ("G") 書式指定子と等価にする必要があります。For example, if you are providing an IFormattable implementation for a class, you want to equate both a null string and an empty string with the general ("G") format specifier.

クラスStringには、次の2つの便利なメソッドが含まれていnullます。このメソッドを使用すると、文字列がまたは空かどうかをテストできます。The String class includes the following two convenience methods that enable you to test whether a string is null or empty:

  • IsNullOrEmptyString.Empty。文字列がnullと等しいかどうかを示します。IsNullOrEmpty, which indicates whether a string is either null or is equal to String.Empty. このメソッドにより、次のようなコードを使用する必要がなくなります。This method eliminates the need to use code such as the following:

    if (str == nullptr || str->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty))
    
    If str Is Nothing OrElse str.Equals(String.Empty) Then
    
  • IsNullOrWhiteSpaceは、文字列が、equals null String.Empty、または空白文字だけで構成されているかどうかを示します。IsNullOrWhiteSpace, which indicates whether a string is null, equals String.Empty, or consists exclusively of white-space characters. このメソッドにより、次のようなコードを使用する必要がなくなります。This method eliminates the need to use code such as the following:

    if (str == nullptr || str->Equals(String::Empty) || str->Trim()->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty) || str.Trim().Equals(String.Empty))
    
    If str Is Nothing OrElse str.Equals(String.Empty) OrElse str.Trim().Equals(String.Empty)
    

次の例ではIsNullOrEmpty 、カスタムTemperatureクラスIFormattable.ToStringの実装でメソッドを使用します。The following example uses the IsNullOrEmpty method in the IFormattable.ToString implementation of a custom Temperature class. メソッドは、"G"、"C"、"F"、"K" の各書式指定文字列をサポートしています。The method supports the "G", "C", "F", and "K" format strings. 空の書式指定文字列または値がでnullある書式指定文字列がメソッドに渡されると、その値は "G" 書式指定文字列に変更されます。If an empty format string or a format string whose value is null is passed to the method, its value is changed to the "G" format string.

public:
   virtual String^ ToString(String^ format, IFormatProvider^ provider) 
   {
      if (String::IsNullOrEmpty(format)) format = "G";  
      if (provider == nullptr) provider = CultureInfo::CurrentCulture;
      
      switch (Convert::ToUInt16(format->ToUpperInvariant()))
      {
         // Return degrees in Celsius.    
         case 'G':
         case 'C':
            return temp.ToString("F2", provider) + L"�C";
         // Return degrees in Fahrenheit.
         case 'F': 
            return (temp * 9 / 5 + 32).ToString("F2", provider) + L"�F";
         // Return degrees in Kelvin.
         case 'K':   
            return (temp + 273.15).ToString();
         default:
            throw gcnew FormatException(
                  String::Format("The {0} format string is not supported.", 
                                 format));
      }                                   
   }
public string ToString(string format, IFormatProvider provider) 
{
   if (String.IsNullOrEmpty(format)) format = "G";  
   if (provider == null) provider = CultureInfo.CurrentCulture;
   
   switch (format.ToUpperInvariant())
   {
      // Return degrees in Celsius.    
      case "G":
      case "C":
         return temp.ToString("F2", provider) + "°C";
      // Return degrees in Fahrenheit.
      case "F": 
         return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F";
      // Return degrees in Kelvin.
      case "K":   
         return (temp + 273.15).ToString();
      default:
         throw new FormatException(
               String.Format("The {0} format string is not supported.", 
                             format));
   }                                   
}
Public Overloads Function ToString(fmt As String, provider As IFormatProvider) As String _
                Implements IFormattable.ToString
   If String.IsNullOrEmpty(fmt) Then fmt = "G"  
   If provider Is Nothing Then provider = CultureInfo.CurrentCulture
   
   Select Case fmt.ToUpperInvariant()
      ' Return degrees in Celsius.    
      Case "G", "C"
         Return temp.ToString("F2", provider) + "°C"
      ' Return degrees in Fahrenheit.
      Case "F" 
         Return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F"
      ' Return degrees in Kelvin.
      Case "K"   
         Return (temp + 273.15).ToString()
      Case Else
         Throw New FormatException(
               String.Format("The {0} format string is not supported.", 
                             fmt))
    End Select                                   
End Function

不変性と StringBuilder クラスImmutability and the StringBuilder class

オブジェクトStringの値は、作成後に変更できないため、不変 (読み取り専用) と呼ばれます。A String object is called immutable (read-only), because its value cannot be modified after it has been created. オブジェクトをString変更するように見えるメソッドは、実際Stringには変更を含む新しいオブジェクトを返します。Methods that appear to modify a String object actually return a new String object that contains the modification.

文字列は不変であるため、1つの文字列として表示されるものに対して繰り返しの追加や削除を実行する文字列操作ルーチンでは、パフォーマンスが大幅に低下する可能性があります。Because strings are immutable, string manipulation routines that perform repeated additions or deletions to what appears to be a single string can exact a significant performance penalty. たとえば、次のコードでは、乱数ジェネレーターを使用して、0x0001 ~ 0x052F の範囲で1000文字の文字列を作成します。For example, the following code uses a random number generator to create a string with 1000 characters in the range 0x0001 to 0x052F. コードは、という名前strの既存の文字列に新しい文字を追加するために文字列の連結を使用するように見えますが、実際には、連結操作ごとに新しいStringオブジェクトを作成します。Although the code appears to use string concatenation to append a new character to the existing string named str, it actually creates a new String object for each concatenation operation.

using namespace System;
using namespace System::IO;
using namespace System::Text;

void main()
{
   Random^ rnd = gcnew Random();

   String^ str = String::Empty;
   StreamWriter^ sw = gcnew StreamWriter(".\\StringFile.txt", 
                        false, Encoding::Unicode);

   for (int ctr = 0; ctr <= 1000; ctr++) {
      str += Convert::ToChar(rnd->Next(1, 0x0530)); 
      if (str->Length % 60 == 0)
         str += Environment::NewLine;          
   }                    
   sw->Write(str);
   sw->Close();
}
using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      
      string str = String.Empty;
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                           false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         str += Convert.ToChar(rnd.Next(1, 0x0530)); 
         if (str.Length % 60 == 0)
            str += Environment.NewLine;          
      }                    
      sw.Write(str);
      sw.Close();
   }
}
Imports System.IO
Imports System.Text

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      
      Dim str As String = String.Empty
      Dim sw As New StreamWriter(".\StringFile.txt", 
                           False, Encoding.Unicode)

      For ctr As Integer = 0 To 1000
         str += ChrW(rnd.Next(1, &h0530)) 
         If str.Length Mod 60 = 0 Then str += vbCrLf          
      Next                    
      sw.Write(str)
      sw.Close()
   End Sub
End Module

文字列の値にStringBuilder対して複数のString変更を行う操作には、クラスの代わりにクラスを使用できます。You can use the StringBuilder class instead of the String class for operations that make multiple changes to the value of a string. Stringクラスのインスタンスとは異なりStringBuilder 、オブジェクトは変更可能です。文字列の部分文字列を連結、追加、または削除すると、1つの文字列に対して操作が実行されます。Unlike instances of the String class, StringBuilder objects are mutable; when you concatenate, append, or delete substrings from a string, the operations are performed on a single string. StringBuilderオブジェクトの値の変更が完了したら、 StringBuilder.ToStringメソッドを呼び出して文字列に変換できます。When you have finished modifying the value of a StringBuilder object, you can call its StringBuilder.ToString method to convert it to a string. 次の例ではString 、前の例で使用したを置き換えて、0x0001 から0x052f までの範囲にStringBuilderある1000のランダム文字をオブジェクトで連結します。The following example replaces the String used in the previous example to concatenate 1000 random characters in the range to 0x0001 to 0x052F with a StringBuilder object.

using namespace System;
using namespace System::IO;
using namespace System::Text;

void main()
{
   Random^ rnd = gcnew Random();

   StringBuilder^ sb = gcnew StringBuilder();
   StreamWriter^ sw = gcnew StreamWriter(".\\StringFile.txt", 
                        false, Encoding::Unicode);

   for (int ctr = 0; ctr <= 1000; ctr++) {
      sb->Append(Convert::ToChar(rnd->Next(1, 0x0530))); 
      if (sb->Length % 60 == 0)
         sb->AppendLine();          
   }                    
   sw->Write(sb->ToString());
   sw->Close();
}
using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      StringBuilder sb = new StringBuilder();
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                                         false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         sb.Append(Convert.ToChar(rnd.Next(1, 0x0530))); 
         if (sb.Length % 60 == 0)
            sb.AppendLine();          
      }                    
      sw.Write(sb.ToString());
      sw.Close();
   }
}
Imports System.IO
Imports System.Text

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim sb As New StringBuilder()
      Dim sw As New StreamWriter(".\StringFile.txt", 
                                 False, Encoding.Unicode)

      For ctr As Integer = 0 To 1000
         sb.Append(ChrW(rnd.Next(1, &h0530))) 
         If sb.Length Mod 60 = 0 Then sb.AppendLine()          
      Next                    
      sw.Write(sb.ToString())
      sw.Close()
   End Sub
End Module

序数およびカルチャに依存する操作Ordinal vs. culture-sensitive operations

Stringクラスのメンバーは、オブジェクトに対して序数またはカルチャに依存したString (言語) 操作を実行します。Members of the String class perform either ordinal or culture-sensitive (linguistic) operations on a String object. 序数操作は、各Charオブジェクトの数値に対して動作します。An ordinal operation acts on the numeric value of each Char object. カルチャに依存する操作は、 Stringオブジェクトの値に対して作用し、カルチャ固有の大文字と小文字の区別、並べ替え、書式設定、および解析の規則を考慮に入れます。A culture-sensitive operation acts on the value of the String object, and takes culture-specific casing, sorting, formatting, and parsing rules into account. カルチャに依存する操作は、明示的に宣言されたカルチャまたは暗黙的な現在のカルチャのコンテキストで実行されます。Culture-sensitive operations execute in the context of an explicitly declared culture or the implicit current culture. 2種類の操作では、同じ文字列に対して実行すると、まったく異なる結果が生成される可能性があります。The two kinds of operations can produce very different results when they are performed on the same string.

また、.net では、カルチャに依存しない言語文字列操作もCultureInfo.InvariantCultureサポートしています。インバリアントカルチャ () は、地域に依存しない英語のカルチャ設定に厳密に基づいています。.NET also supports culture-insensitive linguistic string operations by using the invariant culture (CultureInfo.InvariantCulture), which is loosely based on the culture settings of the English language independent of region. 他のSystem.Globalization.CultureInfo設定とは異なり、インバリアントカルチャの設定は、1台のコンピューター、システムからシステム、および .net のバージョン間で一貫性が保たれていることが保証されます。Unlike other System.Globalization.CultureInfo settings, the settings of the invariant culture are guaranteed to remain consistent on a single computer, from system to system, and across versions of .NET. インバリアントカルチャは、すべてのカルチャでの文字列比較と順序付けの安定性を確保するブラックボックスの一種として認識されます。The invariant culture can be seen as a kind of black box that ensures stability of string comparisons and ordering across all cultures.

重要

アプリケーションで、ファイル名や名前付きパイプなどのシンボル識別子、または XML ファイル内のテキストベースのデータなどの永続化されたデータに関するセキュリティ上の決定を行う場合、この操作では、カルチャに依存した比較ではなく序数の比較を使用する必要があります。If your application makes a security decision about a symbolic identifier such as a file name or named pipe, or about persisted data such as the text-based data in an XML file, the operation should use an ordinal comparison instead of a culture-sensitive comparison. これは、カルチャに依存した比較では、有効なカルチャによって異なる結果が生成される可能性があるのに対し、序数の比較は比較対象の文字のバイナリ値のみに依存するためです。This is because a culture-sensitive comparison can yield different results depending on the culture in effect, whereas an ordinal comparison depends solely on the binary value of the compared characters.

重要

文字列操作を実行するほとんどのメソッドには、型StringComparisonのパラメーターを持つオーバーロードが含まれています。これにより、メソッドが序数またはカルチャに依存した操作を実行するかどうかを指定できます。Most methods that perform string operations include an overload that has a parameter of type StringComparison, which enables you to specify whether the method performs an ordinal or culture-sensitive operation. 一般に、メソッド呼び出しの意図を明確にするには、このオーバーロードを呼び出す必要があります。In general, you should call this overload to make the intent of your method call clear. 文字列に対して序数およびカルチャに依存した操作を使用するためのベストプラクティスとガイダンスについては、「文字列を使用するためのベストプラクティス」を参照してください。For best practices and guidance for using ordinal and culture-sensitive operations on strings, see Best Practices for Using Strings.

大文字と小文字の区別、解析と書式設定比較と並べ替え、および等しいかどうかのテストは、序数またはカルチャに依存する操作になります。Operations for casing, parsing and formatting, comparison and sorting, and testing for equality can be either ordinal or culture-sensitive. 以下のセクションでは、操作の各カテゴリについて説明します。The following sections discuss each category of operation.

ヒント

常にメソッドのオーバーロードを呼び出して、メソッド呼び出しの意図を明確にする必要があります。You should always call a method overload that makes the intent of your method call clear. Compare(String, String)たとえば、メソッドを呼び出して、現在のカルチャの規則を使用して2つの文字列のカルチャに依存した比較を実行する代わりに、の値をStringComparison.CurrentCultureに指定comparisonTypeしてCompare(String, String, StringComparison)メソッドを呼び出す必要があります。引数.For example, instead of calling the Compare(String, String) method to perform a culture-sensitive comparison of two strings by using the conventions of the current culture, you should call the Compare(String, String, StringComparison) method with a value of StringComparison.CurrentCulture for the comparisonType argument. 詳細については、「文字列を使用するためのベスト プラクティス」を参照してください。For more information, see Best Practices for Using Strings.

Windows オペレーティング システムの並べ替え操作と比較操作で使用される文字の重みに関する情報を含む一連のテキスト ファイルである並べ替え重みテーブル と、Linux と macOS 用の並べ替え重みテーブルである デフォルト Unicode 照合基本テーブルをダウンロードできます。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, and the Default Unicode Collation Element Table, the sort weight table for Linux and macOS.

大文字Casing

大文字と小文字の規則は、Unicode 文字の大文字と小文字を変更する方法を決定します。たとえば、小文字から大文字に変換します。Casing rules determine how to change the capitalization of a Unicode character; for example, from lowercase to uppercase. 多くの場合、文字列比較の前に大文字と小文字の演算が実行されます。Often, a casing operation is performed before a string comparison. たとえば、文字列を大文字に変換して、別の大文字の文字列と比較できるようにすることができます。For example, a string might be converted to uppercase so that it can be compared with another uppercase string. ToLowerまたはToLowerInvariantメソッドを呼び出して文字列内の文字を小文字に変換することができます。 ToUpperまた、メソッドまたはToUpperInvariantメソッドを呼び出して、文字列内の文字を大文字に変換することもできます。You can convert the characters in a string to lowercase by calling the ToLower or ToLowerInvariant method, and you can convert them to uppercase by calling the ToUpper or ToUpperInvariant method. また、メソッドを使用してTextInfo.ToTitleCase 、文字列を大文字に変換することもできます。In addition, you can use the TextInfo.ToTitleCase method to convert a string to title case.

注意

Linux および macOS システム上で実行されている .NET Core のみ: C と Posix のカルチャの照合順序の動作では、大文字小文字が常に区別されます。これらのカルチャでは想定されている Unicode 照合順序が使われないためです。.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.

文字種の操作は、現在のカルチャ、指定されたカルチャ、またはインバリアントカルチャの規則に基づいて行うことができます。Casing operations can be based on the rules of the current culture, a specified culture, or the invariant culture. 大文字小文字の割り当ては使用されるカルチャによって異なる場合があるため、大文字と小文字の区別の結果はカルチャによって異なる場合があります。Because case mappings can vary depending on the culture used, the result of casing operations can vary based on culture. 大文字と小文字の違いには、次の3種類があります。The actual differences in casing are of three kinds:

  • ラテン文字の大文字 I (U + 0049)、ラテン小文字 I (U + 0069)、ラテン大文字文字 I (U + 0130)、およびラテン小文字 I (U + 0131) の大文字と小文字の対応付けには違いがあります。Differences in the case mapping of LATIN CAPITAL LETTER I (U+0049), LATIN SMALL LETTER I (U+0069), LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130), and LATIN SMALL LETTER DOTLESS I (U+0131). Tr-TR (トルコ語) と az-Latn-AZ (アゼルバイジャン, Latin) カルチャで、tr、az、az-Latn ニュートラルカルチャでは、ラテン大文字の小文字 i はラテン文字の小文字 i で、ラテン小文字 i はという文字になります。上にドットが付いたラテン大文字 I。In the tr-TR (Turkish (Turkey)) and az-Latn-AZ (Azerbaijan, Latin) cultures, and in the tr, az, and az-Latn neutral cultures, the lowercase equivalent of LATIN CAPITAL LETTER I is LATIN SMALL LETTER DOTLESS I, and the uppercase equivalent of LATIN SMALL LETTER I is LATIN CAPITAL LETTER I WITH DOT ABOVE. インバリアントカルチャを含め、その他のすべてのカルチャでは、ラテン小文字 I とラテン大文字の I は小文字で、大文字に相当します。In all other cultures, including the invariant culture, LATIN SMALL LETTER I and LATIN CAPITAL LETTER I are lowercase and uppercase equivalents.

    次の例では、カルチャに依存した大文字と小文字の比較に依存している場合に、ファイルシステムへのアクセスを防止するように設計された文字列比較を実行する方法を示します。The following example demonstrates how a string comparison designed to prevent file system access can fail if it relies on a culture-sensitive casing comparison. (インバリアントカルチャの大文字と小文字の表記規則が使用されている必要があります)。(The casing conventions of the invariant culture should have been used.)

    using System;
    using System.Globalization;
    using System.Threading;
    
    public class Example
    {
       const string disallowed = "file";
       
       public static void Main()
       {
          IsAccessAllowed(@"FILE:\\\c:\users\user001\documents\FinancialInfo.txt");
       }
    
       private static void IsAccessAllowed(String resource)
       {
          CultureInfo[] cultures = { CultureInfo.CreateSpecificCulture("en-US"),
                                     CultureInfo.CreateSpecificCulture("tr-TR") };
          String scheme = null;
          int index = resource.IndexOfAny( new Char[] { '\\', '/' } );
          if (index > 0) 
             scheme = resource.Substring(0, index - 1);
    
          // Change the current culture and perform the comparison.
          foreach (var culture in cultures) {
             Thread.CurrentThread.CurrentCulture = culture;
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
             Console.WriteLine(resource);
             Console.WriteLine("Access allowed: {0}", 
                               ! String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase));      
             Console.WriteLine();
          }   
       }
    }
    // The example displays the following output:
    //       Culture: English (United States)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: False
    //       
    //       Culture: Turkish (Turkey)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: True
    
    Imports System.Globalization
    Imports System.Threading
    
    Module Example
       Const disallowed = "file"
       
       Public Sub Main()
          IsAccessAllowed("FILE:\\\c:\users\user001\documents\FinancialInfo.txt")
       End Sub
    
       Private Sub IsAccessAllowed(resource As String)
          Dim cultures() As CultureInfo = { CultureInfo.CreateSpecificCulture("en-US"),
                                            CultureInfo.CreateSpecificCulture("tr-TR") }
          Dim scheme As String = Nothing
          Dim index As Integer = resource.IndexOfAny( {"\"c, "/"c })
          If index > 0 Then scheme = resource.Substring(0, index - 1)
    
          ' Change the current culture and perform the comparison.
          For Each culture In cultures
             Thread.CurrentThread.CurrentCulture = culture
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName)
             Console.WriteLine(resource)
             Console.WriteLine("Access allowed: {0}", 
                               Not String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase))      
             Console.WriteLine()
          Next   
       End Sub      
    End Module
    ' The example displays the following output:
    '       Culture: English (United States)
    '       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    '       Access allowed: False
    '       
    '       Culture: Turkish (Turkey)
    '       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    '       Access allowed: True
    
  • インバリアントカルチャと他のすべてのカルチャとの大文字と小文字のマッピングの違い。Differences in case mappings between the invariant culture and all other cultures. このような場合、インバリアントカルチャの大文字と小文字の規則を使用して文字を大文字または小文字に変更すると、同じ文字が返されます。In these cases, using the casing rules of the invariant culture to change a character to uppercase or lowercase returns the same character. 他のすべてのカルチャでは、別の文字が返されます。For all other cultures, it returns a different character. 影響を受ける文字の一部を次の表に示します。Some of the affected characters are listed in the following table.

    文字Character がに変更された場合If changed to 戻り値Returns
    ミクロン記号 (U + 00B5)MICRON SIGN (U+00B5) 大文字Uppercase ギリシャ文字ミューミュー (U +-39C)GREEK CAPITAL LETTER MU (U+-39C)
    上にドットが付いたラテン大文字 I (U + 0130)LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130) 小文字Lowercase ラテン小文字 I (U + 0069)LATIN SMALL LETTER I (U+0069)
    ラテン文字の小文字 I (U + 0131)LATIN SMALL LETTER DOTLESS I (U+0131) 大文字Uppercase ラテン大文字 I (U + 0049)LATIN CAPITAL LETTER I (U+0049)
    ラテン小文字 (U + 017F)LATIN SMALL LETTER LONG S (U+017F) 大文字Uppercase ラテン大文字 S (U + 「0053」)LATIN CAPITAL LETTER S (U+0053)
    英小文字 Z がキャロン (U + 01C5) のラテン文字の大文字 DLATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON (U+01C5) 小文字Lowercase ラテン小文字 DZ とキャロン (U + 01C6)LATIN SMALL LETTER DZ WITH CARON (U+01C6)
    ギリシャ YPOGEGRAMMENI (U + 0345) の組み合わせCOMBINING GREEK YPOGEGRAMMENI (U+0345) 大文字Uppercase ギリシャ文字イオータ (U + 0399)GREEK CAPITAL LETTER IOTA (U+0399)
  • 2文字の大文字と小文字の組み合わせが ASCII 文字の範囲内にある場合の大文字と小文字のマッピングの違い。Differences in case mappings of two-letter mixed-case pairs in the ASCII character range. ほとんどのカルチャでは、2文字の大文字と小文字の組み合わせは、等価の2文字の大文字または小文字のペアと等しくなります。In most cultures, a two-letter mixed-case pair is equal to the equivalent two-letter uppercase or lowercase pair. これは、次のカルチャにおける次の2文字のペアに対しては当てはまりません。これは、各ケースが digraph と比較されるためです。This is not true for the following two-letter pairs in the following cultures, because in each case they are compared to a digraph:

    • hr-HR (クロアチア語) カルチャの "lJ" と "nJ"。"lJ" and "nJ" in the hr-HR (Croatian (Croatia)) culture.

    • CS-CZ (チェコ語 (チェコ共和国)) および sk-SK (スロバキア語) カルチャの "cH"。"cH" in the cs-CZ (Czech (Czech Republic)) and sk-SK (Slovak (Slovakia)) cultures.

    • da-DK (デンマーク語 (デンマーク)) カルチャの "aA"。"aA" in the da-DK (Danish (Denmark)) culture.

    • "cS"、"dZ"、"dZS"、"nY"、"sZ"、"tY"、および hu-HU (ハンガリー語 (ハンガリー)) カルチャの "zS"。"cS", "dZ", "dZS", "nY", "sZ", "tY", and "zS" in the hu-HU (Hungarian (Hungary)) culture.

    • es-ES_tradnl (スペイン語 (スペイン)、従来の並べ替え) カルチャの "cH" と "lL"。"cH" and "lL" in the es-ES_tradnl (Spanish (Spain, Traditional Sort)) culture.

    • vi-VN (ベトナム語) カルチャの "cH"、"gI"、"kH"、"nG" "nH"、"pH"、"qU"、"tH"、および "tR"。"cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH", and "tR" in the vi-VN (Vietnamese (Vietnam)) culture.

    ただし、これらのペアのカルチャに依存した比較によって問題が発生する状況が発生することは珍しくありません。これらのペアは、固定文字列または識別子では一般的ではありません。However, it is unusual to encounter a situation in which a culture-sensitive comparison of these pairs creates problems, because these pairs are uncommon in fixed strings or identifiers.

次の例では、文字列を大文字に変換する場合のカルチャ間の大文字と小文字の違いについて説明します。The following example illustrates some of the differences in casing rules between cultures when converting strings to uppercase.

using namespace System;
using namespace System::Globalization;
using namespace System::IO;

String^ ShowHexValue(String^ s);

void main()
{
   StreamWriter^ sw = gcnew StreamWriter(".\\case.txt");   
   array<String^>^ words = gcnew array<String^> { L"file", L"sıfır", L"Dženana" };
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               gcnew CultureInfo("en-US"),  
                                                               gcnew CultureInfo("tr-TR") };

   for each (String^ word in words) {
      sw->WriteLine("{0}:", word);
      for each (CultureInfo^ culture in cultures) {
         String^ name = String::IsNullOrEmpty(culture->Name) ? 
                              "Invariant" : culture->Name;
         String^ upperWord = word->ToUpper(culture);
         sw->WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                        upperWord, ShowHexValue(upperWord));

      }
      sw->WriteLine();  
   }
   sw->Close();
}

String^ ShowHexValue(String^ s)
{
   String^ retval = nullptr;
   for each (Char ch in s) {
      array<Byte>^ bytes = BitConverter::GetBytes(ch);
      retval += String::Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
   }
   return retval;
} 
// The example displays the following output: 
//    file: 
//        Invariant:    FILE               00 46 00 49 00 4C 00 45  
//            en-US:    FILE               00 46 00 49 00 4C 00 45  
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45  
//     
//    sıfır: 
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52  
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52  
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52  
//     
//    Dženana: 
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41  
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41  
//            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\case.txt");   
      string[] words = { "file", "sıfır", "Dženana" };
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"),  
                                 new CultureInfo("tr-TR") };

      foreach (var word in words) {
         sw.WriteLine("{0}:", word);
         foreach (var culture in cultures) {
            string name = String.IsNullOrEmpty(culture.Name) ? 
                                 "Invariant" : culture.Name;
            string upperWord = word.ToUpper(culture);
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord));
     
         }
         sw.WriteLine();  
      }
      sw.Close();
   }

   private static string ShowHexValue(string s)
   {
      string retval = null;
      foreach (var ch in s) {
         byte[] bytes = BitConverter.GetBytes(ch);
         retval += String.Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
      }
      return retval;
   } 
}
// The example displays the following output:
//    file:
//        Invariant:    FILE               00 46 00 49 00 4C 00 45 
//            en-US:    FILE               00 46 00 49 00 4C 00 45 
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
//    
//    sıfır:
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//    
//    Dženana:
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
//            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
Imports System.Globalization
Imports System.IO

Module Example
   Public Sub Main()
      Dim sw As New StreamWriter(".\case.txt")   
      Dim words As String() = { "file", "sıfır", "Dženana" }
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        New CultureInfo("en-US"),  
                                        New CultureInfo("tr-TR") }

      For Each word In words
         sw.WriteLine("{0}:", word)
         For Each culture In cultures
            Dim name As String = If(String.IsNullOrEmpty(culture.Name),  
                                 "Invariant", culture.Name)
            Dim upperWord As String = word.ToUpper(culture)
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord))
     
         Next
         sw.WriteLine()  
      Next
      sw.Close()
   End Sub

   Private Function ShowHexValue(s As String) As String
      Dim retval As String = Nothing
      For Each ch In s
         Dim bytes() As Byte = BitConverter.GetBytes(ch)
         retval += String.Format("{0:X2} {1:X2} ", bytes(1), bytes(0))     
      Next
      Return retval
   End Function
End Module
' The example displays the following output:
'    file:
'        Invariant:    FILE               00 46 00 49 00 4C 00 45 
'            en-US:    FILE               00 46 00 49 00 4C 00 45 
'            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
'    
'    sıfır:
'        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
'            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
'            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
'    
'    Dženana:
'        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
'            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
'            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41  

解析と書式設定Parsing and formatting

書式設定と解析は逆の操作です。Formatting and parsing are inverse operations. 書式設定規則は、日付と時刻、数値などの値を文字列形式に変換する方法を決定します。一方、解析規則は、文字列形式を日付や時刻などの値に変換する方法を決定します。Formatting rules determine how to convert a value, such as a date and time or a number, to its string representation, whereas parsing rules determine how to convert a string representation to a value such as a date and time. 書式設定規則と解析規則は、どちらもカルチャ規則に依存します。Both formatting and parsing rules are dependent on cultural conventions. 次の例は、カルチャ固有の日付文字列を解釈するときに発生する可能性のあるあいまいさを示しています。The following example illustrates the ambiguity that can arise when interpreting a culture-specific date string. 日付文字列の生成に使用されたカルチャの規則を理解していなければ、03/01/2011、3/1/2011、および01/03/2011 が、2011または3月1日の2011を表しているかどうかを知ることはできません。Without knowing the conventions of the culture that was used to produce a date string, it is not possible to know whether 03/01/2011, 3/1/2011, and 01/03/2011 represent January 3, 2011 or March 1, 2011.

using namespace System;
using namespace System::Globalization;

void main()
{
   DateTime^ date = gcnew DateTime(2011, 3, 1);
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               gcnew CultureInfo("en-US"), 
                                                               gcnew CultureInfo("fr-FR") };

   for each (CultureInfo^ culture in cultures)
      Console::WriteLine("{0,-12} {1}", String::IsNullOrEmpty(culture->Name) ?
                        "Invariant" : culture->Name, 
                        date->ToString("d", culture));                                    
}
// The example displays the following output: 
//       Invariant    03/01/2011 
//       en-US        3/1/2011 
//       fr-FR        01/03/2011
using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date = new DateTime(2011, 3, 1);
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"), 
                                 new CultureInfo("fr-FR") };

      foreach (var culture in cultures)
         Console.WriteLine("{0,-12} {1}", String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.ToString("d", culture));                                    
   }
}
// The example displays the following output:
//       Invariant    03/01/2011
//       en-US        3/1/2011
//       fr-FR        01/03/2011
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dat As Date = #3/1/2011#
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        New CultureInfo("en-US"), 
                                        New CultureInfo("fr-FR") }

      For Each culture In cultures
         Console.WriteLine("{0,-12} {1}", If(String.IsNullOrEmpty(culture.Name), 
                           "Invariant", culture.Name), 
                           dat.ToString("d", culture))
      Next                                                         
   End Sub
End Module
' The example displays the following output:
'       Invariant    03/01/2011
'       en-US        3/1/2011
'       fr-FR        01/03/2011

同様に、次の例に示すように、1つの文字列では、解析操作で規則が使用されているカルチャに応じて異なる日付を生成できます。Similarly, as the following example shows, a single string can produce different dates depending on the culture whose conventions are used in the parsing operation.

using namespace System;
using namespace System::Globalization;

void main()
{
   String^ dateString = "07/10/2011";
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               CultureInfo::CreateSpecificCulture("en-GB"), 
                                                               CultureInfo::CreateSpecificCulture("en-US") };
   Console::WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                "Month", "Day");
   for each (CultureInfo^ culture in cultures) {
      DateTime date = DateTime::Parse(dateString, culture);
      Console::WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                        String::IsNullOrEmpty(culture->Name) ?
                        "Invariant" : culture->Name, 
                        date.Month, date.Day);
   }                      
}
// The example displays the following output: 
//       Date String     Culture    Month      Day 
//        
//       07/10/2011    Invariant        7       10 
//       07/10/2011        en-GB       10        7 
//       07/10/2011        en-US        7       10

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString = "07/10/2011";
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 CultureInfo.CreateSpecificCulture("en-GB"), 
                                 CultureInfo.CreateSpecificCulture("en-US") };
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                 "Month", "Day");
      foreach (var culture in cultures) {
         DateTime date = DateTime.Parse(dateString, culture);
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.Month, date.Day);
      }                      
   }
}
// The example displays the following output:
//       Date String     Culture    Month      Day
//       
//       07/10/2011    Invariant        7       10
//       07/10/2011        en-GB       10        7
//       07/10/2011        en-US        7       10
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateString As String = "07/10/2011"
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        CultureInfo.CreateSpecificCulture("en-GB"), 
                                        CultureInfo.CreateSpecificCulture("en-US") }
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", "Date String", "Culture", 
                                                 "Month", "Day")
      Console.WriteLine()                                                 
      For Each culture In cultures
         Dim dat As Date = DateTime.Parse(dateString, culture)
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           If(String.IsNullOrEmpty(culture.Name), 
                           "Invariant", culture.Name), 
                           dat.Month, dat.Day)
      Next
   End Sub
End Module
' The example displays the following output:
'       Date String     Culture    Month      Day
'       
'       07/10/2011    Invariant        7       10
'       07/10/2011        en-GB       10        7
'       07/10/2011        en-US        7       10

文字列の比較と並べ替えString comparison and sorting

文字列の比較と並べ替えの規則は、カルチャによって異なります。Conventions for comparing and sorting strings vary from culture to culture. たとえば、並べ替え順序は、ふりがなまたは文字の視覚的表現に基づいている場合があります。For example, the sort order may be based on phonetics or on the visual representation of characters. 東アジア圏の言語では、文字が表意文字の画数と部首によって並べ替えられます。In East Asian languages, characters are sorted by the stroke and radical of ideographs. また、並べ替えは、言語やカルチャで使用されているアルファベットの順序によっても異なります。Sorting also depends on the order languages and cultures use for the alphabet. たとえば、デンマーク語の文字 "Æ" は、アルファベットでは "Z" の後に位置します。For example, the Danish language has an "Æ" character that it sorts after "Z" in the alphabet. また、比較では大文字と小文字を区別するか、大文字と小文字を区別しないことがあります。また、場合によっては、大文字と小文字を区別する規則もIn addition, comparisons can be case-sensitive or case-insensitive, and in some cases casing rules also differ by culture. 一方、序数に基づく比較では、文字列の比較と並べ替えを行うときに、文字列内の個々の文字の Unicode コードポイントを使用します。Ordinal comparison, on the other hand, uses the Unicode code points of individual characters in a string when comparing and sorting strings.

並べ替え規則は、Unicode 文字のアルファベット順と、2つの文字列の比較方法を決定します。Sort rules determine the alphabetic order of Unicode characters and how two strings compare to each other. たとえば、メソッドはString.Compare(String, String, StringComparison)StringComparisonパラメーターに基づいて2つの文字列を比較します。For example, the String.Compare(String, String, StringComparison) method compares two strings based on the StringComparison parameter. パラメーター値がStringComparison.CurrentCultureの場合、メソッドは、現在のカルチャの規則を使用する言語的な比較を実行します。 StringComparison.Ordinalパラメーター値がの場合、メソッドは序数に基づく比較を実行します。If the parameter value is StringComparison.CurrentCulture, the method performs a linguistic comparison that uses the conventions of the current culture; if the parameter value is StringComparison.Ordinal, the method performs an ordinal comparison. したがって、次の例に示すように、現在のカルチャが米国の場合、英語の場合、(カルチャにString.Compare(String, String, StringComparison)依存した比較を使用した) メソッドの最初の呼び出しでは、"a" より小さい "a" が考慮されますが、(序数による比較を使用した) 同じメソッドへの2回目の呼び出しでは、"a" より大きい "a" と見なされます。Consequently, as the following example shows, if the current culture is U.S. English, the first call to the String.Compare(String, String, StringComparison) method (using culture-sensitive comparison) considers "a" less than "A", but the second call to the same method (using ordinal comparison) considers "a" greater than "A".

using namespace System;
using namespace System::Globalization;
using namespace System::Threading;

void main()
{
   Thread::CurrentThread->CurrentCulture = CultureInfo::CreateSpecificCulture("en-US");
   Console::WriteLine(String::Compare("A", "a", StringComparison::CurrentCulture));
   Console::WriteLine(String::Compare("A", "a", StringComparison::Ordinal));
}
// The example displays the following output: 
//       1 
//       -32
using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture));
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       1
//       -32
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture))
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal))
   End Sub
End Module
' The example displays the following output:
'       1                                                                                     
'       -32

.NET では、単語、文字列、および序数の並べ替え規則がサポートされています。.NET supports word, string, and ordinal sort rules:

  • 単語での並べ替えでは、英数字以外の特定の Unicode 文字には特別な重みが割り当てられる、カルチャに依存した文字列の比較が行われます。A word sort performs a culture-sensitive comparison of strings in which certain nonalphanumeric Unicode characters might have special weights assigned to them. たとえば、ハイフン (-) には非常に小さな重みが割り当てられています。そのため、並べ替えられたリスト内で "co-op" と "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. Word の並べ替え規則をString使用して2つの文字列を比較するメソッドの一覧については、「カテゴリ別の文字列操作」セクションを参照してください。For a list of the String methods that compare two strings using word sort rules, see the String operations by category section.

  • 文字列の並べ替えでは、カルチャに依存した比較も実行されます。A string sort also performs a culture-sensitive comparison. これは単語の並べ替えに似ていますが、特殊なケースは存在せず、英数字以外のすべての記号はすべての英数字の Unicode 文字の前に記述されます。It is similar to a word sort, except that there are no special cases, and all nonalphanumeric symbols come before all alphanumeric Unicode characters. 2つのCompareInfo.Compare options 文字列は、値が指定されたパラメーターを持つメソッドオーバーロードを呼び出すことによって、文字列並べ替え規則を使用してCompareOptions.StringSort比較できます。Two strings can be compared using string sort rules by calling the CompareInfo.Compare method overloads that have an options parameter that is supplied a value of CompareOptions.StringSort. これは、文字列の並べ替え規則を使用して2つの文字列を比較するために .NET で提供される唯一の方法です。Note that this is the only method that .NET provides to compare two strings using string sort rules.

  • 序数の並べ替えでは、文字列内の各 Char オブジェクトの数値に基づいて文字列を比較します。An ordinal sort compares strings based on the numeric value of each Char object in the string. 文字の小文字と大文字のバージョンには異なるコードポイントがあるため、序数による比較では大文字と小文字が自動的に区別されます。An ordinal comparison is automatically case-sensitive because the lowercase and uppercase versions of a character have different code points. ただし、case が重要でない場合は、大文字と小文字を区別しない序数の比較を指定できます。However, if case is not important, you can specify an ordinal comparison that ignores case. これは、インバリアントカルチャを使用して文字列を大文字に変換し、その結果に対して序数に基づく比較を実行することと同じです。This is equivalent to converting the string to uppercase by using the invariant culture and then performing an ordinal comparison on the result. 序数の並べ替え規則をString使用して2つの文字列を比較するメソッドの一覧については、「カテゴリ別の文字列操作」セクションを参照してください。For a list of the String methods that compare two strings using ordinal sort rules, see the String operations by category section.

カルチャに依存した比較とは、 CultureInfo CultureInfo.InvariantCultureプロパティによって指定されたインバリアントカルチャを含む、明示的または暗黙的にオブジェクトを使用する比較です。A culture-sensitive comparison is any comparison that explicitly or implicitly uses a CultureInfo object, including the invariant culture that is specified by the CultureInfo.InvariantCulture property. 暗黙のカルチャは、現在のカルチャであり、プロパティThread.CurrentCultureCultureInfo.CurrentCultureプロパティで指定されます。The implicit culture is the current culture, which is specified by the Thread.CurrentCulture and CultureInfo.CurrentCulture properties. アルファベット文字の並べ替え順序にはかなりのバリエーションがあります (つまり、 Char.IsLetterプロパティが返すtrue文字は、カルチャによって異なります)。There is considerable variation in the sort order of alphabetic characters (that is, characters for which the Char.IsLetter property returns true) across cultures. CultureInfo などCompare(String, String, CultureInfo, CompareOptions)の文字列比較メソッドにオブジェクトを渡すことによって、特定のカルチャの規則を使用するカルチャに依存した比較を指定できます。You can specify a culture-sensitive comparison that uses the conventions of a specific culture by supplying a CultureInfo object to a string comparison method such as Compare(String, String, CultureInfo, CompareOptions). 現在のカルチャの規則を使用するカルチャに依存した比較を指定するにStringComparison.CurrentCulture CompareOptions.OrdinalStringComparison.CurrentCultureIgnoreCase CompareOptions.OrdinalIgnoreCase 、、、 CompareOptionsまたは以外の列挙体の任意のメンバーを適切なに指定します。Compareメソッドのオーバーロード。You can specify a culture-sensitive comparison that uses the conventions of the current culture by supplying StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase, or any member of the CompareOptions enumeration other than CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase to an appropriate overload of the Compare method. 通常、カルチャに依存した比較は並べ替えに適していますが、序数による比較は適切ではありません。A culture-sensitive comparison is generally appropriate for sorting whereas an ordinal comparison is not. 序数に基づく比較は、通常、2つの文字列が等しいかどうかを判断する (つまり、id を決定する) 場合に適していますが、カルチャに依存した比較は区別されません。An ordinal comparison is generally appropriate for determining whether two strings are equal (that is, for determining identity) whereas a culture-sensitive comparison is not.

次の例は、カルチャに依存した比較と序数による比較の違いを示しています。The following example illustrates the difference between culture-sensitive and ordinal comparison. この例では、3つの文字列 "Apple"、"Æble"、および "AEble" を評価します。これは、序数に基づく比較と、(各Compareメソッドが呼び出された時点での既定のカルチャである) da および en-us カルチャの規則を使用します。The example evaluates three strings, "Apple", "Æble", and "AEble", using ordinal comparison and the conventions of the da-DK and en-US cultures (each of which is the default culture at the time the Compare method is called). デンマーク語では文字 "Æ" が個々の文字として扱われ、アルファベットの "Z" の後に並べ替えられるため、"Æble" という文字列は "Apple" よりも大きくなります。Because the Danish language treats the character "Æ" as an individual letter and sorts it after "Z" in the alphabet, the string "Æble" is greater than "Apple". ただし、"Æble" は "AEble" と同等とは見なされないため、"Æble" は "AEble" よりも大きくなります。However, "Æble" is not considered equivalent to "AEble", so "Æble" is also greater than "AEble". En-us カルチャでは、文字 "Æ" は含まれませんが、"AE" と等価として扱われます。 "Æble" が "Apple" より小さく、"AEble" と等しい理由を説明します。The en-US culture doesn't include the letter"Æ" but treats it as equivalent to "AE", which explains why "Æble" is less than "Apple" but equal to "AEble". 一方、序数に基づく比較では、"Apple" は "Æble" より小さく、"Æble" は "AEble" よりも大きいと見なされます。Ordinal comparison, on the other hand, considers "Apple" to be less than "Æble", and "Æble" to be greater than "AEble".

using System;
using System.Globalization;
using System.Threading;

public class CompareStringSample
{
   public static void Main()
   {
      string str1 = "Apple";
      string str2 = "Æble"; 
      string str3 = "AEble";
      
      // Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));
      
      // Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));
      
      // Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison");
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal));
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       Current culture: da-DK
//       Comparison of Apple with Æble: -1
//       Comparison of Æble with AEble: 1
//       
//       Current culture: en-US
//       Comparison of Apple with Æble: 1
//       Comparison of Æble with AEble: 0
//       
//       Ordinal comparison
//       Comparison of Apple with Æble: -133
//       Comparison of Æble with AEble: 133
Imports System.Globalization
Imports System.Threading

Public Module Example
   Public Sub Main()
      Dim str1 As String = "Apple"
      Dim str2 As String = "Æble"
      Dim str3 As String = "AEble"
      
      ' Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, String.Compare(str2, str3))
      Console.WriteLine()
      
      ' Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, String.Compare(str2, str3))
      Console.WriteLine()
      
      ' Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison")
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal))
   End Sub
End Module
' The example displays the following output:
'       Current culture: da-DK
'       Comparison of Apple with Æble: -1
'       Comparison of Æble with AEble: 1
'       
'       Current culture: en-US
'       Comparison of Apple with Æble: 1
'       Comparison of Æble with AEble: 0
'       
'       Ordinal comparison
'       Comparison of Apple with Æble: -133
'       Comparison of Æble with AEble: 133

次の一般的なガイドラインを使用して、適切な並べ替えまたは文字列の比較方法を選択します。Use the following general guidelines to choose an appropriate sorting or string comparison method:

  • ユーザーのカルチャに基づいて文字列を並べ替えたい場合は、現在のカルチャの規則に基づいて文字列を並べ替える必要があります。If you want the strings to be ordered based on the user's culture, you should order them based on the conventions of the current culture. ユーザーのカルチャが変更された場合は、並べ替えられた文字列の順序も変わります。If the user's culture changes, the order of sorted strings will also change accordingly. たとえば、類義語辞典アプリケーションでは、ユーザーのカルチャに基づいて常に単語を並べ替える必要があります。For example, a thesaurus application should always sort words based on the user's culture.

  • 特定のカルチャの規則に基づいて文字列を並べ替える場合は、そのカルチャを表すCultureInfoオブジェクトを比較メソッドに渡すことによって、文字列の順序を指定する必要があります。If you want the strings to be ordered based on the conventions of a specific culture, you should order them by supplying a CultureInfo object that represents that culture to a comparison method. たとえば、特定の言語を学生に教えるように設計されたアプリケーションでは、その言語を話すカルチャのいずれかの規則に基づいて文字列を並べ替える必要があります。For example, in an application designed to teach students a particular language, you want strings to be ordered based on the conventions of one of the cultures that speaks that language.

  • カルチャ間で文字列の順序が変更されないようにするには、インバリアントカルチャの規則に基づいて文字列を並べ替えるか、序数に基づく比較を使用する必要があります。If you want the order of strings to remain unchanged across cultures, you should order them based on the conventions of the invariant culture or use an ordinal comparison. たとえば、序数の並べ替えを使用して、ファイル、プロセス、ミューテックス、または名前付きパイプの名前を整理します。For example, you would use an ordinal sort to organize the names of files, processes, mutexes, or named pipes.

  • セキュリティに関する決定 (ユーザー名が有効かどうかなど) に関する比較については、 Equalsメソッドのオーバーロードを呼び出すことによって、常に序数テストを実行する必要があります。For a comparison that involves a security decision (such as whether a username is valid), you should always perform an ordinal test for equality by calling an overload of the Equals method.

注意

文字列比較で使用されるカルチャに依存した並べ替えと大文字と小文字の区別の規則は、.NET のバージョンによって異なります。The culture-sensitive sorting and casing rules used in string comparison depend on the version of the .NET. Windows 8Windows 8オペレーティングシステムで実行されている .NET Framework 4.5 以降のバージョンでは、並べ替え、大文字と小文字の区別、正規化、および unicode 文字の情報が unicode 6.0 標準に準拠しています。In the .NET Framework 4.5 and later versions running on the Windows 8Windows 8 operating system, sorting, casing, normalization, and Unicode character information conforms to the Unicode 6.0 standard. その他の Windows オペレーティングシステムでは、Unicode 5.0 標準に準拠しています。On other Windows operating systems, it conforms to the Unicode 5.0 standard. .NET Core では、基になるオペレーティングシステムでサポートされている Unicode 標準のバージョンによって異なります。On .NET Core, it depends on the version of the Unicode Standard supported by the underlying operating system.

単語、文字列、および序数の並べ替え規則の詳細についてはSystem.Globalization.CompareOptions 、「」を参照してください。For more information about word, string, and ordinal sort rules, see the System.Globalization.CompareOptions topic. 各ルールを使用する場合のその他の推奨事項については、「文字列を使用するためのベストプラクティス」を参照してください。For additional recommendations on when to use each rule, see Best Practices for Using Strings.

通常、文字列の並べ替え順序を決定するためCompareになどの文字列比較メソッドを直接呼び出すことはありません。Ordinarily, you don't call string comparison methods such as Compare directly to determine the sort order of strings. 代わりに、またはArray.Sort List<T>.Sortなどの並べ替えメソッドによって、比較メソッドが呼び出されます。Instead, comparison methods are called by sorting methods such as Array.Sort or List<T>.Sort. 次の例では、文字列比較メソッドを明示的に呼び出すことなく、4つの異なる並べ替え操作 (現在のカルチャを使用した単語の並べ替え、インバリアントカルチャを使用した単語の並べ替え、インバリアントカルチャを使用した単語の並べ替え、インバリアントカルチャを使用した文字列の並べ替え) を実行します。ただし、使用する比較の種類を指定します。The following example performs four different sorting operations (word sort using the current culture, word sort using the invariant culture, ordinal sort, and string sort using the invariant culture) without explicitly calling a string comparison method, although they do specify the type of comparison to use. 各種類の並べ替えでは、配列内の文字列の一意の順序が生成されることに注意してください。Note that each type of sort produces a unique ordering of strings in its array.

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

// IComparer<String> implementation to perform string sort. 
ref class SCompare : System::Collections::Generic::IComparer<String^>
{
public:
   SCompare() {};

   virtual int Compare(String^ x, String^ y)
   {
      return CultureInfo::CurrentCulture->CompareInfo->Compare(x, y, CompareOptions::StringSort);
   }
};

void main()
{
   array<String^>^ strings = gcnew array<String^> { "coop", "co-op", "cooperative", 
                                                    L"co\x00ADoperative", L"c�ur", "coeur" };

   // Perform a word sort using the current (en-US) culture. 
   array<String^>^ current = gcnew array<String^>(strings->Length); 
   strings->CopyTo(current, 0); 
   Array::Sort(current, StringComparer::CurrentCulture);

   // Perform a word sort using the invariant culture. 
   array<String^>^ invariant = gcnew array<String^>(strings->Length);
   strings->CopyTo(invariant, 0); 
   Array::Sort(invariant, StringComparer::InvariantCulture);

   // Perform an ordinal sort. 
   array<String^>^ ordinal = gcnew array<String^>(strings->Length);
   strings->CopyTo(ordinal, 0); 
   Array::Sort(ordinal, StringComparer::Ordinal);

   // Perform a string sort using the current culture. 
   array<String^>^ stringSort = gcnew array<String^>(strings->Length);
   strings->CopyTo(stringSort, 0); 
   Array::Sort(stringSort, gcnew SCompare());

   // Display array values
   Console::WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                     "Original", "Word Sort", "Invariant Word", 
                     "Ordinal Sort", "String Sort");
   for (int ctr = 0; ctr < strings->Length; ctr++)
      Console::WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                         strings[ctr], current[ctr], invariant[ctr], 
                         ordinal[ctr], stringSort[ctr] );          
}
// The example displays the following output: 
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort 
//     
//             coop          c�ur            c�ur         co-op         co-op 
//            co-op         coeur           coeur         coeur          c�ur 
//      cooperative          coop            coop          coop         coeur 
//      co�operative         co-op           co-op   cooperative          coop 
//             c�ur   cooperative     cooperative   co�operative   cooperative 
//            coeur   co�operative     co�operative          c�ur   co�operative
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
 
public class Example
{
   public static void Main()
   {
      string[] strings = { "coop", "co-op", "cooperative", 
                           "co\u00ADoperative", "cœur", "coeur" };

      // Perform a word sort using the current (en-US) culture.
      string[] current = new string[strings.Length]; 
      strings.CopyTo(current, 0); 
      Array.Sort(current, StringComparer.CurrentCulture);

      // Perform a word sort using the invariant culture.
      string[] invariant = new string[strings.Length];
      strings.CopyTo(invariant, 0); 
      Array.Sort(invariant, StringComparer.InvariantCulture);

      // Perform an ordinal sort.
      string[] ordinal = new string[strings.Length];
      strings.CopyTo(ordinal, 0); 
      Array.Sort(ordinal, StringComparer.Ordinal);

      // Perform a string sort using the current culture.
      string[] stringSort = new string[strings.Length];
      strings.CopyTo(stringSort, 0); 
      Array.Sort(stringSort, new SCompare());

      // Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort");
      for (int ctr = 0; ctr < strings.Length; ctr++)
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings[ctr], current[ctr], invariant[ctr], 
                           ordinal[ctr], stringSort[ctr] );          
   }
}

// IComparer<String> implementation to perform string sort.
internal class SCompare : IComparer<String>
{
   public int Compare(string x, string y)
   {
      return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort);
   }
}
// The example displays the following output:
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
//    
//             coop          cœur            cœur         co-op         co-op
//            co-op         coeur           coeur         coeur          cœur
//      cooperative          coop            coop          coop         coeur
//     co­operative         co-op           co-op   cooperative          coop
//             cœur   cooperative     cooperative  co­operative   cooperative
//            coeur  co­operative    co­operative          cœur  co­operative
Imports System.Collections
Imports System.Collections.Generic
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim strings() As String = { "coop", "co-op", "cooperative", 
                                  "co" + ChrW(&h00AD) + "operative", 
                                  "cœur", "coeur" }

      ' Perform a word sort using the current (en-US) culture.
      Dim current(strings.Length - 1) As String  
      strings.CopyTo(current, 0) 
      Array.Sort(current, StringComparer.CurrentCulture)

      ' Perform a word sort using the invariant culture.
      Dim invariant(strings.Length - 1) As String
      strings.CopyTo(invariant, 0) 
      Array.Sort(invariant, StringComparer.InvariantCulture)

      ' Perform an ordinal sort.
      Dim ordinal(strings.Length - 1) As String
      strings.CopyTo(ordinal, 0) 
      Array.Sort(ordinal, StringComparer.Ordinal)

      ' Perform a string sort using the current culture.
      Dim stringSort(strings.Length - 1) As String
      strings.CopyTo(stringSort, 0) 
      Array.Sort(stringSort, new SCompare())

      ' Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort")
      Console.WriteLine()
                                                      
      For ctr As Integer = 0 To strings.Length - 1
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings(ctr), current(ctr), invariant(ctr), 
                           ordinal(ctr), stringSort(ctr))   
      Next                                  
   End Sub
End Module

' IComparer<String> implementation to perform string sort.
Friend Class SCompare : Implements IComparer(Of String)
   Public Function Compare(x As String, y As String) As Integer _
                   Implements IComparer(Of String).Compare
      Return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort)
   End Function
End Class
' The example displays the following output:
'         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
'    
'             coop          cœur            cœur         co-op         co-op
'            co-op         coeur           coeur         coeur          cœur
'      cooperative          coop            coop          coop         coeur
'     co­operative         co-op           co-op   cooperative          coop
'             cœur   cooperative     cooperative  co­operative   cooperative
'            coeur  co­operative    co­operative          cœur  co­operative

ヒント

内部的には、.NET は並べ替えキーを使用して、カルチャに依存した文字列の比較をサポートします。Internally, .NET uses sort keys to support culturally sensitive string comparison. 文字列内の各文字には、アルファベット順、大文字と小文字の区別、発音の区別など、さまざまなカテゴリの並べ替えウェイトが指定されます。Each character in a string is given several categories of sort weights, including alphabetic, case, and diacritic. SortKeyクラスによって表される並べ替えキーは、特定の文字列に対してこれらの重みのリポジトリを提供します。A sort key, represented by the SortKey class, provides a repository of these weights for a particular string. アプリが同じ文字列セットに対して多数の検索または並べ替え操作を実行する場合、使用するすべての文字列に対して並べ替えキーを生成して格納することで、パフォーマンスを向上させることができます。If your app performs a large number of searching or sorting operations on the same set of strings, you can improve its performance by generating and storing sort keys for all the strings that it uses. 並べ替えまたは比較操作が必要な場合は、文字列の代わりに並べ替えキーを使用します。When a sort or comparison operation is required, you use the sort keys instead of the strings. 詳細については、SortKey クラスを参照してください。For more information, see the SortKey class.

文字列比較規則を指定しない場合、などの並べ替えメソッドArray.Sort(Array)は、カルチャに依存し、大文字と小文字を区別する文字列の並べ替えを実行します。If you don't specify a string comparison convention, sorting methods such as Array.Sort(Array) perform a culture-sensitive, case-sensitive sort on strings. 次の例は、現在のカルチャを変更することによって、配列内の並べ替えられた文字列の順序に影響を与える方法を示しています。The following example illustrates how changing the current culture affects the order of sorted strings in an array. この例では、3つの文字列の配列を作成します。It creates an array of three strings. 最初に、System.Threading.Thread.CurrentThread.CurrentCulture プロパティを en-US に設定し、Array.Sort(Array) メソッドを呼び出します。First, it sets the System.Threading.Thread.CurrentThread.CurrentCulture property to en-US and calls the Array.Sort(Array) method. これよって、英語 (米国) カルチャの並べ替え規則に基づく並べ替え順序が適用されます。The resulting sort order is based on sorting conventions for the English (United States) culture. 次に、System.Threading.Thread.CurrentThread.CurrentCulture プロパティを da-DK に設定し、再度 Array.Sort メソッドを呼び出します。Next, the example sets the System.Threading.Thread.CurrentThread.CurrentCulture property to da-DK and calls the Array.Sort method again. 適用される並べ替え順序が en-US の並べ替え順序と異なる点に注意してください。これは、デンマーク語 (デンマーク) の並べ替え規則が使用されるためです。Notice how the resulting sort order differs from the en-US results because it uses the sorting conventions for Danish (Denmark).

using System;
using System.Globalization;
using System.Threading;

public class ArraySort 
{
   public static void Main(String[] args) 
   {
      // Create and initialize a new array to store the strings.
      string[] stringArray = { "Apple", "Æble", "Zebra"};

      // Display the values of the array.
      Console.WriteLine( "The original string array:");
      PrintIndexAndValues(stringArray);

      // Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      // Sort the values of the array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"en-US\":");
      PrintIndexAndValues(stringArray); 

      // Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      // Sort the values of the Array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"da-DK\":");
      PrintIndexAndValues(stringArray); 
   }
   public static void PrintIndexAndValues(string[] myArray)  
   {
      for (int i = myArray.GetLowerBound(0); i <= 
            myArray.GetUpperBound(0); i++ )
         Console.WriteLine("[{0}]: {1}", i, myArray[i]);
      Console.WriteLine();      
   }
}
// The example displays the following output:
//       The original string array:
//       [0]: Apple
//       [1]: Æble
//       [2]: Zebra
//       
//       After sorting for the "en-US" culture:
//       [0]: Æble
//       [1]: Apple
//       [2]: Zebra
//       
//       After sorting for the culture "da-DK":
//       [0]: Apple
//       [1]: Zebra
//       [2]: Æble
Imports System.Globalization
Imports System.IO
Imports System.Threading

Public Class TextToFile   
   Public Shared Sub Main()
      ' Creates and initializes a new array to store 
      ' these date/time objects.
      Dim stringArray() As String = { "Apple", "Æble", "Zebra"}
      
      ' Displays the values of the array.
      Console.WriteLine("The original string array:")
      PrintIndexAndValues(stringArray)
      
      ' Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
      ' Sort the values of the Array.
      Array.Sort(stringArray)
      
      ' Display the values of the array.
      Console.WriteLine("After sorting for the ""en-US"" culture:")
      PrintIndexAndValues(stringArray)
      
      ' Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
      ' Sort the values of the Array.
      Array.Sort(stringArray)
      
      ' Displays the values of the Array.
      Console.WriteLine("After sorting for the culture ""da-DK"":")
      PrintIndexAndValues(stringArray)
   End Sub

   Public Shared Sub PrintIndexAndValues(myArray() As String)
      For i As Integer = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
         Console.WriteLine("[{0}]: {1}", i, myArray(i))
      Next
      Console.WriteLine()
   End Sub 
End Class
' The example displays the following output:
'       The original string array:
'       [0]: Apple
'       [1]: Æble
'       [2]: Zebra
'       
'       After sorting for the "en-US" culture:
'       [0]: Æble
'       [1]: Apple
'       [2]: Zebra
'       
'       After sorting for the culture "da-DK":
'       [0]: Apple
'       [1]: Zebra
'       [2]: Æble

警告

文字列を比較する主な目的が等しいかどうかを判断するには、 String.Equalsメソッドを呼び出す必要があります。If your primary purpose in comparing strings is to determine whether they are equal, you should call the String.Equals method. 通常は、を使用Equalsして序数による比較を実行する必要があります。Typically, you should use Equals to perform an ordinal comparison. メソッドString.Compareは、主に文字列の並べ替えを目的としています。The String.Compare method is intended primarily to sort strings.

文字列検索メソッド ( String.StartsWithString.IndexOfなど) では、カルチャに依存した文字列の比較も実行できます。String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons. 次の例は、 IndexOfメソッドを使用した、序数とカルチャに依存した比較の違いを示しています。The following example illustrates the differences between ordinal and culture-sensitive comparisons using the IndexOf method. 現在のカルチャが英語 (米国) であるカルチャに依存した検索では、部分文字列 "oe" が合字 "する。" と一致すると見なされます。A culture-sensitive search in which the current culture is English (United States) considers the substring "oe" to match the ligature "œ". ソフトハイフン (U + 00ad) はゼロ幅の文字であるため、検索では、ソフトハイフンをEmptyと同等のものとして扱い、文字列の先頭で一致を検索します。Because a soft hyphen (U+00AD) is a zero-width character, the search treats the soft hyphen as equivalent to Empty and finds a match at the beginning of the string. 一方、序数検索では、どちらの場合も一致が見つかりません。An ordinal search, on the other hand, does not find a match in either case.

using namespace System;

void FindInString(String^ s, String^ substring, StringComparison options);

void main()
{
   // Search for "oe" and "�u" in "�ufs" and "oeufs".
   String^ s1 = L"�ufs";
   String^ s2 = L"oeufs";
   FindInString(s1, "oe", StringComparison::CurrentCulture);
   FindInString(s1, "oe", StringComparison::Ordinal);
   FindInString(s2, "�u", StringComparison::CurrentCulture);
   FindInString(s2, "�u", StringComparison::Ordinal);
   Console::WriteLine();

   String^ s3 = L"co\x00ADoperative";
   FindInString(s3, L"\x00AD", StringComparison::CurrentCulture);
   FindInString(s3, L"\x00AD", StringComparison::Ordinal);
}

void FindInString(String^ s, String^ substring, StringComparison options)
{
   int result = s->IndexOf(substring, options);
   if (result != -1)
      Console::WriteLine("'{0}' found in {1} at position {2}", 
                        substring, s, result);
   else
      Console::WriteLine("'{0}' not found in {1}", 
                        substring, s);                                                  
}
// The example displays the following output:
//      'oe' found in oufs at position 0
//      'oe' not found in oufs
//      'ou' found in oeufs at position 0
//      'ou' not found in oeufs
//
//      '-' found in co-operative at position 0
//      '-' found in co-operative at position 2
using System;

public class Example
{
   public static void Main()
   {
      // Search for "oe" and "œu" in "œufs" and "oeufs".
      string s1 = "œufs";
      string s2 = "oeufs";
      FindInString(s1, "oe", StringComparison.CurrentCulture);
      FindInString(s1, "oe", StringComparison.Ordinal);
      FindInString(s2, "œu", StringComparison.CurrentCulture);
      FindInString(s2, "œu", StringComparison.Ordinal);
      Console.WriteLine();
      
      string s3 = "co\u00ADoperative";
      FindInString(s3, "\u00AD", StringComparison.CurrentCulture);
      FindInString(s3, "\u00AD", StringComparison.Ordinal);
   }

   private static void FindInString(string s, string substring, StringComparison options)
   {
      int result = s.IndexOf(substring, options);
      if (result != -1)
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result);
      else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s);                                                  
   }
}
// The example displays the following output:
//       'oe' found in œufs at position 0
//       'oe' not found in œufs
//       'œu' found in oeufs at position 0
//       'œu' not found in oeufs
//       
//       '­' found in co­operative at position 0
//       '­' found in co­operative at position 2
Module Example
   Public Sub Main()
      ' Search for "oe" and "œu" in "œufs" and "oeufs".
      Dim s1 As String = "œufs"
      Dim s2 As String = "oeufs"
      FindInString(s1, "oe", StringComparison.CurrentCulture)
      FindInString(s1, "oe", StringComparison.Ordinal)
      FindInString(s2, "œu", StringComparison.CurrentCulture)
      FindInString(s2, "œu", StringComparison.Ordinal)
      Console.WriteLine()
      
      Dim softHyphen As String = ChrW(&h00AD)
      Dim s3 As String = "co" + softHyphen + "operative"
      FindInString(s3, softHyphen, StringComparison.CurrentCulture)
      FindInString(s3, softHyphen, StringComparison.Ordinal)
   End Sub

   Private Sub FindInString(s As String, substring As String, 
                            options As StringComparison)
      Dim result As Integer = s.IndexOf(substring, options)
      If result <> -1
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result)
      Else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s)
      End If                                                                          
   End Sub
End Module
' The example displays the following output:
'       'oe' found in œufs at position 0
'       'oe' not found in œufs
'       'œu' found in oeufs at position 0
'       'œu' not found in oeufs
'       
'       '­' found in co­operative at position 0
'       '­' found in co­operative at position 2

文字列の検索Searching Strings

文字列検索メソッド (やString.StartsWith String.IndexOfなど) では、カルチャに依存した文字列比較や序数の文字列比較を実行して、指定した文字列に文字または部分文字列が見つかったかどうかを判断することもできます。String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons to determine whether a character or substring is found in a specified string.

メソッドなどの個々のString文字IndexOfAnyを検索するクラスの検索メソッド、またはメソッドなどの文字セットのいずれかで、すべて序数検索が実行されます。 IndexOfThe search methods in the String class that search for an individual character, such as the IndexOf method, or one of a set of characters, such as the IndexOfAny method, all perform an ordinal search. 文字に対してCompareInfo CompareInfo.IndexOf(String, Char)カルチャに依存した検索を実行するには、やCompareInfo.LastIndexOf(String, Char)などのメソッドを呼び出す必要があります。To perform a culture-sensitive search for a character, you must call a CompareInfo method such as CompareInfo.IndexOf(String, Char) or CompareInfo.LastIndexOf(String, Char). 序数とカルチャに依存した比較を使用して文字を検索した結果は、大きく異なることに注意してください。Note that the results of searching for a character using ordinal and culture-sensitive comparison can be very different. たとえば、カルチャによっては、カルチャに応じて、"AE" (U + 041U + 0045) のように、構成済みの Unicode 文字 ("AE" (U + 041U +) など) を検索する場合は、カルチャによって異なります。For example, a search for a precomposed Unicode character such as the ligature "Æ" (U+00C6) might match any occurrence of its components in the correct sequence, such as "AE" (U+041U+0045), depending on the culture. 次の例は、個々の文字String.IndexOf(Char)CompareInfo.IndexOf(String, Char)検索するときのメソッドとメソッドの違いを示しています。The following example illustrates the difference between the String.IndexOf(Char) and CompareInfo.IndexOf(String, Char) methods when searching for an individual character. 文字列 "æ" (U + 00E6) は、en-us カルチャの規則を使用する場合は文字列 "航空写真" にありますが、-DK カルチャの規則を使用する場合や序数の比較を実行する場合には見つかりません。The ligature "æ" (U+00E6) is found in the string "aerial" when using the conventions of the en-US culture, but not when using the conventions of the da-DK culture or when performing an ordinal comparison.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "da-DK", "en-US" };
      CompareInfo ci;
      String str = "aerial";
      Char ch = 'æ';  // U+00E6
      
      Console.Write("Ordinal comparison -- ");
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch));
      
      foreach (var cultureName in cultureNames) {
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo;
         Console.Write("{0} cultural comparison -- ", cultureName);
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch));
      }
   }
}
// The example displays the following output:
//       Ordinal comparison -- Position of 'æ' in aerial: -1
//       da-DK cultural comparison -- Position of 'æ' in aerial: -1
//       en-US cultural comparison -- Position of 'æ' in aerial: 0
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "da-DK", "en-US" }
      Dim ci As CompareInfo
      Dim str As String = "aerial"
      Dim ch As Char = "æ"c  ' U+00E6
      
      Console.Write("Ordinal comparison -- ")
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch))
      
      For Each cultureName In cultureNames
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo
         Console.Write("{0} cultural comparison -- ", cultureName)
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch))
      Next
   End Sub
End Module
' The example displays the following output:
'       Ordinal comparison -- Position of 'æ' in aerial: -1
'       da-DK cultural comparison -- Position of 'æ' in aerial: -1
'       en-US cultural comparison -- Position of 'æ' in aerial: 0

一方、検索オプションがStringStringComparisonのパラメーターによって明示的に指定されていない場合、文字ではなく文字列を検索するクラスメソッドは、カルチャに依存した検索を実行します。On the other hand, String class methods that search for a string rather than a character perform a culture-sensitive search if search options are not explicitly specified by a parameter of type StringComparison. 唯一の例外はContainsで、序数検索を実行します。The sole exception is Contains, which performs an ordinal search.

等しいかどうかのテストTesting for equality

並べ替え順序String.Compareにおいて2つの文字列の関係を確認するには、メソッドを使用します。Use the String.Compare method to determine the relationship of two strings in the sort order. 通常、これはカルチャに依存する操作です。Typically, this is a culture-sensitive operation. これに対して、 String.Equalsメソッドを呼び出して、等しいかどうかをテストします。In contrast, call the String.Equals method to test for equality. 通常、等しいかどうかのテストでは、ユーザー入力と、有効なユーザー名、パスワード、またはファイルシステムパスなどの既知の文字列を比較します。これは通常、序数操作です。Because the test for equality usually compares user input with some known string, such as a valid user name, a password, or a file system path, it is typically an ordinal operation.

警告

String.Compareメソッドを呼び出し、戻り値が0かどうかを判断することで、等しいかどうかをテストできます。It is possible to test for equality by calling the String.Compare method and determining whether the return value is zero. ただし、この方法は推奨されません。However, this practice is not recommended. 2つの文字列が等しいかどうかを判断するには、 String.Equalsメソッドのオーバーロードのいずれかを呼び出す必要があります。To determine whether two strings are equal, you should call one of the overloads of the String.Equals method. どちらのメソッドにも、比較の種類Equals(String, StringComparison)を明示的にEquals(String, String, StringComparison)指定するSystem.StringComparisonパラメーターが含まれているので、呼び出すには、インスタンスメソッドまたは静的メソッドのいずれかを使用することをお勧めします。The preferred overload to call is either the instance Equals(String, StringComparison) method or the static Equals(String, String, StringComparison) method, because both methods include a System.StringComparison parameter that explicitly specifies the type of comparison.

次の例は、序数を使用する必要がある場合に、カルチャに依存した比較を実行する危険性を示しています。The following example illustrates the danger of performing a culture-sensitive comparison for equality when an ordinal one should be used instead. この場合、コードの目的は、"FILE://" という文字列の URL の先頭を大文字小文字を区別しない比較を実行することで、"FILE://" または "file://" で始まる Url からのファイルシステムアクセスを禁止することです。In this case, the intent of the code is to prohibit file system access from URLs that begin with "FILE://" or "file://" by performing a case-insensitive comparison of the beginning of a URL with the string "FILE://". ただし、カルチャに依存した比較が、"file://" で始まる URL でトルコ語 (トルコ) カルチャを使用して実行された場合、等値比較は失敗します。これは、小文字の "i" が "i" ではなく "i" であるためです。However, if a culture-sensitive comparison is performed using the Turkish (Turkey) culture on a URL that begins with "file://", the comparison for equality fails, because the Turkish uppercase equivalent of the lowercase "i" is "İ" instead of "I". その結果、ファイルシステムへのアクセスが誤って許可されます。As a result, file system access is inadvertently permitted. 一方、序数に基づく比較を実行すると、等値比較が成功し、ファイルシステムアクセスが拒否されます。On the other hand, if an ordinal comparison is performed, the comparison for equality succeeds, and file system access is denied.

using namespace System;
using namespace System::Globalization;
using namespace System::Threading;

bool TestForEquality(String^ str, StringComparison cmp);

void main()
{
   Thread::CurrentThread->CurrentCulture = CultureInfo::CreateSpecificCulture("tr-TR");      

   String^ filePath = "file://c:/notes.txt";

   Console::WriteLine("Culture-sensitive test for equality:");
   if (! TestForEquality(filePath, StringComparison::CurrentCultureIgnoreCase))
      Console::WriteLine("Access to {0} is allowed.", filePath);
   else
      Console::WriteLine("Access to {0} is not allowed.", filePath);

   Console::WriteLine("\nOrdinal test for equality:");
   if (! TestForEquality(filePath, StringComparison::OrdinalIgnoreCase))
      Console::WriteLine("Access to {0} is allowed.", filePath);
   else
      Console::WriteLine("Access to {0} is not allowed.", filePath);
}

bool TestForEquality(String^ str, StringComparison cmp)
{
      int position = str->IndexOf("://");
      if (position < 0) return false;

      String^ substring = str->Substring(0, position);  
      return substring->Equals("FILE", cmp);
}
// The example displays the following output: 
//       Culture-sensitive test for equality: 
//       Access to file://c:/notes.txt is allowed. 
//        
//       Ordinal test for equality: 
//       Access to file://c:/notes.txt is not allowed.
using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR");      

      string filePath = "file://c:/notes.txt";
      
      Console.WriteLine("Culture-sensitive test for equality:");
      if (! TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
      
      Console.WriteLine("\nOrdinal test for equality:");
      if (! TestForEquality(filePath, StringComparison.OrdinalIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
   }

   private static bool TestForEquality(string str, StringComparison cmp)
   {
      int position = str.IndexOf("://");
      if (position < 0) return false;

      string substring = str.Substring(0, position);  
      return substring.Equals("FILE", cmp);
   }
}
// The example displays the following output:
//       Culture-sensitive test for equality:
//       Access to file://c:/notes.txt is allowed.
//       
//       Ordinal test for equality:
//       Access to file://c:/notes.txt is not allowed.
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR")      

      Dim filePath As String = "file://c:/notes.txt"
      
      Console.WriteLine("Culture-sensitive test for equality:")
      If Not TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase) Then
         Console.WriteLine("Access to {0} is allowed.", filePath)
      Else
         Console.WriteLine("Access to {0} is not allowed.", filePath)
      End If       
      Console.WriteLine()
      
      Console.WriteLine("Ordinal test for equality:")
      If Not TestForEquality(filePath, StringComparison.OrdinalIgnoreCase) Then
         Console.WriteLine("Access to {0} is allowed.", filePath)
      Else
         Console.WriteLine("Access to {0} is not allowed.", filePath)
      End If       
   End Sub
   
   Private Function TestForEquality(str As String, cmp As StringComparison) As Boolean
      Dim position As Integer = str.IndexOf("://")
      If position < 0 Then Return False

      Dim substring As String = str.Substring(0, position)  
      Return substring.Equals("FILE", cmp)
   End Function
End Module
' The example displays the following output:
'       Culture-sensitive test for equality:
'       Access to file://c:/notes.txt is allowed.
'       
'       Ordinal test for equality:
'       Access to file://c:/notes.txt is not allowed.

正規化Normalization

Unicode 文字には複数の表現があります。Some Unicode characters have multiple representations. たとえば、次のコードポイントは、"ắ" という文字を表すことができます。For example, any of the following code points can represent the letter "ắ":

  • U+1EAFU+1EAF

  • U + 0103 U + 0301U+0103 U+0301

  • U + 0061 U + 0306 U + 0301U+0061 U+0306 U+0301

1つの文字に対して複数の表現を使用すると、検索、並べ替え、照合、およびその他の文字列操作が複雑になります。Multiple representations for a single character complicate searching, sorting, matching, and other string operations.

Unicode 規格では、同等のバイナリ表現に対して Unicode 文字の1つのバイナリ表現を返す正規化と呼ばれるプロセスが定義されています。The Unicode standard defines a process called normalization that returns one binary representation of a Unicode character for any of its equivalent binary representations. 正規化では、さまざまなルールに従って、正規化形式と呼ばれる複数のアルゴリズムを使用できます。Normalization can use several algorithms, called normalization forms, that follow different rules. .NET では、Unicode 正規形 C、D、KC、および KD がサポートされています。.NET supports Unicode normalization forms C, D, KC, and KD. 文字列が同じ正規化形式に正規化されている場合は、序数による比較を使用して比較できます。When strings have been normalized to the same normalization form, they can be compared by using ordinal comparison.

序数による比較は、各文字列の対応するCharオブジェクトの Unicode スカラー値のバイナリ比較です。An ordinal comparison is a binary comparison of the Unicode scalar value of corresponding Char objects in each string. クラスStringには、次のような序数による比較を実行できるさまざまなメソッドが含まれています。The String class includes a number of methods that can perform an ordinal comparison, including the following:

String.IsNormalized()メソッドを呼び出すことによって文字列が正規形 C に正規化されるかどうかを判断String.IsNormalized(NormalizationForm)できます。また、メソッドを呼び出して、文字列が指定した正規化形式に正規化されているかどうかを判断することもできます。You can determine whether a string is normalized to normalization form C by calling the String.IsNormalized() method, or you can call the String.IsNormalized(NormalizationForm) method to determine whether a string is normalized to a specified normalization form. メソッドを呼び出してString.Normalize()文字列を正規形 C に変換することもできます。また、メソッドを呼び出してString.Normalize(NormalizationForm) 、文字列を指定した正規化形式に変換することもできます。You can also call the String.Normalize() method to convert a string to normalization form C, or you can call the String.Normalize(NormalizationForm) method to convert a string to a specified normalization form. 文字列の正規化と比較の詳細な手順については、メソッドNormalize()Normalize(NormalizationForm)メソッドを参照してください。For step-by-step information about normalizing and comparing strings, see the Normalize() and Normalize(NormalizationForm) methods.

次の簡単な例は、文字列の正規化を示しています。The following simple example illustrates string normalization. この例では、3つの異なる文字列の3つの異なる方法で文字 "ố" を定義し、等値比較を使用して、各文字列が他の2つの文字列と異なることを判断します。It defines the letter "ố" in three different ways in three different strings, and uses an ordinal comparison for equality to determine that each string differs from the other two strings. 次に、各文字列をサポートされている正規化形式に変換し、指定された正規化形式で各文字列の序数による比較を実行します。It then converts each string to the supported normalization forms, and again performs an ordinal comparison of each string in a specified normalization form. どちらの場合も、2番目の等しいテストでは、文字列が等しいことが示されます。In each case, the second test for equality shows that the strings are equal.

using namespace System;
using namespace System::Globalization;
using namespace System::IO;
using namespace System::Text;

public ref class Example
{
private:
   StreamWriter^ sw;

   void TestForEquality(... array<String^>^  words)
   {
      for (int ctr = 0; ctr <= words->Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words->Length - 1; ctr2++) 
            sw->WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr]->Equals(words[ctr2], StringComparison::Ordinal));
   }

   String^ ShowBytes(String^ str)
   {
      String^ result = nullptr;
      for each (Char ch in str)
         result += String::Format("{0} ", Convert::ToUInt16(ch).ToString("X4")); 
      return result->Trim();            
   } 

   array<String^>^ NormalizeStrings(NormalizationForm nf, ... array<String^>^ words)
   {
      for (int ctr = 0; ctr < words->Length; ctr++)
         if (! words[ctr]->IsNormalized(nf))
            words[ctr] = words[ctr]->Normalize(nf); 
      return words;   
   }

public: 
   void Execute()
   {
      sw = gcnew StreamWriter(".\\TestNorm1.txt");

      // Define three versions of the same word.  
      String^ s1 = L"sống";        // create word with U+1ED1 
      String^ s2 = L"s\x00F4\x0301ng";
      String^ s3 = L"so\x0302\x0301ng";

      TestForEquality(s1, s2, s3);      
      sw->WriteLine();

      // Normalize and compare strings using each normalization form. 
      for each (String^ formName in Enum::GetNames(NormalizationForm::typeid))
      {
         sw->WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum::Parse(NormalizationForm::typeid, formName);
         array<String^>^ sn = NormalizeStrings(nf, s1, s2, s3 );
         TestForEquality(sn);           
         sw->WriteLine("\n");                                        
      }

      sw->Close(); 
   }
};

void main()
{
   Example^ ex = gcnew Example();
   ex->Execute();
}
// The example produces the following output:
// The example displays the following output: 
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False 
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False 
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False 
//        
//       Normalization FormC: 
//        
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//        
//        
//       Normalization FormD: 
//        
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//        
//        
//       Normalization FormKC: 
//        
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//        
//        
//       Normalization FormKD: 
//        
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
using System;
using System.Globalization;
using System.IO;
using System.Text;

public class Example
{
   private static StreamWriter sw;
   
   public static void Main()
   {
      sw = new StreamWriter(@".\TestNorm1.txt");

      // Define three versions of the same word. 
      string s1 = "sống";        // create word with U+1ED1
      string s2 = "s\u00F4\u0301ng";
      string s3 = "so\u0302\u0301ng";

      TestForEquality(s1, s2, s3);      
      sw.WriteLine();

      // Normalize and compare strings using each normalization form.
      foreach (string formName in Enum.GetNames(typeof(NormalizationForm)))
      {
         sw.WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum.Parse(typeof(NormalizationForm), formName);
         string[] sn = NormalizeStrings(nf, s1, s2, s3);
         TestForEquality(sn);           
         sw.WriteLine("\n");                                        
      }
      
      sw.Close();   
   }

   private static void TestForEquality(params string[] words)
   {
      for (int ctr = 0; ctr <= words.Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words.Length - 1; ctr2++) 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr].Equals(words[ctr2], StringComparison.Ordinal));
   }

   private static string ShowBytes(string str)
   {
      string result = null;
      foreach (var ch in str)
         result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4")); 
      return result.Trim();            
   } 
   
   private static string[] NormalizeStrings(NormalizationForm nf, params string[] words)
   {
      for (int ctr = 0; ctr < words.Length; ctr++)
         if (! words[ctr].IsNormalized(nf))
            words[ctr] = words[ctr].Normalize(nf); 
      return words;   
   }
}
// The example displays the following output:
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       
//       Normalization FormC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       
//       
//       Normalization FormKC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormKD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
Imports System.Globalization
Imports System.IO
Imports System.Text

Module Example
   Private sw As StreamWriter
       
   Public Sub Main()
      sw = New StreamWriter(".\TestNorm1.txt")

      ' Define three versions of the same word. 
      Dim s1 As String = "sống"        ' create word with U+1ED1
      Dim s2 AS String = "s" + ChrW(&h00F4) + ChrW(&h0301) + "ng"
      Dim s3 As String = "so" + ChrW(&h0302) + ChrW(&h0301) + "ng"

      TestForEquality(s1, s2, s3)      
      sw.WriteLine()

      ' Normalize and compare strings using each normalization form.
      For Each formName In [Enum].GetNames(GetType(NormalizationForm))
         sw.WriteLine("Normalization {0}:", formName) 
         Dim nf As NormalizationForm = CType([Enum].Parse(GetType(NormalizationForm), formName),  
                                             NormalizationForm)
         Dim sn() As String = NormalizeStrings(nf, s1, s2, s3)
         TestForEquality(sn)           
         sw.WriteLine(vbCrLf)                                        
      Next
      
      sw.Close()   
   End Sub

   Private Sub TestForEquality(ParamArray words As String())
      For ctr As Integer = 0 To words.Length - 2
         For ctr2 As Integer = ctr + 1 To words.Length - 1 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words(ctr), ShowBytes(words(ctr)),
                         words(ctr2), ShowBytes(words(ctr2)),
                         words(ctr).Equals(words(ctr2), StringComparison.Ordinal))
         Next                
      Next   
   End Sub

   Private Function ShowBytes(str As String) As String
      Dim result As String = Nothing
      For Each ch In str
         result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4")) 
      Next
      Return result.Trim()            
   End Function  
   
   Private Function NormalizeStrings(nf As NormalizationForm, ParamArray words() As String) As String()
      For ctr As Integer = 0 To words.Length - 1
         If Not words(ctr).IsNormalized(nf) Then
            words(ctr) = words(ctr).Normalize(nf)
         End If    
      Next
      Return words   
   End Function
End Module
' The example displays the following output:
'       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
'       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
'       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
'       
'       Normalization FormC:
'       
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       
'       
'       Normalization FormD:
'       
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       
'       
'       Normalization FormKC:
'       
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       
'       
'       Normalization FormKD:
'       
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True

正規化および正規化形式の詳細についてはSystem.Text.NormalizationForm、「」 および「Unicode 標準の付属品 #15」を参照してください。Unicode.org web サイトでの Unicode 正規形と正規化に関するFAQFor more information about normalization and normalization forms, see System.Text.NormalizationForm, as well as Unicode Standard Annex #15: Unicode Normalization Forms and the Normalization FAQ on the unicode.org website.

カテゴリ別の文字列操作String operations by category

クラスStringは、文字列の比較、文字列の等価性のテスト、文字列内の文字または部分文字列の検索、文字列の変更、文字列の文字列の抽出、文字列の結合、値の書式設定、文字列のコピーを行うためのメンバーを提供します。文字列を正規化する。The String class provides members for comparing strings, testing strings for equality, finding characters or substrings in a string, modifying a string, extracting substrings from a string, combining strings, formatting values, copying a string, and normalizing a string.

文字列の比較Comparing strings

Stringのメソッドを使用すると、文字列を比較して、並べ替え順序における相対的な位置を決定できます。You can compare strings to determine their relative position in the sort order by using the following String methods:

  • Compare並べ替え順序において、1つの文字列と2番目の文字列の関係を示す整数を返します。Compare returns an integer that indicates the relationship of one string to a second string in the sort order.

  • CompareOrdinalコードポイントの比較に基づいて、1つの文字列と2番目の文字列との関係を示す整数を返します。CompareOrdinal returns an integer that indicates the relationship of one string to a second string based on a comparison of their code points.

  • CompareTo並べ替え順序において、現在の文字列インスタンスと2番目の文字列との関係を示す整数を返します。CompareTo returns an integer that indicates the relationship of the current string instance to a second string in the sort order. メソッドCompareTo(String)IComparable<T> 、クラスStringIComparableとの実装を提供します。The CompareTo(String) method provides the IComparable and IComparable<T> implementations for the String class.

文字列の等価性をテストするTesting strings for equality

2つのEquals文字列が等しいかどうかを判断するには、メソッドを呼び出します。You call the Equals method to determine whether two strings are equal. インスタンスEquals(String, String, StringComparison)と静的Equals(String, StringComparison)オーバーロードを使用すると、比較対象がカルチャに依存するか、序数であるか、また、大文字と小文字を区別するか無視するかを指定できます。The instance Equals(String, String, StringComparison) and the static Equals(String, StringComparison) overloads let you specify whether the comparison is culture-sensitive or ordinal, and whether case is considered or ignored. 等しいかどうかのテストは序数で、システムリソースへのアクセスを決定する等価比較 (ファイルシステムオブジェクトなど) は常に序数である必要があります。Most tests for equality are ordinal, and comparisons for equality that determine access to a system resource (such as a file system object) should always be ordinal.

文字列内の文字の検索Finding characters in a string

クラスStringには、次の2種類の検索メソッドが含まれています。The String class includes two kinds of search methods:

  • 特定の部分文字列Booleanが文字列インスタンス内に存在するかどうかを示す値を返すメソッド。Methods that return a Boolean value to indicate whether a particular substring is present in a string instance. これにはContainsEndsWith、、 StartsWithおよびの各メソッドが含まれます。These include the Contains, EndsWith, and StartsWith methods.

  • 文字列インスタンス内の部分文字列の開始位置を示すメソッド。Methods that indicate the starting position of a substring in a string instance. これにはIndexOf IndexOfAny LastIndexOfAny 、、、、およびの各メソッドが含まれます。 LastIndexOfThese include the IndexOf, IndexOfAny, LastIndexOf, and LastIndexOfAny methods.

警告

特定の部分文字列ではなく特定のパターンの文字列を検索する場合は、正規表現を使用する必要があります。If you want to search a string for a particular pattern rather than a specific substring, you should use regular expressions. 詳細については、「 .net の正規表現」を参照してください。For more information, see .NET Regular Expressions.

文字列の変更Modifying a string

クラスStringには、文字列の値を変更するために表示される次のメソッドが含まれています。The String class includes the following methods that appear to modify the value of a string:

  • Insert現在Stringのインスタンスに文字列を挿入します。Insert inserts a string into the current String instance.

  • PadLeft文字列の先頭に指定された文字を1回以上挿入します。PadLeft inserts one or more occurrences of a specified character at the beginning of a string.

  • PadRight文字列の末尾に、指定した文字を1回以上挿入します。PadRight inserts one or more occurrences of a specified character at the end of a string.

  • Remove現在Stringのインスタンスから部分文字列を削除します。Remove deletes a substring from the current String instance.

  • Replace部分文字列を現在Stringのインスタンス内の別の部分文字列に置き換えます。Replace replaces a substring with another substring in the current String instance.

  • ToLower文字列ToLowerInvariant内のすべての文字を小文字に変換します。ToLower and ToLowerInvariant convert all the characters in a string to lowercase.

  • ToUpper文字列ToUpperInvariant内のすべての文字を大文字に変換します。ToUpper and ToUpperInvariant convert all the characters in a string to uppercase.

  • Trim文字列の先頭と末尾から、出現するすべての文字を削除します。Trim removes all occurrences of a character from the beginning and end of a string.

  • TrimEnd文字列の末尾から、出現するすべての文字を削除します。TrimEnd removes all occurrences of a character from the end of a string.

  • TrimStart文字列の先頭から、出現するすべての文字を削除します。TrimStart removes all occurrences of a character from the beginning of a string.

重要

すべての文字列変更メソッドは、 String新しいオブジェクトを返します。All string modification methods return a new String object. 現在のインスタンスの値は変更されません。They don't modify the value of the current instance.

文字列からの部分文字列の抽出Extracting substrings from a string

メソッドString.Splitは、1つの文字列を複数の文字列に分割します。The String.Split method separates a single string into multiple strings. メソッドのオーバーロードを使用すると、複数の区切り記号を指定して、メソッドによって抽出される部分文字列の最大数を決定し、空の文字列 (区切り記号が隣接している場合に発生する) が返される文字列に含まれるかどうかを判断できます。Overloads of the method allow you to specify multiple delimiters, to determine the maximum number of substrings that the method extracts, and to determine whether empty strings (which occur when delimiters are adjacent) are included among the returned strings.

結合 (文字列を)Combining strings

文字列のString連結には、次のメソッドを使用できます。The following String methods can be used for string concatenation:

  • Concat1つ以上の部分文字列を1つの文字列に結合します。Concat combines one or more substrings into a single string.

  • Join1つ以上の部分文字列を連結して1つの要素にし、各部分文字列の間に区切り記号を追加します。Join concatenates one or more substrings into a single element and adds a separator between each substring.

値の書式設定Formatting values

メソッドString.Formatは、複合書式指定機能を使用して、文字列内の1つまたは複数のプレースホルダーを、いくつかのオブジェクトまたは値の文字列形式に置き換えます。The String.Format method uses the composite formatting feature to replace one or more placeholders in a string with the string representation of some object or value. Formatメソッドは、多くの場合、次の操作を行うために使用されます。The Format method is often used to do the following:

  • 数値の文字列形式を文字列に埋め込む場合は。To embed the string representation of a numeric value in a string.

  • 日付と時刻の値の文字列形式を文字列に埋め込む場合は。To embed the string representation of a date and time value in a string.

  • 列挙値の文字列形式を文字列に埋め込む場合は。To embed the string representation of an enumeration value in a string.

  • IFormattableインターフェイスをサポートするオブジェクトの文字列形式を文字列に埋め込む場合は。To embed the string representation of some object that supports the IFormattable interface in a string.

  • より大きな文字列内のフィールド内の部分文字列を右揃えまたは左揃えにする場合は。To right-justify or left-justify a substring in a field within a larger string.

書式設定操作と例の詳細についてはFormat 、「オーバーロードの概要」を参照してください。For detailed information about formatting operations and examples, see the Format overload summary.

文字列のコピーCopying a string

文字列のコピーを作成Stringするには、次のメソッドを呼び出します。You can call the following String methods to make a copy of a string:

  • Clone既存Stringのオブジェクトへの参照を返します。Clone returns a reference to an existing String object.

  • Copy既存の文字列のコピーを作成します。Copy creates a copy of an existing string.

  • CopyTo文字列の一部を文字配列にコピーします。CopyTo copies a portion of a string to a character array.

文字列の正規化Normalizing a string

Unicode では、1つの文字に複数のコードポイントを含めることができます。In Unicode, a single character can have multiple code points. 正規化では、これらの同等の文字が同じバイナリ表現に変換されます。Normalization converts these equivalent characters into the same binary representation. メソッドString.Normalizeは正規化を実行し、メソッドString.IsNormalizedは文字列が正規化されているかどうかを判断します。The String.Normalize method performs the normalization, and the String.IsNormalized method determines whether a string is normalized.

詳細と例については、このトピックで前述した「正規化」セクションを参照してください。For more information and an example, see the Normalization section earlier in this topic.

コンストラクター

String(Char*) String(Char*) String(Char*) String(Char*)

String クラスの新しいインスタンスを初期化し、指定した Unicode 文字配列を指すポインターにより示される値に設定します。Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters.

String(Char*, Int32, Int32) String(Char*, Int32, Int32) String(Char*, Int32, Int32) String(Char*, Int32, Int32)

String クラスの新しいインスタンスを初期化し、Unicode 文字の配列を指す指定のポインター、配列内の開始文字位置、および長さにより示される値に設定します。Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters, a starting character position within that array, and a length.

String(Char, Int32) String(Char, Int32) String(Char, Int32) String(Char, Int32)

String クラスの新しいインスタンスを初期化し、指定した回数だけ繰り返した指定の Unicode 文字が示す値に設定します。Initializes a new instance of the String class to the value indicated by a specified Unicode character repeated a specified number of times.

String(Char[]) String(Char[]) String(Char[]) String(Char[])

String クラスの新しいインスタンスを初期化し、Unicode 文字の配列により示される値に設定します。Initializes a new instance of the String class to the value indicated by an array of Unicode characters.

String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32)

String クラスの新しいインスタンスを初期化し、Unicode 文字の配列、配列内の開始文字位置、および長さにより示される値に設定します。Initializes a new instance of the String class to the value indicated by an array of Unicode characters, a starting character position within that array, and a length.

String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>)
String(SByte*) String(SByte*) String(SByte*) String(SByte*)

String クラスの新しいインスタンスを初期化し、8 ビット符号付き整数の配列を指すポインターにより示される値に設定します。Initializes a new instance of the String class to the value indicated by a pointer to an array of 8-bit signed integers.

String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32)

String クラスの新しいインスタンスを初期化し、8 ビット符号付き整数の配列を指す指定のポインター、配列内の開始位置、および長さにより示される値に設定します。Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, and a length.

String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding)

String クラスの新しいインスタンスを初期化し、8 ビット符号付き整数の配列を指す指定のポインター、配列内の開始位置、長さ、および Encoding オブジェクトにより示される値に設定します。Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an Encoding object.

フィールド

Empty Empty Empty Empty

空の文字列を表します。Represents the empty string. このフィールドは読み取り専用です。This field is read-only.

プロパティ

Chars[Index] Chars[Index] Chars[Index] Chars[Index]
Chars[Int32] Chars[Int32] Chars[Int32] Chars[Int32]

現在の String オブジェクト内の指定された位置にある Char オブジェクトを取得します。Gets the Char object at a specified position in the current String object.

Chars[Range] Chars[Range] Chars[Range] Chars[Range]
Length Length Length Length

現在の String オブジェクト内の文字数を取得します。Gets the number of characters in the current String object.

メソッド

Clone() Clone() Clone() Clone()

この Stringインスタンスへの参照を返します。Returns a reference to this instance of String.

Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32)

指定した 2 つの String オブジェクトの部分文字列を比較し、それらの相対位置を並べ替え順序で示す整数を返します。Compares substrings of two specified String objects and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean)

指定した 2 つの String オブジェクトの部分文字列を比較し、並べ替え順序におけるそれらの相対位置を示す整数を返します。比較時に、大文字と小文字を区別するかどうかを設定できます。Compares substrings of two specified String objects, ignoring or honoring their case, and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)

指定した 2 つの String オブジェクトの部分文字列を比較し、並べ替え順序におけるそれらの相対位置を示す整数を返します。比較時に、大文字と小文字を区別するかどうかを指定し、比較に影響を及ぼすカルチャ固有の情報を使用します。Compares substrings of two specified String objects, ignoring or honoring their case and using culture-specific information to influence the comparison, and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)

指定した 2 つの String オブジェクトの部分文字列を比較し、2 つの部分文字列の互いのリレーションシップを並べ替え順序で示す整数を返します。比較時に、指定した比較オプションと、比較に影響を及ぼすカルチャ固有の情報を使用します。Compares substrings of two specified String objects using the specified comparison options and culture-specific information to influence the comparison, and returns an integer that indicates the relationship of the two substrings to each other in the sort order.

Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison)

指定した規則を使用して、指定した 2 つの String オブジェクトの部分文字列を比較し、並べ替え順序におけるそれらの相対位置を示す整数を返します。Compares substrings of two specified String objects using the specified rules, and returns an integer that indicates their relative position in the sort order.

Compare(String, String) Compare(String, String) Compare(String, String) Compare(String, String)

指定した 2 つの String オブジェクトを比較し、それらの相対位置を並べ替え順序で示す整数を返します。Compares two specified String objects and returns an integer that indicates their relative position in the sort order.

Compare(String, String, Boolean) Compare(String, String, Boolean) Compare(String, String, Boolean) Compare(String, String, Boolean)

指定した 2 つの String オブジェクトを比較し、並べ替え順序におけるそれらの相対位置を示す整数を返します。比較時に、大文字と小文字を区別するかどうかを設定できます。Compares two specified String objects, ignoring or honoring their case, and returns an integer that indicates their relative position in the sort order.

Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo)

指定した 2 つの String オブジェクトを比較し、並べ替え順序におけるそれらの相対位置を示す整数を返します。比較時に、大文字と小文字を区別するかどうかを指定し、比較に影響を及ぼすカルチャ固有の情報を使用します。Compares two specified String objects, ignoring or honoring their case, and using culture-specific information to influence the comparison, and returns an integer that indicates their relative position in the sort order.

Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions)

指定した 2 つの String オブジェクトを比較し、2 つの文字列の互いのリレーションシップを並べ替え順序で示す整数を返します。比較時に、指定した比較オプションと、比較に影響を及ぼすカルチャ固有の情報を使用します。Compares two specified String objects using the specified comparison options and culture-specific information to influence the comparison, and returns an integer that indicates the relationship of the two strings to each other in the sort order.

Compare(String, String, StringComparison) Compare(String, String, StringComparison) Compare(String, String, StringComparison) Compare(String, String, StringComparison)

指定した規則を使用して、指定した 2 つの String オブジェクトを比較し、並べ替え順序におけるそれらの相対位置を示す整数を返します。Compares two specified String objects using the specified rules, and returns an integer that indicates their relative position in the sort order.

CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32)

それぞれの部分文字列の対応する Char オブジェクトの数値を評価することにより、指定した 2 つの String オブジェクトの部分文字列を比較します。Compares substrings of two specified String objects by evaluating the numeric values of the corresponding Char objects in each substring.

CompareOrdinal(String, String) CompareOrdinal(String, String) CompareOrdinal(String, String) CompareOrdinal(String, String)

それぞれの文字列の対応する String オブジェクトの数値を評価することで、指定した 2 つの Char を比較します。Compares two specified String objects by evaluating the numeric values of the corresponding Char objects in each string.

CompareTo(Object) CompareTo(Object) CompareTo(Object) CompareTo(Object)

このインスタンスと指定した Object とを比較し、並べ替え順序において、このインスタンスの位置が指定した Object の前、後ろ、または同じのいずれであるかを示します。Compares this instance with a specified Object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified Object.

CompareTo(String) CompareTo(String) CompareTo(String) CompareTo(String)

このインスタンスと指定した String オブジェクトとを比較し、並べ替え順序において、このインスタンスの位置が指定した文字列の前、後ろ、または同じのいずれであるかを示します。Compares this instance with a specified String object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified string.

Concat(IEnumerable<String>) Concat(IEnumerable<String>) Concat(IEnumerable<String>) Concat(IEnumerable<String>)

IEnumerable<T> 型の構築された String コレクションのメンバーを連結します。Concatenates the members of a constructed IEnumerable<T> collection of type String.

Concat(Object) Concat(Object) Concat(Object) Concat(Object)

指定されたオブジェクトの文字列形式を作成します。Creates the string representation of a specified object.

Concat(Object, Object) Concat(Object, Object) Concat(Object, Object) Concat(Object, Object)

指定した 2 つのオブジェクトの文字列形式を連結します。Concatenates the string representations of two specified objects.

Concat(Object, Object, Object) Concat(Object, Object, Object) Concat(Object, Object, Object) Concat(Object, Object, Object)

指定した 3 つのオブジェクトの文字列形式を連結します。Concatenates the string representations of three specified objects.

Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object)

4 つの指定したオブジェクトと、オプションの可変長パラメーター リストで指定した任意のオブジェクトの文字列表現を連結します。Concatenates the string representations of four specified objects and any objects specified in an optional variable length parameter list.

Concat(Object[]) Concat(Object[]) Concat(Object[]) Concat(Object[])

指定された Object 配列の要素の文字列表記を連結します。Concatenates the string representations of the elements in a specified Object array.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

2 つの指定された読み取り専用文字スパンの文字列形式を連結します。Concatenates the string representations of two specified read-only character spans.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

3 つの指定された読み取り専用文字スパンの文字列形式を連結します。Concatenates the string representations of three specified read-only character spans.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

4 つの指定された読み取り専用文字スパンの文字列形式を連結します。Concatenates the string representations of four specified read-only character spans.

Concat(String, String) Concat(String, String) Concat(String, String) Concat(String, String)

指定した 2 つの String インスタンスを連結します。Concatenates two specified instances of String.

Concat(String, String, String) Concat(String, String, String) Concat(String, String, String) Concat(String, String, String)

String の指定した 3 つのインスタンスを連結します。Concatenates three specified instances of String.

Concat(String, String, String, String) Concat(String, String, String, String) Concat(String, String, String, String) Concat(String, String, String, String)

指定した 4 つの String インスタンスを連結します。Concatenates four specified instances of String.

Concat(String[]) Concat(String[]) Concat(String[]) Concat(String[])

指定した String 配列の要素を連結します。Concatenates the elements of a specified String array.

Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>)

IEnumerable<T> 実装のメンバーを連結します。Concatenates the members of an IEnumerable<T> implementation.

Contains(Char) Contains(Char) Contains(Char) Contains(Char)

指定した文字がこの文字列内に存在するかどうかを示す値を返します。Returns a value indicating whether a specified character occurs within this string.

Contains(Char, StringComparison) Contains(Char, StringComparison) Contains(Char, StringComparison) Contains(Char, StringComparison)

指定された比較規則を使用して、指定された文字がこの文字列内に含まれるかどうかを示す値を返します。Returns a value indicating whether a specified character occurs within this string, using the specified comparison rules.

Contains(String) Contains(String) Contains(String) Contains(String)

指定した部分文字列がこの文字列内に存在するかどうかを示す値を返します。Returns a value indicating whether a specified substring occurs within this string.

Contains(String, StringComparison) Contains(String, StringComparison) Contains(String, StringComparison) Contains(String, StringComparison)

指定された比較規則を使用して、指定された文字列がこの文字列内に含まれるかどうかを示す値を返します。Returns a value indicating whether a specified string occurs within this string, using the specified comparison rules.

Copy(String) Copy(String) Copy(String) Copy(String)

指定した String と同じ値を使用して、String の新しいインスタンスを作成します。Creates a new instance of String with the same value as a specified String.

CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32)

このインスタンスの指定位置から指定した数の文字を、Unicode 文字の配列内の指定位置へコピーします。Copies a specified number of characters from a specified position in this instance to a specified position in an array of Unicode characters.

Create<TState>(Int32, TState, SpanAction<Char,TState>) Create<TState>(Int32, TState, SpanAction<Char,TState>) Create<TState>(Int32, TState, SpanAction<Char,TState>) Create<TState>(Int32, TState, SpanAction<Char,TState>)
EndsWith(Char) EndsWith(Char) EndsWith(Char) EndsWith(Char)
EndsWith(String) EndsWith(String) EndsWith(String) EndsWith(String)

この文字列インスタンスの末尾が、指定した文字列と一致するかどうかを判断します。Determines whether the end of this string instance matches the specified string.

EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo)

指定されたカルチャを使って比較した場合に、この文字列インスタンスの末尾が、指定された文字列と一致するかどうかを判断します。Determines whether the end of this string instance matches the specified string when compared using the specified culture.

EndsWith(String, StringComparison) EndsWith(String, StringComparison) EndsWith(String, StringComparison) EndsWith(String, StringComparison)

指定された比較オプションを使って比較した場合に、この文字列インスタンスの末尾が、指定された文字列と一致するかどうかを判断します。Determines whether the end of this string instance matches the specified string when compared using the specified comparison option.

EnumerateRunes() EnumerateRunes() EnumerateRunes() EnumerateRunes()

この文字列から Rune の列挙体を返します。Returns an enumeration of Rune from this string.

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

このインスタンスと、指定したオブジェクトの値が同一かどうかを判断します。String オブジェクトを指定する必要があります。Determines whether this instance and a specified object, which must also be a String object, have the same value.

Equals(String) Equals(String) Equals(String) Equals(String)

このインスタンスと、指定した別の String の値が同一かどうかを判断します。Determines whether this instance and another specified String object have the same value.

Equals(String, String) Equals(String, String) Equals(String, String) Equals(String, String)

指定した 2 つの String オブジェクトの値が同一かどうかを判断します。Determines whether two specified String objects have the same value.

Equals(String, String, StringComparison) Equals(String, String, StringComparison) Equals(String, String, StringComparison) Equals(String, String, StringComparison)

指定した 2 つの String オブジェクトの値が同一かどうかを判断します。Determines whether two specified String objects have the same value. 比較に使用するカルチャ、大文字と小文字の区別、および、並べ替え規則をパラメーターで指定します。A parameter specifies the culture, case, and sort rules used in the comparison.

Equals(String, StringComparison) Equals(String, StringComparison) Equals(String, StringComparison) Equals(String, StringComparison)

この文字列と、指定した String オブジェクトの値が同一かどうかを判断します。Determines whether this string and a specified String object have the same value. 比較に使用するカルチャ、大文字と小文字の区別、および、並べ替え規則をパラメーターで指定します。A parameter specifies the culture, case, and sort rules used in the comparison.

Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object)

指定した文字列の 1 つまたは複数の書式項目を、対応するオブジェクトの文字列形式に置換します。Replaces the format item or items in a specified string with the string representation of the corresponding object. パラメーターにより、カルチャに固有の書式情報が指定されます。A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object)

文字列の書式項目を、指定した 2 つのオブジェクトの文字列形式に置換します。Replaces the format items in a string with the string representation of two specified objects. パラメーターにより、カルチャに固有の書式情報が指定されます。A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object)

文字列の書式項目を、指定した 3 つのオブジェクトの文字列形式に置換します。Replaces the format items in a string with the string representation of three specified objects. パラメーターにより、カルチャに固有の書式設定情報を指定します。An parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[])

文字列の書式項目を、指定した配列内の対応するオブジェクトの文字列表記に置換します。Replaces the format items in a string with the string representations of corresponding objects in a specified array. パラメーターにより、カルチャに固有の書式情報が指定されます。A parameter supplies culture-specific formatting information.

Format(String, Object) Format(String, Object) Format(String, Object) Format(String, Object)

文字列の 1 つ以上の書式項目を、指定されたオブジェクトの文字列表記に置換します。Replaces one or more format items in a string with the string representation of a specified object.

Format(String, Object, Object) Format(String, Object, Object) Format(String, Object, Object) Format(String, Object, Object)

文字列の書式項目を、指定した 2 つのオブジェクトの文字列形式に置換します。Replaces the format items in a string with the string representation of two specified objects.

Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object)

文字列の書式項目を、指定した 3 つのオブジェクトの文字列形式に置換します。Replaces the format items in a string with the string representation of three specified objects.

Format(String, Object[]) Format(String, Object[]) Format(String, Object[]) Format(String, Object[])

指定した文字列の書式項目を、指定した配列内の対応するオブジェクトの文字列形式に置換します。Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

この文字列に含まれる個々の文字を反復処理するオブジェクトを取得します。Retrieves an object that can iterate through the individual characters in this string.

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

この文字列のハッシュ コードを返します。Returns the hash code for this string.

GetHashCode(ReadOnlySpan<Char>) GetHashCode(ReadOnlySpan<Char>) GetHashCode(ReadOnlySpan<Char>) GetHashCode(ReadOnlySpan<Char>)

指定された読み取り専用文字スパンのハッシュ コードを返します。Returns the hash code for the provided read-only character span.

GetHashCode(ReadOnlySpan<Char>, StringComparison) GetHashCode(ReadOnlySpan<Char>, StringComparison) GetHashCode(ReadOnlySpan<Char>, StringComparison) GetHashCode(ReadOnlySpan<Char>, StringComparison)

指定された規則を使用して、指定された読み取り専用の文字スパンのハッシュ コードを返します。Returns the hash code for the provided read-only character span using the specified rules.

GetHashCode(StringComparison) GetHashCode(StringComparison) GetHashCode(StringComparison) GetHashCode(StringComparison)

指定された規則を使用して、この文字列のハッシュ コードを返します。Returns the hash code for this string using the specified rules.

GetPinnableReference() GetPinnableReference() GetPinnableReference() GetPinnableReference()

インデックス 0 にある文字列の要素への参照を返します。Returns a reference to the element of the string at index zero.

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

現在のインスタンスの Type を取得します。Gets the Type of the current instance.

(Inherited from Object)
GetTypeCode() GetTypeCode() GetTypeCode() GetTypeCode()

TypeCode クラスには String を返します。Returns the TypeCode for class String.

IndexOf(Char) IndexOf(Char) IndexOf(Char) IndexOf(Char)

指定した Unicode 文字がこの文字列内で最初に見つかった位置の 0 から始まるインデックスをレポートします。Reports the zero-based index of the first occurrence of the specified Unicode character in this string.

IndexOf(Char, Int32) IndexOf(Char, Int32) IndexOf(Char, Int32) IndexOf(Char, Int32)

指定した Unicode 文字がこの文字列内で最初に見つかった位置の 0 から始まるインデックスをレポートします。Reports the zero-based index of the first occurrence of the specified Unicode character in this string. 検索は、指定した文字位置から開始されます。The search starts at a specified character position.

IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32)

指定文字がこのインスタンス内で最初に見つかった位置の 0 から始まるインデックスをレポートします。Reports the zero-based index of the first occurrence of the specified character in this instance. 検索は指定した文字位置から開始され、指定した数の文字位置が検査されます。The search starts at a specified character position and examines a specified number of character positions.

IndexOf(Char, StringComparison) IndexOf(Char, StringComparison) IndexOf(Char, StringComparison) IndexOf(Char, StringComparison)

指定した Unicode 文字がこの文字列内で最初に見つかった位置の 0 から始まるインデックスをレポートします。Reports the zero-based index of the first occurrence of the specified Unicode character in this string. 指定した文字に使用する検索の種類をパラメーターで指定します。A parameter specifies the type of search to use for the specified character.

IndexOf(String) IndexOf(String) IndexOf(String) IndexOf(String)

指定された文字列がこのインスタンス内で最初に見つかった位置の 0 から始まるインデックスをレポートします。Reports the zero-based index of the first occurrence of the specified string in this instance.

IndexOf(String, Int32) IndexOf(String, Int32) IndexOf(String, Int32) IndexOf(String, Int32)

指定された文字列がこのインスタンス内で最初に見つかった位置の 0 から始まるインデックスをレポートします。Reports the zero-based index of the first occurrence of the specified string in this instance. 検索は、指定した文字位置から開始されます。The search starts at a specified character position.

IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32)

指定された文字列がこのインスタンス内で最初に見つかった位置の 0 から始まるインデックスをレポートします。Reports the zero-based index of the first occurrence of the specified string in this instance. 検索は指定した文字位置から開始され、指定した数の文字位置が検査されます。The search starts at a specified character position and examines a specified number of character positions.

IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison)

指定した文字列が現在の String オブジェクト内で最初に見つかった位置の 0 から始まるインデックスをレポートします。Reports the zero-based index of the first occurrence of the specified string in the current String object. 現在の文字列での検索開始位置、現在の文字列で検索する文字の数、および指定した文字列に使用する検索の種類をパラメーターで指定します。Parameters specify the starting search position in the current string, the number of characters in the current string to search, and the type of search to use for the specified string.

IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison)

指定した文字列が現在の String オブジェクト内で最初に見つかった位置の 0 から始まるインデックスをレポートします。Reports the zero-based index of the first occurrence of the specified string in the current String object. 現在の文字列内での検索の開始位置、および指定した文字列に使用する検索の種類をパラメーターで指定します。Parameters specify the starting search position in the current string and the type of search to use for the specified string.

IndexOf(String, StringComparison) IndexOf(String, StringComparison) IndexOf(String, StringComparison) IndexOf(String, StringComparison)

指定した文字列が現在の String オブジェクト内で最初に見つかった位置の 0 から始まるインデックスをレポートします。Reports the zero-based index of the first occurrence of the specified string in the current String object. 指定した文字列に使用する検索の種類をパラメーターで指定します。A parameter specifies the type of search to use for the specified string.

IndexOfAny(Char[]) IndexOfAny(Char[]) IndexOfAny(Char[]) IndexOfAny(Char[])

Unicode 文字の指定した配列内にある文字がこのインスタンスで最初に見つかった位置の 0 から始まるインデックスをレポートします。Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters.

IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32)

Unicode 文字の指定した配列内にある文字がこのインスタンスで最初に見つかった位置の 0 から始まるインデックスをレポートします。Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. 検索は、指定した文字位置から開始されます。The search starts at a specified character position.

IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32)

Unicode 文字の指定した配列内にある文字がこのインスタンスで最初に見つかった位置の 0 から始まるインデックスをレポートします。Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. 検索は指定した文字位置から開始され、指定した数の文字位置が検査されます。The search starts at a specified character position and examines a specified number of character positions.

Insert(Int32, String) Insert(Int32, String) Insert(Int32, String) Insert(Int32, String)

このインスタンス内の指定したインデックス位置に指定した文字列を挿入する場合の、新しい文字列を返します。Returns a new string in which a specified string is inserted at a specified index position in this instance.

Intern(String) Intern(String) Intern(String) Intern(String)

指定した String へのシステム参照を取得します。Retrieves the system's reference to the specified String.

IsInterned(String) IsInterned(String) IsInterned(String) IsInterned(String)

指定した String への参照を取得します。Retrieves a reference to a specified String.

IsNormalized() IsNormalized() IsNormalized() IsNormalized()

この文字列が、Unicode 正規形 C であるかどうかを示します。Indicates whether this string is in Unicode normalization form C.

IsNormalized(NormalizationForm) IsNormalized(NormalizationForm) IsNormalized(NormalizationForm) IsNormalized(NormalizationForm)

この文字列が、指定された Unicode 正規形であるかどうかを示します。Indicates whether this string is in the specified Unicode normalization form.

IsNullOrEmpty(String) IsNullOrEmpty(String) IsNullOrEmpty(String) IsNullOrEmpty(String)

指定された文字列が null または空の文字列 ("") であるかどうかを示します。Indicates whether the specified string is null or an empty string ("").

IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String)

指定された文字列が null または空であるか、空白文字だけで構成されているかどうかを示します。Indicates whether a specified string is null, empty, or consists only of white-space characters.

Join(Char, Object[]) Join(Char, Object[]) Join(Char, Object[]) Join(Char, Object[])
Join(Char, String[]) Join(Char, String[]) Join(Char, String[]) Join(Char, String[])
Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32)
Join(String, IEnumerable<String>) Join(String, IEnumerable<String>) Join(String, IEnumerable<String>) Join(String, IEnumerable<String>)

IEnumerable<T> 型の構築された String コレクションのメンバーを連結します。各メンバーの間には、指定した区切り記号が挿入されます。Concatenates the members of a constructed IEnumerable<T> collection of type String, using the specified separator between each member.

Join(String, Object[]) Join(String, Object[]) Join(String, Object[]) Join(String, Object[])

オブジェクト配列の要素を連結します。各要素の間には、指定した区切り記号が挿入されます。Concatenates the elements of an object array, using the specified separator between each element.

Join(String, String[]) Join(String, String[]) Join(String, String[]) Join(String, String[])

文字列配列のすべての要素を連結します。各要素の間には、指定した区切り記号が挿入されます。Concatenates all the elements of a string array, using the specified separator between each element.

Join(String, String[], Int32, Int32) Join(String, String[], Int32, Int32) Join(String, String[], Int32, Int32) Join(String, String[], Int32, Int32)

文字列配列の指定した要素を連結します。各要素の間には、指定した区切り記号が挿入されます。Concatenates the specified elements of a string array, using the specified separator between each element.

Join<T>(Char, IEnumerable<T>) Join<T>(Char, IEnumerable<T>) Join<T>(Char, IEnumerable<T>) Join<T>(Char, IEnumerable<T>)
Join<T>(String, IEnumerable<T>) Join<T>(String, IEnumerable<T>) Join<T>(String, IEnumerable<T>) Join<T>(String, IEnumerable<T>)

コレクションのメンバーを連結します。各メンバーの間には、指定した区切り記号が挿入されます。Concatenates the members of a collection, using the specified separator between each member.

LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char)

このインスタンス内で最後に出現する指定 Unicode 文字の 0 から始まるインデックス位置をレポートします。Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance.

LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32)

このインスタンス内で最後に出現する指定 Unicode 文字の 0 から始まるインデックス位置をレポートします。Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. 検索は、指定された文字位置から開始され、文字列の先頭に向かって逆方向に進みます。The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32)

このインスタンス内の部分文字列で最後に出現する指定 Unicode 文字の 0 から始まるインデックス位置をレポートします。Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. 検索は指定された文字位置から開始し、文字列の開始に向かって後方に移動し、文字位置の指定された数だけ行われます。The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(String) LastIndexOf(String) LastIndexOf(String) LastIndexOf(String)

指定された文字列がこのインスタンス内で最後に見つかった 0 から始まるインデックス位置をレポートします。Reports the zero-based index position of the last occurrence of a specified string within this instance.

LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32)

指定された文字列がこのインスタンス内で最後に見つかった 0 から始まるインデックス位置をレポートします。Reports the zero-based index position of the last occurrence of a specified string within this instance. 検索は、指定された文字位置から開始され、文字列の先頭に向かって逆方向に進みます。The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32)

指定された文字列がこのインスタンス内で最後に見つかった 0 から始まるインデックス位置をレポートします。Reports the zero-based index position of the last occurrence of a specified string within this instance. 検索は指定された文字位置から開始し、文字列の開始に向かって後方に移動し、文字位置の指定された数だけ行われます。The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison)

指定された文字列がこのインスタンス内で最後に見つかった 0 から始まるインデックス位置をレポートします。Reports the zero-based index position of the last occurrence of a specified string within this instance. 検索は指定された文字位置から開始し、文字列の開始に向かって後方に移動し、文字位置の指定された数だけ行われます。The search starts at a specified character position and proceeds backward toward the beginning of the string for the specified number of character positions. 指定した文字列を検索するときに実行する比較の種類をパラメーターで指定します。A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison)

指定した文字列が現在の String オブジェクト内で最後に見つかった 0 から始まる位置のインデックスをレポートします。Reports the zero-based index of the last occurrence of a specified string within the current String object. 検索は、指定された文字位置から開始され、文字列の先頭に向かって逆方向に進みます。The search starts at a specified character position and proceeds backward toward the beginning of the string. 指定した文字列を検索するときに実行する比較の種類をパラメーターで指定します。A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison)

指定した文字列が現在の String オブジェクト内で最後に見つかった 0 から始まる位置のインデックスをレポートします。Reports the zero-based index of the last occurrence of a specified string within the current String object. 指定した文字列に使用する検索の種類をパラメーターで指定します。A parameter specifies the type of search to use for the specified string.

LastIndexOfAny(Char[]) LastIndexOfAny(Char[]) LastIndexOfAny(Char[]) LastIndexOfAny(Char[])

Unicode 配列内の指定した 1 つ以上の文字がこのインスタンスで最後に見つかった 0 から始まるインデックス位置をレポートします。Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array.

LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32)

Unicode 配列内の指定した 1 つ以上の文字がこのインスタンスで最後に見つかった 0 から始まるインデックス位置をレポートします。Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. 検索は、指定された文字位置から開始され、文字列の先頭に向かって逆方向に進みます。The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32)

Unicode 配列内の指定した 1 つ以上の文字がこのインスタンスで最後に見つかった 0 から始まるインデックス位置をレポートします。Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. 検索は指定された文字位置から開始し、文字列の開始に向かって後方に移動し、文字位置の指定された数だけ行われます。The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

現在の Object の簡易コピーを作成します。Creates a shallow copy of the current Object.

(Inherited from Object)
Normalize() Normalize() Normalize() Normalize()

この文字列と同じテキスト値を持ち、なおかつ、バイナリ表現が Unicode 正規形 C である新しい文字列を返します。Returns a new string whose textual value is the same as this string, but whose binary representation is in Unicode normalization form C.

Normalize(NormalizationForm) Normalize(NormalizationForm) Normalize(NormalizationForm) Normalize(NormalizationForm)

この文字列と同じテキスト値を持ち、なおかつ、バイナリ表現が、指定された Unicode 正規形である新しい文字列を返します。Returns a new string whose textual value is the same as this string, but whose binary representation is in the specified Unicode normalization form.

PadLeft(Int32) PadLeft(Int32) PadLeft(Int32) PadLeft(Int32)

指定された文字数になるまで左側に空白を埋め込むことで、このインスタンス内の文字を右寄せした新しい文字列を返します。Returns a new string that right-aligns the characters in this instance by padding them with spaces on the left, for a specified total length.

PadLeft(Int32, Char) PadLeft(Int32, Char) PadLeft(Int32, Char) PadLeft(Int32, Char)

指定された文字数になるまで左側に指定された Unicode 文字を埋め込むことで、このインスタンス内の文字を右寄せした新しい文字列を返します。Returns a new string that right-aligns the characters in this instance by padding them on the left with a specified Unicode character, for a specified total length.

PadRight(Int32) PadRight(Int32) PadRight(Int32) PadRight(Int32)

指定された文字数になるまで右側に空白を埋め込むことで、この文字列内の文字を左寄せした新しい文字列を返します。Returns a new string that left-aligns the characters in this string by padding them with spaces on the right, for a specified total length.

PadRight(Int32, Char) PadRight(Int32, Char) PadRight(Int32, Char) PadRight(Int32, Char)

指定された文字数になるまで右側に指定された Unicode 文字を埋め込むことで、この文字列内の文字を左寄せした新しい文字列を返します。Returns a new string that left-aligns the characters in this string by padding them on the right with a specified Unicode character, for a specified total length.

Remove(Int32) Remove(Int32) Remove(Int32) Remove(Int32)

現在のインスタンスの指定した位置から指定した最後の位置までの全文字が削除された新しい文字列を返します。Returns a new string in which all the characters in the current instance, beginning at a specified position and continuing through the last position, have been deleted.

Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32)

現在のインスタンス内の指定した位置から指定した文字数が削除された新しい文字列を返します。Returns a new string in which a specified number of characters in the current instance beginning at a specified position have been deleted.

Replace(Char, Char) Replace(Char, Char) Replace(Char, Char) Replace(Char, Char)

このインスタンスに出現する指定された Unicode 文字をすべて、別の指定された Unicode 文字に置換した新しい文字列を返します。Returns a new string in which all occurrences of a specified Unicode character in this instance are replaced with another specified Unicode character.

Replace(String, String) Replace(String, String) Replace(String, String) Replace(String, String)

現在のインスタンスに出現する指定した文字列をすべて、別に指定した文字列に置換した新しい文字列を返します。Returns a new string in which all occurrences of a specified string in the current instance are replaced with another specified string.

Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo)
Replace(String, String, StringComparison) Replace(String, String, StringComparison) Replace(String, String, StringComparison) Replace(String, String, StringComparison)
Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions)
Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions)
Split(Char[]) Split(Char[]) Split(Char[]) Split(Char[])

配列内の文字に基づいて文字列を部分文字列に分割します。Splits a string into substrings that are based on the characters in an array.

Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32)

配列内の文字に基づいて文字列を最大数の部分文字列に分割します。Splits a string into a maximum number of substrings based on the characters in an array. 返される部分文字列の最大数を指定します。You also specify the maximum number of substrings to return.

Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions)

配列内の文字に基づいて文字列を最大数の部分文字列に分割します。Splits a string into a maximum number of substrings based on the characters in an array.

Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions)

配列内の文字に基づいて文字列を部分文字列に分割します。Splits a string into substrings based on the characters in an array. 部分文字列が空の配列の要素を含めるかどうかを指定することができます。You can specify whether the substrings include empty array elements.

Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions)
Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions)
Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions)

配列内の文字列に基づいて文字列を最大数の部分文字列に分割します。Splits a string into a maximum number of substrings based on the strings in an array. 部分文字列が空の配列の要素を含めるかどうかを指定することができます。You can specify whether the substrings include empty array elements.

Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions)

配列内の文字列に基づいて文字列を部分文字列に分割します。Splits a string into substrings based on the strings in an array. 部分文字列が空の配列の要素を含めるかどうかを指定することができます。You can specify whether the substrings include empty array elements.

StartsWith(Char) StartsWith(Char) StartsWith(Char) StartsWith(Char)
StartsWith(String) StartsWith(String) StartsWith(String) StartsWith(String)

この文字列インスタンスの先頭が、指定した文字列と一致するかどうかを判断します。Determines whether the beginning of this string instance matches the specified string.

StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo)

指定されたカルチャを使って比較した場合に、この文字列インスタンスの先頭が、指定された文字列と一致するかどうかを判断します。Determines whether the beginning of this string instance matches the specified string when compared using the specified culture.

StartsWith(String, StringComparison) StartsWith(String, StringComparison) StartsWith(String, StringComparison) StartsWith(String, StringComparison)

指定された比較オプションを使って比較した場合に、この文字列インスタンスの先頭が、指定された文字列と一致するかどうかを判断します。Determines whether the beginning of this string instance matches the specified string when compared using the specified comparison option.

Substring(Index) Substring(Index) Substring(Index) Substring(Index)
Substring(Int32) Substring(Int32) Substring(Int32) Substring(Int32)

インスタンスから部分文字列を取得します。Retrieves a substring from this instance. 部分文字列は、文字列中の指定した文字の位置で開始し、文字列の末尾まで続きます。The substring starts at a specified character position and continues to the end of the string.

Substring(Int32, Int32) Substring(Int32, Int32) Substring(Int32, Int32) Substring(Int32, Int32)

インスタンスから部分文字列を取得します。Retrieves a substring from this instance. この部分文字列は、指定した文字位置から開始し、指定した文字数の文字列です。The substring starts at a specified character position and has a specified length.

Substring(Range) Substring(Range) Substring(Range) Substring(Range)
ToCharArray() ToCharArray() ToCharArray() ToCharArray()

このインスタンスの文字を Unicode 文字配列へコピーします。Copies the characters in this instance to a Unicode character array.

ToCharArray(Int32, Int32) ToCharArray(Int32, Int32) ToCharArray(Int32, Int32) ToCharArray(Int32, Int32)

このインスタンスの指定した部分文字列の文字を Unicode 文字配列へコピーします。Copies the characters in a specified substring in this instance to a Unicode character array.

ToLower() ToLower() ToLower() ToLower()

この文字列のコピーを小文字に変換して返します。Returns a copy of this string converted to lowercase.

ToLower(CultureInfo) ToLower(CultureInfo) ToLower(CultureInfo) ToLower(CultureInfo)

指定されたカルチャの大文字と小文字の規則を使用して、この文字列のコピーを小文字に変換して返します。Returns a copy of this string converted to lowercase, using the casing rules of the specified culture.

ToLowerInvariant() ToLowerInvariant() ToLowerInvariant() ToLowerInvariant()

インバリアント カルチャの大文字と小文字の規則を使用して、この String オブジェクトのコピーを小文字に変換して返します。Returns a copy of this String object converted to lowercase using the casing rules of the invariant culture.

ToString() ToString() ToString() ToString()

String のこのインスタンスを返します。実際の変換処理は実行されません。Returns this instance of String; no actual conversion is performed.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider)

String のこのインスタンスを返します。実際の変換処理は実行されません。Returns this instance of String; no actual conversion is performed.

ToUpper() ToUpper() ToUpper() ToUpper()

この文字列のコピーを大文字に変換して返します。Returns a copy of this string converted to uppercase.

ToUpper(CultureInfo) ToUpper(CultureInfo) ToUpper(CultureInfo) ToUpper(CultureInfo)

指定されたカルチャの大文字と小文字の規則を使用して、この文字列のコピーを大文字に変換して返します。Returns a copy of this string converted to uppercase, using the casing rules of the specified culture.

ToUpperInvariant() ToUpperInvariant() ToUpperInvariant() ToUpperInvariant()

インバリアント カルチャの大文字と小文字の規則を使用して、この String オブジェクトのコピーを大文字に変換して返します。Returns a copy of this String object converted to uppercase using the casing rules of the invariant culture.

Trim() Trim() Trim() Trim()

現在の String オブジェクトの先頭および末尾にある空白文字をすべて削除します。Removes all leading and trailing white-space characters from the current String object.

Trim(Char) Trim(Char) Trim(Char) Trim(Char)
Trim(Char[]) Trim(Char[]) Trim(Char[]) Trim(Char[])

現在の String オブジェクトの先頭および末尾から、配列で指定された文字セットをすべて削除します。Removes all leading and trailing occurrences of a set of characters specified in an array from the current String object.

TrimEnd() TrimEnd() TrimEnd() TrimEnd()
TrimEnd(Char) TrimEnd(Char) TrimEnd(Char) TrimEnd(Char)
TrimEnd(Char[]) TrimEnd(Char[]) TrimEnd(Char[]) TrimEnd(Char[])

現在の String オブジェクトの末尾から、配列で指定された文字セットをすべて削除します。Removes all trailing occurrences of a set of characters specified in an array from the current String object.

TrimStart() TrimStart() TrimStart() TrimStart()
TrimStart(Char) TrimStart(Char) TrimStart(Char) TrimStart(Char)
TrimStart(Char[]) TrimStart(Char[]) TrimStart(Char[]) TrimStart(Char[])

現在の String オブジェクトの先頭から、配列で指定された文字セットをすべて削除します。Removes all leading occurrences of a set of characters specified in an array from the current String object.

演算子

Equality(String, String) Equality(String, String) Equality(String, String) Equality(String, String)

指定した 2 つの文字列の値が同一かどうかを判断します。Determines whether two specified strings have the same value.

Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>)
Inequality(String, String) Inequality(String, String) Inequality(String, String) Inequality(String, String)

指定した 2 つの文字列の値が異なるかどうかを判断します。Determines whether two specified strings have different values.

明示的なインターフェイスの実装

IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object)
IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider)

このメンバーの詳細については、「ToBoolean(IFormatProvider)」をご覧ください。For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider)

このメンバーの詳細については、「ToByte(IFormatProvider)」をご覧ください。For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider)

このメンバーの詳細については、「ToChar(IFormatProvider)」をご覧ください。For a description of this member, see ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider)

このメンバーの説明については、ToDateTime(IFormatProvider) のトピックを参照してください。For a description of this member, see ToDateTime(IFormatProvider).

IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider)

このメンバーの説明については、ToDecimal(IFormatProvider) のトピックを参照してください。For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider)

このメンバーの詳細については、「ToDouble(IFormatProvider)」をご覧ください。For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider)

このメンバーの詳細については、「ToInt16(IFormatProvider)」をご覧ください。For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider)

このメンバーの説明については、ToInt32(IFormatProvider) のトピックを参照してください。For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider)

このメンバーの説明については、ToInt64(IFormatProvider) のトピックを参照してください。For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider)

このメンバーの説明については、ToSByte(IFormatProvider) のトピックを参照してください。For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider)

このメンバーの詳細については、「ToSingle(IFormatProvider)」をご覧ください。For a description of this member, see ToSingle(IFormatProvider).

IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider)
IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider)

このメンバーの詳細については、「ToType(Type, IFormatProvider)」をご覧ください。For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider)

このメンバーの詳細については、「ToUInt16(IFormatProvider)」をご覧ください。For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider)

このメンバーの説明については、ToUInt32(IFormatProvider) のトピックを参照してください。For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider)

このメンバーの説明については、ToUInt64(IFormatProvider) のトピックを参照してください。For a description of this member, see ToUInt64(IFormatProvider).

IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

現在の String オブジェクトを反復処理する列挙子を返します。Returns an enumerator that iterates through the current String object.

IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator()

現在の String オブジェクトを反復処理する列挙子を返します。Returns an enumerator that iterates through the current String object.

拡張メソッド

CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>)

指定した入力 DataTable オブジェクトに応じて (ジェネリック パラメーター TDataRow)、IEnumerable<T> オブジェクトのコピーを格納する DataRow を返します。Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

指定した入力 DataRow オブジェクトに応じて (ジェネリック パラメーター TDataTable)、指定した IEnumerable<T>DataRow オブジェクトをコピーします。Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

指定した入力 DataRow オブジェクトに応じて (ジェネリック パラメーター TDataTable)、指定した IEnumerable<T>DataRow オブジェクトをコピーします。Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

IEnumerable の要素を、指定した型にキャストします。Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

指定された型に基づいて IEnumerable の要素をフィルター処理します。Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

クエリの並列化を有効にします。Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

IEnumerableIQueryable に変換します。Converts an IEnumerable to an IQueryable.

AsMemory(String) AsMemory(String) AsMemory(String) AsMemory(String)

挿入先の文字列の一部に新しい ReadOnlyMemory<Char> を作成します。Creates a new ReadOnlyMemory<Char> over the portion of the target string.

AsMemory(String, Index) AsMemory(String, Index) AsMemory(String, Index) AsMemory(String, Index)

指定したインデックスを開始位置として、挿入先の文字列の一部に対して新しい ReadOnlyMemory<Char> を作成します。Creates a new ReadOnlyMemory<Char> over a portion of the target string starting at a specified index.

AsMemory(String, Int32) AsMemory(String, Int32) AsMemory(String, Int32) AsMemory(String, Int32)

指定した文字位置を開始位置として、挿入先の文字列の一部に対して新しい ReadOnlyMemory<Char> を作成します。Creates a new ReadOnlyMemory<Char> over a portion of the target string starting at a specified character position.

AsMemory(String, Int32, Int32) AsMemory(String, Int32, Int32) AsMemory(String, Int32, Int32) AsMemory(String, Int32, Int32)

指定した位置 (長さを含む) を開始位置として、挿入先の文字列の一部に対して新しい ReadOnlyMemory<Char> を作成します。Creates a new ReadOnlyMemory<Char> over a portion of the target string beginning at a specified position with a length.

AsMemory(String, Range) AsMemory(String, Range) AsMemory(String, Range) AsMemory(String, Range)

挿入先の文字列の指定範囲に新しい ReadOnlyMemory<Char> を作成します。Creates a new ReadOnlyMemory<Char> over a specified range of the target string.

AsSpan(String) AsSpan(String) AsSpan(String) AsSpan(String)

指定された位置から指定された文字数だけ、挿入先の文字列の一部に対して読み取り専用の新しい範囲を作成します。Creates a new read-only span over a portion of the target string from a specified position for a specified number of characters.

AsSpan(String, Int32) AsSpan(String, Int32) AsSpan(String, Int32) AsSpan(String, Int32)

指定された位置から文字列の終わりまで、挿入先の文字列の一部に対して読み取り専用の新しい範囲を作成します。Creates a new read-only span over a portion of the target string from a specified position to the end of the string.

AsSpan(String, Int32, Int32) AsSpan(String, Int32, Int32) AsSpan(String, Int32, Int32) AsSpan(String, Int32, Int32)

文字列に対して新しい読み取り専用のスパンを作成します。Creates a new read-only span over a string.

IsNormalized(String) IsNormalized(String) IsNormalized(String) IsNormalized(String)

指定された文字列が、Unicode 正規形 C であるかどうかを示します。Indicates whether the specified string is in Unicode normalization form C.

IsNormalized(String, NormalizationForm) IsNormalized(String, NormalizationForm) IsNormalized(String, NormalizationForm) IsNormalized(String, NormalizationForm)

文字列が指定された Unicode 正規形であるかどうかを示します。Indicates whether a string is in a specified Unicode normalization form.

Normalize(String) Normalize(String) Normalize(String) Normalize(String)

文字列を Unicode 正規形 C に正規化します。Normalizes a string to a Unicode normalization form C.

Normalize(String, NormalizationForm) Normalize(String, NormalizationForm) Normalize(String, NormalizationForm) Normalize(String, NormalizationForm)

文字列を、指定された Unicode 正規形に正規化します。Normalizes a string to the specified Unicode normalization form.

Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>)

ソース コレクション内のすべてのノードの先祖が格納された、要素のコレクションを返します。Returns a collection of elements that contains the ancestors of every node in the source collection.

Ancestors<T>(IEnumerable<T>, XName) Ancestors<T>(IEnumerable<T>, XName) Ancestors<T>(IEnumerable<T>, XName) Ancestors<T>(IEnumerable<T>, XName)

ソース コレクション内のすべてのノードの先祖が格納され、フィルター処理された要素のコレクションを返します。Returns a filtered collection of elements that contains the ancestors of every node in the source collection. 一致する XName を持つ要素のみがコレクションに含められます。Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>)

ソース コレクション内のすべてのドキュメントおよび要素の子孫ノードのコレクションを返します。Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>)

ソース コレクション内のすべての要素とドキュメントの子孫要素が格納された要素のコレクションを返します。Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName) Descendants<T>(IEnumerable<T>, XName) Descendants<T>(IEnumerable<T>, XName) Descendants<T>(IEnumerable<T>, XName)

ソース コレクション内のすべての要素とドキュメントの子孫要素が格納され、フィルター処理された要素のコレクションを返します。Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. 一致する XName を持つ要素のみがコレクションに含められます。Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>)

ソース コレクション内のすべての要素およびドキュメントの子要素のコレクションを返します。Returns a collection of the child elements of every element and document in the source collection.

Elements<T>(IEnumerable<T>, XName) Elements<T>(IEnumerable<T>, XName) Elements<T>(IEnumerable<T>, XName) Elements<T>(IEnumerable<T>, XName)

ソース コレクション内のすべての要素およびドキュメントの、フィルター処理された子要素のコレクションを返します。Returns a filtered collection of the child elements of every element and document in the source collection. 一致する XName を持つ要素のみがコレクションに含められます。Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>)

ソース コレクション内のすべてのノードがドキュメント順に並べ替えて格納された、ノードのコレクションを返します。Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>)

ソース コレクション内のすべてのドキュメントおよび要素の子ノードのコレクションを返します。Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>)

ソース コレクション内の親ノードからすべてのノードを削除します。Removes every node in the source collection from its parent node.

適用対象

スレッド セーフ

この型はスレッド セーフです。This type is thread safe.

こちらもご覧ください