String.LastIndexOf String.LastIndexOf String.LastIndexOf String.LastIndexOf Method

Definition

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines angegebenen Unicode-Zeichens oder einer angegebenen Unicode-Zeichenfolge in dieser Instanz an.Reports the zero-based index position of the last occurrence of a specified Unicode character or string within this instance. Die Methode gibt -1 zurück, wenn das Zeichen oder die Zeichenfolge in dieser Instanz nicht gefunden wird.The method returns -1 if the character or string is not found in this instance.

Überlädt

LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison)

Gibt den NULL-basierten Index des letzten Vorkommens einer angegebenen Zeichenfolge im aktuellen String-Objekt an.Reports the zero-based index of the last occurrence of a specified string within the current String object. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt.The search starts at a specified character position and proceeds backward toward the beginning of the string. Ein Parameter gibt den Typ des bei der Suche nach der angegebenen Zeichenfolge auszuführenden Vergleichs an.A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an.Reports the zero-based index position of the last occurrence of a specified string within this instance. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge.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) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens des angegebenen Unicode-Zeichens in einer Teilzeichenfolge dieser Instanz an.Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge.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) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison)

Gibt den NULL-basierten Index des letzten Vorkommens einer angegebenen Zeichenfolge im aktuellen String-Objekt an.Reports the zero-based index of the last occurrence of a specified string within the current String object. Ein Parameter gibt den Typ der Suche für die angegebene Zeichenfolge an.A parameter specifies the type of search to use for the specified string.

LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char)

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines angegebenen Unicode-Zeichens in dieser Instanz an.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance.

LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines angegebenen Unicode-Zeichens in dieser Instanz an.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(String) LastIndexOf(String) LastIndexOf(String) LastIndexOf(String)

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an.Reports the zero-based index position of the last occurrence of a specified string within this instance.

LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison)

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an.Reports the zero-based index position of the last occurrence of a specified string within this instance. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge.The search starts at a specified character position and proceeds backward toward the beginning of the string for the specified number of character positions. Ein Parameter gibt den Typ des bei der Suche nach der angegebenen Zeichenfolge auszuführenden Vergleichs an.A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an.Reports the zero-based index position of the last occurrence of a specified string within this instance. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison)

Gibt den NULL-basierten Index des letzten Vorkommens einer angegebenen Zeichenfolge im aktuellen String-Objekt an.Reports the zero-based index of the last occurrence of a specified string within the current String object. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt.The search starts at a specified character position and proceeds backward toward the beginning of the string. Ein Parameter gibt den Typ des bei der Suche nach der angegebenen Zeichenfolge auszuführenden Vergleichs an.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

Parameter

value
String String String String

Die zu suchende Zeichenfolge.The string to seek.

startIndex
Int32 Int32 Int32 Int32

Die Anfangsposition der Suche.The search starting position. Die Suche wird von startIndex bis zum Anfang dieser Instanz fortgesetzt.The search proceeds from startIndex toward the beginning of this instance.

comparisonType
StringComparison StringComparison StringComparison StringComparison

Einer der Enumerationswerte, der die Regeln für die Suche angibt.One of the enumeration values that specifies the rules for the search.

Gibt zurück

Die nullbasierte Anfangsindexposition des value-Parameters, wenn diese Zeichenfolge gefunden wurde, oder -1, wenn sie nicht gefunden wurde oder die aktuelle Instanz gleich Empty ist.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. Wenn value Empty ist, ist der Rückgabewert der kleinere startIndex und die letzte Indexposition in dieser Instanz.If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

Ausnahmen

Die aktuelle Instanz entspricht nicht Empty, und startIndex ist kleiner als 0 (null) oder größer als die Länge der aktuellen Instanz.The current instance does not equal Empty, and startIndex is less than zero or greater than the length of the current instance.

- oder --or- Die aktuelle Instanz entspricht Empty, und startIndex ist kleiner als -1 oder größer als 0 (null).The current instance equals Empty, and startIndex is less than -1 or greater than zero.

comparisonType ist kein gültiger StringComparison-Wert.comparisonType is not a valid StringComparison value.

Beispiele

Das folgende Beispiel zeigt drei Überladungen, die von der LastIndexOf -Methode, die das letzte Vorkommen einer Zeichenfolge innerhalb einer anderen Zeichenfolge, die mit unterschiedlichen Werten der suchen die StringComparison Enumeration.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
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 'Main
End Class 'Sample

'
'Note: This code example was executed on a console whose user interface 
'culture is "en-US" (English-United States).
'
'This code example produces the following results:
'
'Find the 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
'

Hinweise

Der Index die Nummerierung beginnt bei 0 (null).Index numbering starts from zero. D. h. das erste Zeichen in der Zeichenfolge ist, am Index 0 (null) und das letzte liegt bei Length - 1.That is, the first character in the string is at index zero and the last is at Length - 1.

Die Suche beginnt an der startIndex Zeichen, Position und wird fortgesetzt, bis entweder rückwärts value gefunden wird oder die Position des erste Zeichens überprüft wurde.The search begins at the startIndex character position and proceeds backward until either value is found or the first character position has been examined. Z. B. wenn startIndex ist Length - 1, sucht die Methode alle Zeichen aus dem letzten Zeichen in der Zeichenfolge an den Anfang.For example, if startIndex is Length - 1, the method searches every character from the last character in the string to the beginning.

