String.IndexOf String.IndexOf String.IndexOf String.IndexOf Method

定義

このインスタンス内で最初に出現する指定 Unicode 文字または文字列の 0 から始まるインデックスをレポートします。Reports the zero-based index of the first occurrence of a specified Unicode character or string within this instance. このインスタンス内で文字または文字列が見つからない場合、このメソッドは -1 を返します。The method returns -1 if the character or string is not found in this instance.

オーバーロード

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

public:
 int IndexOf(System::String ^ value, int startIndex, int count, StringComparison comparisonType);
public int IndexOf (string value, int startIndex, int count, StringComparison comparisonType);
member this.IndexOf : string * int * int * StringComparison -> int
Public Function IndexOf (value As String, startIndex As Integer, count As Integer, comparisonType As StringComparison) As Integer

パラメーター

value
String String String String

シークする文字列。The string to seek.

startIndex
Int32 Int32 Int32 Int32

検索が開始される位置。The search starting position.

count
Int32 Int32 Int32 Int32

検査する文字位置の数。The number of character positions to examine.

comparisonType
StringComparison StringComparison StringComparison StringComparison

検索の規則を指定する列挙値の 1 つ。One of the enumeration values that specifies the rules for the search.

戻り値

その文字列が見つかった場合は、現在のインスタンスの先頭からの、value パラメーターの 0 から始まるインデックス位置。見つからなかった場合は、-1。The zero-based index position of the value parameter from the start of the current instance if that string is found, or -1 if it is not. valueEmpty の場合、戻り値は startIndex です。If value is Empty, the return value is startIndex.

例外

count または startIndex が負の値です。count or startIndex is negative.

または-or- startIndex はこのインスタンスの長さを超えています。startIndex is greater than the length of this instance.

または-or- count がこの文字列の長さ - startIndex より大きいです。count is greater than the length of this string minus startIndex.

comparisonType は有効な StringComparison 値ではありません。comparisonType is not a valid StringComparison value.

次の例では、3 つのオーバー ロード、IndexOfのさまざまな値を使用して別の文字列内の文字列の最初の出現箇所を検索するメソッド、StringComparison列挙体。The following example demonstrates three overloads of the IndexOf method that find the first occurrence of a string within another string using different values of the StringComparison enumeration.

// This code example demonstrates the 
// System.String.IndexOf(String, ..., StringComparison) methods.

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

