セールス: 1-800-867-1380
目次を折りたたむ
目次を展開する
展開 最小化
この記事は機械翻訳されたものです。 記事の文章にポインターを重ねると、原文のテキストが表示されます。 詳細情報
訳文
原文
情報
要求されたトピックは次のとおりです。しかし、このトピックはこのライブラリには含まれていません。

String クラス

 

テキストを一連の Unicode 文字として表現します。

この型の .NET Framework ソース コードを参照するには、参照ソースをご覧ください。

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

System.Object
  System.String

[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class String : IComparable, ICloneable, IConvertible, 
	IEnumerable, IComparable<string>, IEnumerable<char>, IEquatable<string>

名前説明
System_CAPS_pubmethodString(Char*)

String クラスの新しいインスタンスを初期化し、指定した Unicode 文字配列を指すポインターにより示される値に設定します。

System_CAPS_pubmethodString(Char*, Int32, Int32)

String クラスの新しいインスタンスを初期化し、Unicode 文字の配列を指す指定のポインター、配列内の開始文字位置、および長さにより示される値に設定します。

System_CAPS_pubmethodString(Char, Int32)

String クラスの新しいインスタンスを初期化し、指定した回数だけ繰り返した指定の Unicode 文字が示す値に設定します。

System_CAPS_pubmethodString(Char[])

String クラスの新しいインスタンスを初期化し、Unicode 文字の配列により示される値に設定します。

System_CAPS_pubmethodString(Char[], Int32, Int32)

String クラスの新しいインスタンスを初期化し、Unicode 文字の配列、配列内の開始文字位置、および長さにより示される値に設定します。

System_CAPS_pubmethodString(SByte*)

String クラスの新しいインスタンスを初期化し、8 ビット符号付き整数の配列を指すポインターにより示される値に設定します。

System_CAPS_pubmethodString(SByte*, Int32, Int32)

String クラスの新しいインスタンスを初期化し、8 ビット符号付き整数の配列を指す指定のポインター、配列内の開始位置、および長さにより示される値に設定します。

System_CAPS_pubmethodString(SByte*, Int32, Int32, Encoding)

String クラスの新しいインスタンスを初期化し、8 ビット符号付き整数の配列を指す指定のポインター、配列内の開始位置、長さ、および Encoding オブジェクトにより示される値に設定します。

名前説明
System_CAPS_pubpropertyChars[Int32]

現在の Char オブジェクト内の指定した位置にある String オブジェクトを取得します。

System_CAPS_pubpropertyLength

現在の String オブジェクト内の文字数を取得します。

名前説明
System_CAPS_pubmethodClone()

この String インスタンスへの参照を返します。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, Int32, String, Int32, Int32)

指定した 2 つの String オブジェクトの部分文字列を比較し、それらの相対位置を並べ替え順序で示す整数を返します。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, Int32, String, Int32, Int32, Boolean)

指定した 2 つの String オブジェクトの部分文字列を比較し、並べ替え順序におけるそれらの相対位置を示す整数を返します。比較時に、大文字と小文字を区別するかどうかを設定できます。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)

指定した 2 つの String オブジェクトの部分文字列を比較し、並べ替え順序におけるそれらの相対位置を示す整数を返します。比較時に、大文字と小文字を区別するかどうかを指定し、比較に影響を及ぼすカルチャ固有の情報を使用します。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)

指定した 2 つの String オブジェクトの部分文字列を比較し、2 つの部分文字列の互いのリレーションシップを並べ替え順序で示す整数を返します。比較時に、指定した比較オプションと、比較に影響を及ぼすカルチャ固有の情報を使用します。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, Int32, String, Int32, Int32, StringComparison)

指定した規則を使用して、指定した 2 つの String オブジェクトの部分文字列を比較し、並べ替え順序におけるそれらの相対位置を示す整数を返します。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, String)

指定した 2 つの String オブジェクトを比較し、それらの相対位置を並べ替え順序で示す整数を返します。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, String, Boolean)

指定した 2 つの String オブジェクトを比較し、並べ替え順序におけるそれらの相対位置を示す整数を返します。比較時に、大文字と小文字を区別するかどうかを設定できます。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, String, Boolean, CultureInfo)

指定した 2 つの String オブジェクトを比較し、並べ替え順序におけるそれらの相対位置を示す整数を返します。比較時に、大文字と小文字を区別するかどうかを指定し、比較に影響を及ぼすカルチャ固有の情報を使用します。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, String, CultureInfo, CompareOptions)

指定した 2 つの String オブジェクトを比較し、2 つの文字列の互いのリレーションシップを並べ替え順序で示す整数を返します。比較時に、指定した比較オプションと、比較に影響を及ぼすカルチャ固有の情報を使用します。

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, String, StringComparison)

指定した規則を使用して、指定した 2 つの String オブジェクトを比較し、並べ替え順序におけるそれらの相対位置を示す整数を返します。

System_CAPS_pubmethodSystem_CAPS_staticCompareOrdinal(String, Int32, String, Int32, Int32)

それぞれの部分文字列の対応する String オブジェクトの数値を評価することにより、指定した 2 つの Char オブジェクトの部分文字列を比較します。

System_CAPS_pubmethodSystem_CAPS_staticCompareOrdinal(String, String)

それぞれの文字列の対応する String オブジェクトの数値を評価することで、指定した 2 つの Char を比較します。

System_CAPS_pubmethodCompareTo(Object)

このインスタンスと指定した Object とを比較し、並べ替え順序において、このインスタンスの位置が指定した Object の前、後ろ、または同じのいずれであるかを示します。

System_CAPS_pubmethodCompareTo(String)

このインスタンスと指定した String オブジェクトとを比較し、並べ替え順序において、このインスタンスの位置が指定した文字列の前、後ろ、または同じのいずれであるかを示します。

System_CAPS_pubmethodSystem_CAPS_staticConcat(IEnumerable<String>)

IEnumerable<T> 型の構築された String コレクションのメンバーを連結します。

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object)

指定されたオブジェクトの文字列形式を作成します。

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object, Object)

指定した 2 つのオブジェクトの文字列形式を連結します。

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object, Object, Object)

指定した 3 つのオブジェクトの文字列形式を連結します。

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object, Object, Object, Object)

4 つの指定したオブジェクトと、オプションの可変長パラメーター リストで指定した任意のオブジェクトの文字列表現を連結します。

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object[])

指定した Object 配列の要素の文字列形式を連結します。

System_CAPS_pubmethodSystem_CAPS_staticConcat(String, String)

指定した 2 つの String インスタンスを連結します。

System_CAPS_pubmethodSystem_CAPS_staticConcat(String, String, String)

指定した 3 つの String インスタンスを連結します。

System_CAPS_pubmethodSystem_CAPS_staticConcat(String, String, String, String)

指定した 4 つの String インスタンスを連結します。

System_CAPS_pubmethodSystem_CAPS_staticConcat(String[])

指定した String 配列の要素を連結します。

System_CAPS_pubmethodSystem_CAPS_staticConcat<T>(IEnumerable<T>)

IEnumerable<T> 実装のメンバーを連結します。

System_CAPS_pubmethodContains(String)

指定した部分文字列がこの文字列内に存在するかどうかを示す値を返します。

System_CAPS_pubmethodSystem_CAPS_staticCopy(String)

指定した String と同じ値を使用して、String の新しいインスタンスを作成します。

System_CAPS_pubmethodCopyTo(Int32, Char[], Int32, Int32)

このインスタンスの指定位置から指定した数の文字を、Unicode 文字の配列内の指定位置へコピーします。

System_CAPS_pubmethodEndsWith(String)

この文字列インスタンスの末尾が、指定した文字列と一致するかどうかを判断します。

System_CAPS_pubmethodEndsWith(String, Boolean, CultureInfo)

指定されたカルチャを使って比較した場合に、この文字列インスタンスの末尾が、指定された文字列と一致するかどうかを判断します。

System_CAPS_pubmethodEndsWith(String, StringComparison)

指定された比較オプションを使って比較した場合に、この文字列インスタンスの末尾が、指定された文字列と一致するかどうかを判断します。

System_CAPS_pubmethodEquals(Object)

このインスタンスと、指定したオブジェクトの値が同一かどうかを判断します。String オブジェクトを指定する必要があります。(Object.Equals(Object) をオーバーライドする。)

System_CAPS_pubmethodEquals(String)

このインスタンスと、指定した別の String の値が同一かどうかを判断します。

System_CAPS_pubmethodSystem_CAPS_staticEquals(String, String)

指定した 2 つの String オブジェクトの値が同一かどうかを判断します。

System_CAPS_pubmethodSystem_CAPS_staticEquals(String, String, StringComparison)

指定した 2 つの String オブジェクトの値が同一かどうかを判断します。比較に使用するカルチャ、大文字と小文字の区別、および、並べ替え規則をパラメーターで指定します。

System_CAPS_pubmethodEquals(String, StringComparison)

この文字列と、指定した String オブジェクトの値が同一かどうかを判断します。比較に使用するカルチャ、大文字と小文字の区別、および、並べ替え規則をパラメーターで指定します。

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object)

指定した文字列の 1 つまたは複数の書式項目を、対応するオブジェクトの文字列形式に置換します。パラメーターにより、カルチャに固有の書式情報が指定されます。

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object, Object)

指定した文字列の書式項目を、指定した 2 つのオブジェクトの文字列形式に置換します。パラメーターにより、カルチャに固有の書式情報が指定されます。

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object, Object, Object)