Die comparisonType Parameter gibt an, dass für die Suche die value Parameter unter Verwendung der aktuellen oder der invarianten Kultur, mithilfe einer Suche Groß- und Kleinschreibung beachtet und mithilfe von Word oder Ordinalvergleichsregeln.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.

Hinweise für Aufrufer

Zeichensätze enthalten ignorierbare Zeichen, d. h. Zeichen, die bei der Durchführung eines linguistischen oder kulturabhängigen Vergleichs nicht berücksichtigt werden.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. Bei einer kulturabhängige Suche (das heißt, wenn comparisonType nicht Ordinal oder OrdinalIgnoreCase ist), bei der value ein ignorierbares Zeichen enthält, ist das Ergebnis das gleiche wie bei einer Suche ohne dieses Zeichen.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. Wenn value besteht nur aus ein oder mehrere Ignorierbare Zeichen, die LastIndexOf(String, Int32, StringComparison) Methode gibt immer startIndex, d.h. die Zeichenposition, an dem die Suche beginnt.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.

Im folgenden Beispiel die LastIndexOf(String, Int32, StringComparison) Methode wird verwendet, um die Position (U + 00AD) über einen bedingten Bindestrich gefolgt von einem "m", beginnend mit dem letzten "m" in zwei Zeichenfolgen zu suchen.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. Nur eine der Zeichenfolgen enthält die erforderliche Teilzeichenfolge.Only one of the strings contains the required substring. Wenn Sie das Beispiel ausgeführt wird, auf die .NET Framework 4.NET Framework 4 oder höher in beiden Fällen, da die bedingten Bindestrich ein ignorierbares Zeichen ist die Methode gibt den Index des "m" in der Zeichenfolge, wenn sie einen kulturabhängigen Vergleich ausführt.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. Beachten Sie, dass bei der ersten Zeichenfolge, die den bedingten Bindestrich gefolgt von einem "m" umfasst, die Methode den Index des bedingten Bindestrichs nicht zurückgeben kann, sondern stattdessen den Index des "m" zurückgibt.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". Die Methode gibt den Index des bedingten Bindestrichs in der ersten Zeichenfolge nur dann zurück, wenn sie einen Ordinalvergleich ausführt.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) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an.Reports the zero-based index position of the last occurrence of a specified string within this instance. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge.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

Parameter

value
String String String String

Die zu suchende Zeichenfolge.The string to seek.

startIndex
Int32 Int32 Int32 Int32

Die Anfangsposition der Suche.The search starting position. Die Suche wird von startIndex bis zum Anfang dieser Instanz fortgesetzt.The search proceeds from startIndex toward the beginning of this instance.

count
Int32 Int32 Int32 Int32

Die Anzahl der zu überprüfenden Zeichenpositionen.The number of character positions to examine.

Gibt zurück

Die nullbasierte Anfangsindexposition von value, wenn diese Zeichenfolge gefunden wurde, oder -1, wenn sie nicht gefunden wurde oder die aktuelle Instanz gleich Empty ist.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. Wenn value Empty ist, ist der Rückgabewert der kleinere startIndex und die letzte Indexposition in dieser Instanz.If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

Ausnahmen

count ist ein negativer Wert.count is negative.

- oder --or- Die aktuelle Instanz entspricht nicht Empty, und startIndex ist ein negativer Wert.The current instance does not equal Empty, and startIndex is negative.

- oder --or- Die aktuelle Instanz entspricht nicht Empty, und startIndex ist größer als die Länge dieser Instanz.The current instance does not equal Empty, and startIndex is greater than the length of this instance.

- oder --or- Die aktuelle Instanz entspricht nicht Empty, und startIndex - count+ 1 gibt eine Position an, die nicht innerhalb dieser Instanz liegt.The current instance does not equal Empty, and startIndex - count+ 1 specifies a position that is not within this instance.

- oder --or- Die aktuelle Instanz entspricht Empty, und start ist kleiner als -1 oder größer als 0 (null).The current instance equals Empty and start is less than -1 or greater than zero.

- oder --or- Die aktuelle Instanz entspricht Empty, und count ist größer als 1.The current instance equals Empty and count is greater than 1.

Beispiele

Das folgende Beispiel sucht den Index der alle Vorkommen einer Zeichenfolge in Teilzeichenfolgen, arbeiten an den Anfang der Teilzeichenfolge am Ende der Teilzeichenfolge.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)
Imports System
 _

Class Sample
   
   Public Shared Sub Main()
      
      Dim br1 As String = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-"
      Dim br2 As String = "0123456789012345678901234567890123456789012345678901234567890123456"
      Dim str As String = "Now is the time for all good men to come to the aid of their party."
      Dim start As Integer
      Dim at As Integer
      Dim 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 'Main 
End Class 'Sample
'
'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
'
'

Hinweise

