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. AStringオブジェクトのシーケンシャル コレクションは、System.Charするは、文字列を表すオブジェクトSystem.Charオブジェクトは utf-16 コード単位に対応します。A 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.

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

文字列オブジェクトをインスタンス化します。 Instantiating a String object
オブジェクトと Unicode 文字を char します。 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

文字列オブジェクトをインスタンス化します。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      
    
  • 文字列連結演算子を使用して、(+ (C#) と (& a) または Visual Basic では、+) の任意の組み合わせから 1 つの文字列を作成するStringインスタンスと文字列リテラル。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.      
    

オブジェクトと Unicode 文字を char します。Char objects and Unicode characters

文字列内の各文字は Unicode コード ポイントまたは Unicode 文字の序数 (数値) 値とも呼ばれる、Unicode スカラー値によって定義されます。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 コード単位のシーケンシャル コレクションのインスタンスを構成、作成することは、Stringが整形式の Unicode 文字列でないオブジェクト。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.

1 つCharオブジェクトは、通常は 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. ただし、コード ポイントはエンコードされた 1 つ以上の要素を必要があります (1 つ以上Charオブジェクト)。However, a code point might require more than one encoded element (more than one Char object). Unicode 標準では、2 種類の対応する文字を定義する複数Charオブジェクト: 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. たとえば、ä 文字が a で表されますCharコード ポイントが U + a 続けて 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. この文字は、1 つで定義することもCharU + 00E4 のコード ポイントを持つオブジェクト。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
    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          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

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

文字列内の各文字が、関連付けられている Unicode 文字カテゴリでの .NET で表される、UnicodeCategory列挙体。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 のバージョンでは、 .NET Framework 4.NET Framework 4、.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. 以降では、.NET Framework のバージョンの場合は true。 これはまた、 .NET Framework 4.5.NET Framework 4.5 Windows 7 で実行されています。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. 以降では、.NET Framework 4.5.NET Framework 4.5で Window 8 および 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 では、文字列比較と並べ替えの情報によって提供されるInternational Components for 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.5 および Windows 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またはwcslen関数が必ずしも等しくString.Lengthします。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.

ネイティブ C および C++ コードをインスタンス化することを確認する必要がありますStringオブジェクト、および渡されるコード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. これに対して、埋め込まれた null 文字は常と見なされますなどの方法で文字列を検索するときにContainsStartsWith、およびIndexOfします。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内のオブジェクト (Unicode 文字ではありません)、Stringします。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[Int32]プロパティでは、個別にアクセスできます。Charインデックス位置を示す文字列内でのオブジェクト。The Chars[Int32] property lets you access individual Char objects by their index position in the string. Chars[Int32]プロパティは (Visual Basic) で既定のプロパティまたはインデクサー (c#) を個別にアクセスすることができますCharなど、次のコードを使用して文字列内のオブジェクト。Because the Chars[Int32] 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.
using System;

public class Example
{
   public static 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.
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.
using System;

public class Example
{
   public static void Main()
   {
      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 でエンコードされた 1 つ以上にするため、連続したインデックス値は、連続する Unicode 文字に対応しない可能性がありますCharオブジェクト。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. 代わりに Unicode 文字を使用するChar、オブジェクトを使用して、System.Globalization.StringInfoTextElementEnumeratorクラス。To work with Unicode characters instead of Char objects, use the System.Globalization.StringInfo and TextElementEnumerator classes. 次の例で動作するコードの違いを示しています。Charオブジェクトと Unicode 文字で動作するコードです。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
using System;
using System.Collections.Generic;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // 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++;
         }
      }

      TextElementEnumerator te = 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がスローされます、空の文字列を渡すと、 FormatExceptionFor 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を一般 ("G") 書式指定子では、null 文字列と空の文字列の両方を調べる場合に必要なクラスの実装、します。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:

  • IsNullOrEmpty、文字列がいずれかどうかを示すnullと等しいかString.Emptyします。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、文字列があるかどうかを示す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メソッドで、IFormattable.ToStringのカスタム実装Temperatureクラス。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

AStringオブジェクトは不変と呼ばれます (読み取り専用)、作成した後、その値を変更できないためです。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. たとえば、次のコードは、範囲 0x052F を 0x0001 に 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で 0x052F を 0x0001 に範囲のランダムな文字で 1000 を連結する前の例で使用される、StringBuilderオブジェクト。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インバリアント カルチャの設定の設定、システム、および .NET のバージョン間でのシステムからの 1 台のコンピューター上の一貫性を保持することが保証されます。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 つの文字列のカルチャに依存した比較を実行するメソッドを呼び出す必要があります、Compare(String, String, StringComparison)の値を持つメソッドStringComparison.CurrentCulturecomparisonType引数。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. たとえば、もう 1 つの大文字の文字列を比較できるように文字列を大文字に変換する可能性があります。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.

大文字小文字操作は、現在のカルチャや指定されたカルチャの場合は、インバリアント カルチャの規則に基づくことができます。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:

  • LATIN CAPITAL LETTER I の大文字と小文字のマッピングの相違点 (u+0049) ラテン小さな文字 I (u+0069) LATIN CAPITAL LETTER 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 (トルコ語 (トルコ)) と Latn-AZ-AZ (アゼルバイジャン、ラテン文字) のカルチャと、tr、az、az Latn ニュートラル カルチャでラテン大文字の 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 および大文字と小文字の対応は私 LATIN CAPITAL LETTER、インバリアント カルチャを含むです。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 ギリシャ文字 MU (U +-39 C)GREEK CAPITAL LETTER MU (U+-39C)
    LATIN CAPITAL LETTER は丸印が付きます (U+0130) の上LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130) 小文字Lowercase 小規模のラテン文字は (U+0069)LATIN SMALL LETTER I (U+0069)
    ラテン文字ドットは (U + 0131)LATIN SMALL LETTER DOTLESS I (U+0131) 大文字Uppercase LATIN CAPITAL LETTER は (U+0049)LATIN CAPITAL LETTER I (U+0049)
    ラテン文字の長い S (U + 017F)LATIN SMALL LETTER LONG S (U+017F) 大文字Uppercase LATIN CAPITAL LETTER S (U + 0053)LATIN CAPITAL LETTER S (U+0053)
    CARON で小さな文字 Z で LATIN CAPITAL LETTER D (U + 01C 5)LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON (U+01C5) 小文字Lowercase CARON でラテン文字の小さな DZ (U + 01C 6)LATIN SMALL LETTER DZ WITH CARON (U+01C6)
    結合ギリシャ YPOGEGRAMMENI (U + 0345)COMBINING GREEK YPOGEGRAMMENI (U+0345) 大文字Uppercase ギリシャ文字 IOTA (U + 0399)GREEK CAPITAL LETTER IOTA (U+0399)
  • ASCII 文字の範囲の小文字が混在ペアの 2 文字の大文字と小文字のマッピングの相違。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. いずれの場合も、digraph を比較するために次のカルチャでは、次の 2 文字のペアの場合は true はありません。This is not true for the following two-letter pairs in the following cultures, because in each case they are compared to a digraph:

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

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

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

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

    • "cH"と"lL"es-es_tradnl (スペイン語 (スペイン、トラディショナル ソート)) のカルチャ。"cH" and "lL" in the es-ES_tradnl (Spanish (Spain, Traditional Sort)) culture.

    • "cH"、"gI"、"kH"、"nG""nH"、"pH"、"qU"、"tH"と"tR"vi VN (ベトナム語 (ベトナム)) のカルチャ。"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. 日付文字列を生成するために使用されたカルチャの規則を知ることがなく、2011 年 1 月 3 日か、2011 年 3 月 1 日の 03/01/2011、2011 年 3 月 1 日および 01/03/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)メソッドに基づいて 2 つの文字列を比較し、StringComparisonパラメーター。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. たとえば、ハイフン (-) は、"coop"と"co-op"、並べ替えられたリストで互いの横に表示されるように、それに割り当てられている重みが非常に小さい場合があります。For example, the hyphen (-) might have a very small weight assigned to it so that "coop" and "co-op" appear next to each other in a sorted list. 一覧については、String単語の並べ替え規則を使用して 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. ただし、ケースが重要ではない場合は、ケースを区別しない、序数に基づく比較を指定できます。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.CurrentCultureStringComparison.CurrentCultureIgnoreCase、またはのメンバーはすべて、CompareOptions以外の列挙CompareOptions.OrdinalまたはCompareOptions.OrdinalIgnoreCaseに適切なオーバー ロード、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 つの文字列が等しいかどうかを決定するために一般的に適切な (つまり、アイデンティティを決定するため) カルチャに依存する比較では、一方です。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"、序数に基づく比較と DA-DK および EN-US カルチャの規則を使用して評価されます (それぞれが、時の既定のカルチャ、Compareメソッドが呼び出されます)。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". 序数の比較は、その一方で、"AEble"より大きい値を指定するには、"Æble"と"Æble"よりも小さくするには、"Apple"を考慮します。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. .NET Framework 4.5 およびそれ以降のバージョンで実行されている、 Windows 8Windows 8 Unicode 6.0 標準に準拠しているオペレーティング システム、並べ替え、大文字小文字の区別、正規化、および Unicode 文字に関する情報。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 Standard バージョンに依存します。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.StartsWithString.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クラスなど、個々 の文字を検索する、IndexOfメソッド、または、文字のセットのいずれかなど、IndexOfAnyメソッドすべて序数に基づく検索を実行します。The 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. などの合字「Æ」などの構成済みの Unicode 文字の検索 (U + 00 C 6) は"AE"など、正しいシーケンスでは、そのコンポーネントの出現が一致 (U + 041U + 0045)、カルチャによって異なります。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 カルチャの規則を使用する場合が DA-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

その一方で、Stringを検索する文字ではなく、文字列検索オプションが明示的に型のパラメーターで指定されていない場合、カルチャに依存する検索を実行するメソッドをクラスStringComparisonします。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"の代わりにします。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.

序数の比較は、対応する Unicode スカラー値のバイナリ比較をCharそれぞれの文字列。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:

呼び出して、文字列が正規形 C に正規化されたかどうかを判断することができます、String.IsNormalized()またはメソッドを呼び出すことができます、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 Standard Annex #15。Unicode 正規化フォーム正規化 FAQ unicode.org web サイト。For 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 並べ替え順序で 2 つ目の文字列に 1 つの文字列の関係を示す整数を返します。Compare returns an integer that indicates the relationship of one string to a second string in the sort order.

  • CompareOrdinal 文字列がコード ポイントの比較に基づいて、2 番目の文字列を 1 つのリレーションシップを示す整数を返します。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)メソッドを提供、IComparableIComparable<T>の実装、Stringクラス。The CompareTo(String) method provides the IComparable and IComparable<T> implementations for the String class.

文字列が等しいかどうかをテストします。Testing strings for equality

呼び出す、Equalsする 2 つの文字列が等しいかどうかを判断するメソッド。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 つの種類 search メソッドにはが含まれています。The String class includes two kinds of search 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 部分文字列を現在のもう 1 つの部分文字列に置き換えます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:

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

  • Join 1 つの要素に 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

1 つの文字は Unicode では、複数のコード ポイントを持つことができます。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[Int32] Chars[Int32] Chars[Int32] Chars[Int32]

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

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(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)
Contains(Char, StringComparison) Contains(Char, StringComparison) Contains(Char, StringComparison) Contains(Char, StringComparison)
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)
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.

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(StringComparison) GetHashCode(StringComparison) GetHashCode(StringComparison) GetHashCode(StringComparison)
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 occurrrence of the specxified 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(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.

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.

Extension Methods

ToImmutableArray<TSource>(IEnumerable<TSource>) ToImmutableArray<TSource>(IEnumerable<TSource>) ToImmutableArray<TSource>(IEnumerable<TSource>) ToImmutableArray<TSource>(IEnumerable<TSource>)

指定されたコレクションから、変更できない配列を作成します。Creates an immutable array from the specified collection.

ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

ソース キーに変換関数を適用し、変更できないディクショナリを既存の要素のコレクションから作成します。Constructs an immutable dictionary from an existing collection of elements, applying a transformation function to the source keys.

ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

シーケンスの変換に基づき、変更できないディクショナリを作成します。Constructs an immutable dictionary based on some transformation of a sequence.

ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>) ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>) ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>) ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>)