指定した文字列の書式項目を、指定した 3 つのオブジェクトの文字列形式に置換します。パラメーターにより、カルチャに固有の書式設定情報を指定します。

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object[])

指定した文字列の書式項目を、指定した配列内の対応するオブジェクトの文字列形式に置換します。パラメーターにより、カルチャに固有の書式情報が指定されます。

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object)

指定した文字列の 1 つまたは複数の書式項目を、指定したオブジェクトの文字列形式に置換します。

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object, Object)

指定した文字列の書式項目を、指定した 2 つのオブジェクトの文字列形式に置換します。

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object, Object, Object)

指定した文字列の書式項目を、指定した 3 つのオブジェクトの文字列形式に置換します。

System_CAPS_pubmethodSystem_CAPS_staticFormat(String, Object[])

指定した文字列の書式項目を、指定した配列内の対応するオブジェクトの文字列形式に置換します。

System_CAPS_pubmethodGetEnumerator()

この文字列に含まれる個々の文字を反復処理するオブジェクトを取得します。

System_CAPS_pubmethodGetHashCode()

この文字列のハッシュ コードを返します。(Object.GetHashCode() をオーバーライドする。)

System_CAPS_pubmethodGetType()

現在のインスタンスの Type を取得します。(Object から継承されました。)

System_CAPS_pubmethodGetTypeCode()

TypeCode クラスには String を返します。

System_CAPS_pubmethodIndexOf(Char)

指定した Unicode 文字がこの文字列内で最初に見つかった位置の 0 から始まるインデックスをレポートします。

System_CAPS_pubmethodIndexOf(Char, Int32)

指定した Unicode 文字がこの文字列内で最初に見つかった位置の 0 から始まるインデックスをレポートします。検索は、指定した文字位置から開始されます。

System_CAPS_pubmethodIndexOf(Char, Int32, Int32)

指定文字がこのインスタンス内で最初に見つかった位置の 0 から始まるインデックスをレポートします。検索は指定した文字位置から開始され、指定した数の文字位置が検査されます。

System_CAPS_pubmethodIndexOf(String)

指定された文字列がこのインスタンス内で最初に見つかった位置の 0 から始まるインデックスをレポートします。

System_CAPS_pubmethodIndexOf(String, Int32)

指定された文字列がこのインスタンス内で最初に見つかった位置の 0 から始まるインデックスをレポートします。検索は、指定した文字位置から開始されます。

System_CAPS_pubmethodIndexOf(String, Int32, Int32)

指定された文字列がこのインスタンス内で最初に見つかった位置の 0 から始まるインデックスをレポートします。検索は指定した文字位置から開始され、指定した数の文字位置が検査されます。

System_CAPS_pubmethodIndexOf(String, Int32, Int32, StringComparison)

指定した文字列が現在の String オブジェクト内で最初に見つかった位置の 0 から始まるインデックスをレポートします。現在の文字列での検索位置、現在の文字列で検索する文字の数、および指定した文字列に使用する検索の種類をパラメーターで指定します。

System_CAPS_pubmethodIndexOf(String, Int32, StringComparison)

指定した文字列が現在の String オブジェクト内で最初に見つかった位置の 0 から始まるインデックスをレポートします。現在の文字列内での検索の開始位置、および指定した文字列に使用する検索の種類をパラメーターで指定します。

System_CAPS_pubmethodIndexOf(String, StringComparison)

指定した文字列が現在の String オブジェクト内で最初に見つかった位置の 0 から始まるインデックスをレポートします。指定した文字列に使用する検索の種類をパラメーターで指定します。

System_CAPS_pubmethodIndexOfAny(Char[])

Unicode 文字の指定した配列内にある文字がこのインスタンスで最初に見つかった位置の 0 から始まるインデックスをレポートします。

System_CAPS_pubmethodIndexOfAny(Char[], Int32)

Unicode 文字の指定した配列内にある文字がこのインスタンスで最初に見つかった位置の 0 から始まるインデックスをレポートします。検索は、指定した文字位置から開始されます。

System_CAPS_pubmethodIndexOfAny(Char[], Int32, Int32)

Unicode 文字の指定した配列内にある文字がこのインスタンスで最初に見つかった位置の 0 から始まるインデックスをレポートします。検索は指定した文字位置から開始され、指定した数の文字位置が検査されます。

System_CAPS_pubmethodInsert(Int32, String)

このインスタンス内の指定したインデックス位置に指定した文字列を挿入した、新しい文字列を返します。

System_CAPS_pubmethodSystem_CAPS_staticIntern(String)

指定した String へのシステム参照を取得します。

System_CAPS_pubmethodSystem_CAPS_staticIsInterned(String)

指定した String への参照を取得します。

System_CAPS_pubmethodIsNormalized()

この文字列が、Unicode 正規形 C であるかどうかを示します。

System_CAPS_pubmethodIsNormalized(NormalizationForm)

この文字列が、指定された Unicode 正規形であるかどうかを示します。

System_CAPS_pubmethodSystem_CAPS_staticIsNullOrEmpty(String)

指定された文字列が null または Empty 文字列であるかどうかを示します。

System_CAPS_pubmethodSystem_CAPS_staticIsNullOrWhiteSpace(String)

指定された文字列が null または空であるか、空白文字だけで構成されているかどうかを示します。

System_CAPS_pubmethodSystem_CAPS_staticJoin(String, IEnumerable<String>)

IEnumerable<T> 型の構築された String コレクションのメンバーを連結します。各メンバーの間には、指定した区切り記号が挿入されます。

System_CAPS_pubmethodSystem_CAPS_staticJoin(String, Object[])

オブジェクト配列の要素を連結します。各要素の間には、指定した区切り記号が挿入されます。

System_CAPS_pubmethodSystem_CAPS_staticJoin(String, String[])

文字列配列のすべての要素を連結します。各要素の間には、指定した区切り記号が挿入されます。

System_CAPS_pubmethodSystem_CAPS_staticJoin(String, String[], Int32, Int32)

文字列配列の指定した要素を連結します。各要素の間には、指定した区切り記号が挿入されます。

System_CAPS_pubmethodSystem_CAPS_staticJoin<T>(String, IEnumerable<T>)

コレクションのメンバーを連結します。各メンバーの間には、指定した区切り記号が挿入されます。

System_CAPS_pubmethodLastIndexOf(Char)

このインスタンス内で最後に出現する指定 Unicode 文字の 0 から始まるインデックス位置をレポートします。

System_CAPS_pubmethodLastIndexOf(Char, Int32)

このインスタンス内で最後に出現する指定 Unicode 文字の 0 から始まるインデックス位置をレポートします。検索は、指定された文字位置から開始され、文字列の先頭に向かって逆方向に進みます。

System_CAPS_pubmethodLastIndexOf(Char, Int32, Int32)

このインスタンス内の部分文字列で最後に出現する指定 Unicode 文字の 0 から始まるインデックス位置をレポートします。検索は指定された文字位置から開始し、文字列の開始に向かって後方に移動し、文字位置の指定された数だけ行われます。

System_CAPS_pubmethodLastIndexOf(String)

指定された文字列がこのインスタンス内で最後に見つかった 0 から始まるインデックス位置をレポートします。

System_CAPS_pubmethodLastIndexOf(String, Int32)

指定された文字列がこのインスタンス内で最後に見つかった 0 から始まるインデックス位置をレポートします。検索は、指定された文字位置から開始され、文字列の先頭に向かって逆方向に進みます。

System_CAPS_pubmethodLastIndexOf(String, Int32, Int32)

指定された文字列がこのインスタンス内で最後に見つかった 0 から始まるインデックス位置をレポートします。検索は指定された文字位置から開始し、文字列の開始に向かって後方に移動し、文字位置の指定された数だけ行われます。

System_CAPS_pubmethodLastIndexOf(String, Int32, Int32, StringComparison)

指定された文字列がこのインスタンス内で最後に見つかった 0 から始まるインデックス位置をレポートします。検索は指定された文字位置から開始し、文字列の開始に向かって後方に移動し、文字位置の指定された数だけ行われます。指定した文字列を検索するときに実行する比較の種類をパラメーターで指定します。

System_CAPS_pubmethodLastIndexOf(String, Int32, StringComparison)

指定した文字列が現在の String オブジェクト内で最後に見つかった 0 から始まる位置のインデックスをレポートします。検索は、指定された文字位置から開始され、文字列の先頭に向かって逆方向に進みます。指定した文字列を検索するときに実行する比較の種類をパラメーターで指定します。

System_CAPS_pubmethodLastIndexOf(String, StringComparison)

指定した文字列が現在の String オブジェクト内で最後に見つかった 0 から始まる位置のインデックスをレポートします。指定した文字列に使用する検索の種類をパラメーターで指定します。

System_CAPS_pubmethodLastIndexOfAny(Char[])

Unicode 配列内の指定した 1 つ以上の文字がこのインスタンスで最後に見つかった 0 から始まるインデックス位置をレポートします。

System_CAPS_pubmethodLastIndexOfAny(Char[], Int32)

Unicode 配列内の指定した 1 つ以上の文字がこのインスタンスで最後に見つかった 0 から始まるインデックス位置をレポートします。検索は、指定された文字位置から開始され、文字列の先頭に向かって逆方向に進みます。

System_CAPS_pubmethodLastIndexOfAny(Char[], Int32, Int32)

Unicode 配列内の指定した 1 つ以上の文字がこのインスタンスで最後に見つかった 0 から始まるインデックス位置をレポートします。検索は指定された文字位置から開始し、文字列の開始に向かって後方に移動し、文字位置の指定された数だけ行われます。