Der Index die Nummerierung beginnt bei 0 (null).Index numbering starts from zero. D. h. das erste Zeichen in der Zeichenfolge ist, am Index 0 (null) und das letzte liegt bei Length - 1.That is, the first character in the string is at index zero and the last is at Length - 1.

Die Suche beginnt an der startIndex Zeichen Position dieser Instanz und wird fortgesetzt, bis entweder rückwärts value gefunden wird oder count Zeichenpositionen überprüft wurden.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. Z. B. wenn startIndex ist Length - 1, sucht die Methode nach hinten count Zeichen aus dem letzten Zeichen in der Zeichenfolge.For example, if startIndex is Length - 1, the method searches backward count characters from the last character in the string.

Diese Methode führt eine Wortsuche (Groß-/Kleinschreibung beachtet und kulturabhängige) mit der aktuellen Kultur.This method performs a word (case-sensitive and culture-sensitive) search using the current culture.

Zeichensätze enthalten ignorierbare Zeichen, d. h. Zeichen, die bei der Durchführung eines linguistischen oder kulturabhängigen Vergleichs nicht berücksichtigt werden.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. Bei einer kulturabhängige Suche, bei der value ein ignorierbares Zeichen enthält, ist das Ergebnis das gleiche wie bei einer Suche ohne dieses Zeichen.In a culture-sensitive search, if value contains an ignorable character, the result is equivalent to searching with that character removed. Wenn value besteht nur aus ein oder mehrere Ignorierbare Zeichen, die LastIndexOf Methode gibt immer startIndex, d.h. die Zeichenposition, an dem die Suche beginnt.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. Im folgenden Beispiel die LastIndexOf Methode wird verwendet, um die Position der einen bedingten Bindestrich (U + 00AD) in den beiden Zeichen zu finden, die vor der letzten "m" von zwei Zeichenfolgen.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. Nur eine der Zeichenfolgen enthält die erforderliche Teilzeichenfolge.Only one of the strings contains the required substring. Wenn Sie das Beispiel ausgeführt wird, auf die .NET Framework 4.NET Framework 4 oder höher in beiden Fällen, da die bedingten Bindestrich ein ignorierbares Zeichen ist die Methode gibt den Index des "m" in der Zeichenfolge, wenn sie einen kulturabhängigen Vergleich ausführt.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. Beachten Sie, dass bei der ersten Zeichenfolge, die den bedingten Bindestrich gefolgt von einem "m" umfasst, die Methode den Index des bedingten Bindestrichs nicht zurückgeben kann, sondern stattdessen den Index des "m" zurückgibt.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

Hinweise für Aufrufer

Siehe bewährte Methoden für die Verwendung von Zeichenfolgen, es wird empfohlen, dass Sie vermeiden, Aufrufen von Methoden zum Zeichenfolgenvergleich, die Standardwerte ersetzen, und rufen stattdessen die Methoden, die für Parameter explizit angegeben werden müssen.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. Aufrufen, um diesen Vorgang auszuführen, mit die Vergleichsregeln der aktuellen Kultur, die LastIndexOf(String, Int32, Int32, StringComparison) methodenüberladung mit einem Wert von CurrentCulture für seine comparisonType Parameter.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.

Siehe auch

LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens des angegebenen Unicode-Zeichens in einer Teilzeichenfolge dieser Instanz an.Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge.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

Parameter

value
Char Char Char Char

Das zu suchende Unicode-Zeichen.The Unicode character to seek.

startIndex
Int32 Int32 Int32 Int32

Die Anfangsposition der Suche.The starting position of the search. Die Suche wird von startIndex bis zum Anfang dieser Instanz fortgesetzt.The search proceeds from startIndex toward the beginning of this instance.

count
Int32 Int32 Int32 Int32

Die Anzahl der zu überprüfenden Zeichenpositionen.The number of character positions to examine.

Gibt zurück

Die nullbasierte Indexposition von value, wenn dieses Zeichen gefunden wurde, oder -1, wenn es nicht gefunden wurde oder die aktuelle Instanz gleich Empty ist.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.

Ausnahmen

Die aktuelle Instanz entspricht nicht Empty, und startIndex ist kleiner als 0 (null) oder größer oder gleich der Länge dieser Instanz.The current instance does not equal Empty, and startIndex is less than zero or greater than or equal to the length of this instance.

- oder --or- Die aktuelle Instanz entspricht nicht Empty, und startIndex - count + 1 ist kleiner als 0 (null).The current instance does not equal Empty, and startIndex - count + 1 is less than zero.

Beispiele

Das folgende Beispiel sucht den Index der alle Vorkommen eines Zeichens in einer Teilzeichenfolge, arbeiten an den Anfang der Teilzeichenfolge am Ende der Teilzeichenfolge.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)
Imports System
 _

Class Sample
   
   Public Shared Sub Main()
      
      Dim br1 As String = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-"
      Dim br2 As String = "0123456789012345678901234567890123456789012345678901234567890123456"
      Dim str As String = "Now is the time for all good men to come to the aid of their party."
      Dim start As Integer
      Dim at As Integer
      Dim 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 'Main 
End Class 'Sample
'
'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
'
'

Hinweise