キーと値のペアのシーケンスを列挙し、その内容の変更できないディクショナリを生成します。Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents.

ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>) ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>) ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>) ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>)

キーと値のペアのシーケンスを列挙し、指定されたキーの比較子を使用してその内容の変更できないディクショナリを生成します。Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents by using the specified key comparer.

ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>, IEqualityComparer<TValue>) ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>, IEqualityComparer<TValue>) ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>, IEqualityComparer<TValue>) ToImmutableDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)

キーと値のペアのシーケンスを列挙し、指定されたキーの比較子と値の比較子を使用してその内容の変更できないディクショナリを生成します。Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents by using the specified key and value comparers.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

シーケンスを列挙して変換し、その内容の変更できないディクショナリを生成します。Enumerates and transforms a sequence, and produces an immutable dictionary of its contents.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>) ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>) ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>) ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)

シーケンスを列挙して変換し、指定されたキーの比較子を使用してその内容の変更できないディクショナリを生成します。Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key comparer.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>) ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>) ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>) ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)

シーケンスを列挙して変換し、指定されたキーの比較子および値の比較子を使用してその内容の変更できないディクショナリを生成します。Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key and value comparers.

ToImmutableHashSet<TSource>(IEnumerable<TSource>) ToImmutableHashSet<TSource>(IEnumerable<TSource>) ToImmutableHashSet<TSource>(IEnumerable<TSource>) ToImmutableHashSet<TSource>(IEnumerable<TSource>)

