Information
The topic you requested is included in another documentation set. For convenience, it's displayed below. Choose Switch to see the topic in its original location.

String.LastIndexOf Method (Char, Int32, Int32)

Reports the index position of the last occurrence of the specified Unicode character in a substring within this instance. The search starts at a specified character position and examines a specified number of character positions.

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

public int LastIndexOf (
	char value,
	int startIndex,
	int count
)
public int LastIndexOf (
	char value, 
	int startIndex, 
	int count
)
public function LastIndexOf (
	value : char, 
	startIndex : int, 
	count : int
) : int
Not applicable.

Parameters

value

A Unicode character to seek.

startIndex

The starting position of a substring within this instance.

count

The number of character positions to examine.

Return Value

The index position of value if that character is found, or -1 if it is not.

Exception typeCondition

ArgumentNullException

value is a null reference (Nothing in Visual Basic).

ArgumentOutOfRangeException

startIndex or count is less than zero or greater than the length of this instance.

Index numbering starts from zero.

This method begins searching at the startIndex character position of this instance and proceeds backwards towards the beginning until either value is found or count character positions have been examined. The search is case-sensitive.

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

The following code 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 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)
import System.*;

class Sample
{
    public static void main(String[] args)
    {
        String br1 = "0----+----1----+----2----+----3----+----4----+----5----+"
            + "----6----+-";
        String br2 = "01234567890123456789012345678901234567890123456789012345"
            + "67890123456";
        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.get_Length() - 1;
        end = start / 2 - 1;
        Console.WriteLine("All occurrences of 't' from position {0} to {1}.",
            (Int32)start, (Int32)end);
        Console.Write("{1}{0}", Environment.get_NewLine(), br1);
        Console.Write("{1}{0}", Environment.get_NewLine(), br2);
        Console.WriteLine("{1}{0}", Environment.get_NewLine(), 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} ", (Int32)at);
                start = at - 1;
            }
        }
        Console.Write("{0}{0}{0}", Environment.get_NewLine());
    } //main
} //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


*/

Windows 98, Windows Server 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile for Pocket PC, Windows Mobile for Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The Microsoft .NET Framework 3.0 is supported on Windows Vista, Microsoft Windows XP SP2, and Windows Server 2003 SP1.

.NET Framework

Supported in: 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 2.0, 1.0

XNA Framework

Supported in: 1.0

Community Additions

Show:
© 2014 Microsoft