Der Index die Nummerierung beginnt bei 0 (null).Index numbering starts from zero. D. h. das erste Zeichen in der Zeichenfolge ist, am Index 0 (null) und das letzte liegt bei Length - 1.That is, the first character in the string is at index zero and the last is at Length - 1.

Diese Methode beginnt die Suche an der startIndex Zeichen, Position und wird fortgesetzt, bis zum Anfang dieser Instanz erst nach hinten value gefunden wird oder count Zeichenpositionen überprüft wurden.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. Z. B. wenn startIndex ist Length - 1, sucht die Methode nach hinten count Zeichen aus dem letzten Zeichen in der Zeichenfolge.For example, if startIndex is Length - 1, the method searches backward count characters from the last character in the string. Bei der Suche wird die Groß- und Kleinschreibung berücksichtigt.The search is case-sensitive.

Diese Methode führt eine ordinale (kulturunabhängige) Suche, in dem ein Zeichen als gleich betrachtet, ein anderes Zeichen nur dann, wenn die Unicode-Skalarwert identisch sind.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. Um eine kulturabhängige Suche durchzuführen, verwenden die CompareInfo.LastIndexOf -Methode, in dem ein Unicode-Skalarwert, ein zusammengesetztes Zeichen, z. B. die Ligatur "Æ" (U + 00 C 6) betrachtet werden kann entspricht jedem Vorkommen des Zeichens-Komponenten in der Korrigieren Sie die Sequenz, wie z. B. "AE" (U + 0041, U + 0045), je nach Kultur.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.

Siehe auch

LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison)

Gibt den NULL-basierten Index des letzten Vorkommens einer angegebenen Zeichenfolge im aktuellen String-Objekt an.Reports the zero-based index of the last occurrence of a specified string within the current String object. Ein Parameter gibt den Typ der Suche für die angegebene Zeichenfolge an.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

Parameter

value
String String String String

Die zu suchende Zeichenfolge.The string to seek.

comparisonType
StringComparison StringComparison StringComparison StringComparison

Einer der Enumerationswerte, der die Regeln für die Suche angibt.One of the enumeration values that specifies the rules for the search.

Gibt zurück

Die nullbasierte Indexposition des value-Parameters, wenn diese Zeichenfolge gefunden wurde, andernfalls -1.The zero-based starting index position of the value parameter if that string is found, or -1 if it is not. Wenn valueEmpty ist, ist der Rückgabewert die letzte Indexposition in dieser Instanz.If value is Empty, the return value is the last index position in this instance.

Ausnahmen

comparisonType ist kein gültiger StringComparison-Wert.comparisonType is not a valid StringComparison value.

Beispiele

Das folgende Beispiel zeigt drei Überladungen, die von der LastIndexOf -Methode, die das letzte Vorkommen einer Zeichenfolge innerhalb einer anderen Zeichenfolge, die mit unterschiedlichen Werten der suchen die StringComparison Enumeration.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
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 'Main
End Class 'Sample

'
'Note: This code example was executed on a console whose user interface 
'culture is "en-US" (English-United States).
'
'This code example produces the following results:
'
'Find the 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
'

Hinweise

Der Index die Nummerierung beginnt bei 0 (null).Index numbering starts from zero. D. h. das erste Zeichen in der Zeichenfolge ist, am Index 0 (null) und das letzte liegt bei Length - 1.That is, the first character in the string is at index zero and the last is at Length - 1.

Die comparisonType Parameter gibt an, dass für die Suche die value Parameter unter Verwendung der aktuellen oder der invarianten Kultur, mithilfe einer Suche Groß- und Kleinschreibung beachtet und mithilfe von Word oder Ordinalvergleichsregeln.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.

Die Suche beginnt an der Position des letzten Zeichens dieser Instanz und wird rückwärts bis entweder fortgesetzt, value gefunden wird oder die Position des erste Zeichens überprüft wurde.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.

Hinweise für Aufrufer

Zeichensätze enthalten ignorierbare Zeichen, d. h. Zeichen, die bei der Durchführung eines linguistischen oder kulturabhängigen Vergleichs nicht berücksichtigt werden.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. Bei einer kulturabhängige Suche (das heißt, wenn options nicht Ordinal oder OrdinalIgnoreCase ist), bei der value ein ignorierbares Zeichen enthält, ist das Ergebnis das gleiche wie bei einer Suche ohne dieses Zeichen.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. Wenn value besteht nur aus ein oder mehrere Ignorierbare Zeichen, die LastIndexOf(String, StringComparison) Methode gibt immer Length -1, der die letzte Indexposition in der aktuellen Instanz darstellt.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.

Im folgenden Beispiel die LastIndexOf(String, StringComparison) Methode wird verwendet, um drei Teilzeichenfolgen (einen bedingten Bindestrich (U + 00AD), einen bedingten Bindestrich gefolgt von "n" und einen bedingten Bindestrich gefolgt von "m") in zwei Zeichenfolgen zu suchen.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. Nur eine der Zeichenfolgen enthält einen bedingten Bindestrich.Only one of the strings contains a soft hyphen. Wenn Sie das Beispiel ausgeführt wird, auf die .NET Framework 4.NET Framework 4 oder höher, da der bedingten Bindestrich ein ignorierbares Zeichen ist, eine kulturabhängige Suche derselbe Wert zurückgegeben, die es zurückgegeben würde, wenn es sich bei bedingten Bindestrichs nicht in der Suchzeichenfolge enthalten waren.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. Allerdings eine Ordinalsuche erfolgreich bedingten Bindestrichs in einer Zeichenfolge sucht und gibt an, dass sie nicht vorhanden ist aus der zweiten Zeichenfolge.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) LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char)

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines angegebenen Unicode-Zeichens in dieser Instanz an.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