シーケンスを列挙し、その内容の変更できないハッシュ セットを生成します。Enumerates a sequence and produces an immutable hash set of its contents.

ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

シーケンスを列挙し、その内容の変更できないハッシュ セットを生成して、指定された等値比較子をセットの種類に使用します。Enumerates a sequence, produces an immutable hash set of its contents, and uses the specified equality comparer for the set type.

ToImmutableList<TSource>(IEnumerable<TSource>) ToImmutableList<TSource>(IEnumerable<TSource>) ToImmutableList<TSource>(IEnumerable<TSource>) ToImmutableList<TSource>(IEnumerable<TSource>)

シーケンスを列挙し、その内容の変更できないリストを生成します。Enumerates a sequence and produces an immutable list of its contents.

ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>) ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>) ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>) ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>)

キーと値のペアのシーケンスを列挙し、その内容の変更できない並べ替えられたディクショナリを生成します。Enumerates a sequence of key/value pairs and produces an immutable sorted dictionary of its contents.

ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IComparer<TKey>) ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IComparer<TKey>) ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IComparer<TKey>) ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IComparer<TKey>)

キーと値のペアのシーケンスを列挙し、指定されたキーの比較子を使用してその内容の変更できないディクショナリを生成します。Enumerates a sequence of key/value pairs and produces an immutable dictionary of its contents by using the specified key comparer.

ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IComparer<TKey>, IEqualityComparer<TValue>) ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IComparer<TKey>, IEqualityComparer<TValue>) ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IComparer<TKey>, IEqualityComparer<TValue>) ToImmutableSortedDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IComparer<TKey>, IEqualityComparer<TValue>)

キーと値のペアのシーケンスを列挙し、指定されたキーの比較子と値の比較子を使用してその内容の変更できない並べ替えられたディクショナリを生成します。Enumerates a sequence of key/value pairs and produces an immutable sorted dictionary of its contents by using the specified key and value comparers.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

シーケンスを列挙して変換し、その内容の変更できない並べ替えられたディクショナリを生成します。Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>) ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>) ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>) ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)

シーケンスを列挙して変換し、指定されたキーの比較子を使用してその内容の変更できない並べ替えられたディクショナリを生成します。Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key comparer.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>) ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>) ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>) ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)

シーケンスを列挙して変換し、指定されたキーの比較子と値の比較子を使用してその内容の変更できない並べ替えられたディクショナリを生成します。Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key and value comparers.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>) ToImmutableSortedSet<TSource>(IEnumerable<TSource>) ToImmutableSortedSet<TSource>(IEnumerable<TSource>) ToImmutableSortedSet<TSource>(IEnumerable<TSource>)

シーケンスを列挙し、その内容の変更できない並べ替えられたセットを生成します。Enumerates a sequence and produces an immutable sorted set of its contents.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>) ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>) ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>) ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)

シーケンスを列挙し、その内容の変更できない並べ替えられたセットを生成して、指定された比較子を使用します。Enumerates a sequence, produces an immutable sorted set of its contents, and uses the specified comparer.

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.

Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>) Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>) Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>) Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)

シーケンスにアキュムレータ関数を適用します。Applies an accumulator function over a sequence.

Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>) Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>) Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>) Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)

シーケンスにアキュムレータ関数を適用します。Applies an accumulator function over a sequence. 指定されたシード値が最初のアキュムレータ値として使用されます。The specified seed value is used as the initial accumulator value.

Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>) Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>) Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>) Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)

シーケンスにアキュムレータ関数を適用します。Applies an accumulator function over a sequence. 指定したシード値は最初のアキュムレータ値として使用され、指定した関数は結果値の選択に使用されます。The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.

All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

シーケンスのすべての要素が条件を満たしているかどうかを判断します。Determines whether all elements of a sequence satisfy a condition.

Any<TSource>(IEnumerable<TSource>) Any<TSource>(IEnumerable<TSource>) Any<TSource>(IEnumerable<TSource>) Any<TSource>(IEnumerable<TSource>)

シーケンスに要素が含まれているかどうかを判断します。Determines whether a sequence contains any elements.

Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

シーケンスの任意の要素が条件を満たしているかどうかを判断します。Determines whether any element of a sequence satisfies a condition.

Append<TSource>(IEnumerable<TSource>, TSource) Append<TSource>(IEnumerable<TSource>, TSource) Append<TSource>(IEnumerable<TSource>, TSource) Append<TSource>(IEnumerable<TSource>, TSource)

シーケンスの末尾に値を追加します。Appends a value to the end of the sequence.

AsEnumerable<TSource>(IEnumerable<TSource>) AsEnumerable<TSource>(IEnumerable<TSource>) AsEnumerable<TSource>(IEnumerable<TSource>) AsEnumerable<TSource>(IEnumerable<TSource>)

IEnumerable<T> として型指定された入力を返します。Returns the input typed as IEnumerable<T>.

Average(IEnumerable<Decimal>) Average(IEnumerable<Decimal>) Average(IEnumerable<Decimal>) Average(IEnumerable<Decimal>)

Decimal 値のシーケンスの平均値を計算します。Computes the average of a sequence of Decimal values.

