String.LastIndexOf 方法

定义

报告指定 Unicode 字符或字符串在此实例中的最后一个匹配项的从零开始的索引的位置。Reports the zero-based index position of the last 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.

重载

LastIndexOf(String, Int32, StringComparison)

报告指定字符串在当前 String 对象中最后一个匹配项的从零开始的索引。Reports the zero-based index of the last occurrence of a specified string within the current String object. 在指定的字符位置开始和在向后的右边该字符串的开头处理的搜索。The search starts at a specified character position and proceeds backward toward the beginning of the string. 一个参数指定要执行搜索指定字符串的比较类型。A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, Int32, Int32)

报告指定字符串在此实例中的最后一个匹配项的从零开始的索引的位置。Reports the zero-based index position of the last occurrence of a specified string within this instance. 搜索在指定字符位置的数目的字符串开始时,开始指定字符和其后面的位置。The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(Char, Int32, Int32)

报告指定的 Unicode 字符在此实例内的子字符串中的最后一个匹配项的从零开始的索引的位置。Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. 搜索在指定字符位置的数目的字符串开始时,开始指定字符和其后面的位置。The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(String, StringComparison)

报告指定字符串在当前 String 对象中最后一个匹配项的从零开始的索引。Reports the zero-based index of the last occurrence of a specified string within the current String object. 一个参数指定要用于指定字符串的搜索类型。A parameter specifies the type of search to use for the specified string.

LastIndexOf(Char)

报告指定 Unicode 字符在此实例中的最后一个匹配项的从零开始的索引的位置。Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance.

LastIndexOf(Char, Int32)

报告指定 Unicode 字符在此实例中的最后一个匹配项的从零开始的索引的位置。Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. 在指定的字符位置开始和在向后的右边该字符串的开头处理的搜索。The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(String)

报告指定字符串在此实例中的最后一个匹配项的从零开始的索引的位置。Reports the zero-based index position of the last occurrence of a specified string within this instance.

LastIndexOf(String, Int32, Int32, StringComparison)

报告指定字符串在此实例中的最后一个匹配项的从零开始的索引的位置。Reports the zero-based index position of the last occurrence of a specified string within this instance. 搜索在所指定的字符位置的数目的字符串开始时,开始指定字符和其后面的位置。The search starts at a specified character position and proceeds backward toward the beginning of the string for the specified number of character positions. 一个参数指定要执行搜索指定字符串的比较类型。A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, Int32)

报告指定字符串在此实例中的最后一个匹配项的从零开始的索引的位置。Reports the zero-based index position of the last occurrence of a specified string within this instance. 在指定的字符位置开始和在向后的右边该字符串的开头处理的搜索。The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(String, Int32, StringComparison)

报告指定字符串在当前 String 对象中最后一个匹配项的从零开始的索引。Reports the zero-based index of the last occurrence of a specified string within the current String object. 在指定的字符位置开始和在向后的右边该字符串的开头处理的搜索。The search starts at a specified character position and proceeds backward toward the beginning of the string. 一个参数指定要执行搜索指定字符串的比较类型。A parameter specifies the type of comparison to perform when searching for the specified string.

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

参数

value
String

要搜寻的字符串。The string to seek.

startIndex
Int32

搜索起始位置。The search starting position. startIndex 此实例的开头开始搜索。The search proceeds from startIndex toward the beginning of this instance.

comparisonType
StringComparison

指定搜索规则的枚举值之一。One of the enumeration values that specifies the rules for the search.

返回

如果找到该字符串,则为 value 参数的从零开始的起始索引位置;如果未找到该字符串或当前实例等于 Empty,则为 -1。The zero-based starting index position of the value parameter if that string is found, or -1 if it is not found or if the current instance equals Empty. 如果 valueEmpty,则返回值为 startIndex 和此实例中的最后一个索引位置中的较小者。If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

异常

valuenullvalue is null.

当前实例不等于 Empty,并且 startIndex 小于零或大于当前实例的长度。The current instance does not equal Empty, and startIndex is less than zero or greater than the length of the current instance.

-or- 当前实例等于 Empty,并且 startIndex 小于-1 或大于零。The current instance equals Empty, and startIndex is less than -1 or greater than zero.

comparisonType 不是有效的 StringComparison 值。comparisonType is not a valid StringComparison value.

示例

下面的示例演示 LastIndexOf 方法的三个重载,该方法使用 StringComparison 枚举的不同值在另一个字符串内查找字符串的最后一个匹配项。The following example demonstrates three overloads of the LastIndexOf method that find the last occurrence of a string within another string using different values of the StringComparison enumeration.

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

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