Parameter

value
Char Char Char Char

Das zu suchende Unicode-Zeichen.The Unicode character to seek.

Gibt zurück

Die nullbasierte Indexposition von value, wenn dieses Zeichen gefunden wurde, andernfalls -1.The zero-based index position of value if that character is found, or -1 if it is not.

Beispiele

Das folgende Beispiel definiert eine ExtractFilename Methode, verwendet der LastIndexOf(Char) Methode, um das letzte Verzeichnistrennzeichen in einer Zeichenfolge gesucht und Dateinamen der Zeichenfolge zu extrahieren.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. Wenn die Datei vorhanden ist, gibt die Methode den Dateinamen ohne Pfad zurück.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

Hinweise

Der Index die Nummerierung beginnt bei 0 (null).Index numbering starts from zero. D. h. das erste Zeichen in der Zeichenfolge ist, am Index 0 (null) und das letzte liegt bei Length - 1.That is, the first character in the string is at index zero and the last is at Length - 1.

Diese Methode beginnt die Suche an der Position des letzten Zeichens dieser Instanz und wird rückwärts bis entweder fortgesetzt, value gefunden wird oder die Position des erste Zeichens überprüft wurde.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. Bei der Suche wird die Groß- und Kleinschreibung berücksichtigt.The search is case-sensitive.

Diese Methode führt eine ordinale (kulturunabhängige) Suche, in dem ein Zeichen als gleich betrachtet, ein anderes Zeichen nur dann, wenn die Unicode-Skalarwerten identisch sind.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. Um eine kulturabhängige Suche durchzuführen, verwenden die CompareInfo.LastIndexOf -Methode, in dem ein Unicode-Skalarwert, ein zusammengesetztes Zeichen, z. B. die Ligatur "Æ" (U + 00 C 6) betrachtet werden kann entspricht jedem Vorkommen des Zeichens-Komponenten in der Korrigieren Sie die Sequenz, wie z. B. "AE" (U + 0041, U + 0045), je nach Kultur.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.

Siehe auch

LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines angegebenen Unicode-Zeichens in dieser Instanz an.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt.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

Parameter

value
Char Char Char Char

Das zu suchende Unicode-Zeichen.The Unicode character to seek.

startIndex
Int32 Int32 Int32 Int32

Die Anfangsposition der Suche.The starting position of the search. Die Suche wird von startIndex bis zum Anfang dieser Instanz fortgesetzt.The search proceeds from startIndex toward the beginning of this instance.

Gibt zurück

Die nullbasierte Indexposition von value, wenn dieses Zeichen gefunden wurde, oder -1, wenn es nicht gefunden wurde oder die aktuelle Instanz gleich Empty ist.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.

Ausnahmen

Die aktuelle Instanz entspricht nicht Empty, und startIndex ist kleiner als 0 (null) oder größer oder gleich der Länge dieser Instanz.The current instance does not equal Empty, and startIndex is less than zero or greater than or equal to the length of this instance.

Beispiele

Das folgende Beispiel sucht den Index der alle Vorkommen eines Zeichens in einer Zeichenfolge am Ende der Zeichenfolge an den Anfang der Zeichenfolge verwenden.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 'Main
End Class 'Sample
'
'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
'

Hinweise

Der Index die Nummerierung beginnt bei 0 (null).Index numbering starts from zero. D. h. das erste Zeichen in der Zeichenfolge ist, am Index 0 (null) und das letzte liegt bei Length -1. diese Methode beginnt die Suche an der startIndex Zeichen Position dieser Instanz und wird rückwärts bis zum Anfang der aktuellen Instanz erst fortgesetzt value gefunden wird oder die Position des erste Zeichens überprüft wurde.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. Z. B. wenn startIndex ist Length - 1, sucht die Methode alle Zeichen aus dem letzten Zeichen in der Zeichenfolge an den Anfang.For example, if startIndex is Length - 1, the method searches every character from the last character in the string to the beginning. Bei der Suche wird die Groß- und Kleinschreibung berücksichtigt.The search is case-sensitive.

Diese Methode führt eine ordinale (kulturunabhängige) Suche, in dem ein Zeichen als gleich betrachtet, ein anderes Zeichen nur dann, wenn die Unicode-Skalarwerten identisch sind.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. Um eine kulturabhängige Suche durchzuführen, verwenden die CompareInfo.LastIndexOf -Methode, in dem ein Unicode-Skalarwert, ein zusammengesetztes Zeichen, z. B. die Ligatur "Æ" (U + 00 C 6) betrachtet werden kann entspricht jedem Vorkommen des Zeichens-Komponenten in der Korrigieren Sie die Sequenz, wie z. B. "AE" (U + 0041, U + 0045), je nach Kultur.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.