Average(IEnumerable<Double>) Average(IEnumerable<Double>) Average(IEnumerable<Double>) Average(IEnumerable<Double>)

Double 値のシーケンスの平均値を計算します。Computes the average of a sequence of Double values.

Average(IEnumerable<Int32>) Average(IEnumerable<Int32>) Average(IEnumerable<Int32>) Average(IEnumerable<Int32>)

Int32 値のシーケンスの平均値を計算します。Computes the average of a sequence of Int32 values.

Average(IEnumerable<Int64>) Average(IEnumerable<Int64>) Average(IEnumerable<Int64>) Average(IEnumerable<Int64>)

Int64 値のシーケンスの平均値を計算します。Computes the average of a sequence of Int64 values.

Average(IEnumerable<Nullable<Decimal>>) Average(IEnumerable<Nullable<Decimal>>) Average(IEnumerable<Nullable<Decimal>>) Average(IEnumerable<Nullable<Decimal>>)

Null 許容型の Decimal 値のシーケンスの平均を計算します。Computes the average of a sequence of nullable Decimal values.

Average(IEnumerable<Nullable<Double>>) Average(IEnumerable<Nullable<Double>>) Average(IEnumerable<Nullable<Double>>) Average(IEnumerable<Nullable<Double>>)

Null 許容型の Double 値のシーケンスの平均を計算します。Computes the average of a sequence of nullable Double values.

Average(IEnumerable<Nullable<Int32>>) Average(IEnumerable<Nullable<Int32>>) Average(IEnumerable<Nullable<Int32>>) Average(IEnumerable<Nullable<Int32>>)

Null 許容型の Int32 値のシーケンスの平均を計算します。Computes the average of a sequence of nullable Int32 values.

Average(IEnumerable<Nullable<Int64>>) Average(IEnumerable<Nullable<Int64>>) Average(IEnumerable<Nullable<Int64>>) Average(IEnumerable<Nullable<Int64>>)

Null 許容型の Int64 値のシーケンスの平均を計算します。Computes the average of a sequence of nullable Int64 values.

Average(IEnumerable<Nullable<Single>>) Average(IEnumerable<Nullable<Single>>) Average(IEnumerable<Nullable<Single>>) Average(IEnumerable<Nullable<Single>>)

Null 許容型の Single 値のシーケンスの平均を計算します。Computes the average of a sequence of nullable Single values.

Average(IEnumerable<Single>) Average(IEnumerable<Single>) Average(IEnumerable<Single>) Average(IEnumerable<Single>)

Single 値のシーケンスの平均値を計算します。Computes the average of a sequence of Single values.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

入力シーケンスの各要素に対して変換関数を呼び出して取得する Decimal 値のシーケンスの平均値を計算します。Computes the average of a sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

入力シーケンスの各要素に対して変換関数を呼び出して取得する Double 値のシーケンスの平均値を計算します。Computes the average of a sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

入力シーケンスの各要素に対して変換関数を呼び出して取得する Int32 値のシーケンスの平均値を計算します。Computes the average of a sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

入力シーケンスの各要素に対して変換関数を呼び出して取得する Int64 値のシーケンスの平均値を計算します。Computes the average of a sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

入力シーケンスの各要素に対して変換関数を呼び出して取得する null 許容の Decimal 値のシーケンスの平均値を計算します。Computes the average of a sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

入力シーケンスの各要素に対して変換関数を呼び出して取得する null 許容の Double 値のシーケンスの平均値を計算します。Computes the average of a sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

入力シーケンスの各要素に対して変換関数を呼び出して取得する null 許容の Int32 値のシーケンスの平均値を計算します。Computes the average of a sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

入力シーケンスの各要素に対して変換関数を呼び出して取得する null 許容の Int64 値のシーケンスの平均値を計算します。Computes the average of a sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

入力シーケンスの各要素に対して変換関数を呼び出して取得する null 許容の Single 値のシーケンスの平均値を計算します。Computes the average of a sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

入力シーケンスの各要素に対して変換関数を呼び出して取得する Single 値のシーケンスの平均値を計算します。Computes the average of a sequence of Single values that are obtained by invoking a transform function on each element of the input sequence.

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

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

Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

2 つのシーケンスを連結します。Concatenates two sequences.

Contains<TSource>(IEnumerable<TSource>, TSource) Contains<TSource>(IEnumerable<TSource>, TSource) Contains<TSource>(IEnumerable<TSource>, TSource) Contains<TSource>(IEnumerable<TSource>, TSource)

既定の等値比較子を使用して、指定した要素がシーケンスに含まれているかどうかを判断します。Determines whether a sequence contains a specified element by using the default equality comparer.

Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>) Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>) Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>) Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)

指定した IEqualityComparer<T> を使用して、指定した要素がシーケンスに含まれているかどうかを判断します。Determines whether a sequence contains a specified element by using a specified IEqualityComparer<T>.

Count<TSource>(IEnumerable<TSource>) Count<TSource>(IEnumerable<TSource>) Count<TSource>(IEnumerable<TSource>) Count<TSource>(IEnumerable<TSource>)

シーケンス内の要素数を返します。Returns the number of elements in a sequence.

Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

条件を満たす、指定されたシーケンス内の要素の数を表す数値を返します。Returns a number that represents how many elements in the specified sequence satisfy a condition.

DefaultIfEmpty<TSource>(IEnumerable<TSource>) DefaultIfEmpty<TSource>(IEnumerable<TSource>) DefaultIfEmpty<TSource>(IEnumerable<TSource>) DefaultIfEmpty<TSource>(IEnumerable<TSource>)

指定したシーケンスの要素を返します。シーケンスが空の場合はシングルトン コレクションにある型パラメーターの既定値を返します。Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.

DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource) DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource) DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource) DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)

指定されたシーケンスの要素を返します。シーケンスが空の場合はシングルトン コレクションにある型パラメーターの既定値を返します。Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.

Distinct<TSource>(IEnumerable<TSource>) Distinct<TSource>(IEnumerable<TSource>) Distinct<TSource>(IEnumerable<TSource>) Distinct<TSource>(IEnumerable<TSource>)

既定の等値比較子を使用して値を比較することにより、シーケンスから一意の要素を返します。Returns distinct elements from a sequence by using the default equality comparer to compare values.

Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

