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

정의

이 인스턴스에서 맨 처음 발견되는 지정된 유니코드 문자 또는 문자열의 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(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, 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(Char) IndexOf(Char) IndexOf(Char) IndexOf(Char)

이 문자열에서 맨 처음 발견되는 지정된 유니코드 문자의 0부터 시작하는 인덱스를 보고합니다. Reports the zero-based index of the first occurrence of the specified Unicode character in this string.

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

이 문자열에서 맨 처음 발견되는 지정된 유니코드 문자의 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(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

검색 규칙을 지정하는 열거형 값 중 하나입니다. 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.

예제

다음 exampledemonstrates 세 오버 로드는 IndexOf 의 다른 값을 사용 하 여 다른 문자열 내에 있는 문자열의 처음 발견 하는 메서드를 StringComparison 열거형입니다.The following exampledemonstrates 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 현재 또는 고정 문화권을 사용 하 고 대/소문자 구분 또는 대/소문자 구분 검색을 사용 하 여 단어 또는 서 수 비교 규칙을 사용 하 여 매개 변수입니다.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. 하는 경우 value 하나 이상의 무시할 수 있는 문자로 구성 되어 합니다 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" 뒤에 하이픈이 (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. 문자열 중 하나에만 필수 부분 문자열이 포함되어 있습니다. 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. [! 코드 csharpSystem.String.IndexOf#24] [! 코드 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

검색 규칙을 지정하는 열거형 값 중 하나입니다. 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.

예제

다음 exampledemonstrates 세 오버 로드는 IndexOf 의 다른 값을 사용 하 여 다른 문자열 내에 있는 문자열의 처음 발견 하는 메서드를 StringComparison 열거형입니다.The following exampledemonstrates 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 현재 또는 고정 문화권을 사용 하 고 대/소문자 구분 또는 대/소문자 구분 검색을 사용 하 여 단어 또는 서 수 비교 규칙을 사용 하 여 매개 변수입니다.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. 하는 경우 value 하나 이상의 무시할 수 있는 문자로 구성 되어 합니다 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"가 포함 된 두 문자열의 세 번째 문자 위치부터 뒤에 하이픈이 (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. 문자열 중 하나에만 필수 부분 문자열이 포함 되어 있습니다. 예제를 실행 하는 경우는 .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. [! 코드 csharpSystem.String.IndexOf#25] [! 코드 vbSystem.String.IndexOf#25] [!code-csharpSystem.String.IndexOf#25] [!code-vbSystem.String.IndexOf#25]

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. 하는 경우 value 하나 이상의 무시할 수 있는 문자로 구성 되어 합니다 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" 뒤에 하이픈이 (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. 문자열 중 하나에만 필수 부분 문자열이 포함되어 있습니다.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) 값을 사용 하 여 메서드 오버 로드 CurrentCulture 에 대 한 해당 comparisonType 매개 변수입니다. 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, 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

검색할 유니코드 문자입니다. 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.

이 메서드는 유니코드 스칼라 값이 같은 서 수 (문화권) 검색을 수행 합니다.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 6), 유니코드 스칼라 값 간주 될 수 있습니다 문자 구성 요소에서의 모든 항목에는 "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

검색 규칙을 지정하는 열거형 값 중 하나입니다. 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.

예제

다음 exampledemonstrates 세 오버 로드는 IndexOf 의 다른 값을 사용 하 여 다른 문자열 내에 있는 문자열의 처음 발견 하는 메서드를 StringComparison 열거형입니다.The following exampledemonstrates 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 현재 또는 고정 문화권을 사용 하 고 대/소문자 구분 또는 대/소문자 구분 검색을 사용 하 여 단어 또는 서 수 비교 규칙을 사용 하 여 매개 변수입니다.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. 하는 경우 value 하나 이상의 무시할 수 있는 문자로 구성 되어 합니다 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) 메서드는 두 문자열의 세 가지 부분 문자열 (하이픈이 (U + 00AD), "n" 뒤에 하이픈이 및 하이픈이 뒤에 "m")을 찾는 데 사용 됩니다. 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. 문자열 중 하나에만 사용자 지정 하이픈이 포함되어 있습니다. 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. 그러나 서 수 검색을 성공적으로 사용자 지정 하이픈 한 문자열에서 찾아 보고 없는 것에서 두 번째 문자열입니다. An ordinal search, however, successfully finds the soft hyphen in one string and reports that it is absent from the second string. [! 코드 csharpSystem.String.IndexOf#26] [! 코드 vbSystem.String.IndexOf#26] [!code-csharpSystem.String.IndexOf#26] [!code-vbSystem.String.IndexOf#26]

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

이 문자열에서 맨 처음 발견되는 지정된 유니코드 문자의 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

검색할 유니코드 문자입니다. 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.

이 메서드는 유니코드 스칼라 값이 같은 서 수 (문화권) 검색을 수행 합니다.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 6), 유니코드 스칼라 값 간주 될 수 있습니다 문자 구성 요소에서의 모든 항목에는 "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(Char, StringComparison) IndexOf(Char, StringComparison) IndexOf(Char, StringComparison) IndexOf(Char, StringComparison)

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

반환

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

이 문자열에서 맨 처음 발견되는 지정된 유니코드 문자의 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

검색할 유니코드 문자입니다. 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.

이 메서드는 유니코드 스칼라 값이 같은 서 수 (문화권) 검색을 수행 합니다.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 6), 유니코드 스칼라 값 간주 될 수 있습니다 문자 구성 요소에서의 모든 항목에는 "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.

예외

예제

다음 예제에서는 "animal"에서 "n"를 검색합니다.The following example searches for the "n" in "animal". 문자열 인덱스를 보다는 0부터 시작 하므로 IndexOf(String) 메서드 "n" 위치 1 임을 나타냅니다.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. 하는 경우 value 하나 이상의 무시할 수 있는 문자로 구성 되어 합니다 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) 메서드는 두 문자열의 세 가지 부분 문자열 (하이픈이 (U + 00AD), "n" 뒤에 하이픈이 및 하이픈이 뒤에 "m")을 찾는 데 사용 됩니다.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. 문자열 중 하나에만 사용자 지정 하이픈이 포함되어 있습니다.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) 값을 사용 하 여 메서드 오버 로드 CurrentCulture 에 대 한 해당 comparisonType 매개 변수입니다. 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(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. 하는 경우 value 하나 이상의 무시할 수 있는 문자로 구성 되어 합니다 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) 메서드는 두 문자열의 "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. 문자열 중 하나에만 필수 부분 문자열이 포함되어 있습니다.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) 값을 사용 하 여 메서드 오버 로드 CurrentCulture 에 대 한 해당 comparisonType 매개 변수입니다. 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.

추가 정보

적용 대상