Siehe auch

LastIndexOf(String) LastIndexOf(String) LastIndexOf(String) LastIndexOf(String)

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an.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

Parameter

value
String String String String

Die zu suchende Zeichenfolge.The string to seek.

Gibt zurück

Die nullbasierte Indexposition von value, wenn diese Zeichenfolge gefunden wurde, andernfalls -1.The zero-based starting index position of value if that string is found, or -1 if it is not. Wenn valueEmpty ist, ist der Rückgabewert die letzte Indexposition in dieser Instanz.If value is Empty, the return value is the last index position in this instance.

Ausnahmen

Beispiele

Im folgenden Beispiel wird die Start- und Endtags HTML-Zeichenfolge, wenn die Tags beginnen und am Ende der Zeichenfolge.The following example removes opening and closing HTML tags from a string if the tags begin and end the string. Wenn eine Zeichenfolge mit einer schließenden beendet Klammer Zeichen (">"), im Beispiel wird die LastIndexOf Methode, um den Start des Endtags zu suchen.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>

Hinweise

Der Index die Nummerierung beginnt bei 0 (null).Index numbering starts from zero. D. h. das erste Zeichen in der Zeichenfolge ist, am Index 0 (null) und das letzte liegt bei Length - 1.That is, the first character in the string is at index zero and the last is at Length - 1.

Die Suche beginnt an der Position des letzten Zeichens dieser Instanz und wird rückwärts bis entweder fortgesetzt, value gefunden wird oder die Position des erste Zeichens überprüft wurde.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.

Diese Methode führt eine Wortsuche (Groß-/Kleinschreibung beachtet und kulturabhängige) mit der aktuellen Kultur.This method performs a word (case-sensitive and culture-sensitive) search using the current culture.

Zeichensätze enthalten ignorierbare Zeichen, d. h. Zeichen, die bei der Durchführung eines linguistischen oder kulturabhängigen Vergleichs nicht berücksichtigt werden.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. Bei einer kulturabhängige Suche, bei der value ein ignorierbares Zeichen enthält, ist das Ergebnis das gleiche wie bei einer Suche ohne dieses Zeichen.In a culture-sensitive search, if value contains an ignorable character, the result is equivalent to searching with that character removed. Wenn value besteht nur aus ein oder mehrere Ignorierbare Zeichen, die LastIndexOf(String) Methode gibt immer String.Length -1, der die letzte Indexposition in der aktuellen Instanz darstellt.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. Im folgenden Beispiel die LastIndexOf(String) Methode wird verwendet, um drei Teilzeichenfolgen (einen bedingten Bindestrich (U + 00AD), einen bedingten Bindestrich gefolgt von "n" und einen bedingten Bindestrich gefolgt von "m") in zwei Zeichenfolgen zu suchen.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. Nur eine der Zeichenfolgen enthält einen bedingten Bindestrich.Only one of the strings contains a soft hyphen. Wenn Sie das Beispiel ausgeführt wird, auf die .NET Framework 4.NET Framework 4 oder höher in jedem Fall, da die bedingten Bindestrich ein ignorierbares Zeichen ist das Ergebnis ist identisch, als ob bedingten Bindestrichs nicht in einbezogen wurden, mussten 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. Bei der Suche nach nur einen bedingten Bindestrich erfolgt die Methodenrückgabe, 6 und 5.When searching for a soft hyphen only, the method returns 6 and 5. Diese Werte entsprechen dem Index des letzten Zeichens in den beiden Zeichenfolgen.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

Hinweise für Aufrufer

Siehe bewährte Methoden für die Verwendung von Zeichenfolgen, es wird empfohlen, dass Sie vermeiden, Aufrufen von Methoden zum Zeichenfolgenvergleich, die Standardwerte ersetzen, und rufen stattdessen die Methoden, die für Parameter explizit angegeben werden müssen.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. Um den letzten Index einer Unterzeichenfolge einer Zeichenfolgeninstanz mit die Vergleichsregeln der aktuellen Kultur zu suchen, rufen die LastIndexOf(String, StringComparison) methodenüberladung mit einem Wert von CurrentCulture für seine comparisonType Parameter.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.

Siehe auch

LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison)

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an.Reports the zero-based index position of the last occurrence of a specified string within this instance. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge.The search starts at a specified character position and proceeds backward toward the beginning of the string for the specified number of character positions. Ein Parameter gibt den Typ des bei der Suche nach der angegebenen Zeichenfolge auszuführenden Vergleichs an.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

Parameter

value
String String String String

Die zu suchende Zeichenfolge.The string to seek.

startIndex
Int32 Int32 Int32 Int32

Die Anfangsposition der Suche.The search starting position. Die Suche wird von startIndex bis zum Anfang dieser Instanz fortgesetzt.The search proceeds from startIndex toward the beginning of this instance.

count
Int32 Int32 Int32 Int32

Die Anzahl der zu überprüfenden Zeichenpositionen.The number of character positions to examine.

comparisonType
StringComparison StringComparison StringComparison StringComparison