指定された IEqualityComparer<T> を使用して値を比較することにより、シーケンスから一意の要素を返します。Returns distinct elements from a sequence by using a specified IEqualityComparer<T> to compare values.

ElementAt<TSource>(IEnumerable<TSource>, Int32) ElementAt<TSource>(IEnumerable<TSource>, Int32) ElementAt<TSource>(IEnumerable<TSource>, Int32) ElementAt<TSource>(IEnumerable<TSource>, Int32)

シーケンス内の指定されたインデックス位置にある要素を返します。Returns the element at a specified index in a sequence.

ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32) ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32) ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32) ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)

シーケンス内の指定したインデックス位置にある要素を返します。インデックスが範囲外の場合は既定値を返します。Returns the element at a specified index in a sequence or a default value if the index is out of range.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

既定の等値比較子を使用して値を比較することにより、2 つのシーケンスの差集合を生成します。Produces the set difference of two sequences by using the default equality comparer to compare values.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

指定された IEqualityComparer<T> を使用して値を比較することにより、2 つのシーケンスの差集合を生成します。Produces the set difference of two sequences by using the specified IEqualityComparer<T> to compare values.

First<TSource>(IEnumerable<TSource>) First<TSource>(IEnumerable<TSource>) First<TSource>(IEnumerable<TSource>) First<TSource>(IEnumerable<TSource>)

シーケンスの最初の要素を返します。Returns the first element of a sequence.

First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

指定された条件を満たす、シーケンスの最初の要素を返します。Returns the first element in a sequence that satisfies a specified condition.

FirstOrDefault<TSource>(IEnumerable<TSource>) FirstOrDefault<TSource>(IEnumerable<TSource>) FirstOrDefault<TSource>(IEnumerable<TSource>) FirstOrDefault<TSource>(IEnumerable<TSource>)

シーケンスの最初の要素を返します。シーケンスに要素が含まれていない場合は既定値を返します。Returns the first element of a sequence, or a default value if the sequence contains no elements.

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

条件を満たす、シーケンスの最初の要素を返します。このような要素が見つからない場合は既定値を返します。Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

指定されたキー セレクター関数に従ってシーケンスの要素をグループ化します。Groups the elements of a sequence according to a specified key selector function.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

指定されたキー セレクター関数に従ってシーケンスの要素をグループ化し、指定された比較子を使用してキーを比較します。Groups the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

指定されたキー セレクター関数に従ってシーケンスの要素をグループ化し、指定された関数を使用して各グループの要素を射影します。Groups the elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

キー セレクター関数に従ってシーケンスの要素をグループ化します。Groups the elements of a sequence according to a key selector function. キーの比較には、比較子を使用し、各グループの要素の射影には、指定された関数を使用します。The keys are compared by using a comparer and each group's elements are projected by using a specified function.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>) GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>) GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>) GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)

指定されたキー セレクター関数に従ってシーケンスの要素をグループ化し、各グループとそのキーから結果値を作成します。Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>) GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>) GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>) GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)

指定されたキー セレクター関数に従ってシーケンスの要素をグループ化し、各グループとそのキーから結果値を作成します。Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. キーの比較には、指定された比較子を使用します。The keys are compared by using a specified comparer.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>) GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>) GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>) GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)

指定されたキー セレクター関数に従ってシーケンスの要素をグループ化し、各グループとそのキーから結果値を作成します。Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. 各グループの要素は、指定された関数を使用して射影されます。The elements of each group are projected by using a specified function.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>, IEqualityComparer<TKey>) GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>, IEqualityComparer<TKey>) GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>, IEqualityComparer<TKey>) GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>, IEqualityComparer<TKey>)

指定されたキー セレクター関数に従ってシーケンスの要素をグループ化し、各グループとそのキーから結果値を作成します。Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. キー値の比較には、指定された比較子を使用し、各グループの要素の射影には、指定された関数を使用します。Key values are compared by using a specified comparer, and the elements of each group are projected by using a specified function.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>) GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>) GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>) GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>)

キーが等しいかどうかに基づいて 2 つのシーケンスの要素を相互に関連付け、その結果をグループ化します。Correlates the elements of two sequences based on equality of keys and groups the results. キーの比較には既定の等値比較子が使用されます。The default equality comparer is used to compare keys.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>, IEqualityComparer<TKey>) GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>, IEqualityComparer<TKey>) GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>, IEqualityComparer<TKey>) GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>, IEqualityComparer<TKey>)

キーが等しいかどうかに基づいて 2 つのシーケンスの要素を相互に関連付け、その結果をグループ化します。Correlates the elements of two sequences based on key equality and groups the results. 指定された IEqualityComparer<T> を使用してキーを比較します。A specified IEqualityComparer<T> is used to compare keys.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

既定の等値比較子を使用して値を比較することにより、2 つのシーケンスの積集合を生成します。Produces the set intersection of two sequences by using the default equality comparer to compare values.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

指定された IEqualityComparer<T> を使用して値を比較することにより、2 つのシーケンスの積集合を生成します。Produces the set intersection of two sequences by using the specified IEqualityComparer<T> to compare values.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>) Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>) Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>) Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)

一致するキーに基づいて 2 つのシーケンスの要素を相互に関連付けます。Correlates the elements of two sequences based on matching keys. キーの比較には既定の等値比較子が使用されます。The default equality comparer is used to compare keys.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>) Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>) Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>) Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)

一致するキーに基づいて 2 つのシーケンスの要素を相互に関連付けます。Correlates the elements of two sequences based on matching keys. 指定された IEqualityComparer<T> を使用してキーを比較します。A specified IEqualityComparer<T> is used to compare keys.

Last<TSource>(IEnumerable<TSource>) Last<TSource>(IEnumerable<TSource>) Last<TSource>(IEnumerable<TSource>) Last<TSource>(IEnumerable<TSource>)

シーケンスの最後の要素を返します。Returns the last element of a sequence.

Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

指定された条件を満たす、シーケンスの最後の要素を返します。Returns the last element of a sequence that satisfies a specified condition.

LastOrDefault<TSource>(IEnumerable<TSource>) LastOrDefault<TSource>(IEnumerable<TSource>) LastOrDefault<TSource>(IEnumerable<TSource>) LastOrDefault<TSource>(IEnumerable<TSource>)

シーケンスの最後の要素を返します。シーケンスに要素が含まれていない場合は既定値を返します。Returns the last element of a sequence, or a default value if the sequence contains no elements.

LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

条件を満たす、シーケンスの最後の要素を返します。このような要素が見つからない場合は既定値を返します。Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.

LongCount<TSource>(IEnumerable<TSource>) LongCount<TSource>(IEnumerable<TSource>) LongCount<TSource>(IEnumerable<TSource>) LongCount<TSource>(IEnumerable<TSource>)

シーケンス内の要素の合計数を表す Int64 を返します。Returns an Int64 that represents the total number of elements in a sequence.

LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

シーケンス内で条件を満たす要素の数を表す Int64 を返します。Returns an Int64 that represents how many elements in a sequence satisfy a condition.

Max(IEnumerable<Decimal>) Max(IEnumerable<Decimal>) Max(IEnumerable<Decimal>) Max(IEnumerable<Decimal>)

Decimal 値のシーケンスの最大値を返します。Returns the maximum value in a sequence of Decimal values.

Max(IEnumerable<Double>) Max(IEnumerable<Double>) Max(IEnumerable<Double>) Max(IEnumerable<Double>)

Double 値のシーケンスの最大値を返します。Returns the maximum value in a sequence of Double values.

Max(IEnumerable<Int32>) Max(IEnumerable<Int32>) Max(IEnumerable<Int32>) Max(IEnumerable<Int32>)

Int32 値のシーケンスの最大値を返します。Returns the maximum value in a sequence of Int32 values.

Max(IEnumerable<Int64>) Max(IEnumerable<Int64>) Max(IEnumerable<Int64>) Max(IEnumerable<Int64>)

Int64 値のシーケンスの最大値を返します。Returns the maximum value in a sequence of Int64 values.

Max(IEnumerable<Nullable<Decimal>>) Max(IEnumerable<Nullable<Decimal>>) Max(IEnumerable<Nullable<Decimal>>) Max(IEnumerable<Nullable<Decimal>>)

null 許容の Decimal 値のシーケンスの最大値を返します。Returns the maximum value in a sequence of nullable Decimal values.

Max(IEnumerable<Nullable<Double>>) Max(IEnumerable<Nullable<Double>>) Max(IEnumerable<Nullable<Double>>) Max(IEnumerable<Nullable<Double>>)

null 許容の Double 値のシーケンスの最大値を返します。Returns the maximum value in a sequence of nullable Double values.

Max(IEnumerable<Nullable<Int32>>) Max(IEnumerable<Nullable<Int32>>) Max(IEnumerable<Nullable<Int32>>) Max(IEnumerable<Nullable<Int32>>)

null 許容の Int32 値のシーケンスの最大値を返します。Returns the maximum value in a sequence of nullable Int32 values.

Max(IEnumerable<Nullable<Int64>>) Max(IEnumerable<Nullable<Int64>>) Max(IEnumerable<Nullable<Int64>>) Max(IEnumerable<Nullable<Int64>>)

null 許容の Int64 値のシーケンスの最大値を返します。Returns the maximum value in a sequence of nullable Int64 values.

Max(IEnumerable<Nullable<Single>>) Max(IEnumerable<Nullable<Single>>) Max(IEnumerable<Nullable<Single>>) Max(IEnumerable<Nullable<Single>>)

null 許容の Single 値のシーケンスの最大値を返します。Returns the maximum value in a sequence of nullable Single values.

Max(IEnumerable<Single>) Max(IEnumerable<Single>) Max(IEnumerable<Single>) Max(IEnumerable<Single>)

Single 値のシーケンスの最大値を返します。Returns the maximum value in a sequence of Single values.

Max<TSource>(IEnumerable<TSource>) Max<TSource>(IEnumerable<TSource>) Max<TSource>(IEnumerable<TSource>) Max<TSource>(IEnumerable<TSource>)

ジェネリック シーケンスの最大値を返します。Returns the maximum value in a generic sequence.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

シーケンスの各要素に対して変換関数を呼び出し、Decimal の最大値を返します。Invokes a transform function on each element of a sequence and returns the maximum Decimal value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

シーケンスの各要素に対して変換関数を呼び出し、Double の最大値を返します。Invokes a transform function on each element of a sequence and returns the maximum Double value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

シーケンスの各要素に対して変換関数を呼び出し、Int32 の最大値を返します。Invokes a transform function on each element of a sequence and returns the maximum Int32 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

シーケンスの各要素に対して変換関数を呼び出し、Int64 の最大値を返します。Invokes a transform function on each element of a sequence and returns the maximum Int64 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

シーケンスの各要素に対して変換関数を呼び出し、null 許容の Decimal の最大値を返します。Invokes a transform function on each element of a sequence and returns the maximum nullable Decimal value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

シーケンスの各要素に対して変換関数を呼び出し、null 許容の Double の最大値を返します。Invokes a transform function on each element of a sequence and returns the maximum nullable Double value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

シーケンスの各要素に対して変換関数を呼び出し、null 許容の Int32 の最大値を返します。Invokes a transform function on each element of a sequence and returns the maximum nullable Int32 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

シーケンスの各要素に対して変換関数を呼び出し、null 許容の Int64 の最大値を返します。Invokes a transform function on each element of a sequence and returns the maximum nullable Int64 value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

シーケンスの各要素に対して変換関数を呼び出し、null 許容の Single の最大値を返します。Invokes a transform function on each element of a sequence and returns the maximum nullable Single value.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

シーケンスの各要素に対して変換関数を呼び出し、Single の最大値を返します。Invokes a transform function on each element of a sequence and returns the maximum Single value.

Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

ジェネリック シーケンスの各要素に対して変換関数を呼び出し、結果の最大値を返します。Invokes a transform function on each element of a generic sequence and returns the maximum resulting value.

Min(IEnumerable<Decimal>) Min(IEnumerable<Decimal>) Min(IEnumerable<Decimal>) Min(IEnumerable<Decimal>)

Decimal 値のシーケンスの最小値を返します。Returns the minimum value in a sequence of Decimal values.

Min(IEnumerable<Double>) Min(IEnumerable<Double>) Min(IEnumerable<Double>) Min(IEnumerable<Double>)

Double 値のシーケンスの最小値を返します。Returns the minimum value in a sequence of Double values.

Min(IEnumerable<Int32>) Min(IEnumerable<Int32>) Min(IEnumerable<Int32>) Min(IEnumerable<Int32>)