class Sample 
{
    public static void Main() 
    {
    string intro = "Find the last 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 StringComparsion. Specify the start 
// index and count. 

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

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

// Search using different values of StringComparsion. 
    Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(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 last 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.LastIndexOf(String, ..., StringComparison) methods.

Imports System.Threading
Imports System.Globalization

Class Sample
    Public Shared Sub Main() 
        Dim intro As String = "Find the last 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 StringComparsion. Specify the start 
        ' index and count. 
        Console.WriteLine("Part 1: Start index and count are specified.")
        For Each sc In  scValues
            loc = cat.LastIndexOf(CapitalAWithRing, cat.Length - 1, cat.Length, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparsion. Specify the 
        ' start index. 
        Console.WriteLine(vbCrLf & "Part 2: Start index is specified.")
        For Each sc In  scValues
            loc = cat.LastIndexOf(CapitalAWithRing, cat.Length - 1, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparsion. 
        Console.WriteLine(vbCrLf & "Part 3: Neither start index nor count is specified.")
        For Each sc In  scValues
            loc = cat.LastIndexOf(CapitalAWithRing, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
    
    End Sub
End Class

'
'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 last 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. 也就是说,字符串中的第一个字符位于索引零,最后一个字符位于 Length-1。That is, the first character in the string is at index zero and the last is at Length - 1.

搜索从 startIndex 字符位置开始,并向后翻,直到找到了 value 或检查了第一个字符位置。The search begins at the startIndex character position and proceeds backward until either value is found or the first character position has been examined. 例如,如果 startIndex Length 为-1,则该方法会搜索字符串中最后一个字符的每个字符。For example, if startIndex is Length - 1, the method searches every character from the last character in the string to the beginning.

comparisonType 参数通过使用区分大小写或不区分大小写的搜索以及使用 word 或序号比较规则,指定搜索使用当前或固定区域性的 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. 在区分区域性的搜索 (即,如果 comparisonType 不是 OrdinalOrdinalIgnoreCase) 中,如果 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 只包含一个或多个可忽略字符,则 LastIndexOf(String, Int32, StringComparison) 方法始终返回 startIndex,这是搜索开始处的字符位置。If value consists only of one or more ignorable characters, the LastIndexOf(String, Int32, StringComparison) method always returns startIndex, which is the character position at which the search begins.

在下面的示例中,LastIndexOf(String, Int32, StringComparison) 方法用于查找软连字符(U + 00AD)后跟 "m" 的位置,以两个字符串中的最后一个 "m" 开头。In the following example, the LastIndexOf(String, Int32, StringComparison) method is used to find the position of a soft hyphen (U+00AD) followed by an "m", starting with the final "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 when it performs a culture-sensitive comparison. 注意对于第一个字符串,包含软连字符后跟“m”,该方法无法返回该软连字符的索引,而是返回“m”的索引。Note that in the case of the first string, which includes the soft hyphen followed by an "m", the method fails to return the index of the soft hyphen but instead returns the index of the "m". 只有当此方法执行序号比较时,它才会在第一个字符串中返回软连字符的索引。The method returns the index of the soft hyphen in the first string only when it performs an ordinal comparison.

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

LastIndexOf(String, Int32, Int32)

报告指定字符串在此实例中的最后一个匹配项的从零开始的索引的位置。Reports the zero-based index position of the last occurrence of a specified string within this instance. 搜索在指定字符位置的数目的字符串开始时,开始指定字符和其后面的位置。The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

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

参数

value
String

要搜寻的字符串。The string to seek.

startIndex
Int32

搜索起始位置。The search starting position. startIndex 此实例的开头开始搜索。The search proceeds from startIndex toward the beginning of this instance.

count
Int32

要检查的字符位置数。The number of character positions to examine.

返回

如果找到该字符串,则为 value 的从零开始的起始索引位置;如果未找到该字符串或当前实例等于 Empty,则为 -1。The zero-based starting index position of value if that string is found, or -1 if it is not found or if the current instance equals Empty. 如果 valueEmpty,则返回值为 startIndex 和此实例中的最后一个索引位置中的较小者。If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

异常

valuenullvalue is null.

count 为负数。count is negative.

-or- 当前实例不等于 Empty,并且 startIndex 为负数。The current instance does not equal Empty, and startIndex is negative.

-or- 当前实例不等于 Empty,并且 startIndex 大于此实例的长度。The current instance does not equal Empty, and startIndex is greater than the length of this instance.

-or- 当前实例不等于 Empty,并且 startIndex - count + 1 指定不在此实例内的位置。The current instance does not equal Empty, and startIndex - count+ 1 specifies a position that is not within this instance.

-or- 当前实例等于 Empty 并且 start 小于 -1 或大于零。The current instance equals Empty and start is less than -1 or greater than zero.

-or- 当前实例等于 Empty 并且 count 大于 1。The current instance equals Empty and count is greater than 1.

示例

下面的示例查找子字符串中字符串的所有匹配项的索引(从子字符串的末尾到子字符串的开头)。The following example finds the index of all occurrences of a string in substring, working from the end of the substring to the start of the substring.

// Sample for String::LastIndexOf(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 count;
   int end;
   start = str->Length - 1;
   end = start / 2 - 1;
   Console::WriteLine( "All occurrences of 'he' from position {0} to {1}.", start, end );
   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 > -1) && (at > -1) )
   {
      count = start - end; //Count must be within the substring.
      at = str->LastIndexOf( "he", start, count );
      if ( at > -1 )
      {
         Console::Write( "{0} ", at );
         start = at - 1;
      }
   }

   Console::Write( "{0} {0} {0}", Environment::NewLine );
}

/*
This example produces the following results:
All occurrences of 'he' from position 66 to 32.
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): 56 45
*/
// Sample for String.LastIndexOf(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 count;
    int end;

    start = str.Length-1;
    end = start/2 - 1;
    Console.WriteLine("All occurrences of 'he' from position {0} to {1}.", start, end);
    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 > -1) && (at > -1))
        {
        count = start - end; //Count must be within the substring.
        at = str.LastIndexOf("he", start, count);
        if (at > -1) 
            {
            Console.Write("{0} ", at);
            start = at - 1;
            }
        }
    Console.Write("{0}{0}{0}", Environment.NewLine);
    }
}
/*
This example produces the following results:
All occurrences of 'he' from position 66 to 32.
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): 56 45
*/
' Sample for String.LastIndexOf(String, Int32, Int32)
 _

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 count As Integer
      Dim [end] As Integer

      start = str.Length - 1
      [end] = start / 2 - 1
      Console.WriteLine("All occurrences of 'he' from position {0} to {1}.", start, [end])
      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 > - 1 And at > - 1
         count = start - [end] 'Count must be within the substring.
         at = str.LastIndexOf("he", start, count)
         If at > - 1 Then
            Console.Write("{0} ", at)
            start = at - 1
         End If
      End While
      Console.Write("{0}{0}{0}", Environment.NewLine)
   End Sub
End Class
'
'This example produces the following results:
'All occurrences of 'he' from position 66 to 32.
'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): 56 45
'
'

注解

索引编号从0开始。Index numbering starts from zero. 也就是说,字符串中的第一个字符位于索引零,最后一个字符位于 Length-1。That is, the first character in the string is at index zero and the last is at Length - 1.

搜索将从该实例的 startIndex 字符位置开始,并在 value 找到或已检查 count 个字符位置时向后继续。The search begins at the startIndex character position of this instance and proceeds backward toward the beginning until either value is found or count character positions have been examined. 例如,如果 startIndex Length 为-1,则该方法将向后搜索 count 字符串中的最后一个字符。For example, if startIndex is Length - 1, the method searches backward count characters from the last character in the string.

此方法使用当前区域性执行 word (区分大小写和区分区域性的)搜索。This method performs a word (case-sensitive and culture-sensitive) search using the current culture.

字符集包括可忽略字符,在执行语言性的或区分区域性的比较时该字符不被考虑。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 只包含一个或多个可忽略字符,则 LastIndexOf 方法始终返回 startIndex,这是搜索开始处的字符位置。If value consists only of one or more ignorable characters, the LastIndexOf method always returns startIndex, which is the character position at which the search begins. 在下面的示例中,使用 LastIndexOf 方法来查找两个字符串中 "m" 前面的两个字符中的软连字符(U + 00AD)的位置。In the following example, the LastIndexOf method is used to find the position of a soft hyphen (U+00AD) in the two characters that precede the final "m" of 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()
   {
      int position = 0;
      string s1 = "ani\u00ADmal";
      string s2 = "animal";
      
      // Find the index of the soft hyphen.
      position = s1.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)
         Console.WriteLine(s1.LastIndexOf("\u00AD", position, position + 1));

      position = s2.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)   
         Console.WriteLine(s2.LastIndexOf("\u00AD", position, position + 1));
      
      // Find the index of the soft hyphen followed by "n".
      position = s1.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)
         Console.WriteLine(s1.LastIndexOf("\u00ADn", position, position + 1));

      position = s2.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)   
         Console.WriteLine(s2.LastIndexOf("\u00ADn", position, position + 1));
      
      // Find the index of the soft hyphen followed by "m".
      position = s1.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)
         Console.WriteLine(s1.LastIndexOf("\u00ADm", position, position + 1));

      position = s2.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)   
         Console.WriteLine(s2.LastIndexOf("\u00ADm", position, position + 1));
   }
}
// The example displays the following output:
//       'm' at position 4
//       4
//       'm' at position 3
//       3
//       'm' at position 4
//       1
//       'm' at position 3
//       1
//       'm' at position 4
//       4
//       'm' at position 3
//       3
Module Example
   Public Sub Main()
      Dim position As Integer
      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.
      position = s1.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s1.LastIndexOf(softHyphen, position, position + 1))
      End If
         
      position = s2.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s2.LastIndexOf(softHyphen, position, position + 1))
      End If
      
      ' Find the index of the soft hyphen followed by "n".
      position = s1.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s1.LastIndexOf(softHyphen + "n", position, position + 1))
      End If
         
      position = s2.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s2.LastIndexOf(softHyphen + "n", position, position + 1))
      End If
      
      ' Find the index of the soft hyphen followed by "m".
      position = s1.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s1.LastIndexOf(softHyphen + "m", position, position + 1))
      End If
      
      position = s2.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s2.LastIndexOf(softHyphen + "m", position, position + 1))
      End If
   End Sub