System_CAPS_pubmethodNormalize()

この文字列と同じテキスト値を持ち、なおかつ、バイナリ表現が Unicode 正規形 C である新しい文字列を返します。

System_CAPS_pubmethodNormalize(NormalizationForm)

この文字列と同じテキスト値を持ち、なおかつ、バイナリ表現が、指定された Unicode 正規形である新しい文字列を返します。

System_CAPS_pubmethodPadLeft(Int32)

指定された文字数になるまで左側に空白を埋め込むことで、このインスタンス内の文字を右寄せした新しい文字列を返します。

System_CAPS_pubmethodPadLeft(Int32, Char)

指定された文字数になるまで左側に指定された Unicode 文字を埋め込むことで、このインスタンス内の文字を右寄せした新しい文字列を返します。

System_CAPS_pubmethodPadRight(Int32)

指定された文字数になるまで右側に空白を埋め込むことで、この文字列内の文字を左寄せした新しい文字列を返します。

System_CAPS_pubmethodPadRight(Int32, Char)

指定された文字数になるまで右側に指定された Unicode 文字を埋め込むことで、この文字列内の文字を左寄せした新しい文字列を返します。

System_CAPS_pubmethodRemove(Int32)

現在のインスタンスの指定した位置から指定した最後の位置までの全文字が削除された新しい文字列を返します。

System_CAPS_pubmethodRemove(Int32, Int32)

現在のインスタンス内の指定した位置から指定した文字数が削除された新しい文字列を返します。

System_CAPS_pubmethodReplace(Char, Char)

このインスタンスに出現する指定した Unicode 文字をすべて、別に指定した Unicode 文字に置換した新しい文字列を返します。

System_CAPS_pubmethodReplace(String, String)

現在のインスタンスに出現する指定した文字列をすべて、別に指定した文字列に置換した新しい文字列を返します。

System_CAPS_pubmethodSplit(Char[])

配列内の文字に基づいて文字列を部分文字列に分割します。

System_CAPS_pubmethodSplit(Char[], Int32)

配列内の文字に基づいて文字列を最大数の部分文字列に分割します。返される部分文字列の最大数を指定します。

System_CAPS_pubmethodSplit(Char[], Int32, StringSplitOptions)

配列内の文字に基づいて文字列を最大数の部分文字列に分割します。

System_CAPS_pubmethodSplit(Char[], StringSplitOptions)

配列内の文字に基づいて文字列を部分文字列に分割します。部分文字列が空の配列の要素を含めるかどうかを指定することができます。

System_CAPS_pubmethodSplit(String[], Int32, StringSplitOptions)

配列内の文字列に基づいて文字列を最大数の部分文字列に分割します。部分文字列が空の配列の要素を含めるかどうかを指定することができます。

System_CAPS_pubmethodSplit(String[], StringSplitOptions)

配列内の文字列に基づいて文字列を部分文字列に分割します。部分文字列が空の配列の要素を含めるかどうかを指定することができます。

System_CAPS_pubmethodStartsWith(String)

この文字列インスタンスの先頭が、指定した文字列と一致するかどうかを判断します。

System_CAPS_pubmethodStartsWith(String, Boolean, CultureInfo)

指定されたカルチャを使って比較した場合に、この文字列インスタンスの先頭が、指定された文字列と一致するかどうかを判断します。

System_CAPS_pubmethodStartsWith(String, StringComparison)

指定された比較オプションを使って比較した場合に、この文字列インスタンスの先頭が、指定された文字列と一致するかどうかを判断します。

System_CAPS_pubmethodSubstring(Int32)

インスタンスから部分文字列を取得します。部分文字列は、文字列中の指定した文字の位置で開始し、文字列の末尾まで続きます。

System_CAPS_pubmethodSubstring(Int32, Int32)

インスタンスから部分文字列を取得します。この部分文字列は、指定した文字位置から開始し、指定した文字数の文字列です。

System_CAPS_pubmethodToCharArray()

このインスタンスの文字を Unicode 文字配列へコピーします。

System_CAPS_pubmethodToCharArray(Int32, Int32)

このインスタンスの指定した部分文字列の文字を Unicode 文字配列へコピーします。

System_CAPS_pubmethodToLower()

この文字列のコピーを小文字に変換して返します。

System_CAPS_pubmethodToLower(CultureInfo)

指定されたカルチャの大文字と小文字の規則を使用して、この文字列のコピーを小文字に変換して返します。

System_CAPS_pubmethodToLowerInvariant()

インバリアント カルチャの大文字と小文字の規則を使用して、この String オブジェクトのコピーを小文字に変換して返します。

System_CAPS_pubmethodToString()

String のこのインスタンスを返します。実際の変換処理は実行されません。(Object.ToString() をオーバーライドする。)

System_CAPS_pubmethodToString(IFormatProvider)

String のこのインスタンスを返します。実際の変換処理は実行されません。

System_CAPS_pubmethodToUpper()

この文字列のコピーを大文字に変換して返します。

System_CAPS_pubmethodToUpper(CultureInfo)

指定されたカルチャの大文字と小文字の規則を使用して、この文字列のコピーを大文字に変換して返します。

System_CAPS_pubmethodToUpperInvariant()

インバリアント カルチャの大文字と小文字の規則を使用して、この String オブジェクトのコピーを大文字に変換して返します。

System_CAPS_pubmethodTrim()

現在の String オブジェクトの先頭および末尾にある空白文字をすべて削除します。

System_CAPS_pubmethodTrim(Char[])

現在の String オブジェクトの先頭および末尾から、配列で指定された文字セットをすべて削除します。

System_CAPS_pubmethodTrimEnd(Char[])

現在の String オブジェクトの末尾から、配列で指定された文字セットをすべて削除します。

System_CAPS_pubmethodTrimStart(Char[])

現在の String オブジェクトの先頭から、配列で指定された文字セットをすべて削除します。

名前説明
System_CAPS_pubfieldSystem_CAPS_staticEmpty

空の文字列を表します。このフィールドは読み取り専用です。

名前説明
System_CAPS_puboperatorSystem_CAPS_staticEquality(String, String)

指定した 2 つの文字列の値が同一かどうかを判断します。

System_CAPS_puboperatorSystem_CAPS_staticInequality(String, String)

指定した 2 つの文字列の値が異なるかどうかを判断します。

名前説明
System_CAPS_pubinterfaceSystem_CAPS_privmethodIEnumerable<Char>.GetEnumerator()

現在の String オブジェクトを反復処理する列挙子を返します。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIEnumerable.GetEnumerator()

現在の String オブジェクトを反復処理する列挙子を返します。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

この API は、製品 インフラストラクチャをサポートしており、コードから直接使用されることを想定していません。 このメンバーの詳細については、「ToBoolean」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

この API は、製品 インフラストラクチャをサポートしており、コードから直接使用されることを想定していません。 このメンバーの詳細については、「ToByte」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

この API は、製品 インフラストラクチャをサポートしており、コードから直接使用されることを想定していません。 このメンバーの詳細については、「ToChar」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

この API は、製品 インフラストラクチャをサポートしており、コードから直接使用されることを想定していません。 このメンバーの詳細については、「ToDateTime」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

この API は、製品 インフラストラクチャをサポートしており、コードから直接使用されることを想定していません。 このメンバーの詳細については、「ToDecimal」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

この API は、製品 インフラストラクチャをサポートしており、コードから直接使用されることを想定していません。 このメンバーの詳細については、「ToDouble」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

この API は、製品 インフラストラクチャをサポートしており、コードから直接使用されることを想定していません。 このメンバーの詳細については、「ToInt16」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

この API は、製品 インフラストラクチャをサポートしており、コードから直接使用されることを想定していません。 このメンバーの詳細については、「ToInt32」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

この API は、製品 インフラストラクチャをサポートしており、コードから直接使用されることを想定していません。 このメンバーの詳細については、「ToInt64」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

この API は、製品 インフラストラクチャをサポートしており、コードから直接使用されることを想定していません。 このメンバーの詳細については、「ToSByte」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

この API は、製品 インフラストラクチャをサポートしており、コードから直接使用されることを想定していません。 このメンバーの詳細については、「ToSingle」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

この API は、製品 インフラストラクチャをサポートしており、コードから直接使用されることを想定していません。 このメンバーの詳細については、「ToType」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

この API は、製品 インフラストラクチャをサポートしており、コードから直接使用されることを想定していません。 このメンバーの詳細については、「ToUInt16」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

この API は、製品 インフラストラクチャをサポートしており、コードから直接使用されることを想定していません。 このメンバーの詳細については、「ToUInt32」を参照してください。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

この API は、製品 インフラストラクチャをサポートしており、コードから直接使用されることを想定していません。 このメンバーの詳細については、「ToUInt64」を参照してください。

名前説明
System_CAPS_pubmethodAggregate<Char>(Func<Char, Char, Char>)

オーバーロードされます。シーケンスにアキュムレータ関数を適用します。(Enumerable により定義される。)

System_CAPS_pubmethodAggregate<Char, TAccumulate>(TAccumulate, Func<TAccumulate, Char, TAccumulate>)

オーバーロードされます。シーケンスにアキュムレータ関数を適用します。指定されたシード値が最初のアキュムレータ値として使用されます。(Enumerable により定義される。)

System_CAPS_pubmethodAggregate<Char, TAccumulate, TResult>(TAccumulate, Func<TAccumulate, Char, TAccumulate>, Func<TAccumulate, TResult>)