Einer der Enumerationswerte, der die Regeln für die Suche angibt.One of the enumeration values that specifies the rules for the search.

Gibt zurück

Die nullbasierte Anfangsindexposition des value-Parameters, wenn diese Zeichenfolge gefunden wurde, oder -1, wenn sie nicht gefunden wurde oder die aktuelle Instanz gleich Empty ist.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. Wenn value Empty ist, ist der Rückgabewert der kleinere startIndex und die letzte Indexposition in dieser Instanz.If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

Ausnahmen

count ist ein negativer Wert.count is negative.

- oder --or- Die aktuelle Instanz entspricht nicht Empty, und startIndex ist ein negativer Wert.The current instance does not equal Empty, and startIndex is negative.

- oder --or- Die aktuelle Instanz entspricht nicht Empty, und startIndex ist größer als die Länge dieser Instanz.The current instance does not equal Empty, and startIndex is greater than the length of this instance.

- oder --or- Die aktuelle Instanz entspricht nicht Empty, und startIndex + 1 - count gibt eine Position an, die nicht innerhalb dieser Instanz liegt.The current instance does not equal Empty, and startIndex + 1 - count specifies a position that is not within this instance.

- oder --or- Die aktuelle Instanz entspricht Empty, und start ist kleiner als -1 oder größer als 0 (null).The current instance equals Empty and start is less than -1 or greater than zero.

- oder --or- Die aktuelle Instanz entspricht Empty, und count ist größer als 1.The current instance equals Empty and count is greater than 1.

comparisonType ist kein gültiger StringComparison-Wert.comparisonType is not a valid StringComparison value.

Beispiele

Das folgende Beispiel zeigt drei Überladungen, die von der LastIndexOf -Methode, die das letzte Vorkommen einer Zeichenfolge innerhalb einer anderen Zeichenfolge, die mit unterschiedlichen Werten der suchen die StringComparison Enumeration.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
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 'Main
End Class 'Sample

'
'Note: This code example was executed on a console whose user interface 
'culture is "en-US" (English-United States).
'
'This code example produces the following results:
'
'Find the 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
'

Hinweise

Der Index die Nummerierung beginnt bei 0 (null).Index numbering starts from zero. D. h. das erste Zeichen in der Zeichenfolge ist, am Index 0 (null) und das letzte liegt bei Length - 1.That is, the first character in the string is at index zero and the last is at Length - 1.

Die Suche beginnt an der startIndex Zeichen, Position und wird fortgesetzt, bis entweder rückwärts value gefunden wird oder count Zeichenpositionen überprüft wurden.The search begins at the startIndex character position and proceeds backward until either value is found or count character positions have been examined. Z. B. wenn startIndex ist Length - 1, sucht die Methode nach hinten count Zeichen aus dem letzten Zeichen in der Zeichenfolge.For example, if startIndex is Length - 1, the method searches backward count characters from the last character in the string.

Die comparisonType Parameter gibt an, dass für die Suche die value Parameter unter Verwendung der aktuellen oder der invarianten Kultur, mithilfe einer Suche Groß- und Kleinschreibung beachtet und mithilfe von Word oder Ordinalvergleichsregeln.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.

Hinweise für Aufrufer

Zeichensätze enthalten ignorierbare Zeichen, d. h. Zeichen, die bei der Durchführung eines linguistischen oder kulturabhängigen Vergleichs nicht berücksichtigt werden.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. Bei einer kulturabhängige Suche (das heißt, wenn comparisonType nicht Ordinal oder OrdinalIgnoreCase ist), bei der value ein ignorierbares Zeichen enthält, ist das Ergebnis das gleiche wie bei einer Suche ohne dieses Zeichen.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. Wenn value besteht nur aus ein oder mehrere Ignorierbare Zeichen, die LastIndexOf(String, Int32, Int32, StringComparison) Methode gibt immer startIndex, d.h. die Zeichenposition, an dem die Suche beginnt.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.

Im folgenden Beispiel die LastIndexOf(String, Int32, Int32, StringComparison) Methode wird verwendet, um die Position (U + 00AD) über einen bedingten Bindestrich gefolgt von einem "m" in allen jedoch der ersten Zeichenposition vor dem letzten "m" in zwei Zeichenfolgen zu suchen.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. Nur eine der Zeichenfolgen enthält die erforderliche Teilzeichenfolge.Only one of the strings contains the required substring. Wenn Sie das Beispiel ausgeführt wird, auf die .NET Framework 4.NET Framework 4 oder höher in beiden Fällen, da die bedingten Bindestrich ein ignorierbares Zeichen ist die Methode gibt den Index des "m" in der Zeichenfolge, wenn sie einen kulturabhängigen Vergleich ausführt.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. Wenn sie einen Ordinalvergleich ausführt, sucht er die Teilzeichenfolge jedoch nur in der ersten Zeichenfolge fest.When it performs an ordinal comparison, however, it finds the substring only in the first string. Beachten Sie, dass bei der ersten Zeichenfolge, die den bedingten Bindestrich gefolgt von einem "m" enthält, die Methode ein Fehler auftritt, um den Index des bedingten Bindestrichs zurückzugeben, aber gibt stattdessen den Index des "m" aus, wenn er einen kulturabhängigen Vergleich ausführt.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. Die Methode gibt den Index des bedingten Bindestrichs in der ersten Zeichenfolge nur dann zurück, wenn sie einen Ordinalvergleich ausführt.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) LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an.Reports the zero-based index position of the last occurrence of a specified string within this instance. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt.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