End Module
' The example displays the following output:
'       'm' at position 4
'       4
'       'm' at position 3
'       3
'       'm' at position 4
'       1
'       'm' at position 3
'       1
'       'm' at position 4
'       4
'       'm' at position 3
'       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. 若要通过使用当前区域性的比较规则来执行此操作,请使用其 comparisonType 参数的值 CurrentCulture 调用 LastIndexOf(String, Int32, Int32, StringComparison) 方法重载。To perform this operation by using the comparison rules of the current culture, call the LastIndexOf(String, Int32, Int32, StringComparison) method overload with a value of CurrentCulture for its comparisonType parameter.

另请参阅

LastIndexOf(Char, Int32, Int32)

报告指定的 Unicode 字符在此实例内的子字符串中的最后一个匹配项的从零开始的索引的位置。Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. 搜索在指定字符位置的数目的字符串开始时,开始指定字符和其后面的位置。The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

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

参数

value
Char

要查找的 Unicode 字符。The Unicode character to seek.

startIndex
Int32

搜索的起始位置。The starting position of the search. startIndex 此实例的开头开始搜索。The search proceeds from startIndex toward the beginning of this instance.

count
Int32

要检查的字符位置数。The number of character positions to examine.

返回

如果找到该字符,则为 value 的从零开始的索引位置;如果未找到该字符或当前实例等于 Empty,则为 -1。The zero-based index position of value if that character is found, or -1 if it is not found or if the current instance equals Empty.

异常

当前实例不等于 Empty,并且 startIndex 小于零或大于等于当前实例的长度。The current instance does not equal Empty, and startIndex is less than zero or greater than or equal to the length of this instance.

-or- 当前实例不等于 Empty,并且 startIndex - count + 1 小于零。The current instance does not equal Empty, and startIndex - count + 1 is less than zero.

示例

下面的示例查找子字符串中某个字符的所有匹配项的索引,该索引从子字符串的末尾到子字符串的开头。The following example finds the index of all occurrences of a character in a substring, working from the end of the substring to the start of the substring.

// Sample for String::LastIndexOf(Char, 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 count;
   int end;
   start = str->Length - 1;
   end = start / 2 - 1;
   Console::WriteLine( "All occurrences of 't' from position {0} to {1}.", start, end );
   Console::WriteLine( "\n{0}\n{1}\n{2}", br1, br2, str );
   Console::Write( "The letter 't' occurs at position(s): " );
   count = 0;
   at = 0;
   while ( (start > -1) && (at > -1) )
   {
      count = start - end; //Count must be within the substring.
      at = str->LastIndexOf( 't', start, count );
      if ( at > -1 )
      {
         Console::Write( " {0} ", at );
         start = at - 1;
      }
   }
}