オーバーロードされます。シーケンスにアキュムレータ関数を適用します。指定したシード値は最初のアキュムレータ値として使用され、指定した関数は結果値の選択に使用されます。(Enumerable により定義される。)

System_CAPS_pubmethodAll<Char>(Func<Char, Boolean>)

シーケンスのすべての要素が条件を満たしているかどうかを判断します。(Enumerable により定義される。)

System_CAPS_pubmethodAny<Char>()

オーバーロードされます。シーケンスに要素が含まれているかどうかを判断します。(Enumerable により定義される。)

System_CAPS_pubmethodAny<Char>(Func<Char, Boolean>)

オーバーロードされます。シーケンスの任意の要素が条件を満たしているかどうかを判断します。(Enumerable により定義される。)

System_CAPS_pubmethodAsEnumerable<Char>()

IEnumerable<T> として型指定された入力を返します。(Enumerable により定義される。)

System_CAPS_pubmethodAsParallel()

オーバーロードされます。クエリの並列化を有効にします。(ParallelEnumerable により定義される。)

System_CAPS_pubmethodAsParallel<Char>()

オーバーロードされます。クエリの並列化を有効にします。(ParallelEnumerable により定義される。)

System_CAPS_pubmethodAsQueryable()

オーバーロードされます。 IEnumerableIQueryable に変換します。(Queryable により定義される。)

System_CAPS_pubmethodAsQueryable<Char>()

オーバーロードされます。ジェネリックの IEnumerable<T> をジェネリックの IQueryable<T> に変換します。(Queryable により定義される。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Decimal>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する Decimal 値のシーケンスの平均値を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Double>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する Double 値のシーケンスの平均値を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Int32>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する Int32 値のシーケンスの平均値を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Int64>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する Int64 値のシーケンスの平均値を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Decimal>>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する null 許容の Decimal 値のシーケンスの平均値を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Double>>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する null 許容の Double 値のシーケンスの平均値を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Int32>>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する null 許容の Int32 値のシーケンスの平均値を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Int64>>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する null 許容の Int64 値のシーケンスの平均値を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Single>>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する null 許容の Single 値のシーケンスの平均値を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodAverage<Char>(Func<Char, Single>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する Single 値のシーケンスの平均値を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodCast<TResult>()

IEnumerable の要素を、指定した型にキャストします。(Enumerable により定義される。)

System_CAPS_pubmethodConcat<Char>(IEnumerable<Char>)

2 つのシーケンスを連結します。(Enumerable により定義される。)

System_CAPS_pubmethodContains<Char>(Char)

オーバーロードされます。既定の等値比較子を使用して、指定した要素がシーケンスに含まれているかどうかを判断します。(Enumerable により定義される。)

System_CAPS_pubmethodContains<Char>(Char, IEqualityComparer<Char>)

オーバーロードされます。指定した IEqualityComparer<T> を使用して、指定した要素がシーケンスに含まれているかどうかを判断します。(Enumerable により定義される。)

System_CAPS_pubmethodCount<Char>()

オーバーロードされます。シーケンス内の要素数を返します。(Enumerable により定義される。)

System_CAPS_pubmethodCount<Char>(Func<Char, Boolean>)

オーバーロードされます。条件を満たす、指定されたシーケンス内の要素の数を表す数値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodDefaultIfEmpty<Char>()

オーバーロードされます。指定したシーケンスの要素を返します。シーケンスが空の場合はシングルトン コレクションにある型パラメーターの既定値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodDefaultIfEmpty<Char>(Char)

オーバーロードされます。指定されたシーケンスの要素を返します。シーケンスが空の場合はシングルトン コレクションにある型パラメーターの既定値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodDistinct<Char>()

オーバーロードされます。既定の等値比較子を使用して値を比較することにより、シーケンスから一意の要素を返します。(Enumerable により定義される。)

System_CAPS_pubmethodDistinct<Char>(IEqualityComparer<Char>)

オーバーロードされます。指定された IEqualityComparer<T> を使用して値を比較することにより、シーケンスから一意の要素を返します。(Enumerable により定義される。)

System_CAPS_pubmethodElementAt<Char>(Int32)

シーケンス内の指定されたインデックス位置にある要素を返します。(Enumerable により定義される。)

System_CAPS_pubmethodElementAtOrDefault<Char>(Int32)

シーケンス内の指定されたインデックス位置にある要素を返します。インデックスが範囲外の場合は既定値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodExcept<Char>(IEnumerable<Char>)

オーバーロードされます。既定の等値比較子を使用して値を比較することにより、2 つのシーケンスの差集合を生成します。(Enumerable により定義される。)

System_CAPS_pubmethodExcept<Char>(IEnumerable<Char>, IEqualityComparer<Char>)

オーバーロードされます。指定された IEqualityComparer<T> を使用して値を比較することにより、2 つのシーケンスの差集合を生成します。(Enumerable により定義される。)

System_CAPS_pubmethodFirst<Char>()

オーバーロードされます。シーケンスの最初の要素を返します。(Enumerable により定義される。)

System_CAPS_pubmethodFirst<Char>(Func<Char, Boolean>)

オーバーロードされます。指定された条件を満たす、シーケンスの最初の要素を返します。(Enumerable により定義される。)

System_CAPS_pubmethodFirstOrDefault<Char>()

オーバーロードされます。シーケンスの最初の要素を返します。シーケンスに要素が含まれていない場合は既定値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodFirstOrDefault<Char>(Func<Char, Boolean>)

オーバーロードされます。条件を満たす、シーケンスの最初の要素を返します。このような要素が見つからない場合は既定値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodGroupBy<Char, TKey>(Func<Char, TKey>)

オーバーロードされます。指定されたキー セレクター関数に従ってシーケンスの要素をグループ化します。(Enumerable により定義される。)

System_CAPS_pubmethodGroupBy<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)

オーバーロードされます。指定されたキー セレクター関数に従ってシーケンスの要素をグループ化し、指定された比較子を使用してキーを比較します。(Enumerable により定義される。)

System_CAPS_pubmethodGroupBy<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)

オーバーロードされます。指定されたキー セレクター関数に従ってシーケンスの要素をグループ化し、指定された関数を使用して各グループの要素を射影します。(Enumerable により定義される。)

System_CAPS_pubmethodGroupBy<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)

オーバーロードされます。キー セレクター関数に従ってシーケンスの要素をグループ化します。キーの比較には、比較子を使用し、各グループの要素の射影には、指定された関数を使用します。(Enumerable により定義される。)

System_CAPS_pubmethodGroupBy<Char, TKey, TResult>(Func<Char, TKey>, Func<TKey, IEnumerable<Char>, TResult>)

オーバーロードされます。指定されたキー セレクター関数に従ってシーケンスの要素をグループ化し、各グループとそのキーから結果値を作成します。(Enumerable により定義される。)

System_CAPS_pubmethodGroupBy<Char, TKey, TResult>(Func<Char, TKey>, Func<TKey, IEnumerable<Char>, TResult>, IEqualityComparer<TKey>)

オーバーロードされます。指定されたキー セレクター関数に従ってシーケンスの要素をグループ化し、各グループとそのキーから結果値を作成します。キーの比較には、指定された比較子を使用します。(Enumerable により定義される。)

System_CAPS_pubmethodGroupBy<Char, TKey, TElement, TResult>(Func<Char, TKey>, Func<Char, TElement>, Func<TKey, IEnumerable<TElement>, TResult>)

オーバーロードされます。指定されたキー セレクター関数に従ってシーケンスの要素をグループ化し、各グループとそのキーから結果値を作成します。各グループの要素は、指定された関数を使用して射影されます。(Enumerable により定義される。)

System_CAPS_pubmethodGroupBy<Char, TKey, TElement, TResult>(Func<Char, TKey>, Func<Char, TElement>, Func<TKey, IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)

オーバーロードされます。指定されたキー セレクター関数に従ってシーケンスの要素をグループ化し、各グループとそのキーから結果値を作成します。キー値の比較には、指定された比較子を使用し、各グループの要素の射影には、指定された関数を使用します。(Enumerable により定義される。)

System_CAPS_pubmethodGroupJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, IEnumerable<TInner>, TResult>)

オーバーロードされます。キーが等しいかどうかに基づいて 2 つのシーケンスの要素を相互に関連付け、その結果をグループ化します。キーの比較には既定の等値比較子が使用されます。(Enumerable により定義される。)

System_CAPS_pubmethodGroupJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)

オーバーロードされます。キーが等しいかどうかに基づいて 2 つのシーケンスの要素を相互に関連付け、その結果をグループ化します。指定された IEqualityComparer<T> を使用してキーを比較します。(Enumerable により定義される。)

System_CAPS_pubmethodIntersect<Char>(IEnumerable<Char>)

オーバーロードされます。既定の等値比較子を使用して値を比較することにより、2 つのシーケンスの積集合を生成します。(Enumerable により定義される。)

System_CAPS_pubmethodIntersect<Char>(IEnumerable<Char>, IEqualityComparer<Char>)

オーバーロードされます。指定された IEqualityComparer<T> を使用して値を比較することにより、2 つのシーケンスの積集合を生成します。(Enumerable により定義される。)

System_CAPS_pubmethodJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, TInner, TResult>)

オーバーロードされます。一致するキーに基づいて 2 つのシーケンスの要素を相互に関連付けます。キーの比較には既定の等値比較子が使用されます。(Enumerable により定義される。)