Int32 値のシーケンスの最小値を返します。Returns the minimum value in a sequence of Int32 values.

Min(IEnumerable<Int64>) Min(IEnumerable<Int64>) Min(IEnumerable<Int64>) Min(IEnumerable<Int64>)

Int64 値のシーケンスの最小値を返します。Returns the minimum value in a sequence of Int64 values.

Min(IEnumerable<Nullable<Decimal>>) Min(IEnumerable<Nullable<Decimal>>) Min(IEnumerable<Nullable<Decimal>>) Min(IEnumerable<Nullable<Decimal>>)

null 許容の Decimal 値のシーケンスの最小値を返します。Returns the minimum value in a sequence of nullable Decimal values.

Min(IEnumerable<Nullable<Double>>) Min(IEnumerable<Nullable<Double>>) Min(IEnumerable<Nullable<Double>>) Min(IEnumerable<Nullable<Double>>)

null 許容の Double 値のシーケンスの最小値を返します。Returns the minimum value in a sequence of nullable Double values.

Min(IEnumerable<Nullable<Int32>>) Min(IEnumerable<Nullable<Int32>>) Min(IEnumerable<Nullable<Int32>>) Min(IEnumerable<Nullable<Int32>>)

null 許容の Int32 値のシーケンスの最小値を返します。Returns the minimum value in a sequence of nullable Int32 values.

Min(IEnumerable<Nullable<Int64>>) Min(IEnumerable<Nullable<Int64>>) Min(IEnumerable<Nullable<Int64>>) Min(IEnumerable<Nullable<Int64>>)

null 許容の Int64 値のシーケンスの最小値を返します。Returns the minimum value in a sequence of nullable Int64 values.

Min(IEnumerable<Nullable<Single>>) Min(IEnumerable<Nullable<Single>>) Min(IEnumerable<Nullable<Single>>) Min(IEnumerable<Nullable<Single>>)

null 許容の Single 値のシーケンスの最小値を返します。Returns the minimum value in a sequence of nullable Single values.

Min(IEnumerable<Single>) Min(IEnumerable<Single>) Min(IEnumerable<Single>) Min(IEnumerable<Single>)

Single 値のシーケンスの最小値を返します。Returns the minimum value in a sequence of Single values.

Min<TSource>(IEnumerable<TSource>) Min<TSource>(IEnumerable<TSource>) Min<TSource>(IEnumerable<TSource>) Min<TSource>(IEnumerable<TSource>)

ジェネリック シーケンスの最小値を返します。Returns the minimum value in a generic sequence.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

シーケンスの各要素に対して変換関数を呼び出し、Decimal の最小値を返します。Invokes a transform function on each element of a sequence and returns the minimum Decimal value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

シーケンスの各要素に対して変換関数を呼び出し、Double の最小値を返します。Invokes a transform function on each element of a sequence and returns the minimum Double value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

シーケンスの各要素に対して変換関数を呼び出し、Int32 の最小値を返します。Invokes a transform function on each element of a sequence and returns the minimum Int32 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

シーケンスの各要素に対して変換関数を呼び出し、Int64 の最小値を返します。Invokes a transform function on each element of a sequence and returns the minimum Int64 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

シーケンスの各要素に対して変換関数を呼び出し、null 許容の Decimal の最小値を返します。Invokes a transform function on each element of a sequence and returns the minimum nullable Decimal value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

シーケンスの各要素に対して変換関数を呼び出し、null 許容の Double の最小値を返します。Invokes a transform function on each element of a sequence and returns the minimum nullable Double value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

シーケンスの各要素に対して変換関数を呼び出し、null 許容の Int32 の最小値を返します。Invokes a transform function on each element of a sequence and returns the minimum nullable Int32 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

シーケンスの各要素に対して変換関数を呼び出し、null 許容の Int64 の最小値を返します。Invokes a transform function on each element of a sequence and returns the minimum nullable Int64 value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

シーケンスの各要素に対して変換関数を呼び出し、null 許容の Single の最小値を返します。Invokes a transform function on each element of a sequence and returns the minimum nullable Single value.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>) Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

シーケンスの各要素に対して変換関数を呼び出し、Single の最小値を返します。Invokes a transform function on each element of a sequence and returns the minimum Single value.

Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

ジェネリック シーケンスの各要素に対して変換関数を呼び出し、結果の最小値を返します。Invokes a transform function on each element of a generic sequence and returns the minimum resulting value.

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

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

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

シーケンスの要素をキーに従って昇順に並べ替えます。Sorts the elements of a sequence in ascending order according to a key.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

指定された比較子を使用してシーケンスの要素を昇順に並べ替えます。Sorts the elements of a sequence in ascending order by using a specified comparer.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

シーケンスの要素をキーに従って降順に並べ替えます。Sorts the elements of a sequence in descending order according to a key.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

指定された比較子を使用してシーケンスの要素を降順に並べ替えます。Sorts the elements of a sequence in descending order by using a specified comparer.

Prepend<TSource>(IEnumerable<TSource>, TSource) Prepend<TSource>(IEnumerable<TSource>, TSource) Prepend<TSource>(IEnumerable<TSource>, TSource) Prepend<TSource>(IEnumerable<TSource>, TSource)

シーケンスの先頭に値を追加します。Adds a value to the beginning of the sequence.

Reverse<TSource>(IEnumerable<TSource>) Reverse<TSource>(IEnumerable<TSource>) Reverse<TSource>(IEnumerable<TSource>) Reverse<TSource>(IEnumerable<TSource>)

シーケンスの要素の順序を反転させます。Inverts the order of the elements in a sequence.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

シーケンスの各要素を新しいフォームに射影します。Projects each element of a sequence into a new form.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>) Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>) Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>) Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)

要素のインデックスを組み込むことにより、シーケンスの各要素を新しいフォームに射影します。Projects each element of a sequence into a new form by incorporating the element's index.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)

シーケンスの各要素を IEnumerable<T> に射影し、結果のシーケンスを 1 つのシーケンスに平坦化します。Projects each element of a sequence to an IEnumerable<T> and flattens the resulting sequences into one sequence.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)

シーケンスの各要素を IEnumerable<T> に射影し、結果のシーケンスを 1 つのシーケンスに平坦化します。Projects each element of a sequence to an IEnumerable<T>, and flattens the resulting sequences into one sequence. 各ソース要素のインデックスは、その要素の射影されたフォームで使用されます。The index of each source element is used in the projected form of that element.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