/*
This example produces the following results:
All occurrences of 't' from position 66 to 32.
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): 64 55 44 41 33


*/
// Sample for String.LastIndexOf(Char, 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 count;
    int end;

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

    count = 0;
    at = 0;
    while((start > -1) && (at > -1))
        {
        count = start - end; //Count must be within the substring.
        at = str.LastIndexOf('t', start, count);
        if (at > -1) 
            {
            Console.Write("{0} ", at);
            start = at - 1;
            }
        }
    Console.Write("{0}{0}{0}", Environment.NewLine);
    }
}
/*
This example produces the following results:
All occurrences of 't' from position 66 to 32.
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): 64 55 44 41 33


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

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 count As Integer
      Dim [end] As Integer

      start = str.Length - 1
      [end] = start / 2 - 1
      Console.WriteLine("All occurrences of 't' from position {0} to {1}.", start, [end])
      Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str)
      Console.Write("The letter 't' occurs at position(s): ")
      
      count = 0
      at = 0
      While start > - 1 And at > - 1
         count = start - [end] 'Count must be within the substring.
         at = str.LastIndexOf("t"c, start, count)
         If at > - 1 Then
            Console.Write("{0} ", at)
            start = at - 1
         End If
      End While
      Console.Write("{0}{0}{0}", Environment.NewLine)
   End Sub
End Class
'
'This example produces the following results:
'All occurrences of 't' from position 66 to 32.
'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): 64 55 44 41 33
'
'

注解

索引编号从0开始。Index numbering starts from zero. 也就是说,字符串中的第一个字符位于索引零,最后一个字符位于 Length-1。That is, the first character in the string is at index zero and the last is at Length - 1.

此方法从 startIndex 字符位置开始搜索,并沿此实例的开头向后前进,直到找到 value 或已检查 count 字符位置。This method begins searching at the startIndex character position and proceeds backward toward the beginning of this instance until either value is found or count character positions have been examined. 例如,如果 startIndex Length 为-1,则该方法将向后搜索 count 字符串中的最后一个字符。For example, if startIndex is Length - 1, the method searches backward count characters from the last character in the string. 搜索区分大小写。The search is case-sensitive.

此方法执行序号(不区分区域性)搜索,其中字符仅在其 Unicode 标量值相同时才被视为等效于另一个字符。This method performs an ordinal (culture-insensitive) search, where a character is considered equivalent to another character only if their Unicode scalar value are the same. 若要执行区分区域性的搜索,请使用 CompareInfo.LastIndexOf 方法,其中表示预构成字符的 Unicode 标量值(如连字 "Æ" (U + 00C6))可能被视为与正确序列,如 "AE" (U + 0041,U + 0045),具体取决于区域性。To perform a culture-sensitive search, use the CompareInfo.LastIndexOf 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.

另请参阅

LastIndexOf(String, StringComparison)

报告指定字符串在当前 String 对象中最后一个匹配项的从零开始的索引。Reports the zero-based index of the last occurrence of a specified string within the current String object. 一个参数指定要用于指定字符串的搜索类型。A parameter specifies the type of search to use for the specified string.

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

参数

value
String

要搜寻的字符串。The string to seek.

comparisonType
StringComparison

指定搜索规则的枚举值之一。One of the enumeration values that specifies the rules for the search.

返回

如果找到该字符串,则为 value 参数的从零开始的起始索引位置;如果未找到该字符串,则为 -1。The zero-based starting index position of the value parameter if that string is found, or -1 if it is not. 如果 valueEmpty,则返回值为此实例中的最后一个索引位置。If value is Empty, the return value is the last index position in this instance.

异常

valuenullvalue is null.

comparisonType 不是有效的 StringComparison 值。comparisonType is not a valid StringComparison value.

示例

下面的示例演示 LastIndexOf 方法的三个重载,该方法使用 StringComparison 枚举的不同值在另一个字符串内查找字符串的最后一个匹配项。The following example demonstrates three overloads of the LastIndexOf method that find the last occurrence of a string within another string using different values of the StringComparison enumeration.

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

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

class Sample 
{
    public static void Main() 
    {
    string intro = "Find the last 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 StringComparsion. Specify the start 
// index and count. 

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

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

// Search using different values of StringComparsion. 
    Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(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 last 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.LastIndexOf(String, ..., StringComparison) methods.

Imports System.Threading
Imports System.Globalization

Class Sample
    Public Shared Sub Main() 
        Dim intro As String = "Find the last 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 StringComparsion. Specify the start 
        ' index and count. 
        Console.WriteLine("Part 1: Start index and count are specified.")
        For Each sc In  scValues
            loc = cat.LastIndexOf(CapitalAWithRing, cat.Length - 1, cat.Length, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparsion. Specify the 
        ' start index. 
        Console.WriteLine(vbCrLf & "Part 2: Start index is specified.")
        For Each sc In  scValues
            loc = cat.LastIndexOf(CapitalAWithRing, cat.Length - 1, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparsion. 
        Console.WriteLine(vbCrLf & "Part 3: Neither start index nor count is specified.")
        For Each sc In  scValues
            loc = cat.LastIndexOf(CapitalAWithRing, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
    
    End Sub
End Class

'
'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 last 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. 也就是说,字符串中的第一个字符位于索引零,最后一个字符位于 Length-1。That is, the first character in the string is at index zero and the last is at Length - 1.

comparisonType 参数通过使用区分大小写或不区分大小写的搜索以及使用 word 或序号比较规则,指定搜索使用当前或固定区域性的 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.

此搜索从该实例的最后一个字符位置开始,并在找到 value 找到或检查了第一个字符位置之前继续向后定位。The search begins at the last character position of this instance and proceeds backward toward the beginning until either value is found or the first character position has been examined.

调用方说明

字符集包括可忽略字符,在执行语言性的或区分区域性的比较时该字符不被考虑。Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. 在区分区域性的搜索 (即,如果 options 不是 OrdinalOrdinalIgnoreCase) 中,如果 value 包含一个可忽略字符,则结果与移除了该字符的搜索等效。In a culture-sensitive search (that is, if options is not Ordinal or OrdinalIgnoreCase), if value contains an ignorable character, the result is equivalent to searching with that character removed. 如果 value 只包含一个或多个可忽略字符,则 LastIndexOf(String, StringComparison) 方法始终返回 Length-1,表示当前实例中的最后一个索引位置。If value consists only of one or more ignorable characters, the LastIndexOf(String, StringComparison) method always returns Length - 1, which represents the last index position in the current instance.

在下面的示例中,LastIndexOf(String, StringComparison) 方法用于查找两个字符串中的三个子字符串(软连字符(U + 00AD)、软连字符后跟 "n" 和软连字符后跟 "m"。In the following example, the LastIndexOf(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.

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

LastIndexOf(Char)

报告指定 Unicode 字符在此实例中的最后一个匹配项的从零开始的索引的位置。Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance.

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

参数

value
Char

要查找的 Unicode 字符。The Unicode character to seek.

返回

如果找到该字符,则为 value 的从零开始的索引位置;如果未找到,则为 -1。The zero-based index position of value if that character is found, or -1 if it is not.

示例

下面的示例定义了一个 ExtractFilename 方法,该方法使用 LastIndexOf(Char) 方法查找字符串中的最后一个目录分隔符字符并提取字符串的文件名。The following example defines an ExtractFilename method that uses the LastIndexOf(Char) method to find the last directory separator character in a string and to extract the string's file name. 如果文件存在,则方法将返回文件名,而不返回其路径。If the file exists, the method returns the file name without its path.

using System;
using System.IO;

public class TestLastIndexOf
{
   public static void Main()
   {
      string filename;
      
      filename = ExtractFilename(@"C:\temp\");
      Console.WriteLine("{0}", String.IsNullOrEmpty(filename) ? "<none>" : filename);
      
      filename = ExtractFilename(@"C:\temp\delegate.txt"); 
      Console.WriteLine("{0}", String.IsNullOrEmpty(filename) ? "<none>" : filename);

      filename = ExtractFilename("delegate.txt");      
      Console.WriteLine("{0}", String.IsNullOrEmpty(filename) ? "<none>" : filename);
      
      filename = ExtractFilename(@"C:\temp\notafile.txt");
      Console.WriteLine("{0}", String.IsNullOrEmpty(filename) ? "<none>" : filename);
   }

   public static string ExtractFilename(string filepath)
   {
      // If path ends with a "\", it's a path only so return String.Empty.
      if (filepath.Trim().EndsWith(@"\"))
         return String.Empty;
      
      // Determine where last backslash is.
      int position = filepath.LastIndexOf('\\');
      // If there is no backslash, assume that this is a filename.
      if (position == -1)
      {
         // Determine whether file exists in the current directory.
         if (File.Exists(Environment.CurrentDirectory + Path.DirectorySeparatorChar + filepath)) 
            return filepath;
         else
            return String.Empty;
      }
      else
      {
         // Determine whether file exists using filepath.
         if (File.Exists(filepath))
            // Return filename without file path.
            return filepath.Substring(position + 1);
         else
            return String.Empty;
      }
   }
}
Imports System.IO

Public Module Test
   Public Sub Main()
      Dim filename As String 
      
      filename = ExtractFilename("C:\temp\")
      Console.WriteLine("{0}", IIf(String.IsNullOrEmpty(fileName), "<none>", filename))
      
      filename = ExtractFilename("C:\temp\delegate.txt") 
      Console.WriteLine("{0}", IIf(String.IsNullOrEmpty(fileName), "<none>", filename))

      filename = ExtractFilename("delegate.txt")      
      Console.WriteLine("{0}", IIf(String.IsNullOrEmpty(fileName), "<none>", filename))
      
      filename = ExtractFilename("C:\temp\notafile.txt")
      Console.WriteLine("{0}", IIf(String.IsNullOrEmpty(fileName), "<none>", filename))
   End Sub
   
   Public Function ExtractFilename(filepath As String) As String
      ' If path ends with a "\", it's a path only so return String.Empty.
      If filepath.Trim().EndsWith("\") Then Return String.Empty
      
      ' Determine where last backslash is.
      Dim position As Integer = filepath.LastIndexOf("\"c)
      ' If there is no backslash, assume that this is a filename.
      If position = -1 Then
         ' Determine whether file exists in the current directory.
         If File.Exists(Environment.CurrentDirectory + Path.DirectorySeparatorChar + filepath) Then
            Return filepath
         Else
            Return String.Empty
         End If
      Else
         ' Determine whether file exists using filepath.
         If File.Exists(filepath) Then
            ' Return filename without file path.
            Return filepath.Substring(position + 1)
         Else
            Return String.Empty
         End If                     
      End If
   End Function
End Module 
' The example displays the following output:
'        delegate.txt

注解

索引编号从0开始。Index numbering starts from zero. 也就是说,字符串中的第一个字符位于索引零,最后一个字符位于 Length-1。That is, the first character in the string is at index zero and the last is at Length - 1.

此方法从该实例的最后一个字符位置开始搜索,然后在找到 value 找到或检查了第一个字符位置之后,再向后移动。This method begins searching at the last character position of this instance and proceeds backward toward the beginning until either value is found or the first character position has been examined. 搜索区分大小写。The search is case-sensitive.

此方法执行序号(不区分区域性)搜索,其中,仅当字符的 Unicode 标量值相同时,才将其视为等效于另一个字符。This method performs an ordinal (culture-insensitive) search, where a character is considered equivalent to another character only if their Unicode scalar values are the same. 若要执行区分区域性的搜索,请使用 CompareInfo.LastIndexOf 方法,其中表示预构成字符的 Unicode 标量值(如连字 "Æ" (U + 00C6))可能被视为与正确序列,如 "AE" (U + 0041,U + 0045),具体取决于区域性。To perform a culture-sensitive search, use the CompareInfo.LastIndexOf 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.

另请参阅

LastIndexOf(Char, Int32)

报告指定 Unicode 字符在此实例中的最后一个匹配项的从零开始的索引的位置。Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. 在指定的字符位置开始和在向后的右边该字符串的开头处理的搜索。The search starts at a specified character position and proceeds backward toward the beginning of the string.

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

参数

value
Char

要查找的 Unicode 字符。The Unicode character to seek.

startIndex
Int32

搜索的起始位置。The starting position of the search. startIndex 此实例的开头开始搜索。The search proceeds from startIndex toward the beginning of this instance.

返回

如果找到该字符,则为 value 的从零开始的索引位置;如果未找到该字符或当前实例等于 Empty,则为 -1。The zero-based index position of value if that character is found, or -1 if it is not found or if the current instance equals Empty.

异常

当前实例不等于 Empty,并且 startIndex 小于零或大于等于当前实例的长度。The current instance does not equal Empty, and startIndex is less than zero or greater than or equal to the length of this instance.

示例

下面的示例查找字符串中出现的所有字符的索引,该索引从字符串的末尾到字符串的开头。The following example finds the index of all occurrences of a character in a string, working from the end of the string to the start of the string.

// Sample for String::LastIndexOf(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;
   start = str->Length - 1;
   Console::WriteLine( "All occurrences of 't' from position {0} to 0.", start );
   Console::WriteLine( "{0}\n{1}\n{2}\n", br1, br2, str );
   Console::Write( "The letter 't' occurs at position(s): " );
   at = 0;
   while ( (start > -1) && (at > -1) )
   {
      at = str->LastIndexOf( 't', start );
      if ( at > -1 )
      {
         Console::Write( " {0} ", at );
         start = at - 1;
      }
   }
}

/*
This example produces the following results:
All occurrences of 't' from position 66 to 0.
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): 64 55 44 41 33 11 7
*/
// Sample for String.LastIndexOf(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;

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

    at = 0;
    while((start > -1) && (at > -1))
        {
        at = str.LastIndexOf('t', start);
        if (at > -1) 
            {
            Console.Write("{0} ", at);
            start = at - 1;
            }
        }
    Console.Write("{0}{0}{0}", Environment.NewLine);
    }
}
/*
This example produces the following results:
All occurrences of 't' from position 66 to 0.
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): 64 55 44 41 33 11 7
*/
' Sample for String.LastIndexOf(Char, 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
      
      start = str.Length - 1
      Console.WriteLine("All occurrences of 't' from position {0} to 0.", start)
      Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str)
      Console.Write("The letter 't' occurs at position(s): ")
      
      at = 0
      While start > - 1 And at > - 1
         at = str.LastIndexOf("t"c, start)
         If at > - 1 Then
            Console.Write("{0} ", at)
            start = at - 1
         End If
      End While
      Console.Write("{0}{0}{0}", Environment.NewLine)
   End Sub