System_CAPS_pubmethodJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, TInner, TResult>, IEqualityComparer<TKey>)

オーバーロードされます。一致するキーに基づいて 2 つのシーケンスの要素を相互に関連付けます。指定された IEqualityComparer<T> を使用してキーを比較します。(Enumerable により定義される。)

System_CAPS_pubmethodLast<Char>()

オーバーロードされます。シーケンスの最後の要素を返します。(Enumerable により定義される。)

System_CAPS_pubmethodLast<Char>(Func<Char, Boolean>)

オーバーロードされます。指定された条件を満たす、シーケンスの最後の要素を返します。(Enumerable により定義される。)

System_CAPS_pubmethodLastOrDefault<Char>()

オーバーロードされます。シーケンスの最後の要素を返します。シーケンスに要素が含まれていない場合は既定値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodLastOrDefault<Char>(Func<Char, Boolean>)

オーバーロードされます。条件を満たす、シーケンスの最後の要素を返します。このような要素が見つからない場合は既定値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodLongCount<Char>()

オーバーロードされます。シーケンス内の要素の合計数を表す Int64 を返します。(Enumerable により定義される。)

System_CAPS_pubmethodLongCount<Char>(Func<Char, Boolean>)

オーバーロードされます。シーケンス内で条件を満たす要素の数を表す Int64 を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMax<Char>()