class Sample 
{
    public static void Main() 
    {
    string intro = "Find the first occurrence of a character using different " + 
                   "values of StringComparison.";
    string resultFmt = "Comparison: {0,-28} Location: {1,3}";

// Define a string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
    string CapitalAWithRing = "\u00c5"; 

// Define a string to search. 
// The result of combining the characters LATIN SMALL LETTER A and COMBINING 
// RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character 
// LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
    string cat = "A Cheshire c" + "\u0061\u030a" + "t";

    int loc = 0;
    StringComparison[] scValues = {
        StringComparison.CurrentCulture,
        StringComparison.CurrentCultureIgnoreCase,
        StringComparison.InvariantCulture,
        StringComparison.InvariantCultureIgnoreCase,
        StringComparison.Ordinal,
        StringComparison.OrdinalIgnoreCase };

// Clear the screen and display an introduction.
    Console.Clear();
    Console.WriteLine(intro);

// Display the current culture because culture affects the result. For example, 
// try this code example with the "sv-SE" (Swedish-Sweden) culture.

    Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
    Console.WriteLine("The current culture is \"{0}\" - {1}.", 
                       Thread.CurrentThread.CurrentCulture.Name,
                       Thread.CurrentThread.CurrentCulture.DisplayName);

// Display the string to search for and the string to search.
    Console.WriteLine("Search for the string \"{0}\" in the string \"{1}\"", 
                       CapitalAWithRing, cat);
    Console.WriteLine();

// Note that in each of the following searches, we look for 
// LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains 
// LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates 
// the string was not found.
// Search using different values of StringComparison. Specify the start 
// index and count. 

    Console.WriteLine("Part 1: Start index and count are specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparison. Specify the 
// start index. 
    Console.WriteLine("\nPart 2: Start index is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(CapitalAWithRing, 0, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparison. 
    Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(CapitalAWithRing, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }
    }
}

/*
Note: This code example was executed on a console whose user interface 
culture is "en-US" (English-United States).

This code example produces the following results:

Find the first occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"

Part 1: Start index and count are specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 2: Start index is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 3: Neither start index nor count is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

*/
' This code example demonstrates the 
' System.String.IndexOf(String, ..., StringComparison) methods.

Imports System
Imports System.Threading
Imports System.Globalization

Class Sample
    Public Shared Sub Main() 
        Dim intro As String = "Find the first occurrence of a character using different " & _
                              "values of StringComparison."
        Dim resultFmt As String = "Comparison: {0,-28} Location: {1,3}"
        
        ' Define a string to search for.
        ' U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
        Dim CapitalAWithRing As String = "Å"
        
        ' Define a string to search. 
        ' The result of combining the characters LATIN SMALL LETTER A and COMBINING 
        ' RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character 
        ' LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
        Dim cat As String = "A Cheshire c" & "å" & "t"
        
        Dim loc As Integer = 0
        Dim scValues As StringComparison() =  { _
                        StringComparison.CurrentCulture, _
                        StringComparison.CurrentCultureIgnoreCase, _
                        StringComparison.InvariantCulture, _
                        StringComparison.InvariantCultureIgnoreCase, _
                        StringComparison.Ordinal, _
                        StringComparison.OrdinalIgnoreCase }
        Dim sc As StringComparison
        
        ' Clear the screen and display an introduction.
        Console.Clear()
        Console.WriteLine(intro)
        
        ' Display the current culture because culture affects the result. For example, 
        ' try this code example with the "sv-SE" (Swedish-Sweden) culture.
        Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
        Console.WriteLine("The current culture is ""{0}"" - {1}.", _
                           Thread.CurrentThread.CurrentCulture.Name, _ 
                           Thread.CurrentThread.CurrentCulture.DisplayName)
        
        ' Display the string to search for and the string to search.
        Console.WriteLine("Search for the string ""{0}"" in the string ""{1}""", _
                           CapitalAWithRing, cat)
        Console.WriteLine()
        
        ' Note that in each of the following searches, we look for 
        ' LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains 
        ' LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates 
        ' the string was not found.
        ' Search using different values of StringComparison. Specify the start 
        ' index and count.

        Console.WriteLine("Part 1: Start index and count are specified.")
        For Each sc In  scValues
            loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparison. Specify the 
        ' start index. 

        Console.WriteLine(vbCrLf & "Part 2: Start index is specified.")
        For Each sc In  scValues
            loc = cat.IndexOf(CapitalAWithRing, 0, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparison. 

        Console.WriteLine(vbCrLf & "Part 3: Neither start index nor count is specified.")
        For Each sc In  scValues
            loc = cat.IndexOf(CapitalAWithRing, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
    
    End Sub 'Main
End Class 'Sample

'
'Note: This code example was executed on a console whose user interface 
'culture is "en-US" (English-United States).
'
'This code example produces the following results:
'
'Find the first occurrence of a character using different values of StringComparison.
'The current culture is "en-US" - English (United States).
'Search for the string "Å" in the string "A Cheshire ca°t"
'
'Part 1: Start index and count are specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'
'Part 2: Start index is specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'
'Part 3: Neither start index nor count is specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'

注釈

インデックス番号は 0 (ゼロ) から開始します。Index numbering starts from 0 (zero). startIndex パラメーターには、0 から文字列インスタンスの長さまでの範囲の値を指定できます。The startIndex parameter can range from 0 to the length of the string instance.

検索が始まりますstartIndexし続けてstartIndex + count -1。The search begins at startIndex and continues to startIndex + count -1. ある文字startIndex + count検索には含まれません。The character at startIndex + count is not included in the search.

comparisonTypeを検索するパラメーターを指定します、value現在またはインバリアント カルチャを使用して、または区別しない検索を使用して、word または序数比較規則を使用してパラメーター。The comparisonType parameter specifies to search for the value parameter using the current or invariant culture, using a case-sensitive or case-insensitive search, and using word or ordinal comparison rules.

注意 (呼び出し元)

文字セットには無視できる文字が含まれています。これらの文字は、言語またはカルチャに依存した比較を実行する際には考慮されません。Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. カルチャに依存する検索の場合 (つまり、comparisonTypeOrdinal または OrdinalIgnoreCase でない場合)、value に無視できる文字が含まれていると、その文字を削除して検索した場合と同じ結果になります。In a culture-sensitive search (that is, if comparisonType is not Ordinal or OrdinalIgnoreCase), if value contains an ignorable character, the result is equivalent to searching with that character removed. 場合value1 つまたは複数の無視できる文字のみで構成されて、IndexOf(String, Int32, Int32, StringComparison)メソッドは常に返しますstartIndex、これは、検索の開始文字位置。If value consists only of one or more ignorable characters, the IndexOf(String, Int32, Int32, StringComparison) method always returns startIndex, which is the character position at which the search begins.

次の例では、 IndexOf(String, Int32, Int32, StringComparison) "m"で、3 番目の 2 つの文字列内の 6 番目の文字位置から開始後にソフト ハイフン (U + 00AD) の位置を検索するメソッドを使用します。In the following example, the IndexOf(String, Int32, Int32, StringComparison) method is used to find the position of a soft hyphen (U+00AD) followed by an "m" starting in the third through sixth character positions in two strings. 文字列の 1 つのみに必要な部分文字列が含まれます。Only one of the strings contains the required substring. 例実行している場合、.NET Framework 4.NET Framework 4または後で、どちらの場合も、ソフト ハイフンが、無視できる文字であるため、メソッドのインデックスを返します、文字列内の"m"、カルチャに依存した比較を実行するとき。If the example is run on the .NET Framework 4.NET Framework 4 or later, in both cases, because the soft hyphen is an ignorable character, the method returns the index of "m" in the string when it performs a culture-sensitive comparison. 序数に基づく比較を実行するときに、部分文字列のみで見つけた最初の文字列。When it performs an ordinal comparison, however, it finds the substring only in the first string. 最初の文字列は、"m"の後にソフト ハイフンが含まれている場合、メソッドはソフト ハイフンのインデックスを返すが失敗したが代わりに、カルチャに依存した比較を実行するときに、"m"のインデックスを返しますに注意してください。Note that in the case of the first string, which includes the soft hyphen followed by an "m", the method fails to return the index of the soft hyphen but instead returns the index of the "m" when it performs a culture-sensitive comparison. このメソッドは、序数に基づく比較を実行したときのみ、最初の文字列に含まれるソフト ハイフンのインデックスを返します。The method returns the index of the soft hyphen in the first string only when it performs an ordinal comparison.

[!code-csharpSystem.String.IndexOf#24] [!code-vbSystem.String.IndexOf#24][!code-csharpSystem.String.IndexOf#24] [!code-vbSystem.String.IndexOf#24]

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

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

public:
 int IndexOf(System::String ^ value, int startIndex, StringComparison comparisonType);
public int IndexOf (string value, int startIndex, StringComparison comparisonType);
member this.IndexOf : string * int * StringComparison -> int
Public Function IndexOf (value As String, startIndex As Integer, comparisonType As StringComparison) As Integer

パラメーター

value
String String String String

シークする文字列。The string to seek.

startIndex
Int32 Int32 Int32 Int32

検索が開始される位置。The search starting position.

comparisonType
StringComparison StringComparison StringComparison StringComparison

検索の規則を指定する列挙値の 1 つ。One of the enumeration values that specifies the rules for the search.

戻り値

その文字列が見つかった場合は、現在のインスタンスの先頭からの、value パラメーターの 0 から始まるインデックス位置。見つからなかった場合は、-1。The zero-based index position of the value parameter from the start of the current instance if that string is found, or -1 if it is not. valueEmpty の場合、戻り値は startIndex です。If value is Empty, the return value is startIndex.

例外

startIndex が、0 未満か、またはこの文字列の長さを超えています。startIndex is less than 0 (zero) or greater than the length of this string.

comparisonType は有効な StringComparison 値ではありません。comparisonType is not a valid StringComparison value.

次の例では、3 つのオーバー ロード、IndexOfのさまざまな値を使用して別の文字列内の文字列の最初の出現箇所を検索するメソッド、StringComparison列挙体。The following example demonstrates three overloads of the IndexOf method that find the first occurrence of a string within another string using different values of the StringComparison enumeration.

// This code example demonstrates the 
// System.String.IndexOf(String, ..., StringComparison) methods.

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

class Sample 
{
    public static void Main() 
    {
    string intro = "Find the first occurrence of a character using different " + 
                   "values of StringComparison.";
    string resultFmt = "Comparison: {0,-28} Location: {1,3}";

// Define a string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
    string CapitalAWithRing = "\u00c5"; 

// Define a string to search. 
// The result of combining the characters LATIN SMALL LETTER A and COMBINING 
// RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character 
// LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
    string cat = "A Cheshire c" + "\u0061\u030a" + "t";

    int loc = 0;
    StringComparison[] scValues = {
        StringComparison.CurrentCulture,
        StringComparison.CurrentCultureIgnoreCase,
        StringComparison.InvariantCulture,
        StringComparison.InvariantCultureIgnoreCase,
        StringComparison.Ordinal,
        StringComparison.OrdinalIgnoreCase };

// Clear the screen and display an introduction.
    Console.Clear();
    Console.WriteLine(intro);

// Display the current culture because culture affects the result. For example, 
// try this code example with the "sv-SE" (Swedish-Sweden) culture.

    Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
    Console.WriteLine("The current culture is \"{0}\" - {1}.", 
                       Thread.CurrentThread.CurrentCulture.Name,
                       Thread.CurrentThread.CurrentCulture.DisplayName);

// Display the string to search for and the string to search.
    Console.WriteLine("Search for the string \"{0}\" in the string \"{1}\"", 
                       CapitalAWithRing, cat);
    Console.WriteLine();

// Note that in each of the following searches, we look for 
// LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains 
// LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates 
// the string was not found.
// Search using different values of StringComparison. Specify the start 
// index and count. 

    Console.WriteLine("Part 1: Start index and count are specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparison. Specify the 
// start index. 
    Console.WriteLine("\nPart 2: Start index is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(CapitalAWithRing, 0, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparison. 
    Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(CapitalAWithRing, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }
    }
}

/*
Note: This code example was executed on a console whose user interface 
culture is "en-US" (English-United States).

This code example produces the following results:

Find the first occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"

Part 1: Start index and count are specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 2: Start index is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 3: Neither start index nor count is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

*/
' This code example demonstrates the 
' System.String.IndexOf(String, ..., StringComparison) methods.

Imports System
Imports System.Threading
Imports System.Globalization

Class Sample
    Public Shared Sub Main() 
        Dim intro As String = "Find the first occurrence of a character using different " & _
                              "values of StringComparison."
        Dim resultFmt As String = "Comparison: {0,-28} Location: {1,3}"
        
        ' Define a string to search for.
        ' U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
        Dim CapitalAWithRing As String = "Å"
        
        ' Define a string to search. 
        ' The result of combining the characters LATIN SMALL LETTER A and COMBINING 
        ' RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character 
        ' LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
        Dim cat As String = "A Cheshire c" & "å" & "t"
        
        Dim loc As Integer = 0
        Dim scValues As StringComparison() =  { _
                        StringComparison.CurrentCulture, _
                        StringComparison.CurrentCultureIgnoreCase, _
                        StringComparison.InvariantCulture, _
                        StringComparison.InvariantCultureIgnoreCase, _
                        StringComparison.Ordinal, _
                        StringComparison.OrdinalIgnoreCase }
        Dim sc As StringComparison
        
        ' Clear the screen and display an introduction.
        Console.Clear()
        Console.WriteLine(intro)
        
        ' Display the current culture because culture affects the result. For example, 
        ' try this code example with the "sv-SE" (Swedish-Sweden) culture.
        Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
        Console.WriteLine("The current culture is ""{0}"" - {1}.", _
                           Thread.CurrentThread.CurrentCulture.Name, _ 
                           Thread.CurrentThread.CurrentCulture.DisplayName)
        
        ' Display the string to search for and the string to search.
        Console.WriteLine("Search for the string ""{0}"" in the string ""{1}""", _
                           CapitalAWithRing, cat)
        Console.WriteLine()
        
        ' Note that in each of the following searches, we look for 
        ' LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains 
        ' LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates 
        ' the string was not found.
        ' Search using different values of StringComparison. Specify the start 
        ' index and count.

        Console.WriteLine("Part 1: Start index and count are specified.")
        For Each sc In  scValues
            loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparison. Specify the 
        ' start index. 

        Console.WriteLine(vbCrLf & "Part 2: Start index is specified.")
        For Each sc In  scValues
            loc = cat.IndexOf(CapitalAWithRing, 0, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparison. 

        Console.WriteLine(vbCrLf & "Part 3: Neither start index nor count is specified.")
        For Each sc In  scValues
            loc = cat.IndexOf(CapitalAWithRing, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
    
    End Sub 'Main
End Class 'Sample

'
'Note: This code example was executed on a console whose user interface 
'culture is "en-US" (English-United States).
'
'This code example produces the following results:
'
'Find the first occurrence of a character using different values of StringComparison.
'The current culture is "en-US" - English (United States).
'Search for the string "Å" in the string "A Cheshire ca°t"
'
'Part 1: Start index and count are specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'
'Part 2: Start index is specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'
'Part 3: Neither start index nor count is specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'

注釈

インデックス番号は、0 から始まります。Index numbering starts from 0. startIndex パラメーターには、0 から文字列インスタンスの長さまでの範囲の値を指定できます。The startIndex parameter can range from 0 to the length of the string instance. 場合startIndex文字列インスタンスの長さと等しい、-1 が返されます。If startIndex equals the length of the string instance, the method returns -1.

comparisonTypeを検索するパラメーターを指定します、value現在またはインバリアント カルチャを使用して、または区別しない検索を使用して、word または序数比較規則を使用してパラメーター。The comparisonType parameter specifies to search for the value parameter using the current or invariant culture, using a case-sensitive or case-insensitive search, and using word or ordinal comparison rules.

注意 (呼び出し元)

文字セットには無視できる文字が含まれています。これらの文字は、言語またはカルチャに依存した比較を実行する際には考慮されません。Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. カルチャに依存する検索の場合 (つまり、comparisonTypeOrdinal または OrdinalIgnoreCase でない場合)、value に無視できる文字が含まれていると、その文字を削除して検索した場合と同じ結果になります。In a culture-sensitive search (that is, if comparisonType is not Ordinal or OrdinalIgnoreCase), if value contains an ignorable character, the result is equivalent to searching with that character removed. 場合value1 つまたは複数の無視できる文字のみで構成されて、IndexOf(String, Int32, StringComparison)メソッドは常に返しますstartIndex、これは、検索の開始文字位置。If value consists only of one or more ignorable characters, the IndexOf(String, Int32, StringComparison) method always returns startIndex, which is the character position at which the search begins.

次の例では、 IndexOf(String, Int32, StringComparison) "m"の 2 つの文字列の 3 番目の文字位置から開始後にソフト ハイフン (U + 00AD) の位置を検索するメソッドを使用します。In the following example, the IndexOf(String, Int32, StringComparison) method is used to find the position of a soft hyphen (U+00AD) followed by an "m" starting with the third character position in two strings. 文字列の 1 つだけでは、必要な部分が含まれています。例実行している場合、.NET Framework 4.NET Framework 4または後で、どちらの場合も、ソフト ハイフンが、無視できる文字であるため、メソッドのインデックスを返します、文字列内の"m"、カルチャに依存した比較を実行するとき。Only one of the strings contains the required substring.If the example is run on the .NET Framework 4.NET Framework 4 or later, in both cases, because the soft hyphen is an ignorable character, the method returns the index of "m" in the string when it performs a culture-sensitive comparison. "m" の後にソフト ハイフンが含まれる最初の文字列の場合、メソッドはソフト ハイフンのインデックスを返すことができず、代わりに "m" のインデックスを返すことに注意してください。Note that in the case of the first string, which includes the soft hyphen followed by an "m", the method fails to return the index of the soft hyphen but instead returns the index of the "m". このメソッドは、序数に基づく比較を実行したときのみ、最初の文字列に含まれるソフト ハイフンのインデックスを返します。The method returns the index of the soft hyphen in the first string only when it performs an ordinal comparison.

[!code-csharpSystem.String.IndexOf#25] [!code-vbSystem.String.IndexOf#25][!code-csharpSystem.String.IndexOf#25] [!code-vbSystem.String.IndexOf#25]

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

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

public:
 int IndexOf(char value, int startIndex, int count);
public int IndexOf (char value, int startIndex, int count);
member this.IndexOf : char * int * int -> int
Public Function IndexOf (value As Char, startIndex As Integer, count As Integer) As Integer

パラメーター

value
Char Char Char Char

シークする Unicode 文字。A Unicode character to seek.

startIndex
Int32 Int32 Int32 Int32

検索が開始される位置。The search starting position.

count
Int32 Int32 Int32 Int32

検査する文字位置の数。The number of character positions to examine.

戻り値

その文字が見つかった場合は、文字列の先頭からの、value の 0 から始まるインデックス位置。見つからなかった場合は、-1。The zero-based index position of value from the start of the string if that character is found, or -1 if it is not.

例外

count または startIndex が負の値です。count or startIndex is negative.

または-or- startIndex がこの文字列の長さより大きいです。startIndex is greater than the length of this string.

または-or- count がこの文字列の長さ - startIndex より大きいです。count is greater than the length of this string minus startIndex.

次の例で、IndexOfメソッド。The following example demonstrates the IndexOf method.

// Example for the String::IndexOf( Char, int, int ) method.
using namespace System;
void FindAllChar( Char target, String^ searched )
{
   Console::Write( "The character '{0}' occurs at position(s): ", target );
   int startIndex = -1;
   int hitCount = 0;
   
   // Search for all occurrences of the target.
   while ( true )
   {
      startIndex = searched->IndexOf( target, startIndex + 1, searched->Length - startIndex - 1 );
      
      // Exit the loop if the target is not found.
      if ( startIndex < 0 )
            break;

      Console::Write( "{0}, ", startIndex );
      hitCount++;
   }

   Console::WriteLine( "occurrences: {0}", hitCount );
}

int main()
{
   String^ br1 = "0----+----1----+----2----+----3----+----"
   "4----+----5----+----6----+----7";
   String^ br2 = "0123456789012345678901234567890123456789"
   "0123456789012345678901234567890";
   String^ str = "ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi "
   "ABCDEFGHI abcdefghi ABCDEFGHI";
   Console::WriteLine( "This example of String::IndexOf( Char, int, int )\n"
   "generates the following output." );
   Console::WriteLine( "{0}{1}{0}{2}{0}{3}{0}", Environment::NewLine, br1, br2, str );
   FindAllChar( 'A', str );
   FindAllChar( 'a', str );
   FindAllChar( 'I', str );
   FindAllChar( 'i', str );
   FindAllChar( '@', str );
   FindAllChar( ' ', str );
}

/*
This example of String::IndexOf( Char, int, int )
generates the following output.

0----+----1----+----2----+----3----+----4----+----5----+----6----+----7
01234567890123456789012345678901234567890123456789012345678901234567890
ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI

The character 'A' occurs at position(s): 0, 20, 40, 60, occurrences: 4
The character 'a' occurs at position(s): 10, 30, 50, occurrences: 3
The character 'I' occurs at position(s): 8, 28, 48, 68, occurrences: 4
The character 'i' occurs at position(s): 18, 38, 58, occurrences: 3
The character '@' occurs at position(s): occurrences: 0
The character ' ' occurs at position(s): 9, 19, 29, 39, 49, 59, occurrences: 6
*/
// Example for the String.IndexOf( char, int, int ) method.
using System;

class IndexOfCII 
{
    public static void Main() 
    {
        string br1 = 
            "0----+----1----+----2----+----3----+----" +
            "4----+----5----+----6----+----7";
        string br2 = 
            "0123456789012345678901234567890123456789" +
            "0123456789012345678901234567890";
        string str = 
            "ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi " +
            "ABCDEFGHI abcdefghi ABCDEFGHI";

        Console.WriteLine( 
            "This example of String.IndexOf( char, int, int )\n" +
            "generates the following output." );
        Console.WriteLine( 
            "{0}{1}{0}{2}{0}{3}{0}", 
            Environment.NewLine, br1, br2, str );

        FindAllChar( 'A', str );
        FindAllChar( 'a', str );
        FindAllChar( 'I', str );
        FindAllChar( 'i', str );
        FindAllChar( '@', str );
        FindAllChar( ' ', str );
    }

    static void FindAllChar( Char target, String searched )
    {
        Console.Write( 
            "The character '{0}' occurs at position(s): ", 
            target );

        int     startIndex = -1;
        int     hitCount = 0;

        // Search for all occurrences of the target.
        while( true )
        {
            startIndex = searched.IndexOf( 
                target, startIndex + 1, 
                searched.Length - startIndex - 1 );

            // Exit the loop if the target is not found.
            if( startIndex < 0 )
                break;

            Console.Write( "{0}, ", startIndex );
            hitCount++;
        }

        Console.WriteLine( "occurrences: {0}", hitCount );
    }
}

/*
This example of String.IndexOf( char, int, int )
generates the following output.

0----+----1----+----2----+----3----+----4----+----5----+----6----+----7
01234567890123456789012345678901234567890123456789012345678901234567890
ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI

The character 'A' occurs at position(s): 0, 20, 40, 60, occurrences: 4
The character 'a' occurs at position(s): 10, 30, 50, occurrences: 3
The character 'I' occurs at position(s): 8, 28, 48, 68, occurrences: 4
The character 'i' occurs at position(s): 18, 38, 58, occurrences: 3
The character '@' occurs at position(s): occurrences: 0
The character ' ' occurs at position(s): 9, 19, 29, 39, 49, 59, occurrences: 6
*/
' Example for the String.IndexOf( Char, Integer, Integer ) method.
Imports System
Imports Microsoft.VisualBasic

Module IndexOfCII
   
    Sub Main()
        Dim br1 As String = _
            "0----+----1----+----2----+----3----+----" & _
            "4----+----5----+----6----+----7"
        Dim br2 As String = _
            "0123456789012345678901234567890123456789" & _
            "0123456789012345678901234567890"
        Dim str As String = _
            "ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi " & _
            "ABCDEFGHI abcdefghi ABCDEFGHI"
          
        Console.WriteLine( _
            "This example of String.IndexOf( Char, Integer, Integer )" & _
            vbCrLf & "generates the following output." )
        Console.WriteLine( _
            "{0}{1}{0}{2}{0}{3}{0}", _
            Environment.NewLine, br1, br2, str)

        FindAllChar("A"c, str)
        FindAllChar("a"c, str)
        FindAllChar("I"c, str)
        FindAllChar("i"c, str)
        FindAllChar("@"c, str)
        FindAllChar(" "c, str)
    End Sub 'Main
       
    Sub FindAllChar(target As Char, searched As String)

        Console.Write( _
            "The character ""{0}"" occurs at position(s): ", target)
          
        Dim startIndex As Integer = - 1
        Dim hitCount As Integer = 0
          
        ' Search for all occurrences of the target.
        While True
            startIndex = searched.IndexOf( _
                target, startIndex + 1, _
                searched.Length - startIndex - 1)

            ' Exit the loop if the target is not found.
            If startIndex < 0 Then
                Exit While
            End If 

            Console.Write("{0}, ", startIndex)
            hitCount += 1
        End While
          
        Console.WriteLine("occurrences: {0}", hitCount)

    End Sub 'FindAllChar
End Module 'IndexOfCII

' This example of String.IndexOf( Char, Integer, Integer )
' generates the following output.
' 
' 0----+----1----+----2----+----3----+----4----+----5----+----6----+----7
' 01234567890123456789012345678901234567890123456789012345678901234567890
' ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI
' 
' The character "A" occurs at position(s): 0, 20, 40, 60, occurrences: 4
' The character "a" occurs at position(s): 10, 30, 50, occurrences: 3
' The character "I" occurs at position(s): 8, 28, 48, 68, occurrences: 4
' The character "i" occurs at position(s): 18, 38, 58, occurrences: 3
' The character "@" occurs at position(s): occurrences: 0
' The character " " occurs at position(s): 9, 19, 29, 39, 49, 59, occurrences: 6

注釈

検索が始まりますstartIndexし続けてstartIndex + count -1。The search begins at startIndex and continues to startIndex + count -1. ある文字startIndex + count検索には含まれません。The character at startIndex + count is not included in the search.

インデックス番号は 0 (ゼロ) から開始します。Index numbering starts from 0 (zero). startIndex パラメーターには、0 から文字列インスタンスの長さまでの範囲の値を指定できます。The startIndex parameter can range from 0 to the length of the string instance.

このメソッドは、場所文字と見なされますを別の文字と等価の Unicode スカラー値が同じ場合にのみ、序数 (カルチャに依存しない) 検索を実行します。This method performs an ordinal (culture-insensitive) search, where a character is considered equivalent to another character only if their Unicode scalar values are the same. カルチャに依存する検索を実行するには、使用、CompareInfo.IndexOfメソッド、場所、構成済みの文字を表す、合字「Æ」など (U + 00 C 6)、Unicode スカラー値可能性がありますに相当する文字の構成要素の出現、"AE"などのシーケンスを修正 (u+0041、u+0045)、カルチャによって異なります。To perform a culture-sensitive search, use the CompareInfo.IndexOf method, where a Unicode scalar value representing a precomposed character, such as the ligature "Æ" (U+00C6), might be considered equivalent to any occurrence of the character's components in the correct sequence, such as "AE" (U+0041, U+0045), depending on the culture.

こちらもご覧ください

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

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

public:
 int IndexOf(System::String ^ value, StringComparison comparisonType);
public int IndexOf (string value, StringComparison comparisonType);
member this.IndexOf : string * StringComparison -> int
Public Function IndexOf (value As String, comparisonType As StringComparison) As Integer

パラメーター

value
String String String String

シークする文字列。The string to seek.

comparisonType
StringComparison StringComparison StringComparison StringComparison

検索の規則を指定する列挙値の 1 つ。One of the enumeration values that specifies the rules for the search.

戻り値

その文字列が見つかった場合は、value パラメーターのインデックス位置。見つからなかった場合は -1。The index position of the value parameter if that string is found, or -1 if it is not. valueEmpty の場合、戻り値は 0 です。If value is Empty, the return value is 0.

例外

comparisonType は有効な StringComparison 値ではありません。comparisonType is not a valid StringComparison value.

次の例では、3 つのオーバー ロード、IndexOfのさまざまな値を使用して別の文字列内の文字列の最初の出現箇所を検索するメソッド、StringComparison列挙体。The following example demonstrates three overloads of the IndexOf method that find the first occurrence of a string within another string using different values of the StringComparison enumeration.

// This code example demonstrates the 
// System.String.IndexOf(String, ..., StringComparison) methods.

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

class Sample 
{
    public static void Main() 
    {
    string intro = "Find the first occurrence of a character using different " + 
                   "values of StringComparison.";
    string resultFmt = "Comparison: {0,-28} Location: {1,3}";

// Define a string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
    string CapitalAWithRing = "\u00c5"; 

// Define a string to search. 
// The result of combining the characters LATIN SMALL LETTER A and COMBINING 
// RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character 
// LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
    string cat = "A Cheshire c" + "\u0061\u030a" + "t";

    int loc = 0;
    StringComparison[] scValues = {
        StringComparison.CurrentCulture,
        StringComparison.CurrentCultureIgnoreCase,
        StringComparison.InvariantCulture,
        StringComparison.InvariantCultureIgnoreCase,
        StringComparison.Ordinal,
        StringComparison.OrdinalIgnoreCase };

// Clear the screen and display an introduction.
    Console.Clear();
    Console.WriteLine(intro);

// Display the current culture because culture affects the result. For example, 
// try this code example with the "sv-SE" (Swedish-Sweden) culture.

    Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
    Console.WriteLine("The current culture is \"{0}\" - {1}.", 
                       Thread.CurrentThread.CurrentCulture.Name,
                       Thread.CurrentThread.CurrentCulture.DisplayName);

// Display the string to search for and the string to search.
    Console.WriteLine("Search for the string \"{0}\" in the string \"{1}\"", 
                       CapitalAWithRing, cat);
    Console.WriteLine();

// Note that in each of the following searches, we look for 
// LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains 
// LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates 
// the string was not found.
// Search using different values of StringComparison. Specify the start 
// index and count. 

    Console.WriteLine("Part 1: Start index and count are specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparison. Specify the 
// start index. 
    Console.WriteLine("\nPart 2: Start index is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(CapitalAWithRing, 0, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparison. 
    Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(CapitalAWithRing, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }
    }
}

/*
Note: This code example was executed on a console whose user interface 
culture is "en-US" (English-United States).

This code example produces the following results:

Find the first occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"

Part 1: Start index and count are specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 2: Start index is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 3: Neither start index nor count is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

*/
' This code example demonstrates the 
' System.String.IndexOf(String, ..., StringComparison) methods.

Imports System
Imports System.Threading
Imports System.Globalization

Class Sample
    Public Shared Sub Main() 
        Dim intro As String = "Find the first occurrence of a character using different " & _
                              "values of StringComparison."
        Dim resultFmt As String = "Comparison: {0,-28} Location: {1,3}"
        
        ' Define a string to search for.
        ' U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
        Dim CapitalAWithRing As String = "Å"
        
        ' Define a string to search. 
        ' The result of combining the characters LATIN SMALL LETTER A and COMBINING 
        ' RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character 
        ' LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
        Dim cat As String = "A Cheshire c" & "å" & "t"
        
        Dim loc As Integer = 0
        Dim scValues As StringComparison() =  { _
                        StringComparison.CurrentCulture, _
                        StringComparison.CurrentCultureIgnoreCase, _
                        StringComparison.InvariantCulture, _
                        StringComparison.InvariantCultureIgnoreCase, _
                        StringComparison.Ordinal, _
                        StringComparison.OrdinalIgnoreCase }
        Dim sc As StringComparison
        
        ' Clear the screen and display an introduction.
        Console.Clear()
        Console.WriteLine(intro)
        
        ' Display the current culture because culture affects the result. For example, 
        ' try this code example with the "sv-SE" (Swedish-Sweden) culture.
        Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
        Console.WriteLine("The current culture is ""{0}"" - {1}.", _
                           Thread.CurrentThread.CurrentCulture.Name, _ 
                           Thread.CurrentThread.CurrentCulture.DisplayName)
        
        ' Display the string to search for and the string to search.
        Console.WriteLine("Search for the string ""{0}"" in the string ""{1}""", _
                           CapitalAWithRing, cat)
        Console.WriteLine()
        
        ' Note that in each of the following searches, we look for 
        ' LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains 
        ' LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates 
        ' the string was not found.
        ' Search using different values of StringComparison. Specify the start 
        ' index and count.

        Console.WriteLine("Part 1: Start index and count are specified.")
        For Each sc In  scValues
            loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparison. Specify the 
        ' start index. 

        Console.WriteLine(vbCrLf & "Part 2: Start index is specified.")
        For Each sc In  scValues
            loc = cat.IndexOf(CapitalAWithRing, 0, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparison. 

        Console.WriteLine(vbCrLf & "Part 3: Neither start index nor count is specified.")
        For Each sc In  scValues
            loc = cat.IndexOf(CapitalAWithRing, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
    
    End Sub 'Main
End Class 'Sample

'
'Note: This code example was executed on a console whose user interface 
'culture is "en-US" (English-United States).
'
'This code example produces the following results:
'
'Find the first occurrence of a character using different values of StringComparison.
'The current culture is "en-US" - English (United States).
'Search for the string "Å" in the string "A Cheshire ca°t"
'
'Part 1: Start index and count are specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'
'Part 2: Start index is specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'
'Part 3: Neither start index nor count is specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'

注釈

インデックス番号は 0 から開始します。Index numbering starts from zero.

comparisonTypeを検索するパラメーターを指定します、value現在またはインバリアント カルチャを使用して、または区別しない検索を使用して、word または序数比較規則を使用してパラメーター。The comparisonType parameter specifies to search for the value parameter using the current or invariant culture, using a case-sensitive or case-insensitive search, and using word or ordinal comparison rules.

注意 (呼び出し元)

文字セットには無視できる文字が含まれています。これらの文字は、言語またはカルチャに依存した比較を実行する際には考慮されません。Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. カルチャに依存する検索の場合 (つまり、comparisonTypeOrdinal または OrdinalIgnoreCase でない場合)、value に無視できる文字が含まれていると、その文字を削除して検索した場合と同じ結果になります。In a culture-sensitive search (that is, if comparisonType is not Ordinal or OrdinalIgnoreCase), if value contains an ignorable character, the result is equivalent to searching with that character removed. 場合value1 つまたは複数の無視できる文字のみで構成されて、IndexOf(String, StringComparison)メソッドは常に現在のインスタンスの先頭に一致が見つかったことを示す、0 (ゼロ) を返します。If value consists only of one or more ignorable characters, the IndexOf(String, StringComparison) method always returns 0 (zero) to indicate that the match is found at the beginning of the current instance.

次の例では、IndexOf(String, StringComparison)メソッドを使用して、2 つの文字列 (ソフト ハイフン (U + 00AD)、"n"の後にソフト ハイフンおよびソフト ハイフン、および"m") の 3 つの部分文字列を検索します。In the following example, the IndexOf(String, StringComparison) method is used to find three substrings (a soft hyphen (U+00AD), a soft hyphen followed by "n", and a soft hyphen followed by "m") in two strings. 文字列の 1 つのみにソフト ハイフンが含まれます。Only one of the strings contains a soft hyphen. 例実行している場合、.NET Framework 4.NET Framework 4後、ソフト ハイフンが無視できる文字であるため、カルチャに依存する検索値を返します同じ検索文字列にソフト ハイフンが含まれていないかどうかを返すことができます。If the example is run on the .NET Framework 4.NET Framework 4 or later, because the soft hyphen is an ignorable character, a culture-sensitive search returns the same value that it would return if the soft hyphen were not included in the search string. ただし、序数に基づく検索は、正常に 1 つの文字列でソフト ハイフンを検索して、それが存在しないことを報告 2 番目の文字列から。An ordinal search, however, successfully finds the soft hyphen in one string and reports that it is absent from the second string.

[!code-csharpSystem.String.IndexOf#26] [!code-vbSystem.String.IndexOf#26][!code-csharpSystem.String.IndexOf#26] [!code-vbSystem.String.IndexOf#26]

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

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

public:
 int IndexOf(System::String ^ value, int startIndex, int count);
public int IndexOf (string value, int startIndex, int count);
member this.IndexOf : string * int * int -> int
Public Function IndexOf (value As String, startIndex As Integer, count As Integer) As Integer

パラメーター

value
String String String String

シークする文字列。The string to seek.

startIndex
Int32 Int32 Int32 Int32

検索が開始される位置。The search starting position.

count
Int32 Int32 Int32 Int32

検査する文字位置の数。The number of character positions to examine.

戻り値

その文字列が見つかった場合は、現在のインスタンスの先頭からの、value の 0 から始まるインデックス位置。見つからなかった場合は、-1。The zero-based index position of value from the start of the current instance if that string is found, or -1 if it is not. valueEmpty の場合、戻り値は startIndex です。If value is Empty, the return value is startIndex.

例外

count または startIndex が負の値です。count or startIndex is negative.

または-or- startIndex がこの文字列の長さより大きいです。startIndex is greater than the length of this string.

または-or- count がこの文字列の長さ - startIndex より大きいです。count is greater than the length of this string minus startIndex.

次の例は、文字列のすべての出現箇所のインデックスを検索"he"別の文字列の部分文字列。The following example finds the index of all occurrences of the string "he" within a substring of another string. 検索の反復ごとに検索する文字数を再計算する必要があることに注意してください。Note that the number of characters to be searched must be recalculated for each search iteration.

// Sample for String::IndexOf(String, Int32, Int32)
using namespace System;
int main()
{
   String^ br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-";
   String^ br2 = "0123456789012345678901234567890123456789012345678901234567890123456";
   String^ str = "Now is the time for all good men to come to the aid of their party.";
   int start;
   int at;
   int end;
   int count;
   end = str->Length;
   start = end / 2;
   Console::WriteLine();
   Console::WriteLine( "All occurrences of 'he' from position {0} to {1}.", start, end - 1 );
   Console::WriteLine( "{1}{0}{2}{0}{3}{0}", Environment::NewLine, br1, br2, str );
   Console::Write( "The string 'he' occurs at position(s): " );
   count = 0;
   at = 0;
   while ( (start <= end) && (at > -1) )
   {
      
      // start+count must be a position within -str-.
      count = end - start;
      at = str->IndexOf( "he", start, count );
      if ( at == -1 )
            break;

      Console::Write( "{0} ", at );
      start = at + 1;
   }

   Console::WriteLine();
}

/*
This example produces the following results:

All occurrences of 'he' from position 33 to 66.
0----+----1----+----2----+----3----+----4----+----5----+----6----+-
0123456789012345678901234567890123456789012345678901234567890123456
Now is the time for all good men to come to the aid of their party.

The string 'he' occurs at position(s): 45 56

*/
// Sample for String.IndexOf(String, Int32, Int32)
using System;

class Sample {
    public static void Main() {

    string br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-";
    string br2 = "0123456789012345678901234567890123456789012345678901234567890123456";
    string str = "Now is the time for all good men to come to the aid of their party.";
    int start;
    int at;
    int end;
    int count;

    end = str.Length;
    start = end/2;
    Console.WriteLine();
    Console.WriteLine("All occurrences of 'he' from position {0} to {1}.", start, end-1);
    Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str);
    Console.Write("The string 'he' occurs at position(s): ");

    count = 0;
    at = 0;
    while((start <= end) && (at > -1))
        {
// start+count must be a position within -str-.
        count = end - start;
        at = str.IndexOf("he", start, count);
        if (at == -1) break;
        Console.Write("{0} ", at);
        start = at+1;
        }
    Console.WriteLine();
    }
}
/*
This example produces the following results:

All occurrences of 'he' from position 33 to 66.
0----+----1----+----2----+----3----+----4----+----5----+----6----+-
0123456789012345678901234567890123456789012345678901234567890123456
Now is the time for all good men to come to the aid of their party.

The string 'he' occurs at position(s): 45 56

*/
' Sample for String.IndexOf(String, Int32, Int32)
Imports System

Class Sample
   
   Public Shared Sub Main()
      
      Dim br1 As String = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-"
      Dim br2 As String = "0123456789012345678901234567890123456789012345678901234567890123456"
      Dim str As String = "Now is the time for all good men to come to the aid of their party."
      Dim start As Integer
      Dim at As Integer
      Dim [end] As Integer
      Dim count As Integer
      
      [end] = str.Length
      start = [end] / 2
      Console.WriteLine()
      Console.WriteLine("All occurrences of 'he' from position {0} to {1}.", start, [end] - 1)
      Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str)
      Console.Write("The string 'he' occurs at position(s): ")
      
      count = 0
      at = 0
      While start <= [end] AndAlso at > - 1
         ' start+count must be a position within -str-.
         count = [end] - start
         at = str.IndexOf("he", start, count)
         If at = - 1 Then
            Exit While
         End If
         Console.Write("{0} ", at)
         start = at + 1
      End While
      Console.WriteLine()
   End Sub 'Main
End Class 'Sample
'
'This example produces the following results:
'
'All occurrences of 'he' from position 33 to 66.
'0----+----1----+----2----+----3----+----4----+----5----+----6----+-
'0123456789012345678901234567890123456789012345678901234567890123456
'Now is the time for all good men to come to the aid of their party.
'
'The string 'he' occurs at position(s): 45 56
'
'

注釈

インデックス番号は 0 (ゼロ) から開始します。Index numbering starts from 0 (zero). startIndex パラメーターには、0 から文字列インスタンスの長さまでの範囲の値を指定できます。The startIndex parameter can range from 0 to the length of the string instance.

このメソッドは、現在のカルチャを使用して単語 (大文字小文字を区別し、カルチャに依存する) 検索を実行します。This method performs a word (case-sensitive and culture-sensitive) search using the current culture. 検索が始まりますstartIndexし続けてstartIndex + count -1。The search begins at startIndex and continues to startIndex + count -1. ある文字startIndex + count検索には含まれません。The character at startIndex + count is not included in the search.

文字セットには無視できる文字が含まれています。これらの文字は、言語またはカルチャに依存した比較を実行する際には考慮されません。Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. カルチャに依存した検索では、value に無視できる文字が含まれている場合、その文字を削除して検索した場合と同じ結果になります。In a culture-sensitive search, if value contains an ignorable character, the result is equivalent to searching with that character removed. 場合value1 つまたは複数の無視できる文字のみで構成されて、IndexOf(String, Int32, Int32)メソッドは常に返しますstartIndex、これは、検索の開始文字位置。If value consists only of one or more ignorable characters, the IndexOf(String, Int32, Int32) method always returns startIndex, which is the character position at which the search begins. 次の例では、 IndexOf(String, Int32, Int32) "m"で、3 番目の 2 つの文字列内の 6 番目の文字位置から開始後にソフト ハイフン (U + 00AD) の位置を検索するメソッドを使用します。In the following example, the IndexOf(String, Int32, Int32) method is used to find the position of a soft hyphen (U+00AD) followed by an "m" starting in the third through sixth character positions in two strings. 文字列の 1 つのみに必要な部分文字列が含まれます。Only one of the strings contains the required substring. 例実行している場合、.NET Framework 4.NET Framework 4または後で、どちらの場合も、ソフト ハイフンが、無視できる文字であるため、メソッドのインデックスを返します、文字列内の"m"、カルチャに依存した比較を実行するとき。If the example is run on the .NET Framework 4.NET Framework 4 or later, in both cases, because the soft hyphen is an ignorable character, the method returns the index of "m" in the string when it performs a culture-sensitive comparison. "m" の後にソフト ハイフンが含まれる最初の文字列の場合、メソッドはソフト ハイフンのインデックスを返すことができず、代わりに "m" のインデックスを返すことに注意してください。Note that in the case of the first string, which includes the soft hyphen followed by an "m", the method fails to return the index of the soft hyphen but instead returns the index of the "m".

using System;

public class Example
{
   public static void Main()
   {
      string searchString = "\u00ADm";
      string s1 = "ani\u00ADmal" ;
      string s2 = "animal";

      Console.WriteLine(s1.IndexOf(searchString, 2, 4));
      Console.WriteLine(s2.IndexOf(searchString, 2, 4));
   }
}
// The example displays the following output:
//       4
//       3
Module Example
   Public Sub Main()
      Dim searchString As String = Chrw(&h00AD) + "m"
      Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
      Dim s2 As String = "animal"

      Console.WriteLine(s1.IndexOf(searchString, 2, 4))
      Console.WriteLine(s2.IndexOf(searchString, 2, 4))
   End Sub
End Module
' The example displays the following output:
'       4
'       3

注意 (呼び出し元)

説明したよう文字列を使用するためのベスト プラクティス既定値を代入しを明示的に指定するパラメーターを必要とするメソッドを呼び出す代わりに文字列比較メソッドを呼び出さないようにすることをお勧めします。As explained in Best Practices for Using Strings, we recommend that you avoid calling string comparison methods that substitute default values and instead call methods that require parameters to be explicitly specified. 現在のカルチャの比較規則を使用して、この操作を実行する、呼び出し、IndexOf(String, Int32, Int32, StringComparison)メソッドのオーバー ロードの値を持つCurrentCulturecomparisonTypeパラメーター。To use the comparison rules of the current culture to perform this operation, call the IndexOf(String, Int32, Int32, StringComparison) method overload with a value of CurrentCulture for its comparisonType parameter.

こちらもご覧ください

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

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

public:
 int IndexOf(char value, StringComparison comparisonType);
public int IndexOf (char value, StringComparison comparisonType);
member this.IndexOf : char * StringComparison -> int
Public Function IndexOf (value As Char, comparisonType As StringComparison) As Integer

パラメーター

value
Char Char Char Char

検索対象の文字。The character to seek.

comparisonType
StringComparison StringComparison StringComparison StringComparison

検索の規則を指定する列挙値。An enumeration value that specifies the rules for the search.

戻り値

その文字が見つかった場合は、value の 0 から始まるインデックスでの位置。見つからなかった場合は -1。The zero-based index of value if that character is found, or -1 if it is not.

例外

comparisonType は有効な StringComparison 値ではありません。comparisonType is not a valid StringComparison value.

注釈

インデックス番号は 0 から開始します。Index numbering starts from zero.

comparisonTypeパラメーターは、StringComparison列挙型のメンバーを指定するかどうかの検索、value引数が現在またはインバリアント カルチャを使用して、大文字や大文字と小文字は、または word または序数比較規則を使用します。The comparisonType parameter is a StringComparison enumeration member that specifies whether the search for the value argument uses the current or invariant culture, is case-sensitive or case-insensitive, or uses word or ordinal comparison rules.

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

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

public:
 int IndexOf(char value, int startIndex);
public int IndexOf (char value, int startIndex);
member this.IndexOf : char * int -> int
Public Function IndexOf (value As Char, startIndex As Integer) As Integer

パラメーター

value
Char Char Char Char

シークする Unicode 文字。A Unicode character to seek.

startIndex
Int32 Int32 Int32 Int32

検索が開始される位置。The search starting position.

戻り値

その文字が見つかった場合は、文字列の先頭からの、value の 0 から始まるインデックス位置。見つからなかった場合は、-1。The zero-based index position of value from the start of the string if that character is found, or -1 if it is not.

例外

startIndex が、0 (ゼロ) 未満か、または文字列の長さを超えています。startIndex is less than 0 (zero) or greater than the length of the string.

次の例で、IndexOfメソッド。The following example demonstrates the IndexOf method.

// Sample for String::IndexOf(Char, Int32)
using namespace System;
int main()
{
   String^ br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-";
   String^ br2 = "0123456789012345678901234567890123456789012345678901234567890123456";
   String^ str = "Now is the time for all good men to come to the aid of their party.";
   int start;
   int at;
   Console::WriteLine();
   Console::WriteLine( "All occurrences of 't' from position 0 to {0}.", str->Length - 1 );
   Console::WriteLine( "{1}{0}{2}{0}{3}{0}", Environment::NewLine, br1, br2, str );
   Console::Write( "The letter 't' occurs at position(s): " );
   at = 0;
   start = 0;
   while ( (start < str->Length) && (at > -1) )
   {
      at = str->IndexOf( 't', start );
      if ( at == -1 )
            break;

      Console::Write( "{0} ", at );
      start = at + 1;
   }

   Console::WriteLine();
}

/*
This example produces the following results:

All occurrences of 't' from position 0 to 66.
0----+----1----+----2----+----3----+----4----+----5----+----6----+-
0123456789012345678901234567890123456789012345678901234567890123456
Now is the time for all good men to come to the aid of their party.

The letter 't' occurs at position(s): 7 11 33 41 44 55 64

*/
// Sample for String.IndexOf(Char, Int32)
using System;

class Sample {
    public static void Main() {

    string br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-";
    string br2 = "0123456789012345678901234567890123456789012345678901234567890123456";
    string str = "Now is the time for all good men to come to the aid of their party.";
    int start;
    int at;

    Console.WriteLine();
    Console.WriteLine("All occurrences of 't' from position 0 to {0}.", str.Length-1);
    Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str);
    Console.Write("The letter 't' occurs at position(s): ");

    at = 0;
    start = 0; 
    while((start < str.Length) && (at > -1))
        {
        at = str.IndexOf('t', start);
        if (at == -1) break;
        Console.Write("{0} ", at);
        start = at+1;
        }
    Console.WriteLine();
    }
}
/*
This example produces the following results:

All occurrences of 't' from position 0 to 66.
0----+----1----+----2----+----3----+----4----+----5----+----6----+-
0123456789012345678901234567890123456789012345678901234567890123456
Now is the time for all good men to come to the aid of their party.

The letter 't' occurs at position(s): 7 11 33 41 44 55 64

*/
' Sample for String.IndexOf(Char, Int32)

Module Sample
    Sub Main()

        Dim br1 As String = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-"
        Dim br2 As String = "0123456789012345678901234567890123456789012345678901234567890123456"
        Dim str As String = "Now is the time for all good men to come to the aid of their party."
        Dim start As Integer
        Dim at As Integer

        Console.WriteLine()
        Console.WriteLine("All occurrences of 't' from position 0 to {0}.", str.Length - 1)
        Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str)
        Console.Write("The letter 't' occurs at position(s): ")

        at = 0
        start = 0
        While start < str.Length AndAlso at > -1
            at = str.IndexOf("t"c, start)
            If at = -1 Then
                Exit While
            End If
            Console.Write("{0} ", at)
            start = at + 1
        End While
        Console.WriteLine()
    End Sub
End Module
'
'This example produces the following results:
'
'All occurrences of 't' from position 0 to 66.
'0----+----1----+----2----+----3----+----4----+----5----+----6----+-
'0123456789012345678901234567890123456789012345678901234567890123456
'Now is the time for all good men to come to the aid of their party.
'
'The letter 't' occurs at position(s): 7 11 33 41 44 55 64
'
'

注釈

インデックス番号は、0 から始まります。Index numbering starts from 0. startIndex パラメーターには、0 から文字列インスタンスの長さまでの範囲の値を指定できます。The startIndex parameter can range from 0 to the length of the string instance. 場合startIndex文字列インスタンスの長さと等しい、-1 が返されます。If startIndex equals the length of the string instance, the method returns -1.

検索の範囲はstartIndex文字列の末尾にします。The search ranges from startIndex to the end of the string.

このメソッドは、場所文字と見なされますを別の文字と等価の Unicode スカラー値が同じ場合にのみ、序数 (カルチャに依存しない) 検索を実行します。This method performs an ordinal (culture-insensitive) search, where a character is considered equivalent to another character only if their Unicode scalar values are the same. カルチャに依存する検索を実行するには、使用、CompareInfo.IndexOfメソッド、場所、構成済みの文字を表す、合字「Æ」など (U + 00 C 6)、Unicode スカラー値可能性がありますに相当する文字の構成要素の出現、"AE"などのシーケンスを修正 (u+0041、u+0045)、カルチャによって異なります。To perform a culture-sensitive search, use the CompareInfo.IndexOf method, where a Unicode scalar value representing a precomposed character, such as the ligature "Æ" (U+00C6), might be considered equivalent to any occurrence of the character's components in the correct sequence, such as "AE" (U+0041, U+0045), depending on the culture.

こちらもご覧ください

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

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

public:
 int IndexOf(System::String ^ value);
public int IndexOf (string value);
member this.IndexOf : string -> int
Public Function IndexOf (value As String) As Integer

パラメーター

value
String String String String

シークする文字列。The string to seek.

戻り値

その文字列が見つかった場合は、value の 0 から始まるインデックスでの位置。見つからなかった場合は -1。The zero-based index position of value if that string is found, or -1 if it is not. valueEmpty の場合、戻り値は 0 です。If value is Empty, the return value is 0.

例外

次の例は、「動物」で"n"を検索します。The following example searches for the "n" in "animal". 文字列のインデックスは、1 つではなく、0 から始まるため、IndexOf(String)メソッドは、位置 1 で"n"があることを示します。Because string indexes begin at zero rather than one, the IndexOf(String) method indicates that the "n" is at position 1.

using namespace System;

void main()
{
   String^ str = "animal";
   String^ toFind = "n";
   int index = str->IndexOf("n");
   Console::WriteLine("Found '{0}' in '{1}' at position {2}",
                        toFind, str, index);

}
// The example displays the following output:
//        Found 'n' in 'animal' at position 1
using System;

public class Example
{
   public static void Main()
   {
      String str = "animal";
      String toFind = "n";
      int index = str.IndexOf("n");
      Console.WriteLine("Found '{0}' in '{1}' at position {2}",
                        toFind, str, index);
   }
}
// The example displays the following output:
//        Found 'n' in 'animal' at position 1
Public Module Example
   Public Sub Main()
      Dim str As String = "animal"
      Dim toFind As String = "n"
      Dim index As Integer = str.IndexOf("n")
      Console.WriteLine("Found '{0}' in '{1}' at position {2}",
                        toFind, str, index)
   End Sub
End Module
' The example displays the following output:
'       Found 'n' in 'animal' at position 1

次の例では、IndexOf動物の名前の文の開始位置を決定する方法。The following example uses the IndexOf method to determine the starting position of an animal name in a sentence. この位置を使用して、文に対象の動物を説明する形容詞を挿入します。It then uses this position to insert an adjective that describes the animal into the sentence.

using namespace System;

int main()
{
   String^ animal1 = "fox";
   String^ animal2 = "dog";
   String^ strTarget = String::Format( "The {0} jumps over the {1}.", animal1, animal2 );
   Console::WriteLine( "The original string is:{0}{1}{0}", Environment::NewLine, strTarget );
   Console::Write( "Enter an adjective (or group of adjectives) to describe the {0}: ==> ", animal1 );
   String^ adj1 = Console::ReadLine();
   Console::Write( "Enter an adjective (or group of adjectives) to describe the {0}: ==> ", animal2 );
   String^ adj2 = Console::ReadLine();
   adj1 = String::Concat( adj1->Trim(), " " );
   adj2 = String::Concat( adj2->Trim(), " " );
   strTarget = strTarget->Insert( strTarget->IndexOf( animal1 ), adj1 );
   strTarget = strTarget->Insert( strTarget->IndexOf( animal2 ), adj2 );
   Console::WriteLine( " {0}The final string is: {0} {1}", Environment::NewLine, strTarget );
}
// Output from the example might appear as follows:
//       The original string is:
//       The fox jumps over the dog.
//       
//       Enter an adjective (or group of adjectives) to describe the fox: ==> bold
//       Enter an adjective (or group of adjectives) to describe the dog: ==> lazy
//       
//       The final string is:
//       The bold fox jumps over the lazy dog.
using System;

public class Example {
    public static void Main() 
    {
        string animal1 = "fox";
        string animal2 = "dog";

        string strTarget = String.Format("The {0} jumps over the {1}.", 
                                         animal1, animal2);

        Console.WriteLine("The original string is:{0}{1}{0}", 
                          Environment.NewLine, strTarget);

        Console.Write("Enter an adjective (or group of adjectives) " +
                      "to describe the {0}: ==> ", animal1);
        string adj1 = Console.ReadLine();

        Console.Write("Enter an adjective (or group of adjectives) " + 
                      "to describe the {0}: ==> ", animal2);    
        string adj2 = Console.ReadLine();

        adj1 = adj1.Trim() + " ";
        adj2 = adj2.Trim() + " ";

        strTarget = strTarget.Insert(strTarget.IndexOf(animal1), adj1);
        strTarget = strTarget.Insert(strTarget.IndexOf(animal2), adj2);

        Console.WriteLine("{0}The final string is:{0}{1}", 
                          Environment.NewLine, strTarget);
    }
}
// Output from the example might appear as follows:
//       The original string is:
//       The fox jumps over the dog.
//       
//       Enter an adjective (or group of adjectives) to describe the fox: ==> bold
//       Enter an adjective (or group of adjectives) to describe the dog: ==> lazy
//       
//       The final string is:
//       The bold fox jumps over the lazy dog.
Public Class Example
    Public Shared Sub Main()
        Dim animal1 As String = "fox"
        Dim animal2 As String = "dog"
        Dim strTarget As String = String.Format("The {0} jumps over the {1}.", 
                                                animal1, animal2)
        
        Console.WriteLine("The original string is: {0}{1}{0}", 
                          Environment.NewLine, strTarget)
        
        Console.Write("Enter an adjective (or group of adjectives) " +
                      "to describe the {0}: ==> ", animal1)
        Dim adj1 As String = Console.ReadLine()
        
        Console.Write("Enter an adjective (or group of adjectives) " + 
                      "to describe the {0}: ==> ", animal2)
        Dim adj2 As String = Console.ReadLine()
        
        adj1 = adj1.Trim() + " "
        adj2 = adj2.Trim() + " "
        
        strTarget = strTarget.Insert(strTarget.IndexOf(animal1), adj1)
        strTarget = strTarget.Insert(strTarget.IndexOf(animal2), adj2)
        
        Console.WriteLine("{0}The final string is:{0}{1}", 
                          Environment.NewLine, strTarget)
    End Sub 
End Class 
' Output from the example might appear as follows:
'       The original string is:
'       The fox jumps over the dog.
'       
'       Enter an adjective (or group of adjectives) to describe the fox: ==> bold
'       Enter an adjective (or group of adjectives) to describe the dog: ==> lazy
'       
'       The final string is:
'       The bold fox jumps over the lazy dog.

注釈

インデックス番号は 0 から開始します。Index numbering starts from zero.

このメソッドは、現在のカルチャを使用して単語 (大文字小文字を区別し、カルチャに依存する) 検索を実行します。This method performs a word (case-sensitive and culture-sensitive) search using the current culture. 検索では、このインスタンスの最初の文字位置から開始し、最後の文字位置まで継続されます。The search begins at the first character position of this instance and continues until the last character position.

文字セットには無視できる文字が含まれています。これらの文字は、言語またはカルチャに依存した比較を実行する際には考慮されません。Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. カルチャに依存した検索では、value に無視できる文字が含まれている場合、その文字を削除して検索した場合と同じ結果になります。In a culture-sensitive search, if value contains an ignorable character, the result is equivalent to searching with that character removed. 場合value1 つまたは複数の無視できる文字のみで構成されて、IndexOf(String)メソッドは常に現在のインスタンスの先頭に一致が見つかったことを示す、0 (ゼロ) を返します。If value consists only of one or more ignorable characters, the IndexOf(String) method always returns 0 (zero) to indicate that the match is found at the beginning of the current instance. 次の例では、IndexOf(String)メソッドを使用して、2 つの文字列 (ソフト ハイフン (U + 00AD)、"n"の後にソフト ハイフンおよびソフト ハイフン、および"m") の 3 つの部分文字列を検索します。In the following example, the IndexOf(String) method is used to find three substrings (a soft hyphen (U+00AD), a soft hyphen followed by "n", and a soft hyphen followed by "m") in two strings. 文字列の 1 つのみにソフト ハイフンが含まれます。Only one of the strings contains a soft hyphen. 例実行している場合、.NET Framework 4.NET Framework 4後で、各ケースでソフト ハイフンが、無視できる文字であるため、結果は、場合と同じにソフト ハイフンが含まれていない必要があるかvalueします。If the example is run on the .NET Framework 4.NET Framework 4 or later, in each case, because the soft hyphen is an ignorable character, the result is the same as if the soft hyphen had not been included in value. ソフト ハイフンのみを検索するときに、文字列の先頭に一致が検出されたことを示す、0 (ゼロ) を返します。When searching for a soft hyphen only, the method returns 0 (zero) to indicate that it has found a match at the beginning of the string.

using System;

public class Example
{
   public static void Main()
   {
      string s1 = "ani\u00ADmal";
      string s2 = "animal";
      
      // Find the index of the soft hyphen.
      Console.WriteLine(s1.IndexOf("\u00AD"));
      Console.WriteLine(s2.IndexOf("\u00AD"));
      
      // Find the index of the soft hyphen followed by "n".
      Console.WriteLine(s1.IndexOf("\u00ADn"));
      Console.WriteLine(s2.IndexOf("\u00ADn"));
      
      // Find the index of the soft hyphen followed by "m".
      Console.WriteLine(s1.IndexOf("\u00ADm"));
      Console.WriteLine(s2.IndexOf("\u00ADm"));
   }
}
// The example displays the following output
// if run under the .NET Framework 4 or later:
//       0
//       0
//       1
//       1
//       4
//       3
Module Example
   Public Sub Main()
      Dim softHyphen As String = ChrW(&h00AD)
      Dim s1 As String = "ani" + softHyphen + "mal"
      Dim s2 As String = "animal"
      
      ' Find the index of the soft hyphen.
      Console.WriteLine(s1.IndexOf(softHyphen))
      Console.WriteLine(s2.IndexOf(softHyphen))
      
      ' Find the index of the soft hyphen followed by "n".
      Console.WriteLine(s1.IndexOf(softHyphen + "n"))
      Console.WriteLine(s2.IndexOf(softHyphen + "n"))
      
      ' Find the index of the soft hyphen followed by "m".
      Console.WriteLine(s1.IndexOf(softHyphen + "m"))
      Console.WriteLine(s2.IndexOf(softHyphen + "m"))
   End Sub
End Module
' The example displays the following output 
' if run under the .NET Framework 4 or later:
'       0
'       0
'       1
'       1
'       4
'       3

注意 (呼び出し元)

説明したよう文字列を使用するためのベスト プラクティス既定値を代入しを明示的に指定するパラメーターを必要とするメソッドを呼び出す代わりに文字列比較メソッドを呼び出さないようにすることをお勧めします。As explained in Best Practices for Using Strings, we recommend that you avoid calling string comparison methods that substitute default values and instead call methods that require parameters to be explicitly specified. 文字列インスタンス内の部分文字列の最初のインデックスを検索するには、現在のカルチャの比較規則を使用して、呼び出して、IndexOf(String, StringComparison)メソッドのオーバー ロードの値を持つCurrentCulturecomparisonTypeパラメーター。To find the first index of a substring within a string instance by using the comparison rules of the current culture, call the IndexOf(String, StringComparison) method overload with a value of CurrentCulture for its comparisonType parameter.

こちらもご覧ください

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

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

public:
 int IndexOf(char value);
public int IndexOf (char value);
member this.IndexOf : char -> int
Public Function IndexOf (value As Char) As Integer

パラメーター

value
Char Char Char Char

シークする Unicode 文字。A Unicode character to seek.

戻り値

その文字が見つかった場合は、value の 0 から始まるインデックスでの位置。見つからなかった場合は -1。The zero-based index position of value if that character is found, or -1 if it is not.

次の例では、検索する方法を示します、Stringの文字を使用して、IndexOfメソッド。The following example demonstrates how you can search a String for a character using the IndexOf method.

using namespace System;

void main()
{
   // Create a Unicode String with 5 Greek Alpha characters.
   String^ szGreekAlpha = gcnew String(L'\x0391',5);

   // Create a Unicode String with a 3 Greek Omega characters.
   String^ szGreekOmega = L"\x03A9\x03A9\x03A9";

   String^ szGreekLetters = String::Concat(szGreekOmega, szGreekAlpha, 
                                           szGreekOmega->Clone());

   // Display the entire string.
   Console::WriteLine(szGreekLetters);

   // The first index of Alpha.
   int ialpha = szGreekLetters->IndexOf( L'\x0391');
   // The first index of Omega.
   int iomega = szGreekLetters->IndexOf(L'\x03A9');

   Console::WriteLine("First occurrence of the Greek letter Alpha: Index {0}", 
                      ialpha);
   Console::WriteLine("First occurrence of the Greek letter Omega: Index {0}", 
                      iomega);
}
// The example displays the following output:
//       The string: OOO?????OOO
//       First occurrence of the Greek letter Alpha: Index 3
//       First occurrence of the Greek letter Omega: Index 0
using System;

class Example
{
   static void Main()
   {
      // Create a Unicode string with 5 Greek Alpha characters.
      String szGreekAlpha = new String('\u0391',5);

      // Create a Unicode string with 3 Greek Omega characters.
      String szGreekOmega = "\u03A9\u03A9\u03A9";
      
      String szGreekLetters = String.Concat(szGreekOmega, szGreekAlpha, 
                                            szGreekOmega.Clone());

      // Display the entire string.
      Console.WriteLine("The string: {0}", szGreekLetters);

      // The first index of Alpha.
      int ialpha = szGreekLetters.IndexOf('\u0391');
      // The first index of Omega.
      int iomega = szGreekLetters.IndexOf('\u03A9');

      Console.WriteLine("First occurrence of the Greek letter Alpha: Index {0}", 
                        ialpha);
      Console.WriteLine("First occurrence of the Greek letter Omega: Index {0}", 
                        iomega);
   }
} 
// The example displays the following output:
//    The string: OOO?????OOO
//    First occurrence of the Greek letter Alpha: Index 3
//    First occurrence of the Greek letter Omega: Index 0
Public Module Example
   Public Sub Main()
      ' Create a Unicode string with 5 Greek Alpha characters.
      Dim szGreekAlpha As New String(ChrW(&H0391), 5)

      ' Create a Unicode string with 3 Greek Omega characters.
      Dim szGreekOmega As String = ChrW(&H03A9) + ChrW(&H03A9)+
                                   ChrW(&H03A9)

      Dim szGreekLetters As String = String.Concat(szGreekOmega, szGreekAlpha, _
                                                   szGreekOmega.Clone())

      ' Display the entire string.
      Console.WriteLine(szGreekLetters)

      ' The first index of Alpha.
      Dim iAlpha As Integer = szGreekLetters.IndexOf(ChrW(&H0391))
      ' The first index of Omega.
      Dim iomega As Integer = szGreekLetters.IndexOf(ChrW(&H03A9))

      Console.WriteLine("First occurrence of the Greek letter Alpha: Index {0}", 
                        ialpha)
      Console.WriteLine("First occurrence of the Greek letter Omega: Index {0}", 
                        iomega)
   End Sub
End Module
' The example displays the following output:
'       The string: OOO?????OOO
'       First occurrence of the Greek letter Alpha: Index 3
'       First occurrence of the Greek letter Omega: Index 0

注釈

インデックス番号は 0 から開始します。Index numbering starts from zero.

このメソッドは、場所文字と見なされますを別の文字と等価の Unicode スカラー値が同じ場合にのみ、序数 (カルチャに依存しない) 検索を実行します。This method performs an ordinal (culture-insensitive) search, where a character is considered equivalent to another character only if their Unicode scalar values are the same. カルチャに依存する検索を実行するには、使用、CompareInfo.IndexOfメソッド、場所、構成済みの文字を表す、合字「Æ」など (U + 00 C 6)、Unicode スカラー値可能性がありますに相当する文字の構成要素の出現、"AE"などのシーケンスを修正 (u+0041、u+0045)、カルチャによって異なります。To perform a culture-sensitive search, use the CompareInfo.IndexOf method, where a Unicode scalar value representing a precomposed character, such as the ligature "Æ" (U+00C6), might be considered equivalent to any occurrence of the character's components in the correct sequence, such as "AE" (U+0041, U+0045), depending on the culture.

こちらもご覧ください

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

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

public:
 int IndexOf(System::String ^ value, int startIndex);
public int IndexOf (string value, int startIndex);
member this.IndexOf : string * int -> int
Public Function IndexOf (value As String, startIndex As Integer) As Integer

パラメーター

value
String String String String

シークする文字列。The string to seek.

startIndex
Int32 Int32 Int32 Int32

検索が開始される位置。The search starting position.

戻り値

その文字列が見つかった場合は、現在のインスタンスの先頭からの、value の 0 から始まるインデックス位置。見つからなかった場合は、-1。The zero-based index position of value from the start of the current instance if that string is found, or -1 if it is not. valueEmpty の場合、戻り値は startIndex です。If value is Empty, the return value is startIndex.

例外

startIndex が、0 未満か、またはこの文字列の長さを超えています。startIndex is less than 0 (zero) or greater than the length of this string.

次の例は、対象の文字列内で指定された文字列のすべての出現箇所を検索します。The following example searches for all occurrences of a specified string within a target string.

using namespace System;
int main()
{
   String^ strSource = "This is the string which we will perform the search on";
   Console::WriteLine( "The search string is: {0}\"{1}\" {0}", Environment::NewLine, strSource );
   String^ strTarget = "";
   int found = 0;
   int totFinds = 0;
   do
   {
      Console::Write( "Please enter a search value to look for in the above string (hit Enter to exit) ==> " );
      strTarget = Console::ReadLine();
      if (  !strTarget->Equals( "" ) )
      {
         for ( int i = 0; i < strSource->Length; i++ )
         {
            found = strSource->IndexOf( strTarget, i );
            if (found >= 0)
            {
               totFinds++;
               i = found;
            }
            else
               break;

         }
      }
      else
            return 0;
      Console::WriteLine( "{0}The search parameter '{1}' was found {2} times. {0}", Environment::NewLine, strTarget, totFinds );
      totFinds = 0;
   }
   while ( true );
}

using System;

public class IndexOfTest {
    public static void Main() {

        string strSource = "This is the string which we will perform the search on";

        Console.WriteLine("The search string is:{0}\"{1}\"{0}", Environment.NewLine, strSource);

        string strTarget = "";
        int found = 0;
        int totFinds = 0;

        do {
            Console.Write("Please enter a search value to look for in the above string (hit Enter to exit) ==> ");

            strTarget = Console.ReadLine();

            if (strTarget != "") {

                for (int i = 0; i < strSource.Length; i++) {

                    found = strSource.IndexOf(strTarget, i);

                    if (found >= 0) {
                        totFinds++;
                        i = found;
                    }
                    else
                        break;
                }
            }
            else
                return;

            Console.WriteLine("{0}The search parameter '{1}' was found {2} times.{0}",
                    Environment.NewLine, strTarget, totFinds);

            totFinds = 0;

        } while ( true );
    }
}
Imports System

Public Class IndexOfTest
    
    Public Shared Sub Main()
        Dim strSource As String = "This is the string which we will perform the search on"
        
        Console.WriteLine("The search string is:{0}{1}{0}", Environment.NewLine, strSource)
        Dim strTarget As String = ""
        Dim found As Integer = 0
        Dim totFinds As Integer = 0
        
        Do
            Console.Write("Please enter a search value to look for in the above string (hit Enter to exit) ==> ")
            
            strTarget = Console.ReadLine()
            If strTarget <> "" Then
                Dim i As Integer
                
                
                For i = 0 To strSource.Length - 1
                    
                    found = strSource.IndexOf(strTarget, i)
                    If found >= 0 Then
                        
                        totFinds += 1
                        i = found
                    Else
                        Exit For
                    End If
                Next i
            Else
                Return
            
            End If
            Console.WriteLine("{0}The search parameter '{1}' was found {2} times.{0}", Environment.NewLine, strTarget, totFinds)
            
            totFinds = 0
        
        Loop While True
    End Sub 'Main
End Class 'IndexOfTest

注釈

インデックス番号は、0 から始まります。Index numbering starts from 0. startIndex パラメーターには、0 から文字列インスタンスの長さまでの範囲の値を指定できます。The startIndex parameter can range from 0 to the length of the string instance. 場合startIndex文字列インスタンスの長さと等しい、-1 が返されます。If startIndex equals the length of the string instance, the method returns -1.

このメソッドは、現在のカルチャを使用して単語 (大文字小文字を区別し、カルチャに依存する) 検索を実行します。This method performs a word (case-sensitive and culture-sensitive) search using the current culture. 検索を開始、startIndexのこのインスタンスの位置の文字し、最後の文字位置まで継続されます。The search begins at the startIndex character position of this instance and continues until the last character position.

文字セットには無視できる文字が含まれています。これらの文字は、言語またはカルチャに依存した比較を実行する際には考慮されません。Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. カルチャに依存した検索では、value に無視できる文字が含まれている場合、その文字を削除して検索した場合と同じ結果になります。In a culture-sensitive search, if value contains an ignorable character, the result is equivalent to searching with that character removed. 場合value1 つまたは複数の無視できる文字のみで構成されて、IndexOf(String, Int32)メソッドは常に返しますstartIndex、これは、検索の開始文字位置。If value consists only of one or more ignorable characters, the IndexOf(String, Int32) method always returns startIndex, which is the character position at which the search begins. 次の例では、 IndexOf(String, Int32) 2 つの文字列で"m"の後にソフト ハイフン (U + 00AD) の位置を検索するメソッドを使用します。In the following example, the IndexOf(String, Int32) method is used to find the position of a soft hyphen (U+00AD) followed by an "m" in two strings. 文字列の 1 つのみに必要な部分文字列が含まれます。Only one of the strings contains the required substring. 例実行している場合、.NET Framework 4.NET Framework 4後で、どちらの場合も、ソフト ハイフンが、無視できる文字であるため、メソッドのインデックスを返します、文字列内の"m"またはします。If the example is run on the .NET Framework 4.NET Framework 4 or later, in both cases, because the soft hyphen is an ignorable character, the method returns the index of "m" in the string. "m" の後にソフト ハイフンが含まれる最初の文字列の場合、メソッドはソフト ハイフンのインデックスを返すことができず、代わりに "m" のインデックスを返すことに注意してください。Note that in the case of the first string, which includes the soft hyphen followed by an "m", the method fails to return the index of the soft hyphen but instead returns the index of the "m".

using System;

public class Example
{
   public static void Main()
   {
      string searchString = "\u00ADm";
      string s1 = "ani\u00ADmal" ;
      string s2 = "animal";

      Console.WriteLine(s1.IndexOf(searchString, 2));
      Console.WriteLine(s2.IndexOf(searchString, 2));
   }
}
// The example displays the following output:
//       4
//       3
Module Example
   Public Sub Main()
      Dim searchString As String = Chrw(&h00AD) + "m"
      Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
      Dim s2 As String = "animal"

      Console.WriteLine(s1.IndexOf(searchString, 2))
      Console.WriteLine(s2.IndexOf(searchString, 2))
   End Sub
End Module
' The example displays the following output:
'       4
'       3 

注意 (呼び出し元)

説明したよう文字列を使用するためのベスト プラクティス既定値を代入しを明示的に指定するパラメーターを必要とするメソッドを呼び出す代わりに文字列比較メソッドを呼び出さないようにすることをお勧めします。As explained in Best Practices for Using Strings, we recommend that you avoid calling string comparison methods that substitute default values and instead call methods that require parameters to be explicitly specified. 特定の文字位置の後に発生する部分文字列の最初のインデックスを検索するには、現在のカルチャの比較規則を使用して、呼び出して、IndexOf(String, Int32, StringComparison)の値を持つメソッド オーバー ロードCurrentCulturecomparisonTypeパラメーター。To find the first index of a substring that occurs after a particular character position by using the comparison rules of the current culture, call the IndexOf(String, Int32, StringComparison) method overload with a value of CurrentCulture for its comparisonType parameter.

こちらもご覧ください

適用対象