End Class
'
'This example produces the following results:
'All occurrences of 't' from position 66 to 0.
'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): 64 55 44 41 33 11 7
'

注解

索引编号从0开始。Index numbering starts from zero. 也就是说,字符串中的第一个字符位于索引零,最后一个字符位于 Length-1。此方法从该实例的 startIndex 字符位置开始搜索,并沿当前实例的开头向后前进,直到找到了 value 或已检查了第一个字符位置。That is, the first character in the string is at index zero and the last is at Length - 1.This method begins searching at the startIndex character position of this instance and proceeds backward toward the beginning of the current instance until either value is found or the first character position has been examined. 例如,如果 startIndex Length 为-1,则该方法会搜索字符串中最后一个字符的每个字符。For example, if startIndex is Length - 1, the method searches every character from the last character in the string to the beginning. 搜索区分大小写。The search is case-sensitive.

此方法执行序号(不区分区域性)搜索,其中,仅当字符的 Unicode 标量值相同时,才将其视为等效于另一个字符。This method performs an ordinal (culture-insensitive) search, where a character is considered equivalent to another character only if their Unicode scalar values are the same. 若要执行区分区域性的搜索,请使用 CompareInfo.LastIndexOf 方法,其中表示预构成字符的 Unicode 标量值(如连字 "Æ" (U + 00C6))可能被视为与正确序列,如 "AE" (U + 0041,U + 0045),具体取决于区域性。To perform a culture-sensitive search, use the CompareInfo.LastIndexOf 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.

另请参阅

LastIndexOf(String)

报告指定字符串在此实例中的最后一个匹配项的从零开始的索引的位置。Reports the zero-based index position of the last occurrence of a specified string within this instance.

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

参数

value
String

要搜寻的字符串。The string to seek.

返回

如果找到该字符串,则为 value 的从零开始的起始索引位置;如果未找到该字符串,则为 -1。The zero-based starting index position of value if that string is found, or -1 if it is not. 如果 valueEmpty,则返回值为此实例中的最后一个索引位置。If value is Empty, the return value is the last index position in this instance.

异常

valuenullvalue is null.

示例

下面的示例在标记开始和结束字符串时,删除字符串中的开始和关闭 HTML 标记。The following example removes opening and closing HTML tags from a string if the tags begin and end the string. 如果字符串以右括号字符(">")结尾,则该示例使用 LastIndexOf 方法查找结束标记的开头。If a string ends with a closing bracket character (">"), the example uses the LastIndexOf method to locate the start of the end tag.

using System;