オーバーロードされます。ジェネリック シーケンスの最大値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMax<Char>(Func<Char, Decimal>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、Decimal の最大値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMax<Char>(Func<Char, Double>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、Double の最大値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMax<Char>(Func<Char, Int32>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、Int32 の最大値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMax<Char>(Func<Char, Int64>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、Int64 の最大値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Decimal>>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、null 許容の Decimal の最大値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Double>>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、null 許容の Double の最大値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Int32>>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、null 許容の Int32 の最大値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Int64>>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、null 許容の Int64 の最大値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Single>>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、null 許容の Single の最大値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMax<Char>(Func<Char, Single>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、Single の最大値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMax<Char, TResult>(Func<Char, TResult>)

オーバーロードされます。ジェネリック シーケンスの各要素に対して変換関数を呼び出し、結果の最大値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMin<Char>()

オーバーロードされます。ジェネリック シーケンスの最小値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMin<Char>(Func<Char, Decimal>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、Decimal の最小値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMin<Char>(Func<Char, Double>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、Double の最小値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMin<Char>(Func<Char, Int32>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、Int32 の最小値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMin<Char>(Func<Char, Int64>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、Int64 の最小値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Decimal>>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、null 許容の Decimal の最小値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Double>>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、null 許容の Double の最小値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Int32>>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、null 許容の Int32 の最小値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Int64>>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、null 許容の Int64 の最小値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Single>>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、null 許容の Single の最小値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMin<Char>(Func<Char, Single>)

オーバーロードされます。シーケンスの各要素に対して変換関数を呼び出し、Single の最小値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodMin<Char, TResult>(Func<Char, TResult>)

オーバーロードされます。ジェネリック シーケンスの各要素に対して変換関数を呼び出し、結果の最小値を返します。(Enumerable により定義される。)

System_CAPS_pubmethodOfType<TResult>()

指定された型に基づいて IEnumerable の要素をフィルター処理します。(Enumerable により定義される。)

System_CAPS_pubmethodOrderBy<Char, TKey>(Func<Char, TKey>)

オーバーロードされます。シーケンスの要素をキーに従って昇順に並べ替えます。(Enumerable により定義される。)

System_CAPS_pubmethodOrderBy<Char, TKey>(Func<Char, TKey>, IComparer<TKey>)

オーバーロードされます。指定された比較子を使用してシーケンスの要素を昇順に並べ替えます。(Enumerable により定義される。)

System_CAPS_pubmethodOrderByDescending<Char, TKey>(Func<Char, TKey>)

オーバーロードされます。シーケンスの要素をキーに従って降順に並べ替えます。(Enumerable により定義される。)

System_CAPS_pubmethodOrderByDescending<Char, TKey>(Func<Char, TKey>, IComparer<TKey>)

オーバーロードされます。指定された比較子を使用してシーケンスの要素を降順に並べ替えます。(Enumerable により定義される。)

System_CAPS_pubmethodReverse<Char>()

シーケンスの要素の順序を反転させます。(Enumerable により定義される。)

System_CAPS_pubmethodSelect<Char, TResult>(Func<Char, TResult>)

オーバーロードされます。シーケンスの各要素を新しいフォームに射影します。(Enumerable により定義される。)

System_CAPS_pubmethodSelect<Char, TResult>(Func<Char, Int32, TResult>)

オーバーロードされます。要素のインデックスを組み込むことにより、シーケンスの各要素を新しいフォームに射影します。(Enumerable により定義される。)

System_CAPS_pubmethodSelectMany<Char, TResult>(Func<Char, IEnumerable<TResult>>)

オーバーロードされます。シーケンスの各要素を IEnumerable<T> に射影し、結果のシーケンスを 1 つのシーケンスに平坦化します。(Enumerable により定義される。)

System_CAPS_pubmethodSelectMany<Char, TResult>(Func<Char, Int32, IEnumerable<TResult>>)

オーバーロードされます。シーケンスの各要素を IEnumerable<T> に射影し、結果のシーケンスを 1 つのシーケンスに平坦化します。各ソース要素のインデックスは、その要素の射影されたフォームで使用されます。(Enumerable により定義される。)

System_CAPS_pubmethodSelectMany<Char, TCollection, TResult>(Func<Char, IEnumerable<TCollection>>, Func<Char, TCollection, TResult>)

オーバーロードされます。シーケンスの各要素を IEnumerable<T> に射影し、結果のシーケンスを 1 つのシーケンスに平坦化して、その各要素に対して結果のセレクター関数を呼び出します。(Enumerable により定義される。)

System_CAPS_pubmethodSelectMany<Char, TCollection, TResult>(Func<Char, Int32, IEnumerable<TCollection>>, Func<Char, TCollection, TResult>)

オーバーロードされます。シーケンスの各要素を IEnumerable<T> に射影し、結果のシーケンスを 1 つのシーケンスに平坦化して、その各要素に対して結果のセレクター関数を呼び出します。各ソース要素のインデックスは、その要素の中間の射影されたフォームで使用されます。(Enumerable により定義される。)

System_CAPS_pubmethodSequenceEqual<Char>(IEnumerable<Char>)

オーバーロードされます。要素の型に対して既定の等値比較子を使用して要素を比較することで、2 つのシーケンスが等しいかどうかを判断します。(Enumerable により定義される。)

System_CAPS_pubmethodSequenceEqual<Char>(IEnumerable<Char>, IEqualityComparer<Char>)

オーバーロードされます。指定された IEqualityComparer<T> を使用して要素を比較することで、2 つのシーケンスが等しいかどうかを判断します。(Enumerable により定義される。)

System_CAPS_pubmethodSingle<Char>()

オーバーロードされます。シーケンスの唯一の要素を返します。シーケンス内の要素が 1 つだけではない場合は、例外をスローします。(Enumerable により定義される。)

System_CAPS_pubmethodSingle<Char>(Func<Char, Boolean>)

オーバーロードされます。指定された条件を満たす、シーケンスの唯一の要素を返します。そのような要素が複数存在する場合は、例外をスローします。(Enumerable により定義される。)

System_CAPS_pubmethodSingleOrDefault<Char>()

オーバーロードされます。シーケンスの唯一の要素を返します。シーケンスが空の場合、既定値を返します。シーケンス内に要素が複数ある場合、このメソッドは例外をスローします。(Enumerable により定義される。)

System_CAPS_pubmethodSingleOrDefault<Char>(Func<Char, Boolean>)

オーバーロードされます。指定された条件を満たす、シーケンスの唯一の要素を返します。そのような要素が存在しない場合、既定値を返します。複数の要素が条件を満たす場合、このメソッドは例外をスローします。(Enumerable により定義される。)

System_CAPS_pubmethodSkip<Char>(Int32)

シーケンス内の指定された数の要素をバイパスし、残りの要素を返します。(Enumerable により定義される。)

System_CAPS_pubmethodSkipWhile<Char>(Func<Char, Boolean>)

オーバーロードされます。指定された条件が満たされる限り、シーケンスの要素をバイパスした後、残りの要素を返します。(Enumerable により定義される。)

System_CAPS_pubmethodSkipWhile<Char>(Func<Char, Int32, Boolean>)

オーバーロードされます。指定された条件が満たされる限り、シーケンスの要素をバイパスした後、残りの要素を返します。要素のインデックスは、述語関数のロジックで使用されます。(Enumerable により定義される。)

System_CAPS_pubmethodSum<Char>(Func<Char, Decimal>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する Decimal 値のシーケンスの合計を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodSum<Char>(Func<Char, Double>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する Double 値のシーケンスの合計を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodSum<Char>(Func<Char, Int32>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する Int32 値のシーケンスの合計を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodSum<Char>(Func<Char, Int64>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する Int64 値のシーケンスの合計を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Decimal>>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する null 許容の Decimal 値のシーケンスの合計を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Double>>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する null 許容の Double 値のシーケンスの合計を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Int32>>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する null 許容の Int32 値のシーケンスの合計を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Int64>>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する null 許容の Int64 値のシーケンスの合計を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Single>>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する null 許容の Single 値のシーケンスの合計を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodSum<Char>(Func<Char, Single>)

オーバーロードされます。入力シーケンスの各要素に対して変換関数を呼び出して取得する Single 値のシーケンスの合計を計算します。(Enumerable により定義される。)

System_CAPS_pubmethodTake<Char>(Int32)

シーケンスの先頭から、指定された数の連続する要素を返します。(Enumerable により定義される。)

System_CAPS_pubmethodTakeWhile<Char>(Func<Char, Boolean>)

オーバーロードされます。指定された条件が満たされる限り、シーケンスから要素を返します。(Enumerable により定義される。)

System_CAPS_pubmethodTakeWhile<Char>(Func<Char, Int32, Boolean>)

オーバーロードされます。指定された条件が満たされる限り、シーケンスから要素を返します。要素のインデックスは、述語関数のロジックで使用されます。(Enumerable により定義される。)

System_CAPS_pubmethodToArray<Char>()

IEnumerable<T> から配列を作成します。(Enumerable により定義される。)

System_CAPS_pubmethodToDictionary<Char, TKey>(Func<Char, TKey>)

オーバーロードされます。指定されたキー セレクター関数に従って、IEnumerable<T> から Dictionary<TKey, TValue> を作成します。(Enumerable により定義される。)

System_CAPS_pubmethodToDictionary<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)

オーバーロードされます。指定されたキー セレクター関数およびキーの比較子に従って、IEnumerable<T> から Dictionary<TKey, TValue> を作成します。(Enumerable により定義される。)

System_CAPS_pubmethodToDictionary<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)

オーバーロードされます。指定されたキー セレクター関数および要素セレクター関数に従って、IEnumerable<T> から Dictionary<TKey, TValue> を作成します。(Enumerable により定義される。)

System_CAPS_pubmethodToDictionary<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)

オーバーロードされます。指定されたキー セレクター関数、比較子、および要素セレクター関数に従って、IEnumerable<T> から Dictionary<TKey, TValue> を作成します。(Enumerable により定義される。)

System_CAPS_pubmethodToList<Char>()

IEnumerable<T> から List<T> を作成します。(Enumerable により定義される。)

System_CAPS_pubmethodToLookup<Char, TKey>(Func<Char, TKey>)

オーバーロードされます。指定されたキー セレクター関数に従って、IEnumerable<T> から Lookup<TKey, TElement> を作成します。(Enumerable により定義される。)

System_CAPS_pubmethodToLookup<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)

オーバーロードされます。指定されたキー セレクター関数およびキーの比較子に従って、IEnumerable<T> から Lookup<TKey, TElement> を作成します。(Enumerable により定義される。)

System_CAPS_pubmethodToLookup<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)

オーバーロードされます。指定されたキー セレクター関数および要素セレクター関数に従って、IEnumerable<T> から Lookup<TKey, TElement> を作成します。(Enumerable により定義される。)

System_CAPS_pubmethodToLookup<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)

オーバーロードされます。指定されたキー セレクター関数、比較子、および要素セレクター関数に従って、IEnumerable<T> から Lookup<TKey, TElement> を作成します。(Enumerable により定義される。)

System_CAPS_pubmethodUnion<Char>(IEnumerable<Char>)

オーバーロードされます。既定の等値比較子を使用して、2 つのシーケンスの和集合を生成します。(Enumerable により定義される。)

System_CAPS_pubmethodUnion<Char>(IEnumerable<Char>, IEqualityComparer<Char>)

オーバーロードされます。指定された IEqualityComparer<T> を使用して 2 つのシーケンスの和集合を生成します。(Enumerable により定義される。)

System_CAPS_pubmethodWhere<Char>(Func<Char, Boolean>)

オーバーロードされます。述語に基づいて値のシーケンスをフィルター処理します。(Enumerable により定義される。)

System_CAPS_pubmethodWhere<Char>(Func<Char, Int32, Boolean>)

オーバーロードされます。述語に基づいて値のシーケンスをフィルター処理します。各要素のインデックスは、述語関数のロジックで使用されます。(Enumerable により定義される。)

System_CAPS_pubmethodZip<Char, TSecond, TResult>(IEnumerable<TSecond>, Func<Char, TSecond, TResult>)

2 つのシーケンスの対応する要素に対して、1 つの指定した関数を適用し、結果として 1 つのシーケンスを生成します。(Enumerable により定義される。)

System_CAPS_noteメモ

To view the .NET Framework source code for this type, see the Reference Sourcehttp://referencesource.microsoft.com/#mscorlib/system/string.cs#8281103e6f23cb5c. You can browse through the source code online, download the reference for offline viewing, and step through the sources (including patches and updates) during debugging; see instructionshttp://referencesource.microsoft.com/.

A string is a sequential collection of Unicode characters that is used to represent text. A T:System.String object is a sequential collection of T:System.Char objects that represent a string. The value of the T:System.String object is the content of the sequential collection, and that value is immutable (that is, it is read-only). For more information about the immutability of strings, see the Immutability and the StringBuilder class section later in this topic.The maximum size of a T:System.String object in memory is 2GB, or about 1 billion characters.

In this section:

Instantiating a String object
Char objects and Unicode characters
Strings and embedded null characters
Strings and indexes
Null strings and empty strings
Immutability and the StringBuilder class
Ordinal vs. culture-sensitive operations
Normalization
String operations by category

You can instantiate a T:System.String object in the following ways:

  • By assigning a string literal to a T:System.String variable. This is the most commonly used method for creating a string. The following example uses assignment to create several strings. 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.

    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      
    
  • By calling a T:System.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 does not support calls to these constructors. For detailed information about T:System.String constructors, see the Overload:System.String.#ctor constructor summary.

    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  
    
  • By using the string concatenation operator (+ in C# and & or + in Visual Basic) to create a single string from any combination of T:System.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.
    
  • By retrieving a property or calling a method that returns a string.The following example uses the methods of the T:System.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);
    // The example displays the following output:
    //       Second word: sentence
    
  • By calling a formatting method to convert a value or object to its string representation. The following example uses the feature to embed the string representation of two objects into a string.

    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.      
    

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. Each code point is encoded by using UTF-16 encoding, and the numeric value of each element of the encoding is represented by a T:System.Char object.

A single T:System.Char object usually represents a single code point; that is, the numeric value of the T:System.Char equals the code point. For example, the code point for the character "a" is U+0061. However, a code point might require more than one encoded element (more than one T:System.Char object). The Unicode standard defines three types of characters that correspond to multiple T:System.Char objects: graphemes, Unicode supplementary code points, and characters in the supplementary planes.

  • A grapheme is represented by a base character followed by one or more combining characters. For example, the character ä is represented by a T:System.Char object whose code point is U+0061 followed by a T:System.Char object whose code point is U+0308. This character can also be defined by a single T:System.Char object that has a code point of U+00E4. 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. 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 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
    
  • A Unicode supplementary code point (a surrogate pair) is represented by a T:System.Char object whose code point is a high surrogate followed by a T:System.Char object whose code point is a low surrogate. The code units of high surrogates range from U+D800 to U+DBFF. The code units of low surrogates range from U+DC00 to U+DFFF. Surrogate pairs are used to represent characters in the 16 Unicode supplementary planes. The following example creates a surrogate character and passes it to the M:System.Char.IsSurrogatePair(System.Char,System.Char) method to determine whether it is a surrogate pair.

    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
    

In the .NET Framework, a T:System.String object can include embedded null characters, which count as a part of the string's length. 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. 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 T:System.String objects:

  • The value returned by the strlen or wcslen functions does not necessarily equal P:System.String.Length.

  • The string created by the strcpy_s or wcscpy_s functions is not necessarily identical to the string created by the M:System.String.Copy(System.String) method.

You should ensure that native C and C++ code that instantiates T:System.String objects, and code that is passed T:System.String objects through platform invoke, do not assume that an embedded null character marks the end of the string.

Embedded null characters in a string are also treated differently when a string is sorted (or compared) and when a string is searched. 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. On the other hand, embedded null characters are always considered when searching a string with methods such as M:System.String.Contains(System.String), M:System.String.StartsWith(System.String), and M:System.String.IndexOf(System.String).

An index is the position of a T:System.Char object (not a Unicode character) in a T:System.String. An index is a zero-based, nonnegative number that starts from the first position in the string, which is index position zero. A number of search methods, such as M:System.String.IndexOf(System.Char) and M:System.String.LastIndexOf(System.Char), return the index of a character or substring in the string instance.

The P:System.String.Chars(System.Int32) property lets you access individual T:System.Char objects by their index position in the string. Because the P:System.String.Chars(System.Int32) property is the default property (in Visual Basic) or the indexer (in C#), you can access the individual T:System.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 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.

Because the T:System.String class implements the T:System.Collections.IEnumerable interface, you can also iterate through the T:System.Char objects in a string by using a foreach construct, as the following example shows.

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.

Consecutive index values might not correspond to consecutive Unicode characters, because a Unicode character might be encoded as more than one T:System.Char object. 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. To work with Unicode characters instead of T:System.Char objects, use the T:System.Globalization.StringInfo and T:System.Globalization.TextElementEnumerator classes. The following example illustrates the difference between code that works with T:System.Char objects and code that works with Unicode characters. It compares the number of characters or text elements in each word of a sentence. The string includes two sequences of a base character followed by a combining character.

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

This example works with text elements by using the M:System.Globalization.StringInfo.GetTextElementEnumerator(System.String) method and the T:System.Globalization.TextElementEnumerator class to enumerate all the text elements in a string. You can also retrieve an array that contains the starting index of each text element by calling the M:System.Globalization.StringInfo.ParseCombiningCharacters(System.String) method.

For more information about working with units of text rather than individual T:System.Char values, see the T:System.Globalization.StringInfo class.

A string that has been declared but has not been assigned a value is null. Attempting to call methods on that string throws a T:System.NullReferenceException. A null string is different from an empty string, which is a string whose value is "" or F:System.String.Empty. In some cases, passing either a null string or an empty string as an argument in a method call throws an exception. For example, passing a null string to the M:System.Int32.Parse(System.String) method throws an T:System.ArgumentNullException, and passing an empty string throws a T:System.FormatException. In other cases, a method argument can be either a null string or an empty string. For example, if you are providing an T:System.IFormattable implementation for a class, you want to equate both a null string and an empty string with the general ("G") format specifier.

The T:System.String class includes the following two convenience methods that enable you to test whether a string is null or 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 == null || str.Equals(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 == null || str.Equals(String.Empty) || str.Trim().Equals(String.Empty))
    

The following example uses the M:System.String.IsNullOrEmpty(System.String) method in the M:System.IFormattable.ToString(System.String,System.IFormatProvider) implementation of a custom Temperature class. The method supports the "G", "C", "F", and "K" format strings. 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 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));
   }                                   
}

A T:System.String object is called immutable (read-only), because its value cannot be modified after it has been created. Methods that appear to modify a T:System.String object actually return a new T:System.String object that contains the modification.

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. For example, the following code uses a random number generator to create a string with 1000 characters in the range 0x0001 to 0x052F. Although the code appears to use string concatenation to append a new character to the existing string named str, it actually creates a new T:System.String object for each concatenation operation.

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();
   }
}

You can use the T:System.Text.StringBuilder class instead of the T:System.String class for operations that make multiple changes to the value of a string. Unlike instances of the T:System.String class, T:System.Text.StringBuilder objects are mutable; when you concatenate, append, or delete substrings from a string, the operations are performed on a single string. When you have finished modifying the value of a T:System.Text.StringBuilder object, you can call its M:System.Text.StringBuilder.ToString method to convert it to a string. The following example replaces the T:System.String used in the previous example to concatenate 1000 random characters in the range to 0x0001 to 0x052F with a T:System.Text.StringBuilder object.

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();
   }
}