シーケンスの各要素を IEnumerable<T> に射影し、結果のシーケンスを 1 つのシーケンスに平坦化して、その各要素に対して結果のセレクター関数を呼び出します。Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

シーケンスの各要素を IEnumerable<T> に射影し、結果のシーケンスを 1 つのシーケンスに平坦化して、その各要素に対して結果のセレクター関数を呼び出します。Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. 各ソース要素のインデックスは、その要素の中間の射影されたフォームで使用されます。The index of each source element is used in the intermediate projected form of that element.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

要素の型に対して既定の等値比較子を使用して要素を比較することで、2 つのシーケンスが等しいかどうかを判断します。Determines whether two sequences are equal by comparing the elements by using the default equality comparer for their type.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

指定された IEqualityComparer<T> を使用して要素を比較することで、2 つのシーケンスが等しいかどうかを判断します。Determines whether two sequences are equal by comparing their elements by using a specified IEqualityComparer<T>.

Single<TSource>(IEnumerable<TSource>) Single<TSource>(IEnumerable<TSource>) Single<TSource>(IEnumerable<TSource>) Single<TSource>(IEnumerable<TSource>)

シーケンスの唯一の要素を返し、シーケンス内の要素が 1 つだけでない場合は例外をスローします。Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.

Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

指定された条件を満たす、シーケンスの唯一の要素を返し、そのような要素が複数存在する場合は例外をスローします。Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.

SingleOrDefault<TSource>(IEnumerable<TSource>) SingleOrDefault<TSource>(IEnumerable<TSource>) SingleOrDefault<TSource>(IEnumerable<TSource>) SingleOrDefault<TSource>(IEnumerable<TSource>)

シーケンスの唯一の要素を返します。シーケンスが空の場合、既定値を返します。シーケンス内に要素が複数ある場合、このメソッドは例外をスローします。Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.

SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

指定された条件を満たすシーケンスの唯一の要素、またはそのような要素がない場合は既定値を返します。このメソッドは、複数の要素が条件を満たす場合に例外をスローします。Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition.

Skip<TSource>(IEnumerable<TSource>, Int32) Skip<TSource>(IEnumerable<TSource>, Int32) Skip<TSource>(IEnumerable<TSource>, Int32) Skip<TSource>(IEnumerable<TSource>, Int32)

シーケンス内の指定された数の要素をバイパスし、残りの要素を返します。Bypasses a specified number of elements in a sequence and then returns the remaining elements.

SkipLast<TSource>(IEnumerable<TSource>, Int32) SkipLast<TSource>(IEnumerable<TSource>, Int32) SkipLast<TSource>(IEnumerable<TSource>, Int32) SkipLast<TSource>(IEnumerable<TSource>, Int32)
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

指定された条件が満たされる限り、シーケンスの要素をバイパスした後、残りの要素を返します。Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

指定された条件が満たされる限り、シーケンスの要素をバイパスした後、残りの要素を返します。Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. 要素のインデックスは、述語関数のロジックで使用されます。The element's index is used in the logic of the predicate function.

Sum(IEnumerable<Decimal>) Sum(IEnumerable<Decimal>) Sum(IEnumerable<Decimal>) Sum(IEnumerable<Decimal>)

Decimal 値のシーケンスの合計を計算します。Computes the sum of a sequence of Decimal values.

Sum(IEnumerable<Double>) Sum(IEnumerable<Double>) Sum(IEnumerable<Double>) Sum(IEnumerable<Double>)

Double 値のシーケンスの合計を計算します。Computes the sum of a sequence of Double values.

Sum(IEnumerable<Int32>) Sum(IEnumerable<Int32>) Sum(IEnumerable<Int32>) Sum(IEnumerable<Int32>)

Int32 値のシーケンスの合計を計算します。Computes the sum of a sequence of Int32 values.

Sum(IEnumerable<Int64>) Sum(IEnumerable<Int64>) Sum(IEnumerable<Int64>) Sum(IEnumerable<Int64>)

Int64 値のシーケンスの合計を計算します。Computes the sum of a sequence of Int64 values.

Sum(IEnumerable<Nullable<Decimal>>) Sum(IEnumerable<Nullable<Decimal>>) Sum(IEnumerable<Nullable<Decimal>>) Sum(IEnumerable<Nullable<Decimal>>)

null 許容の Decimal 値のシーケンスの合計を計算します。Computes the sum of a sequence of nullable Decimal values.

Sum(IEnumerable<Nullable<Double>>) Sum(IEnumerable<Nullable<Double>>) Sum(IEnumerable<Nullable<Double>>) Sum(IEnumerable<Nullable<Double>>)

null 許容の Double 値のシーケンスの合計を計算します。Computes the sum of a sequence of nullable Double values.

Sum(IEnumerable<Nullable<Int32>>) Sum(IEnumerable<Nullable<Int32>>) Sum(IEnumerable<Nullable<Int32>>) Sum(IEnumerable<Nullable<Int32>>)

null 許容の Int32 値のシーケンスの合計を計算します。Computes the sum of a sequence of nullable Int32 values.

Sum(IEnumerable<Nullable<Int64>>) Sum(IEnumerable<Nullable<Int64>>) Sum(IEnumerable<Nullable<Int64>>) Sum(IEnumerable<Nullable<Int64>>)

null 許容の Int64 値のシーケンスの合計を計算します。Computes the sum of a sequence of nullable Int64 values.

Sum(IEnumerable<Nullable<Single>>) Sum(IEnumerable<Nullable<Single>>) Sum(IEnumerable<Nullable<Single>>) Sum(IEnumerable<Nullable<Single>>)

null 許容の Single 値のシーケンスの合計を計算します。Computes the sum of a sequence of nullable Single values.

Sum(IEnumerable<Single>) Sum(IEnumerable<Single>) Sum(IEnumerable<Single>) Sum(IEnumerable<Single>)

Single 値のシーケンスの合計を計算します。Computes the sum of a sequence of Single values.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

入力シーケンスの各要素に対して変換関数を呼び出して取得する Decimal 値のシーケンスの合計を計算します。Computes the sum of the sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

入力シーケンスの各要素に対して変換関数を呼び出して取得する Double 値のシーケンスの合計を計算します。Computes the sum of the sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)