public class Example 
{
   public static void Main() 
   {
      string[] strSource = { "<b>This is bold text</b>", "<H1>This is large Text</H1>",
               "<b><i><font color=green>This has multiple tags</font></i></b>",
               "<b>This has <i>embedded</i> tags.</b>",
               "This line ends with a greater than symbol and should not be modified>" };

      // Strip HTML start and end tags from each string if they are present.
      foreach (string s in strSource)
      {
         Console.WriteLine("Before: " + s);
         string item = s;
         // Use EndsWith to find a tag at the end of the line.
         if (item.Trim().EndsWith(">")) 
         {
            // Locate the opening tag.
            int endTagStartPosition = item.LastIndexOf("</");
            // Remove the identified section, if it is valid.
            if (endTagStartPosition >= 0 )
               item = item.Substring(0, endTagStartPosition);

            // Use StartsWith to find the opening tag.
            if (item.Trim().StartsWith("<"))
            {
               // Locate the end of opening tab.
               int openTagEndPosition = item.IndexOf(">");
               // Remove the identified section, if it is valid.
               if (openTagEndPosition >= 0)
                  item = item.Substring(openTagEndPosition + 1);
            }      
         }
         // Display the trimmed string.
         Console.WriteLine("After: " + item);
         Console.WriteLine();
      }                   
   }
}
// The example displays the following output:
//    Before: <b>This is bold text</b>
//    After: This is bold text
//    
//    Before: <H1>This is large Text</H1>
//    After: This is large Text
//    
//    Before: <b><i><font color=green>This has multiple tags</font></i></b>
//    After: <i><font color=green>This has multiple tags</font></i>
//    
//    Before: <b>This has <i>embedded</i> tags.</b>
//    After: This has <i>embedded</i> tags.
//    
//    Before: This line ends with a greater than symbol and should not be modified>
//    After: This line ends with a greater than symbol and should not be modified>
Module Example
   Public Sub Main()
      Dim strSource As String() = { "<b>This is bold text</b>", _
                    "<H1>This is large Text</H1>", _
                    "<b><i><font color=green>This has multiple tags</font></i></b>", _
                    "<b>This has <i>embedded</i> tags.</b>", _
                    "This line ends with a greater than symbol and should not be modified>" }

      ' Strip HTML start and end tags from each string if they are present.
      For Each s As String In strSource
         Console.WriteLine("Before: " + s)
         ' Use EndsWith to find a tag at the end of the line.
         If s.Trim().EndsWith(">") Then 
            ' Locate the opening tag.
            Dim endTagStartPosition As Integer = s.LastIndexOf("</")
            ' Remove the identified section if it is valid.
            If endTagStartPosition >= 0 Then
               s = s.Substring(0, endTagStartPosition)
            End If
            
            ' Use StartsWith to find the opening tag.
            If s.Trim().StartsWith("<") Then
               ' Locate the end of opening tab.
               Dim openTagEndPosition As Integer = s.IndexOf(">")
               ' Remove the identified section if it is valid.
               If openTagEndPosition >= 0 Then
                  s = s.Substring(openTagEndPosition + 1)
               End If   
            End If      
         End If
         ' Display the trimmed string.
         Console.WriteLine("After: " + s)
         Console.WriteLine()
      Next                   
   End Sub
End Module
' The example displays the following output:
'    Before: <b>This is bold text</b>
'    After: This is bold text
'    
'    Before: <H1>This is large Text</H1>
'    After: This is large Text
'    
'    Before: <b><i><font color=green>This has multiple tags</font></i></b>
'    After: <i><font color=green>This has multiple tags</font></i>
'    
'    Before: <b>This has <i>embedded</i> tags.</b>
'    After: This has <i>embedded</i> tags.
'    
'    Before: This line ends with a greater than symbol and should not be modified>
'    After: This line ends with a greater than symbol and should not be modified>

注解

索引编号从0开始。Index numbering starts from zero. 也就是说,字符串中的第一个字符位于索引零,最后一个字符位于 Length-1。That is, the first character in the string is at index zero and the last is at Length - 1.

此搜索从该实例的最后一个字符位置开始,并在找到 value 找到或检查了第一个字符位置之前继续向后定位。The search begins at the last character position of this instance and proceeds backward toward the beginning until either value is found or the first character position has been examined.

此方法使用当前区域性执行 word (区分大小写和区分区域性的)搜索。This method performs a word (case-sensitive and culture-sensitive) search using the current culture.

字符集包括可忽略字符,在执行语言性的或区分区域性的比较时该字符不被考虑。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 只包含一个或多个可忽略字符,则 LastIndexOf(String) 方法始终返回 String.Length-1,表示当前实例中的最后一个索引位置。If value consists only of one or more ignorable characters, the LastIndexOf(String) method always returns String.Length - 1, which represents the last index position in the current instance. 在下面的示例中,LastIndexOf(String) 方法用于查找两个字符串中的三个子字符串(软连字符(U + 00AD)、软连字符后跟 "n" 和软连字符后跟 "m"。In the following example, the LastIndexOf(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. 仅搜索软连字符时,该方法返回6和5。When searching for a soft hyphen only, the method returns 6 and 5. 这些值对应于两个字符串中最后一个字符的索引。These values correspond to the index of the last character in the two strings.

using System;

public class Example
{
   public static void Main()
   {
      string s1 = "ani\u00ADmal";
      string s2 = "animal";
      
      // Find the index of the last soft hyphen.
      Console.WriteLine(s1.LastIndexOf("\u00AD"));
      Console.WriteLine(s2.LastIndexOf("\u00AD"));
      
      // Find the index of the last soft hyphen followed by "n".
      Console.WriteLine(s1.LastIndexOf("\u00ADn"));
      Console.WriteLine(s2.LastIndexOf("\u00ADn"));
      
      // Find the index of the last soft hyphen followed by "m".
      Console.WriteLine(s1.LastIndexOf("\u00ADm"));
      Console.WriteLine(s2.LastIndexOf("\u00ADm"));
   }
}
// The example displays the following output:
//       6
//       5
//       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 last soft hyphen.
      Console.WriteLine(s1.LastIndexOf(softHyphen))
      Console.WriteLine(s2.LastIndexOf(softHyphen))
      
      ' Find the index of the last soft hyphen followed by "n".
      Console.WriteLine(s1.LastIndexOf(softHyphen + "n"))
      Console.WriteLine(s2.LastIndexOf(softHyphen + "n"))
      
      ' Find the index of the last soft hyphen followed by "m".
      Console.WriteLine(s1.LastIndexOf(softHyphen + "m"))
      Console.WriteLine(s2.LastIndexOf(softHyphen + "m"))
   End Sub
End Module
' The example displays the following output:
'       6
'       5
'       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. 若要使用当前区域性的比较规则查找字符串实例内子字符串的最后一个索引,请使用其 comparisonType 参数的值 CurrentCulture 调用 LastIndexOf(String, StringComparison) 方法重载。To find the last index of a substring within a string instance by using the comparison rules of the current culture, call the LastIndexOf(String, StringComparison) method overload with a value of CurrentCulture for its comparisonType parameter.

另请参阅

LastIndexOf(String, Int32, Int32, StringComparison)

报告指定字符串在此实例中的最后一个匹配项的从零开始的索引的位置。Reports the zero-based index position of the last occurrence of a specified string within this instance. 搜索在所指定的字符位置的数目的字符串开始时,开始指定字符和其后面的位置。The search starts at a specified character position and proceeds backward toward the beginning of the string for the specified number of character positions. 一个参数指定要执行搜索指定字符串的比较类型。A parameter specifies the type of comparison to perform when searching for the specified string.

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

参数

value
String

要搜寻的字符串。The string to seek.

startIndex
Int32

搜索起始位置。The search starting position. startIndex 此实例的开头开始搜索。The search proceeds from startIndex toward the beginning of this instance.

count
Int32

要检查的字符位置数。The number of character positions to examine.

comparisonType
StringComparison

指定搜索规则的枚举值之一。One of the enumeration values that specifies the rules for the search.

返回

如果找到该字符串,则为 value 参数的从零开始的起始索引位置;如果未找到该字符串或当前实例等于 Empty,则为 -1。The zero-based starting index position of the value parameter if that string is found, or -1 if it is not found or if the current instance equals Empty. 如果 valueEmpty,则返回值为 startIndex 和此实例中的最后一个索引位置中的较小者。If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

异常

valuenullvalue is null.

count 为负数。count is negative.

-or- 当前实例不等于 Empty,并且 startIndex 为负数。The current instance does not equal Empty, and startIndex is negative.

-or- 当前实例不等于 Empty,并且 startIndex 大于此实例的长度。The current instance does not equal Empty, and startIndex is greater than the length of this instance.

-or- 当前实例不等于 Empty,并且 startIndex + 1 - count 指定不在此实例内的位置。The current instance does not equal Empty, and startIndex + 1 - count specifies a position that is not within this instance.

-or- 当前实例等于 Empty 并且 start 小于 -1 或大于零。The current instance equals Empty and start is less than -1 or greater than zero.

-or- 当前实例等于 Empty 并且 count 大于 1。The current instance equals Empty and count is greater than 1.

comparisonType 不是有效的 StringComparison 值。comparisonType is not a valid StringComparison value.

示例

下面的示例演示 LastIndexOf 方法的三个重载,该方法使用 StringComparison 枚举的不同值在另一个字符串内查找字符串的最后一个匹配项。The following example demonstrates three overloads of the LastIndexOf method that find the last occurrence of a string within another string using different values of the StringComparison enumeration.

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

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

class Sample 
{
    public static void Main() 
    {
    string intro = "Find the last 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 StringComparsion. Specify the start 
// index and count. 

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

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

// Search using different values of StringComparsion. 
    Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(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 last 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.LastIndexOf(String, ..., StringComparison) methods.

Imports System.Threading
Imports System.Globalization

Class Sample
    Public Shared Sub Main() 
        Dim intro As String = "Find the last 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 StringComparsion. Specify the start 
        ' index and count. 
        Console.WriteLine("Part 1: Start index and count are specified.")
        For Each sc In  scValues
            loc = cat.LastIndexOf(CapitalAWithRing, cat.Length - 1, cat.Length, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparsion. Specify the 
        ' start index. 
        Console.WriteLine(vbCrLf & "Part 2: Start index is specified.")
        For Each sc In  scValues
            loc = cat.LastIndexOf(CapitalAWithRing, cat.Length - 1, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparsion. 
        Console.WriteLine(vbCrLf & "Part 3: Neither start index nor count is specified.")
        For Each sc In  scValues
            loc = cat.LastIndexOf(CapitalAWithRing, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
    
    End Sub
End Class

'
'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 last 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. 也就是说,字符串中的第一个字符位于索引零,最后一个字符位于 Length-1。That is, the first character in the string is at index zero and the last is at Length - 1.

搜索从 startIndex 字符位置开始,直到找到 valuecount 字符位置已被检查时向后移动。The search begins at the startIndex character position and proceeds backward until either value is found or count character positions have been examined. 例如,如果 startIndex Length 为-1,则该方法将向后搜索 count 字符串中的最后一个字符。For example, if startIndex is Length - 1, the method searches backward count characters from the last character in the string.

comparisonType 参数通过使用区分大小写或不区分大小写的搜索以及使用 word 或序号比较规则,指定搜索使用当前或固定区域性的 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. 在区分区域性的搜索 (即,如果 comparisonType 不是 OrdinalOrdinalIgnoreCase) 中,如果 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 只包含一个或多个可忽略字符,则 LastIndexOf(String, Int32, Int32, StringComparison) 方法始终返回 startIndex,这是搜索开始处的字符位置。If value consists only of one or more ignorable characters, the LastIndexOf(String, Int32, Int32, StringComparison) method always returns startIndex, which is the character position at which the search begins.

在下面的示例中,LastIndexOf(String, Int32, Int32, StringComparison) 方法用于查找软连字符(U + 00AD)后跟 "m" 的位置,而不是在两个字符串中的最后一个字符位置之前的第一个字符位置。In the following example, the LastIndexOf(String, Int32, Int32, StringComparison) method is used to find the position of a soft hyphen (U+00AD) followed by an "m" in all but the first character position before the final "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 when it performs a culture-sensitive comparison. 但当它执行序号比较时,它只查找第一个字符串中的子字符串。When it performs an ordinal comparison, however, it finds the substring only in the first string. 请注意,对于包含软连字符后跟 "m" 的软连字符的第一个字符串,该方法将无法返回软连字符的索引,而是在执行区分区域性的比较时返回 "m" 的索引。Note that in the case of the first string, which includes the soft hyphen followed by an "m", the method fails to return the index of the soft hyphen but instead returns the index of the "m" when it performs a culture-sensitive comparison. 只有当此方法执行序号比较时,它才会在第一个字符串中返回软连字符的索引。The method returns the index of the soft hyphen in the first string only when it performs an ordinal comparison.

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

LastIndexOf(String, Int32)

报告指定字符串在此实例中的最后一个匹配项的从零开始的索引的位置。Reports the zero-based index position of the last occurrence of a specified string within this instance. 在指定的字符位置开始和在向后的右边该字符串的开头处理的搜索。The search starts at a specified character position and proceeds backward toward the beginning of the string.

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

参数

value
String

要搜寻的字符串。The string to seek.

startIndex
Int32

搜索起始位置。The search starting position. startIndex 此实例的开头开始搜索。The search proceeds from startIndex toward the beginning of this instance.

返回

如果找到该字符串,则为 value 的从零开始的起始索引位置;如果未找到该字符串或当前实例等于 Empty,则为 -1。The zero-based starting index position of value if that string is found, or -1 if it is not found or if the current instance equals Empty. 如果 valueEmpty,则返回值为 startIndex 和此实例中的最后一个索引位置中的较小者。If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

异常

valuenullvalue is null.

当前实例不等于 Empty,并且 startIndex 小于零或大于当前实例的长度。The current instance does not equal Empty, and startIndex is less than zero or greater than the length of the current instance.

-or- 当前实例等于 Empty,并且 startIndex 小于-1 或大于零。The current instance equals Empty, and startIndex is less than -1 or greater than zero.

示例

下面的示例查找目标字符串中字符串的所有匹配项的索引,从目标字符串的末尾到目标字符串的开头。The following example finds the index of all occurrences of a string in target string, working from the end of the target string to the start of the target string.

// Sample for String::LastIndexOf(String, 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;
   start = str->Length - 1;
   Console::WriteLine( "All occurrences of 'he' from position {0} to 0.", start );
   Console::WriteLine( "{0}\n{1}\n{2}\n", br1, br2, str );
   Console::Write( "The string 'he' occurs at position(s): " );
   at = 0;
   while ( (start > -1) && (at > -1) )
   {
      at = str->LastIndexOf( "he", start );
      if ( at > -1 )
      {
         Console::Write( " {0} ", at );
         start = at - 1;
      }
   }

   Console::WriteLine();
}

/*
This example produces the following results:
All occurrences of 'he' from position 66 to 0.
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):  56  45  8
*/
// Sample for String.LastIndexOf(String, 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;

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

    at = 0;
    while((start > -1) && (at > -1))
        {
        at = str.LastIndexOf("he", start);
        if (at > -1) 
            {
            Console.Write("{0} ", at);
            start = at - 1;
            }
        }
    Console.Write("{0}{0}{0}", Environment.NewLine);
    }
}
/*
This example produces the following results:
All occurrences of 'he' from position 66 to 0.
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): 56 45 8


*/
' Sample for String.LastIndexOf(String, Int32)
 _

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

      '#3
      start = str.Length - 1
      Console.WriteLine("All occurrences of 'he' from position {0} to 0.", start)
      Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str)
      Console.Write("The string 'he' occurs at position(s): ")
      
      at = 0
      While start > - 1 And at > - 1
         at = str.LastIndexOf("he", start)
         If at > - 1 Then
            Console.Write("{0} ", at)
            start = at - 1
         End If
      End While
      Console.Write("{0}{0}{0}", Environment.NewLine)
   End Sub
End Class
'
'This example produces the following results:
'All occurrences of 'he' from position 66 to 0.
'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): 56 45 8
'
'

注解

索引编号从0开始。Index numbering starts from zero. 也就是说,字符串中的第一个字符位于索引零,最后一个字符位于 Length-1。That is, the first character in the string is at index zero and the last is at Length - 1.

搜索将从该实例的 startIndex 字符位置开始,并在 value 找到或检查了第一个字符位置之前向后继续。The search begins at the startIndex character position of this instance and proceeds backward toward the beginning until either value is found or the first character position has been examined. 例如,如果 startIndex Length 为-1,则该方法会搜索字符串中最后一个字符的每个字符。For example, if startIndex is Length - 1, the method searches every character from the last character in the string to the beginning.

此方法使用当前区域性执行 word (区分大小写和区分区域性的)搜索。This method performs a word (case-sensitive and culture-sensitive) search using the current culture.

字符集包括可忽略字符,在执行语言性的或区分区域性的比较时该字符不被考虑。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 只包含一个或多个可忽略字符,则 LastIndexOf(String, Int32) 方法始终返回 startIndex,这是搜索开始处的字符位置。If value consists only of one or more ignorable characters, the LastIndexOf(String, Int32) method always returns startIndex, which is the character position at which the search begins. 在下面的示例中,LastIndexOf(String, Int32) 方法用于查找包含软连字符(U + 00AD)并且在字符串中之前或包含最终 "m" 的子字符串。In the following example, the LastIndexOf(String, Int32) method is used to find a substring that includes a soft hyphen (U+00AD) and that precedes or includes the final "m" in a string. 如果该示例在 .NET Framework 4.NET Framework 4 或更高版本上运行,则将忽略搜索字符串中的软连字符,调用方法以查找由软连字符和 "m" 组成的子字符串,并返回字符串中 "m" 的位置。,而调用它查找包含软连字符的子字符串,"n" 返回 "n" 的位置。If the example is run on the .NET Framework 4.NET Framework 4 or later, because the soft hyphen in the search string is ignored, calling the method to find a substring that consists of the soft hyphen and "m" returns the position of the "m" in the string, whereas calling it to find a substring that consists of the soft hyphen and "n" returns the position of the "n". 如果搜索字符串只包含软连字符,则方法返回 "m" 的索引,它表示 startIndex的值。When the search string contains only the soft hyphen, the method returns the index of the "m", which represents the value of startIndex.

using System;

public class Example
{
   public static void Main()
   {
      int position = 0;
      string s1 = "ani\u00ADmal";
      string s2 = "animal";
      
      // Find the index of the soft hyphen.
      position = s1.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)
         Console.WriteLine(s1.LastIndexOf("\u00AD", position));

      position = s2.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)   
         Console.WriteLine(s2.LastIndexOf("\u00AD", position));
      
      // Find the index of the soft hyphen followed by "n".
      position = s1.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)
         Console.WriteLine(s1.LastIndexOf("\u00ADn", position));

      position = s2.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)   
         Console.WriteLine(s2.LastIndexOf("\u00ADn", position));
      
      // Find the index of the soft hyphen followed by "m".
      position = s1.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)
         Console.WriteLine(s1.LastIndexOf("\u00ADm", position));

      position = s2.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)   
         Console.WriteLine(s2.LastIndexOf("\u00ADm", position));
   }
}
// The example displays the following output:
//       'm' at position 4
//       4
//       'm' at position 3
//       3
//       'm' at position 4
//       1
//       'm' at position 3
//       1
//       'm' at position 4
//       4
//       'm' at position 3
//       3
Module Example
   Public Sub Main()
      Dim position As Integer
      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.
      position = s1.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s1.LastIndexOf(softHyphen, position))
      End If
         
      position = s2.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s2.LastIndexOf(softHyphen, position))
      End If
      
      ' Find the index of the soft hyphen followed by "n".
      position = s1.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s1.LastIndexOf(softHyphen + "n", position))
      End If
         
      position = s2.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s2.LastIndexOf(softHyphen + "n", position))
      End If
      
      ' Find the index of the soft hyphen followed by "m".
      position = s1.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s1.LastIndexOf(softHyphen + "m", position))
      End If
      
      position = s2.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s2.LastIndexOf(softHyphen + "m", position))
      End If
   End Sub
End Module
' The example displays the following output:
'       'm' at position 4
'       4
'       'm' at position 3
'       3
'       'm' at position 4
'       1
'       'm' at position 3
'       1
'       'm' at position 4
'       4
'       'm' at position 3
'       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. 若要通过使用当前区域性的比较规则查找特定字符位置之前的子字符串的索引,请使用其 comparisonType 参数的值 CurrentCulture 调用 LastIndexOf(String, Int32, StringComparison) 方法重载。To find the index of a substring that precedes a particular character position by using the comparison rules of the current culture, call the LastIndexOf(String, Int32, StringComparison) method overload with a value of CurrentCulture for its comparisonType parameter.

另请参阅

适用于