Members of the T:System.String class perform either ordinal or culture-sensitive (linguistic) operations on a T:System.String object. An ordinal operation acts on the numeric value of each T:System.Char object. A culture-sensitive operation acts on the value of the T:System.Stringobject, 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. The two kinds of operations can produce very different results when they are performed on the same string.

The .NET Framework also supports culture-insensitive linguistic string operations by using the invariant culture (P:System.Globalization.CultureInfo.InvariantCulture), which is loosely based on the culture settings of the English language independent of region. Unlike other T: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 the .NET Framework. The invariant culture can be seen as a kind of black box that ensures stability of string comparisons and ordering across all cultures.

System_CAPS_security セキュリティ メモ

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.

System_CAPS_important重要

Most methods that perform string operations include an overload that has a parameter of type T:System.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 in the .NET Framework.

Operations forcasing,parsing and formatting, comparison and sorting, andtesting for equality can be either ordinal or culture-sensitive. The following sections discuss each category of operation.

System_CAPS_tipヒント

You should always call a method overload that makes the intent of your method call clear. For example, instead of calling the M:System.String.Compare(System.String,System.String) method to perform a culture-sensitive comparison of two strings by using the conventions of the current culture, you should call the M:System.String.Compare(System.String,System.String,System.StringComparison) method with a value of F:System.StringComparison.CurrentCulture for the comparisonType argument. For more information, see Best Practices for Using Strings in the .NET Framework.

Casing rules determine how to change the capitalization of a Unicode character; for example, from lowercase to uppercase. Often, a casing operation is performed before a string comparison. For example, a string might be converted to uppercase so that it can be compared with another uppercase string. You can convert the characters in a string to lowercase by calling the M:System.String.ToLower or M:System.String.ToLowerInvariant method, and you can convert them to uppercase by calling the M:System.String.ToUpper or M:System.String.ToUpperInvariant method. In addition, you can use the M:System.Globalization.TextInfo.ToTitleCase(System.String) 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. The actual differences in casing are of three kinds:

  • 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). 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. 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
    
  • 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

    MICRON SIGN (U+00B5)

    Uppercase

    GREEK CAPITAL LETTER MU (U+-39C)

    LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130)

    Lowercase

    LATIN SMALL LETTER I (U+0069)

    LATIN SMALL LETTER DOTLESS I (U+0131)

    Uppercase

    LATIN CAPITAL LETTER I (U+0049)

    LATIN SMALL LETTER LONG S (U+017F)

    Uppercase

    LATIN CAPITAL LETTER S (U+0053)

    LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON (U+01C5)

    Lowercase

    LATIN SMALL LETTER DZ WITH CARON (U+01C6)

    COMBINING GREEK YPOGEGRAMMENI (U+0345)

    Uppercase

    GREEK CAPITAL LETTER IOTA (U+0399)

  • Differences in case mappings of two-letter mixed-case pairs in the ASCII character range. In most cultures, a two-letter mixed-case pair is equal to the equivalent two-letter uppercase or lowercase pair. 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" and "nJ" in the hr-HR (Croatian (Croatia)) culture.

    • "cH" in the cs-CZ (Czech (Czech Republic)) and sk-SK (Slovak (Slovakia)) cultures.

    • "aA" in the da-DK (Danish (Denmark)) culture.

    • "cS", "dZ", "dZS", "nY", "sZ", "tY", and "zS" in the hu-HU (Hungarian (Hungary)) culture.

    • "cH" and "lL" in the es-ES_tradnl (Spanish (Spain, Traditional Sort)) culture.

    • "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 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 

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. 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 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

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

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. 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. Ordinal comparison, on the other hand, uses the Unicode code points of individual characters in a string when comparing and sorting strings.

Sort rules determine the alphabetic order of Unicode characters and how two strings compare to each other. For example, the M:System.String.Compare(System.String,System.String,System.StringComparison) method compares two strings based on the T:System.StringComparison parameter. If the parameter value is F:System.StringComparison.CurrentCulture, the method performs a linguistic comparison that uses the conventions of the current culture; if the parameter value is F:System.StringComparison.Ordinal, the method performs an ordinal comparison. Consequently, as the following example shows, if the current culture is U.S. English, the first call to the M:System.String.Compare(System.String,System.String,System.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 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

The .NET Framework supports word, string, and ordinal sort rules:

  • A word sort performs a culture-sensitive comparison of strings in which certain nonalphanumeric Unicode characters might have special weights assigned to them. 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. For a list of the T:System.Stringmethods that compare two strings using word sort rules, see the String operations by category section.

  • A string sort also performs a culture-sensitive comparison. It is similar to a word sort, except that there are no special cases, and all nonalphanumeric symbols come before all alphanumeric Unicode characters. Two strings can be compared using string sort rules by calling the M:System.Globalization.CompareInfo.Compare(System.String,System.String) method overloads that have an options parameter that is supplied a value of F:System.Globalization.CompareOptions.StringSort. Note that this is the only method that the .NET Framework provides to compare two strings using string sort rules.

  • An ordinal sort compares strings based on the numeric value of each T:System.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. For a list of the T:System.String methods that compare two strings using ordinal sort rules, see the String operations by category section.

A culture-sensitive comparison is any comparison that explicitly or implicitly uses a T:System.Globalization.CultureInfo object, including the invariant culture that is specified by the P:System.Globalization.CultureInfo.InvariantCulture property. The implicit culture is the current culture, which is specified by the P:System.Threading.Thread.CurrentCultureand P:System.Globalization.CultureInfo.CurrentCultureproperties. There is considerable variation in the sort order of alphabetic characters (that is, characters for which the M:System.Char.IsLetter(System.Char) property returns true) across cultures. You can specify a culture-sensitive comparison that uses the conventions of a specific culture by supplying a T:System.Globalization.CultureInfo object to a string comparison method such as M:System.String.Compare(System.String,System.String,System.Globalization.CultureInfo,System.Globalization.CompareOptions). You can specify a culture-sensitive comparison that uses the conventions of the current culture by supplying F:System.StringComparison.CurrentCulture, F:System.StringComparison.CurrentCultureIgnoreCase, or any member of the T:System.Globalization.CompareOptions enumeration other than F:System.Globalization.CompareOptions.Ordinal or F:System.Globalization.CompareOptions.OrdinalIgnoreCase to an appropriate overload of the M:System.String.Compare(System.String,System.String) method. A culture-sensitive comparison is generally appropriate for sorting whereas an ordinal comparison is not. 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. 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 M:System.String.Compare(System.String,System.String) method is called). 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". However, "Æble" is not considered equivalent to "AEble", so "Æble" is also greater than "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". 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

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.

  • If you want the strings to be ordered based on the conventions of a specific culture, you should order them by supplying a T:System.Globalization.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.

  • 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 M:System.String.Equals(System.String) method.

System_CAPS_noteメモ

The culture-sensitive sorting and casing rules used in string comparison depend on the version of the .NET Framework. In the net_v45 running on the win8 operating system, sorting, casing, normalization, and Unicode character information conforms to the Unicode 6.0 standard. On other operating systems, it conforms to theUnicode 5.0 standard.

For more information about word, string, and ordinal sort rules, see the T:System.Globalization.CompareOptions topic. For additional recommendations on when to use each rule, see Best Practices for Using Strings in the .NET Framework.

Ordinarily, you do not call string comparison methods such as M:System.String.Compare(System.String,System.String)directly to determine the sort order of strings. Instead, comparison methods are called by sorting methods such as M:System.Array.Sort(System.Array) or M:System.Collections.Generic.List`1.Sort. 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 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
System_CAPS_tipヒント

Internally, the.NET Framework uses sort keys to support culturallysensitive string comparison. Each character in a string is given several categories of sort weights, including alphabetic, case, and diacritic. A sort key, represented by the T:System.Globalization.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. For more information, see the T:System.Globalization.SortKey class.

If you don't specify a string comparison convention, sorting methods such as M:System.Array.Sort(System.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. It creates an array of three strings. First, it sets the System.Threading.Thread.CurrentThread.CurrentCulture property to en-US and calls the M:System.Array.Sort(System.Array) method. The resulting sort order is based on sorting conventions for the English (United States) culture. Next, the example sets the System.Threading.Thread.CurrentThread.CurrentCulture property to da-DK and calls the M:System.Array.Sort(System.Array) method again. 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
System_CAPS_warning警告

If your primary purpose in comparing strings is to determine whether they are equal, you should call the M:System.String.Equals(System.Object) method. Typically, you should use M:System.String.Equals(System.Object)to perform an ordinal comparison. The M:System.String.Compare(System.String,System.String) method is intended primarily to sort strings.

String search methods, such as M:System.String.StartsWith(System.String) and M:System.String.IndexOf(System.Char), also can perform culture-sensitive or ordinal string comparisons. The following example illustrates the differences between ordinal and culture-sensitive comparisons using the M:System.String.IndexOf(System.Char) method. A culture-sensitive search in which the current culture is English (United States) considers the substring "oe" to match the ligature "œ". Because a soft hyphen (U+00AD) is a zero-width character, the search treats the soft hyphen as equivalent to F:System.String.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 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

String search methods, such as M:System.String.StartsWith(System.String) and M:System.String.IndexOf(System.Char), also can perform culture-sensitive or ordinal string comparisons to determine whether a character or substring is found in a specified string.

The search methods in the T:System.String class that search for an individual character, such as theM:System.String.IndexOf(System.String) method, or one of a set of characters, such as the M:System.String.IndexOfAny(System.Char[]) method, all perform an ordinal search. To perform a culture-sensitive search for a character, you must call a T:System.Globalization.CompareInfo method such as M:System.Globalization.CompareInfo.IndexOf(System.String,System.Char) or M:System.Globalization.CompareInfo.LastIndexOf(System.String,System.Char). Note that the results of searching for a character using ordinal and culture-sensitive comparison can be very different. 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. The following example illustrates the difference between the M:System.String.IndexOf(System.Char) and M:System.Globalization.CompareInfo.IndexOf(System.String,System.Char) methods when searching for an individual character. 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

On the other hand, T:System.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 T:System.StringComparison. The sole exception is M:System.String.Contains(System.String), which performs an ordinal search.

Use the M:System.String.Compare(System.String,System.String) method to determine the relationship of two strings in the sort order. Typically, this is a culture-sensitive operation. In contrast, call the M:System.String.Equals(System.String) 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.

System_CAPS_warning警告

It is possible to test for equality by calling the M:System.String.Compare(System.String,System.String) method and determining whether the return value is zero. However, this practice is not recommended. To determine whether two strings are equal, you should call one of the overloads of the M:System.String.Equals(System.String) method. The preferred overload to call is either the instance M:System.String.Equals(System.String,System.StringComparison) method or the static M:System.String.Equals(System.String,System.String,System.StringComparison) method, because both methods include a T: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. 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://". 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 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.

Some Unicode characters have multiple representations. For example, any of the following code points can represent the letter "ắ":

  • U+1EAF

  • U+0103 U+0301

  • U+0061 U+0306 U+0301

Multiple representations for a single character complicate searching, sorting, matching, and other string operations.

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. The .NET Framework 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.

An ordinal comparison is a binary comparison of the Unicode scalar value of corresponding T:System.Char objects in each string. TheT:System.String class includes a number of methods that can perform an ordinal comparison, including the following:

  • Any overload of the M:System.String.Compare(System.String,System.String), M:System.String.Equals(System.Object), M:System.String.StartsWith(System.String), M:System.String.EndsWith(System.String), M:System.String.IndexOf(System.String),and M:System.String.LastIndexOf(System.String) methods that includes a T:System.StringComparison parameter. The method performs an ordinal comparison if you supply a value of F:System.StringComparison.Ordinal or F:System.StringComparison.OrdinalIgnoreCase for this parameter.

  • The overloads of the M:System.String.CompareOrdinal(System.String,System.String) method.

  • Methods that use ordinal comparison by default, such as M:System.String.Contains(System.String), M:System.String.Replace(System.String,System.String), and M:System.String.Split(System.Char[]).

  • Methods that search for a T:System.Charvalue or for the elements in a T:System.Char arrayin a string instance. Such methods include M:System.String.IndexOf(System.Char) and M:System.String.Split(System.Char[]).

You can determine whether a string is normalized to normalization form C by calling the M:System.String.IsNormalized method, or you can call the M:System.String.IsNormalized(System.Text.NormalizationForm) method to determine whether a string is normalized to a specified normalization form. You can also call the M:System.String.Normalize method to convert a string to normalization form C, or you can call the M:System.String.Normalize(System.Text.NormalizationForm) method to convert a string to a specified normalization form. For step-by-step information about normalizing and comparing strings, see the M:System.String.Normalize and M:System.String.Normalize(System.Text.NormalizationForm) methods.

The following simple example illustrates string normalization. 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. In each case, the second test for equality shows that the strings are equal.

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

For more information about normalization and normalization forms, see T:System.Text.NormalizationForm, as well as Unicode Standard Annex #15: Unicode Normalization Formshttp://unicode.org/reports/tr15/ and the Normalization FAQhttp://www.unicode.org/faq/normalization.html on the unicode.org website.

The T:System.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.

You can compare strings to determine their relative position in the sort order by using the following T:System.Stringmethods:

  • Compare returns an integer that indicates the relationship of one string to a second string in the sort order.

  • CompareOrdinal returns an integer that indicates the relationship of one string to a second string based on a comparison of their code points.

  • CompareTo returns an integer that indicates the relationship of the current string instance to a second string in the sort order. The CompareTo(String) method provides the IComparable and IComparable<T> implementations for the String class.

You call the M:System.String.Equals(System.String) method to determine whether two strings are equal. The instance M:System.String.Equals(System.String,System.String,System.StringComparison) and the static M:System.String.Equals(System.String,System.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.

The T:System.String class includes two kinds of search methods:

  • Methods that return a T:System.Boolean value to indicate whether a particular substring is present in a string instance. These include the M:System.String.Contains(System.String), M:System.String.EndsWith(System.String), and M:System.String.StartsWith(System.String) methods.

  • Methods that indicate the starting position of a substring in a string instance. These include the M:System.String.IndexOf(System.String), M:System.String.IndexOfAny(System.Char[]), M:System.String.LastIndexOf(System.String), and M:System.String.LastIndexOfAny(System.Char[]) methods.

System_CAPS_warning警告

If you want to search a string for a particular pattern rather than a specific substring, you should use regular expressions. For more information, see .NET Framework Regular Expressions.

The T:System.String class includes the following methods that appear to modify the value of a string:

  • Insert inserts a string into the current String instance.

  • PadLeft inserts one or more occurrences of a specified character at the beginning of a string.

  • PadRight inserts one or more occurrences of a specified character at the beginning of a string.

  • Remove deletes a substring from the current String instance.

  • Replace replaces a substring with another substring in the current String instance.

  • ToLower and ToLowerInvariant convert all the characters in a string to lowercase.

  • ToUpper and ToUpperInvariant convert all the characters in a string to uppercase.

  • Trim removes all occurrences of a character from the beginning and end of a string.

  • TrimEnd removes all occurrences of a character from the end of a string.

  • TrimStart removes all occurrences of a character from the beginning of a string.

System_CAPS_important重要

All string modification methods return a new T:System.String object. They do not modify the value of the current instance.

The M:System.String.Split(System.Char[]) 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.

The following T:System.String methods can be used for string concatenation:

  • Concat combines one or more substrings into a single string.

  • Join concatenates one or more substrings into a single element and adds a separator between each substring.

The Overload:System.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. The Overload:System.String.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.

  • To embed the string representation of some object that supports the T:System.IFormattable interface in a string.

  • To right-justify or left-justify a substring in a field within a larger string.

For detailed information about formatting operations and examples, see the Overload:System.String.Format overload summary.

You can call the following T:System.String methods to make a copy of a string:

  • Clone returns a reference to an existing String object.

  • Copy creates a copy of an existing string.

  • CopyTo copies a portion of a string to a character array.

In Unicode, a single character can have multiple code points. Normalization converts these equivalent characters into the same binary representation. The M:System.String.Normalize method performs the normalization, and the M:System.String.IsNormalized method determines whether a string is normalized.

For more information and an example, see the Normalization section earlier in this topic.

Universal Windows Platform
4.5 から利用可能
.NET Framework
1.1 から利用可能
Portable Class Library
サポート対象 : portable .NET platforms
Silverlight
2.0 から利用可能
Windows Phone Silverlight
7.0 から利用可能
Windows Phone
8.1 から利用可能

This type is thread safe.

トップに戻る
この情報は役に立ちましたか。
(残り 1500 文字)
フィードバックをいただき、ありがとうございました
表示:
© 2016 Microsoft