Parameter

value
String String String String

Die zu suchende Zeichenfolge.The string to seek.

startIndex
Int32 Int32 Int32 Int32

Die Anfangsposition der Suche.The search starting position. Die Suche wird von startIndex bis zum Anfang dieser Instanz fortgesetzt.The search proceeds from startIndex toward the beginning of this instance.

Gibt zurück

Die nullbasierte Anfangsindexposition von value, wenn diese Zeichenfolge gefunden wurde, oder -1, wenn sie nicht gefunden wurde oder die aktuelle Instanz gleich Empty ist.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. Wenn value Empty ist, ist der Rückgabewert der kleinere startIndex und die letzte Indexposition in dieser Instanz.If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

Ausnahmen

Die aktuelle Instanz entspricht nicht Empty, und startIndex ist kleiner als 0 (null) oder größer als die Länge der aktuellen Instanz.The current instance does not equal Empty, and startIndex is less than zero or greater than the length of the current instance.

- oder --or- Die aktuelle Instanz entspricht Empty, und startIndex ist kleiner als -1 oder größer als 0 (null).The current instance equals Empty, and startIndex is less than -1 or greater than zero.

Beispiele

Das folgende Beispiel sucht den Index der alle Vorkommen einer Zeichenfolge in der Zielzeichenfolge, wird am Ende der Zielzeichenfolge an den Anfang der Zielzeichenfolge arbeiten.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)
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

      '#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 'Main 
End Class 'Sample
'
'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
'
'

Hinweise

Der Index die Nummerierung beginnt bei 0 (null).Index numbering starts from zero. D. h. das erste Zeichen in der Zeichenfolge ist, am Index 0 (null) und das letzte liegt bei Length - 1.That is, the first character in the string is at index zero and the last is at Length - 1.

Die Suche beginnt an der startIndex Zeichen Position dieser Instanz und wird fortgesetzt, bis entweder rückwärts value gefunden wird oder die Position des erste Zeichens überprüft wurde.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. Z. B. wenn startIndex ist Length - 1, sucht die Methode alle Zeichen aus dem letzten Zeichen in der Zeichenfolge an den Anfang.For example, if startIndex is Length - 1, the method searches every character from the last character in the string to the beginning.

Diese Methode führt eine Wortsuche (Groß-/Kleinschreibung beachtet und kulturabhängige) mit der aktuellen Kultur.This method performs a word (case-sensitive and culture-sensitive) search using the current culture.

Zeichensätze enthalten ignorierbare Zeichen, d. h. Zeichen, die bei der Durchführung eines linguistischen oder kulturabhängigen Vergleichs nicht berücksichtigt werden.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. Bei einer kulturabhängige Suche, bei der value ein ignorierbares Zeichen enthält, ist das Ergebnis das gleiche wie bei einer Suche ohne dieses Zeichen.In a culture-sensitive search, if value contains an ignorable character, the result is equivalent to searching with that character removed. Wenn value besteht nur aus ein oder mehrere Ignorierbare Zeichen, die LastIndexOf(String, Int32) Methode gibt immer startIndex, d.h. die Zeichenposition, an dem die Suche beginnt.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. Im folgenden Beispiel die LastIndexOf(String, Int32) Methode wird verwendet, finden Sie eine untergeordnete Zeichenfolge, die einen bedingten Bindestrich (U + 00AD) enthält und die vorangestellt ist, oder das letzte "m" in einer Zeichenfolge enthält.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. Wenn Sie das Beispiel ausgeführt wird, auf die .NET Framework 4.NET Framework 4 oder höher, da bedingten Bindestrichs in der Suchzeichenfolge ignoriert wird, einen Aufruf der Methode zu eine Teilzeichenfolge, die besteht aus den bedingten Bindestrich und "m" gibt die Position des "m" in der Zeichenfolge, suchen, während aufrufen, um eine Substrin suchen g, der den bedingten Bindestrich und "n" besteht, gibt die Position der "n" zurück.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". Wenn die zu suchende Zeichenfolge nur für den bedingten Bindestrich enthält, die Methode gibt den Index des "m", steht für den Wert der 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

Hinweise für Aufrufer

Siehe bewährte Methoden für die Verwendung von Zeichenfolgen, es wird empfohlen, dass Sie vermeiden, Aufrufen von Methoden zum Zeichenfolgenvergleich, die Standardwerte ersetzen, und rufen stattdessen die Methoden, die für Parameter explizit angegeben werden müssen.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. Um den Index einer Teilzeichenfolge suchen, die eine bestimmten Zeichenposition, die mit die Vergleichsregeln der aktuellen Kultur vorangestellt ist, rufen die LastIndexOf(String, Int32, StringComparison) methodenüberladung mit einem Wert von CurrentCulture für seine comparisonType Parameter.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.

Siehe auch

Gilt für: