CompareInfo.IndexOf Method
Definition
Important
Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
Returns the zero-based index of the first occurrence of a value within a string or within a portion of it.
Overloads
IndexOf(ReadOnlySpan<Char>, ReadOnlySpan<Char>, CompareOptions, Int32) |
Searches for the first occurrence of a substring within a source string. |
IndexOf(String, String, Int32, Int32, CompareOptions) |
Searches for the specified substring and returns the zero-based index of the first occurrence within the section of the source string that starts at the specified index and contains the specified number of elements using the specified CompareOptions value. |
IndexOf(String, String, Int32, Int32) |
Searches for the specified substring and returns the zero-based index of the first occurrence within the section of the source string that starts at the specified index and contains the specified number of elements. |
IndexOf(String, String, Int32, CompareOptions) |
Searches for the specified substring and returns the zero-based index of the first occurrence within the section of the source string that extends from the specified index to the end of the string using the specified CompareOptions value. |
IndexOf(String, Char, Int32, Int32) |
Searches for the specified character and returns the zero-based index of the first occurrence within the section of the source string that starts at the specified index and contains the specified number of elements. |
IndexOf(String, Char, Int32, CompareOptions) |
Searches for the specified character and returns the zero-based index of the first occurrence within the section of the source string that extends from the specified index to the end of the string using the specified CompareOptions value. |
IndexOf(String, String, Int32) |
Searches for the specified substring and returns the zero-based index of the first occurrence within the section of the source string that extends from the specified index to the end of the string. |
IndexOf(String, Char, Int32, Int32, CompareOptions) |
Searches for the specified character and returns the zero-based index of the first occurrence within the section of the source string that starts at the specified index and contains the specified number of elements using the specified CompareOptions value. |
IndexOf(String, Char, Int32) |
Searches for the specified character and returns the zero-based index of the first occurrence within the section of the source string that extends from the specified index to the end of the string. |
IndexOf(String, Char, CompareOptions) |
Searches for the specified character and returns the zero-based index of the first occurrence within the entire source string using the specified CompareOptions value. |
IndexOf(ReadOnlySpan<Char>, Rune, CompareOptions) |
Searches for the first occurrence of a Rune within the specified read-only span of characters. |
IndexOf(ReadOnlySpan<Char>, ReadOnlySpan<Char>, CompareOptions) |
Searches for the first occurrence of a substring within the specified read-only span of characters. |
IndexOf(String, String) |
Searches for the specified substring and returns the zero-based index of the first occurrence within the entire source string. |
IndexOf(String, String, CompareOptions) |
Searches for the specified substring and returns the zero-based index of the first occurrence within the entire source string using the specified CompareOptions value. |
IndexOf(String, Char) |
Searches for the specified character and returns the zero-based index of the first occurrence within the entire source string. |
IndexOf(ReadOnlySpan<Char>, ReadOnlySpan<Char>, CompareOptions, Int32)
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Searches for the first occurrence of a substring within a source string.
public:
int IndexOf(ReadOnlySpan<char> source, ReadOnlySpan<char> value, System::Globalization::CompareOptions options, [Runtime::InteropServices::Out] int % matchLength);
public int IndexOf (ReadOnlySpan<char> source, ReadOnlySpan<char> value, System.Globalization.CompareOptions options, out int matchLength);
member this.IndexOf : ReadOnlySpan<char> * ReadOnlySpan<char> * System.Globalization.CompareOptions * int -> int
Public Function IndexOf (source As ReadOnlySpan(Of Char), value As ReadOnlySpan(Of Char), options As CompareOptions, ByRef matchLength As Integer) As Integer
Parameters
- source
- ReadOnlySpan<Char>
The read-only span of characters to search within.
- value
- ReadOnlySpan<Char>
The read-only span of characters containing the substring to locate within source
.
- options
- CompareOptions
The CompareOptions to use during the search.
- matchLength
- Int32
When this method returns, contains the number of characters of source
that matched the desired value. This may be different than the length of value
if a linguistic comparison is performed. Set to 0 if value
is not found within source
.
Returns
The zero-based index into source
where the substring value
first appears; or a negative value if value
cannot be found within source
.
Exceptions
options
contains an unsupported combination of flags.
Remarks
This method has greater overhead than other IndexOf overloads that don't take a matchLength
argument. Call this overload only if you require the match length information.
Applies to
IndexOf(String, String, Int32, Int32, CompareOptions)
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Searches for the specified substring and returns the zero-based index of the first occurrence within the section of the source string that starts at the specified index and contains the specified number of elements using the specified CompareOptions value.
public:
virtual int IndexOf(System::String ^ source, System::String ^ value, int startIndex, int count, System::Globalization::CompareOptions options);
public:
int IndexOf(System::String ^ source, System::String ^ value, int startIndex, int count, System::Globalization::CompareOptions options);
public virtual int IndexOf (string source, string value, int startIndex, int count, System.Globalization.CompareOptions options);
public int IndexOf (string source, string value, int startIndex, int count, System.Globalization.CompareOptions options);
abstract member IndexOf : string * string * int * int * System.Globalization.CompareOptions -> int
override this.IndexOf : string * string * int * int * System.Globalization.CompareOptions -> int
member this.IndexOf : string * string * int * int * System.Globalization.CompareOptions -> int
Public Overridable Function IndexOf (source As String, value As String, startIndex As Integer, count As Integer, options As CompareOptions) As Integer
Public Function IndexOf (source As String, value As String, startIndex As Integer, count As Integer, options As CompareOptions) As Integer
Parameters
- source
- String
The string to search.
- value
- String
The string to locate within source
.
- startIndex
- Int32
The zero-based starting index of the search.
- count
- Int32
The number of elements in the section to search.
- options
- CompareOptions
A value that defines how source
and value
should be compared. options
is either the enumeration value Ordinal, or a bitwise combination of one or more of the following values: IgnoreCase, IgnoreSymbols, IgnoreNonSpace, IgnoreWidth, and IgnoreKanaType.
Returns
The zero-based index of the first occurrence of value
, if found, within the section of source
that starts at startIndex
and contains the number of elements specified by count
, using the specified comparison options; otherwise, -1. Returns startIndex
if value
is an ignorable character.
Exceptions
startIndex
is outside the range of valid indexes for source
.
-or-
count
is less than zero.
-or-
startIndex
and count
do not specify a valid section in source
.
options
contains an invalid CompareOptions value.
Examples
The following example determines the indexes of the first and last occurrences of a character or a substring within a portion of a string.
using namespace System;
using namespace System::Globalization;
void PrintMarker( String^ Prefix, int First, int Last )
{
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 )
{
// Creates an array of Char to hold the markers.
array<Char>^myCharArr = gcnew array<Char>(mySize + 1);
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[ First ] = 'f';
if ( Last > -1 )
myCharArr[ Last ] = 'l';
if ( First == Last )
myCharArr[ First ] = 'b';
// Displays the array of Char as a String.
Console::WriteLine( "{0}{1}", Prefix, gcnew String( myCharArr ) );
}
else
Console::WriteLine( Prefix );
}
int main()
{
// Creates CompareInfo for the InvariantCulture.
CompareInfo^ myComp = CultureInfo::InvariantCulture->CompareInfo;
// iS is the starting index of the substring.
int iS = 8;
// iL is the length of the substring.
int iL = 18;
// myT1 and myT2 are the strings used for padding.
String^ myT1 = gcnew String( '-',iS );
String^ myT2;
// Searches for the ligature Æ.
String^ myStr = "Is AE or ae the same as Æ or æ?";
myT2 = gcnew String( '-',myStr->Length - iS - iL );
Console::WriteLine();
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, iL ), myComp->LastIndexOf( myStr, "AE", iS + iL - 1, iL ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, iL ), myComp->LastIndexOf( myStr, "ae", iS + iL - 1, iL ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, iL ), myComp->LastIndexOf( myStr, L'Æ', iS + iL - 1, iL ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, iL ), myComp->LastIndexOf( myStr, L'æ', iS + iL - 1, iL ) );
Console::WriteLine( "Ordinal : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "AE", iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "ae", iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'Æ', iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'æ', iS + iL - 1, iL, CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "AE", iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "ae", iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'Æ', iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'æ', iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is U\u0308 or u\u0308 the same as \u00DC or \u00FC?";
myT2 = gcnew String( '-',myStr->Length - iS - iL );
Console::WriteLine();
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, iL ), myComp->LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, iL ), myComp->LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, iL ), myComp->LastIndexOf( myStr, L'Ü', iS + iL - 1, iL ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, iL ), myComp->LastIndexOf( myStr, L'ü', iS + iL - 1, iL ) );
Console::WriteLine( "Ordinal : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'Ü', iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'ü', iS + iL - 1, iL, CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'Ü', iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'ü', iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
}
/*
This code produces the following output.
Original : Is AE or ae the same as Æ or æ?
No options : -------- ae the same as Æ -----
AE : b
ae : b
Æ : b
æ : b
Ordinal : -------- ae the same as Æ -----
AE :
ae : b
Æ : b
æ :
IgnoreCase : -------- ae the same as Æ -----
AE : f l
ae : f l
Æ : f l
æ : f l
Original : Is U" or u" the same as Ü or ü?
No options : -------- u" the same as Ü -----
U" : b
u" : b
Ü : b
ü : b
Ordinal : -------- u" the same as Ü -----
U" :
u" : b
Ü : b
ü :
IgnoreCase : -------- u" the same as Ü -----
U" : f l
u" : f l
Ü : f l
ü : f l
*/
using System;
using System.Globalization;
public class SamplesCompareInfo {
public static void Main() {
// Creates CompareInfo for the InvariantCulture.
CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;
// iS is the starting index of the substring.
int iS = 8;
// iL is the length of the substring.
int iL = 18;
// myT1 and myT2 are the strings used for padding.
String myT1 = new String( '-', iS );
String myT2;
// Searches for the ligature Æ.
String myStr = "Is AE or ae the same as Æ or æ?";
myT2 = new String( '-', myStr.Length - iS - iL );
Console.WriteLine();
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, iL ), myComp.LastIndexOf( myStr, "AE", iS + iL - 1, iL ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, iL ), myComp.LastIndexOf( myStr, "ae", iS + iL - 1, iL ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, iL ), myComp.LastIndexOf( myStr, 'Æ', iS + iL - 1, iL ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, iL ), myComp.LastIndexOf( myStr, 'æ', iS + iL - 1, iL ) );
Console.WriteLine( "Ordinal : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "AE", iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "ae", iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'Æ', iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'æ', iS + iL - 1, iL, CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "AE", iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "ae", iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'Æ', iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'æ', iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is \u0055\u0308 or \u0075\u0308 the same as \u00DC or \u00FC?";
myT2 = new String( '-', myStr.Length - iS - iL );
Console.WriteLine();
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, iL ), myComp.LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, iL ), myComp.LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, iL ), myComp.LastIndexOf( myStr, 'Ü', iS + iL - 1, iL ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, iL ), myComp.LastIndexOf( myStr, 'ü', iS + iL - 1, iL ) );
Console.WriteLine( "Ordinal : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'Ü', iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'ü', iS + iL - 1, iL, CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'Ü', iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'ü', iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
}
public static void PrintMarker( String Prefix, int First, int Last ) {
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 ) {
// Creates an array of Char to hold the markers.
Char[] myCharArr = new Char[mySize+1];
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[First] = 'f';
if ( Last > -1 )
myCharArr[Last] = 'l';
if ( First == Last )
myCharArr[First] = 'b';
// Displays the array of Char as a String.
Console.WriteLine( "{0}{1}", Prefix, new String( myCharArr ) );
}
else
{
Console.WriteLine( Prefix );
}
}
}
/*
This code produces the following output.
Original : Is AE or ae the same as Æ or æ?
No options : -------- ae the same as Æ -----
AE : b
ae : b
Æ : b
æ : b
Ordinal : -------- ae the same as Æ -----
AE :
ae : b
Æ : b
æ :
IgnoreCase : -------- ae the same as Æ -----
AE : f l
ae : f l
Æ : f l
æ : f l
Original : Is U" or u" the same as Ü or ü?
No options : -------- u" the same as Ü -----
U" : b
u" : b
Ü : b
ü : b
Ordinal : -------- u" the same as Ü -----
U" :
u" : b
Ü : b
ü :
IgnoreCase : -------- u" the same as Ü -----
U" : f l
u" : f l
Ü : f l
ü : f l
*/
Imports System.Globalization
Public Class SamplesCompareInfo
Public Shared Sub Main()
' Creates CompareInfo for the InvariantCulture.
Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
' iS is the starting index of the substring.
Dim [iS] As Integer = 8
' iL is the length of the substring.
Dim iL As Integer = 18
' myT1 and myT2 are the strings used for padding.
Dim myT1 As New [String]("-"c, [iS])
Dim myT2 As [String]
' Searches for the ligature Æ.
Dim myStr As [String] = "Is AE or ae the same as Æ or æ?"
myT2 = New [String]("-"c, myStr.Length - [iS] - iL)
Console.WriteLine()
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], iL), myComp.LastIndexOf(myStr, "AE", [iS] + iL - 1, iL))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], iL), myComp.LastIndexOf(myStr, "ae", [iS] + iL - 1, iL))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], iL), myComp.LastIndexOf(myStr, "Æ"c, [iS] + iL - 1, iL))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], iL), myComp.LastIndexOf(myStr, "æ"c, [iS] + iL - 1, iL))
Console.WriteLine("Ordinal : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "AE", [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "ae", [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "Æ"c, [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "æ"c, [iS] + iL - 1, iL, CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "AE", [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "ae", [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "Æ"c, [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "æ"c, [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
' Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is " & ChrW(&H0055) & ChrW(&H0308) & " or " & ChrW(&H0075) & ChrW(&H0308) & " the same as " & ChrW(&H00DC) & " or " & ChrW(&H00FC) & "?"
myT2 = New [String]("-"c, myStr.Length - [iS] - iL)
Console.WriteLine()
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], iL), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS] + iL - 1, iL))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], iL), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS] + iL - 1, iL))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], iL), myComp.LastIndexOf(myStr, "Ü"c, [iS] + iL - 1, iL))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], iL), myComp.LastIndexOf(myStr, "ü"c, [iS] + iL - 1, iL))
Console.WriteLine("Ordinal : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "Ü"c, [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "ü"c, [iS] + iL - 1, iL, CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "Ü"c, [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "ü"c, [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
End Sub
Public Shared Sub PrintMarker(Prefix As [String], First As Integer, Last As Integer)
' Determines the size of the array to create.
Dim mySize As Integer
If Last > First Then
mySize = Last
Else
mySize = First
End If
If mySize > - 1 Then
' Creates an array of Char to hold the markers.
Dim myCharArr(mySize + 1) As [Char]
' Inserts the appropriate markers.
If First > - 1 Then
myCharArr(First) = "f"c
End If
If Last > - 1 Then
myCharArr(Last) = "l"c
End If
If First = Last Then
myCharArr(First) = "b"c
End If
' Displays the array of Char as a String.
Console.WriteLine("{0}{1}", Prefix, New [String](myCharArr))
Else
Console.WriteLine(Prefix)
End If
End Sub
End Class
'This code produces the following output.
'
'Original : Is AE or ae the same as Æ or æ?
'No options : -------- ae the same as Æ -----
' AE : b
' ae : b
' Æ : b
' æ : b
'Ordinal : -------- ae the same as Æ -----
' AE :
' ae : b
' Æ : b
' æ :
'IgnoreCase : -------- ae the same as Æ -----
' AE : f l
' ae : f l
' Æ : f l
' æ : f l
'
'Original : Is U" or u" the same as Ü or ü?
'No options : -------- u" the same as Ü -----
' U" : b
' u" : b
' Ü : b
' ü : b
'Ordinal : -------- u" the same as Ü -----
' U" :
' u" : b
' Ü : b
' ü :
'IgnoreCase : -------- u" the same as Ü -----
' U" : f l
' u" : f l
' Ü : f l
' ü : f l
Remarks
The source string is searched forward starting at startIndex
and ending at startIndex
+ count
- 1.
The CompareOptions.StringSort value is not valid for this method.
If options
does not include the Ordinal value, this overload performs a culture-sensitive search. A Unicode 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. If options
includes the Ordinal value, this overload performs an ordinal (culture-insensitive) search, where the Unicode values are compared.
Note
When possible, you should call string comparison methods that have a parameter of type CompareOptions to specify the kind of comparison expected. As a general rule, use linguistic options (using the current culture) for comparing strings displayed in the user interface and specify CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase for security comparisons.
Notes to Callers
Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive sort. 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. If value
consists only of one or more ignorable characters, the IndexOf(String, String, Int32, Int32, CompareOptions) method always returns startIndex
, which is the character position at which the search begins.
In the following example, the IndexOf(String, String, Int32, Int32, CompareOptions) method is used to find the position of a soft hyphen (U+00AD) followed by an "m" starting in the third through sixth character positions in two strings. Only one of the strings contains the required substring. In both cases, because the soft hyphen is an ignorable character, the method returns the index of "m" in the string when it performs a culture-sensitive comparison. When it performs an ordinal comparison, however, it finds the substring only in the first string. Note that in the case of the first string, which includes the soft hyphen followed by an "m", the method fails to return the index of the soft hyphen but instead returns the index of the "m" when it performs a culture-sensitive comparison. The method returns the index of the soft hyphen in the first string only when it performs an ordinal comparison.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;
string searchString = "\u00ADm";
string s1 = "ani\u00ADmal" ;
string s2 = "animal";
Console.WriteLine(ci.IndexOf(s1, searchString, 2, 4, CompareOptions.None));
Console.WriteLine(ci.IndexOf(s1, searchString, 2, 4, CompareOptions.Ordinal));
Console.WriteLine(ci.IndexOf(s2, searchString, 2, 4, CompareOptions.None));
Console.WriteLine(ci.IndexOf(s2, searchString, 2, 4, CompareOptions.Ordinal));
}
}
// The example displays the following output:
// 4
// 3
// 3
// -1
Imports System.Globalization
Module Example
Public Sub Main()
Dim ci As CompareInfo = CultureInfo.CurrentCulture.CompareInfo
Dim searchString As String = Chrw(&h00AD) + "m"
Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
Dim s2 As String = "animal"
Console.WriteLine(ci.IndexOf(s1, searchString, 2, 4, CompareOptions.None))
Console.WriteLine(ci.IndexOf(s1, searchString, 2, 4, CompareOptions.Ordinal))
Console.WriteLine(ci.IndexOf(s2, searchString, 2, 4, CompareOptions.None))
Console.WriteLine(ci.IndexOf(s2, searchString, 2, 4, CompareOptions.Ordinal))
End Sub
End Module
' The example displays the following output:
' 4
' 3
' 3
' -1
See also
Applies to
IndexOf(String, String, Int32, Int32)
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Searches for the specified substring and returns the zero-based index of the first occurrence within the section of the source string that starts at the specified index and contains the specified number of elements.
public:
virtual int IndexOf(System::String ^ source, System::String ^ value, int startIndex, int count);
public:
int IndexOf(System::String ^ source, System::String ^ value, int startIndex, int count);
public virtual int IndexOf (string source, string value, int startIndex, int count);
public int IndexOf (string source, string value, int startIndex, int count);
abstract member IndexOf : string * string * int * int -> int
override this.IndexOf : string * string * int * int -> int
member this.IndexOf : string * string * int * int -> int
Public Overridable Function IndexOf (source As String, value As String, startIndex As Integer, count As Integer) As Integer
Public Function IndexOf (source As String, value As String, startIndex As Integer, count As Integer) As Integer
Parameters
- source
- String
The string to search.
- value
- String
The string to locate within source
.
- startIndex
- Int32
The zero-based starting index of the search.
- count
- Int32
The number of elements in the section to search.
Returns
The zero-based index of the first occurrence of value
, if found, within the section of source
that starts at startIndex
and contains the number of elements specified by count
; otherwise, -1. Returns startIndex
if value
is an ignorable character.
Exceptions
startIndex
is outside the range of valid indexes for source
.
-or-
count
is less than zero.
-or-
startIndex
and count
do not specify a valid section in source
.
Examples
The following example determines the indexes of the first and last occurrences of a character or a substring within a portion of a string.
using namespace System;
using namespace System::Globalization;
void PrintMarker( String^ Prefix, int First, int Last )
{
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 )
{
// Creates an array of Char to hold the markers.
array<Char>^myCharArr = gcnew array<Char>(mySize + 1);
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[ First ] = 'f';
if ( Last > -1 )
myCharArr[ Last ] = 'l';
if ( First == Last )
myCharArr[ First ] = 'b';
// Displays the array of Char as a String.
Console::WriteLine( "{0}{1}", Prefix, gcnew String( myCharArr ) );
}
else
Console::WriteLine( Prefix );
}
int main()
{
// Creates CompareInfo for the InvariantCulture.
CompareInfo^ myComp = CultureInfo::InvariantCulture->CompareInfo;
// iS is the starting index of the substring.
int iS = 8;
// iL is the length of the substring.
int iL = 18;
// myT1 and myT2 are the strings used for padding.
String^ myT1 = gcnew String( '-',iS );
String^ myT2;
// Searches for the ligature Æ.
String^ myStr = "Is AE or ae the same as Æ or æ?";
myT2 = gcnew String( '-',myStr->Length - iS - iL );
Console::WriteLine();
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, iL ), myComp->LastIndexOf( myStr, "AE", iS + iL - 1, iL ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, iL ), myComp->LastIndexOf( myStr, "ae", iS + iL - 1, iL ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, iL ), myComp->LastIndexOf( myStr, L'Æ', iS + iL - 1, iL ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, iL ), myComp->LastIndexOf( myStr, L'æ', iS + iL - 1, iL ) );
Console::WriteLine( "Ordinal : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "AE", iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "ae", iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'Æ', iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'æ', iS + iL - 1, iL, CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "AE", iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "ae", iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'Æ', iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'æ', iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is U\u0308 or u\u0308 the same as \u00DC or \u00FC?";
myT2 = gcnew String( '-',myStr->Length - iS - iL );
Console::WriteLine();
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, iL ), myComp->LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, iL ), myComp->LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, iL ), myComp->LastIndexOf( myStr, L'Ü', iS + iL - 1, iL ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, iL ), myComp->LastIndexOf( myStr, L'ü', iS + iL - 1, iL ) );
Console::WriteLine( "Ordinal : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'Ü', iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'ü', iS + iL - 1, iL, CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'Ü', iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'ü', iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
}
/*
This code produces the following output.
Original : Is AE or ae the same as Æ or æ?
No options : -------- ae the same as Æ -----
AE : b
ae : b
Æ : b
æ : b
Ordinal : -------- ae the same as Æ -----
AE :
ae : b
Æ : b
æ :
IgnoreCase : -------- ae the same as Æ -----
AE : f l
ae : f l
Æ : f l
æ : f l
Original : Is U" or u" the same as Ü or ü?
No options : -------- u" the same as Ü -----
U" : b
u" : b
Ü : b
ü : b
Ordinal : -------- u" the same as Ü -----
U" :
u" : b
Ü : b
ü :
IgnoreCase : -------- u" the same as Ü -----
U" : f l
u" : f l
Ü : f l
ü : f l
*/
using System;
using System.Globalization;
public class SamplesCompareInfo {
public static void Main() {
// Creates CompareInfo for the InvariantCulture.
CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;
// iS is the starting index of the substring.
int iS = 8;
// iL is the length of the substring.
int iL = 18;
// myT1 and myT2 are the strings used for padding.
String myT1 = new String( '-', iS );
String myT2;
// Searches for the ligature Æ.
String myStr = "Is AE or ae the same as Æ or æ?";
myT2 = new String( '-', myStr.Length - iS - iL );
Console.WriteLine();
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, iL ), myComp.LastIndexOf( myStr, "AE", iS + iL - 1, iL ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, iL ), myComp.LastIndexOf( myStr, "ae", iS + iL - 1, iL ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, iL ), myComp.LastIndexOf( myStr, 'Æ', iS + iL - 1, iL ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, iL ), myComp.LastIndexOf( myStr, 'æ', iS + iL - 1, iL ) );
Console.WriteLine( "Ordinal : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "AE", iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "ae", iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'Æ', iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'æ', iS + iL - 1, iL, CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "AE", iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "ae", iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'Æ', iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'æ', iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is \u0055\u0308 or \u0075\u0308 the same as \u00DC or \u00FC?";
myT2 = new String( '-', myStr.Length - iS - iL );
Console.WriteLine();
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, iL ), myComp.LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, iL ), myComp.LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, iL ), myComp.LastIndexOf( myStr, 'Ü', iS + iL - 1, iL ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, iL ), myComp.LastIndexOf( myStr, 'ü', iS + iL - 1, iL ) );
Console.WriteLine( "Ordinal : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'Ü', iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'ü', iS + iL - 1, iL, CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'Ü', iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'ü', iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
}
public static void PrintMarker( String Prefix, int First, int Last ) {
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 ) {
// Creates an array of Char to hold the markers.
Char[] myCharArr = new Char[mySize+1];
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[First] = 'f';
if ( Last > -1 )
myCharArr[Last] = 'l';
if ( First == Last )
myCharArr[First] = 'b';
// Displays the array of Char as a String.
Console.WriteLine( "{0}{1}", Prefix, new String( myCharArr ) );
}
else
{
Console.WriteLine( Prefix );
}
}
}
/*
This code produces the following output.
Original : Is AE or ae the same as Æ or æ?
No options : -------- ae the same as Æ -----
AE : b
ae : b
Æ : b
æ : b
Ordinal : -------- ae the same as Æ -----
AE :
ae : b
Æ : b
æ :
IgnoreCase : -------- ae the same as Æ -----
AE : f l
ae : f l
Æ : f l
æ : f l
Original : Is U" or u" the same as Ü or ü?
No options : -------- u" the same as Ü -----
U" : b
u" : b
Ü : b
ü : b
Ordinal : -------- u" the same as Ü -----
U" :
u" : b
Ü : b
ü :
IgnoreCase : -------- u" the same as Ü -----
U" : f l
u" : f l
Ü : f l
ü : f l
*/
Imports System.Globalization
Public Class SamplesCompareInfo
Public Shared Sub Main()
' Creates CompareInfo for the InvariantCulture.
Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
' iS is the starting index of the substring.
Dim [iS] As Integer = 8
' iL is the length of the substring.
Dim iL As Integer = 18
' myT1 and myT2 are the strings used for padding.
Dim myT1 As New [String]("-"c, [iS])
Dim myT2 As [String]
' Searches for the ligature Æ.
Dim myStr As [String] = "Is AE or ae the same as Æ or æ?"
myT2 = New [String]("-"c, myStr.Length - [iS] - iL)
Console.WriteLine()
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], iL), myComp.LastIndexOf(myStr, "AE", [iS] + iL - 1, iL))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], iL), myComp.LastIndexOf(myStr, "ae", [iS] + iL - 1, iL))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], iL), myComp.LastIndexOf(myStr, "Æ"c, [iS] + iL - 1, iL))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], iL), myComp.LastIndexOf(myStr, "æ"c, [iS] + iL - 1, iL))
Console.WriteLine("Ordinal : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "AE", [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "ae", [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "Æ"c, [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "æ"c, [iS] + iL - 1, iL, CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "AE", [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "ae", [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "Æ"c, [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "æ"c, [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
' Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is " & ChrW(&H0055) & ChrW(&H0308) & " or " & ChrW(&H0075) & ChrW(&H0308) & " the same as " & ChrW(&H00DC) & " or " & ChrW(&H00FC) & "?"
myT2 = New [String]("-"c, myStr.Length - [iS] - iL)
Console.WriteLine()
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], iL), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS] + iL - 1, iL))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], iL), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS] + iL - 1, iL))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], iL), myComp.LastIndexOf(myStr, "Ü"c, [iS] + iL - 1, iL))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], iL), myComp.LastIndexOf(myStr, "ü"c, [iS] + iL - 1, iL))
Console.WriteLine("Ordinal : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "Ü"c, [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "ü"c, [iS] + iL - 1, iL, CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "Ü"c, [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "ü"c, [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
End Sub
Public Shared Sub PrintMarker(Prefix As [String], First As Integer, Last As Integer)
' Determines the size of the array to create.
Dim mySize As Integer
If Last > First Then
mySize = Last
Else
mySize = First
End If
If mySize > - 1 Then
' Creates an array of Char to hold the markers.
Dim myCharArr(mySize + 1) As [Char]
' Inserts the appropriate markers.
If First > - 1 Then
myCharArr(First) = "f"c
End If
If Last > - 1 Then
myCharArr(Last) = "l"c
End If
If First = Last Then
myCharArr(First) = "b"c
End If
' Displays the array of Char as a String.
Console.WriteLine("{0}{1}", Prefix, New [String](myCharArr))
Else
Console.WriteLine(Prefix)
End If
End Sub
End Class
'This code produces the following output.
'
'Original : Is AE or ae the same as Æ or æ?
'No options : -------- ae the same as Æ -----
' AE : b
' ae : b
' Æ : b
' æ : b
'Ordinal : -------- ae the same as Æ -----
' AE :
' ae : b
' Æ : b
' æ :
'IgnoreCase : -------- ae the same as Æ -----
' AE : f l
' ae : f l
' Æ : f l
' æ : f l
'
'Original : Is U" or u" the same as Ü or ü?
'No options : -------- u" the same as Ü -----
' U" : b
' u" : b
' Ü : b
' ü : b
'Ordinal : -------- u" the same as Ü -----
' U" :
' u" : b
' Ü : b
' ü :
'IgnoreCase : -------- u" the same as Ü -----
' U" : f l
' u" : f l
' Ü : f l
' ü : f l
Remarks
The source string is searched forward starting at startIndex
and ending at startIndex
+ count
- 1.
This overload performs a culture-sensitive search. A Unicode 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. To perform an ordinal (culture-insensitive) search, where the Unicode values are compared, you should call one of the overloads that has a parameter of type CompareOptions and use the Ordinal value.
Note
When possible, you should call string comparison methods that have a parameter of type CompareOptions to specify the kind of comparison expected. As a general rule, use linguistic options (using the current culture) for comparing strings displayed in the user interface and specify CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase for security comparisons.
Notes to Callers
Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive sort. In a culture-sensitive search, if value
contains an ignorable character, the result is equivalent to searching with that character removed. If value
consists only of one or more ignorable characters, the IndexOf(String, String, Int32, Int32) method always returns startIndex
, which is the character position at which the search begins.
In the following example, the IndexOf(String, String, Int32, Int32) method is used to find the position of a soft hyphen (U+00AD) followed by an "m" starting in the third through sixth character positions in two strings. Only one of the strings contains the required substring. 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. 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;
using System.Globalization;
public class Example
{
public static void Main()
{
CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;
string searchString = "\u00ADm";
string s1 = "ani\u00ADmal" ;
string s2 = "animal";
Console.WriteLine(ci.IndexOf(s1, searchString, 2, 4));
Console.WriteLine(ci.IndexOf(s2, searchString, 2, 4));
}
}
// The example displays the following output:
// 4
// 3
Imports System.Globalization
Module Example
Public Sub Main()
Dim ci As CompareInfo = CultureInfo.CurrentCulture.CompareInfo
Dim searchString As String = Chrw(&h00AD) + "m"
Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
Dim s2 As String = "animal"
Console.WriteLine(ci.IndexOf(s1, searchString, 2, 4))
Console.WriteLine(ci.IndexOf(s2, searchString, 2, 4))
End Sub
End Module
' The example displays the following output:
' 4
' 3
See also
Applies to
IndexOf(String, String, Int32, CompareOptions)
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Searches for the specified substring and returns the zero-based index of the first occurrence within the section of the source string that extends from the specified index to the end of the string using the specified CompareOptions value.
public:
virtual int IndexOf(System::String ^ source, System::String ^ value, int startIndex, System::Globalization::CompareOptions options);
public:
int IndexOf(System::String ^ source, System::String ^ value, int startIndex, System::Globalization::CompareOptions options);
public virtual int IndexOf (string source, string value, int startIndex, System.Globalization.CompareOptions options);
public int IndexOf (string source, string value, int startIndex, System.Globalization.CompareOptions options);
abstract member IndexOf : string * string * int * System.Globalization.CompareOptions -> int
override this.IndexOf : string * string * int * System.Globalization.CompareOptions -> int
member this.IndexOf : string * string * int * System.Globalization.CompareOptions -> int
Public Overridable Function IndexOf (source As String, value As String, startIndex As Integer, options As CompareOptions) As Integer
Public Function IndexOf (source As String, value As String, startIndex As Integer, options As CompareOptions) As Integer
Parameters
- source
- String
The string to search.
- value
- String
The string to locate within source
.
- startIndex
- Int32
The zero-based starting index of the search.
- options
- CompareOptions
A value that defines how source
and value
should be compared. options
is either the enumeration value Ordinal, or a bitwise combination of one or more of the following values: IgnoreCase, IgnoreSymbols, IgnoreNonSpace, IgnoreWidth, and IgnoreKanaType.
Returns
The zero-based index of the first occurrence of value
, if found, within the section of source
that extends from startIndex
to the end of source
, using the specified comparison options; otherwise, -1. Returns startIndex
if value
is an ignorable character.
Exceptions
startIndex
is outside the range of valid indexes for source
.
options
contains an invalid CompareOptions value.
Examples
The following example determines the indexes of the first and last occurrences of a character or a substring within a portion of a string. Note that IndexOf and LastIndexOf are searching in different portions of the string, even with the same startIndex
parameter.
using namespace System;
using namespace System::Globalization;
void PrintMarker( String^ Prefix, int First, int Last )
{
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 )
{
// Creates an array of Char to hold the markers.
array<Char>^myCharArr = gcnew array<Char>(mySize + 1);
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[ First ] = 'f';
if ( Last > -1 )
myCharArr[ Last ] = 'l';
if ( First == Last )
myCharArr[ First ] = 'b';
// Displays the array of Char as a String.
Console::WriteLine( "{0}{1}", Prefix, gcnew String( myCharArr ) );
}
else
Console::WriteLine( Prefix );
}
int main()
{
// Creates CompareInfo for the InvariantCulture.
CompareInfo^ myComp = CultureInfo::InvariantCulture->CompareInfo;
// iS is the starting index of the substring.
int iS = 20;
// myT1 is the string used for padding.
String^ myT1;
// Searches for the ligature Æ.
String^ myStr = "Is AE or ae the same as Æ or æ?";
Console::WriteLine();
myT1 = gcnew String( '-',iS );
Console::WriteLine( "IndexOf( String, *, {0}, * )", iS );
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS ), -1 );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS ), -1 );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS ), -1 );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS ), -1 );
Console::WriteLine( "Ordinal : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, CompareOptions::Ordinal ), -1 );
Console::WriteLine( "IgnoreCase : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, CompareOptions::IgnoreCase ), -1 );
myT1 = gcnew String( '-',myStr->Length - iS - 1 );
Console::WriteLine( "LastIndexOf( String, *, {0}, * )", iS );
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp->LastIndexOf( myStr, "AE", iS ) );
PrintMarker( " ae : ", -1, myComp->LastIndexOf( myStr, "ae", iS ) );
PrintMarker( " Æ : ", -1, myComp->LastIndexOf( myStr, L'Æ', iS ) );
PrintMarker( " æ : ", -1, myComp->LastIndexOf( myStr, L'æ', iS ) );
Console::WriteLine( "Ordinal : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp->LastIndexOf( myStr, "AE", iS, CompareOptions::Ordinal ) );
PrintMarker( " ae : ", -1, myComp->LastIndexOf( myStr, "ae", iS, CompareOptions::Ordinal ) );
PrintMarker( " Æ : ", -1, myComp->LastIndexOf( myStr, L'Æ', iS, CompareOptions::Ordinal ) );
PrintMarker( " æ : ", -1, myComp->LastIndexOf( myStr, L'æ', iS, CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp->LastIndexOf( myStr, "AE", iS, CompareOptions::IgnoreCase ) );
PrintMarker( " ae : ", -1, myComp->LastIndexOf( myStr, "ae", iS, CompareOptions::IgnoreCase ) );
PrintMarker( " Æ : ", -1, myComp->LastIndexOf( myStr, L'Æ', iS, CompareOptions::IgnoreCase ) );
PrintMarker( " æ : ", -1, myComp->LastIndexOf( myStr, L'æ', iS, CompareOptions::IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is U\u0308 or u\u0308 the same as \u00DC or \u00FC?";
Console::WriteLine();
myT1 = gcnew String( '-',iS );
Console::WriteLine( "IndexOf( String, *, {0}, * )", iS );
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS ), -1 );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS ), -1 );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS ), -1 );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS ), -1 );
Console::WriteLine( "Ordinal : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, CompareOptions::Ordinal ), -1 );
Console::WriteLine( "IgnoreCase : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, CompareOptions::IgnoreCase ), -1 );
myT1 = gcnew String( '-',myStr->Length - iS - 1 );
Console::WriteLine( "LastIndexOf( String, *, {0}, * )", iS );
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp->LastIndexOf( myStr, "U\u0308", iS ) );
PrintMarker( " u\u0308 : ", -1, myComp->LastIndexOf( myStr, "u\u0308", iS ) );
PrintMarker( " Ü : ", -1, myComp->LastIndexOf( myStr, L'Ü', iS ) );
PrintMarker( " ü : ", -1, myComp->LastIndexOf( myStr, L'ü', iS ) );
Console::WriteLine( "Ordinal : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp->LastIndexOf( myStr, "U\u0308", iS, CompareOptions::Ordinal ) );
PrintMarker( " u\u0308 : ", -1, myComp->LastIndexOf( myStr, "u\u0308", iS, CompareOptions::Ordinal ) );
PrintMarker( " Ü : ", -1, myComp->LastIndexOf( myStr, L'Ü', iS, CompareOptions::Ordinal ) );
PrintMarker( " ü : ", -1, myComp->LastIndexOf( myStr, L'ü', iS, CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp->LastIndexOf( myStr, "U\u0308", iS, CompareOptions::IgnoreCase ) );
PrintMarker( " u\u0308 : ", -1, myComp->LastIndexOf( myStr, "u\u0308", iS, CompareOptions::IgnoreCase ) );
PrintMarker( " Ü : ", -1, myComp->LastIndexOf( myStr, L'Ü', iS, CompareOptions::IgnoreCase ) );
PrintMarker( " ü : ", -1, myComp->LastIndexOf( myStr, L'ü', iS, CompareOptions::IgnoreCase ) );
}
/*
This code produces the following output.
IndexOf( String, *, 20, * )
Original : Is AE or ae the same as Æ or æ?
No options : -------------------- as Æ or æ?
AE : f
ae : f
Æ : f
æ : f
Ordinal : -------------------- as Æ or æ?
AE :
ae :
Æ : f
æ : f
IgnoreCase : -------------------- as Æ or æ?
AE : f
ae : f
Æ : f
æ : f
LastIndexOf( String, *, 20, * )
Original : Is AE or ae the same as Æ or æ?
No options : Is AE or ae the same ----------
AE : l
ae : l
Æ : l
æ : l
Ordinal : Is AE or ae the same ----------
AE : l
ae : l
Æ :
æ :
IgnoreCase : Is AE or ae the same ----------
AE : l
ae : l
Æ : l
æ : l
IndexOf( String, *, 20, * )
Original : Is U" or u" the same as Ü or ü?
No options : -------------------- as Ü or ü?
U" : f
u" : f
Ü : f
ü : f
Ordinal : -------------------- as Ü or ü?
U" :
u" :
Ü : f
ü : f
IgnoreCase : -------------------- as Ü or ü?
U" : f
u" : f
Ü : f
ü : f
LastIndexOf( String, *, 20, * )
Original : Is U" or u" the same as Ü or ü?
No options : Is U" or u" the same ----------
U" : l
u" : l
Ü : l
ü : l
Ordinal : Is U" or u" the same ----------
U" : l
u" : l
Ü :
ü :
IgnoreCase : Is U" or u" the same ----------
U" : l
u" : l
Ü : l
ü : l
*/
using System;
using System.Globalization;
public class SamplesCompareInfo {
public static void Main() {
// Creates CompareInfo for the InvariantCulture.
CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;
// iS is the starting index of the substring.
int iS = 20;
// myT1 is the string used for padding.
String myT1;
// Searches for the ligature Æ.
String myStr = "Is AE or ae the same as Æ or æ?";
Console.WriteLine();
myT1 = new String( '-', iS );
Console.WriteLine( "IndexOf( String, *, {0}, * )", iS );
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS ), -1 );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS ), -1 );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS ), -1 );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS ), -1 );
Console.WriteLine( "Ordinal : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, CompareOptions.Ordinal ), -1 );
Console.WriteLine( "IgnoreCase : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, CompareOptions.IgnoreCase ), -1 );
myT1 = new String( '-', myStr.Length - iS - 1 );
Console.WriteLine( "LastIndexOf( String, *, {0}, * )", iS );
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp.LastIndexOf( myStr, "AE", iS ) );
PrintMarker( " ae : ", -1, myComp.LastIndexOf( myStr, "ae", iS ) );
PrintMarker( " Æ : ", -1, myComp.LastIndexOf( myStr, 'Æ', iS ) );
PrintMarker( " æ : ", -1, myComp.LastIndexOf( myStr, 'æ', iS ) );
Console.WriteLine( "Ordinal : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp.LastIndexOf( myStr, "AE", iS, CompareOptions.Ordinal ) );
PrintMarker( " ae : ", -1, myComp.LastIndexOf( myStr, "ae", iS, CompareOptions.Ordinal ) );
PrintMarker( " Æ : ", -1, myComp.LastIndexOf( myStr, 'Æ', iS, CompareOptions.Ordinal ) );
PrintMarker( " æ : ", -1, myComp.LastIndexOf( myStr, 'æ', iS, CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp.LastIndexOf( myStr, "AE", iS, CompareOptions.IgnoreCase ) );
PrintMarker( " ae : ", -1, myComp.LastIndexOf( myStr, "ae", iS, CompareOptions.IgnoreCase ) );
PrintMarker( " Æ : ", -1, myComp.LastIndexOf( myStr, 'Æ', iS, CompareOptions.IgnoreCase ) );
PrintMarker( " æ : ", -1, myComp.LastIndexOf( myStr, 'æ', iS, CompareOptions.IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is \u0055\u0308 or \u0075\u0308 the same as \u00DC or \u00FC?";
Console.WriteLine();
myT1 = new String( '-', iS );
Console.WriteLine( "IndexOf( String, *, {0}, * )", iS );
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS ), -1 );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS ), -1 );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS ), -1 );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS ), -1 );
Console.WriteLine( "Ordinal : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, CompareOptions.Ordinal ), -1 );
Console.WriteLine( "IgnoreCase : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, CompareOptions.IgnoreCase ), -1 );
myT1 = new String( '-', myStr.Length - iS - 1 );
Console.WriteLine( "LastIndexOf( String, *, {0}, * )", iS );
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp.LastIndexOf( myStr, "U\u0308", iS ) );
PrintMarker( " u\u0308 : ", -1, myComp.LastIndexOf( myStr, "u\u0308", iS ) );
PrintMarker( " Ü : ", -1, myComp.LastIndexOf( myStr, 'Ü', iS ) );
PrintMarker( " ü : ", -1, myComp.LastIndexOf( myStr, 'ü', iS ) );
Console.WriteLine( "Ordinal : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp.LastIndexOf( myStr, "U\u0308", iS, CompareOptions.Ordinal ) );
PrintMarker( " u\u0308 : ", -1, myComp.LastIndexOf( myStr, "u\u0308", iS, CompareOptions.Ordinal ) );
PrintMarker( " Ü : ", -1, myComp.LastIndexOf( myStr, 'Ü', iS, CompareOptions.Ordinal ) );
PrintMarker( " ü : ", -1, myComp.LastIndexOf( myStr, 'ü', iS, CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp.LastIndexOf( myStr, "U\u0308", iS, CompareOptions.IgnoreCase ) );
PrintMarker( " u\u0308 : ", -1, myComp.LastIndexOf( myStr, "u\u0308", iS, CompareOptions.IgnoreCase ) );
PrintMarker( " Ü : ", -1, myComp.LastIndexOf( myStr, 'Ü', iS, CompareOptions.IgnoreCase ) );
PrintMarker( " ü : ", -1, myComp.LastIndexOf( myStr, 'ü', iS, CompareOptions.IgnoreCase ) );
}
public static void PrintMarker( String Prefix, int First, int Last ) {
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 ) {
// Creates an array of Char to hold the markers.
Char[] myCharArr = new Char[mySize+1];
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[First] = 'f';
if ( Last > -1 )
myCharArr[Last] = 'l';
if ( First == Last )
myCharArr[First] = 'b';
// Displays the array of Char as a String.
Console.WriteLine( "{0}{1}", Prefix, new String( myCharArr ) );
}
else
{
Console.WriteLine( Prefix );
}
}
}
/*
This code produces the following output.
IndexOf( String, *, 20, * )
Original : Is AE or ae the same as Æ or æ?
No options : -------------------- as Æ or æ?
AE : f
ae : f
Æ : f
æ : f
Ordinal : -------------------- as Æ or æ?
AE :
ae :
Æ : f
æ : f
IgnoreCase : -------------------- as Æ or æ?
AE : f
ae : f
Æ : f
æ : f
LastIndexOf( String, *, 20, * )
Original : Is AE or ae the same as Æ or æ?
No options : Is AE or ae the same ----------
AE : l
ae : l
Æ : l
æ : l
Ordinal : Is AE or ae the same ----------
AE : l
ae : l
Æ :
æ :
IgnoreCase : Is AE or ae the same ----------
AE : l
ae : l
Æ : l
æ : l
IndexOf( String, *, 20, * )
Original : Is U" or u" the same as Ü or ü?
No options : -------------------- as Ü or ü?
U" : f
u" : f
Ü : f
ü : f
Ordinal : -------------------- as Ü or ü?
U" :
u" :
Ü : f
ü : f
IgnoreCase : -------------------- as Ü or ü?
U" : f
u" : f
Ü : f
ü : f
LastIndexOf( String, *, 20, * )
Original : Is U" or u" the same as Ü or ü?
No options : Is U" or u" the same ----------
U" : l
u" : l
Ü : l
ü : l
Ordinal : Is U" or u" the same ----------
U" : l
u" : l
Ü :
ü :
IgnoreCase : Is U" or u" the same ----------
U" : l
u" : l
Ü : l
ü : l
*/
Imports System.Globalization
Public Class SamplesCompareInfo
Public Shared Sub Main()
' Creates CompareInfo for the InvariantCulture.
Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
' iS is the starting index of the substring.
Dim [iS] As Integer = 20
' myT1 is the string used for padding.
Dim myT1 As [String]
' Searches for the ligature Æ.
Dim myStr As [String] = "Is AE or ae the same as Æ or æ?"
Console.WriteLine()
myT1 = New [String]("-"c, [iS])
Console.WriteLine("IndexOf( String, *, {0}, * )", [iS])
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS]), - 1)
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS]), - 1)
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS]), - 1)
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS]), - 1)
Console.WriteLine("Ordinal : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], CompareOptions.Ordinal), - 1)
Console.WriteLine("IgnoreCase : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], CompareOptions.IgnoreCase), - 1)
myT1 = New [String]("-"c, myStr.Length - [iS] - 1)
Console.WriteLine("LastIndexOf( String, *, {0}, * )", [iS])
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" AE : ", - 1, myComp.LastIndexOf(myStr, "AE", [iS]))
PrintMarker(" ae : ", - 1, myComp.LastIndexOf(myStr, "ae", [iS]))
PrintMarker(" Æ : ", - 1, myComp.LastIndexOf(myStr, "Æ"c, [iS]))
PrintMarker(" æ : ", - 1, myComp.LastIndexOf(myStr, "æ"c, [iS]))
Console.WriteLine("Ordinal : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" AE : ", - 1, myComp.LastIndexOf(myStr, "AE", [iS], CompareOptions.Ordinal))
PrintMarker(" ae : ", - 1, myComp.LastIndexOf(myStr, "ae", [iS], CompareOptions.Ordinal))
PrintMarker(" Æ : ", - 1, myComp.LastIndexOf(myStr, "Æ"c, [iS], CompareOptions.Ordinal))
PrintMarker(" æ : ", - 1, myComp.LastIndexOf(myStr, "æ"c, [iS], CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" AE : ", - 1, myComp.LastIndexOf(myStr, "AE", [iS], CompareOptions.IgnoreCase))
PrintMarker(" ae : ", - 1, myComp.LastIndexOf(myStr, "ae", [iS], CompareOptions.IgnoreCase))
PrintMarker(" Æ : ", - 1, myComp.LastIndexOf(myStr, "Æ"c, [iS], CompareOptions.IgnoreCase))
PrintMarker(" æ : ", - 1, myComp.LastIndexOf(myStr, "æ"c, [iS], CompareOptions.IgnoreCase))
' Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is " & ChrW(&H0055) & ChrW(&H0308) & " or " & ChrW(&H0075) & ChrW(&H0308) & " the same as " & ChrW(&H00DC) & " or " & ChrW(&H00FC) & "?"
Console.WriteLine()
myT1 = New [String]("-"c, [iS])
Console.WriteLine("IndexOf( String, *, {0}, * )", [iS])
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS]), - 1)
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS]), - 1)
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS]), - 1)
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS]), - 1)
Console.WriteLine("Ordinal : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], CompareOptions.Ordinal), - 1)
Console.WriteLine("IgnoreCase : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], CompareOptions.IgnoreCase), - 1)
myT1 = New [String]("-"c, myStr.Length - [iS] - 1)
Console.WriteLine("LastIndexOf( String, *, {0}, * )", [iS])
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" U" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS]))
PrintMarker(" u" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS]))
PrintMarker(" Ü : ", - 1, myComp.LastIndexOf(myStr, "Ü"c, [iS]))
PrintMarker(" ü : ", - 1, myComp.LastIndexOf(myStr, "ü"c, [iS]))
Console.WriteLine("Ordinal : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" U" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS], CompareOptions.Ordinal))
PrintMarker(" u" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS], CompareOptions.Ordinal))
PrintMarker(" Ü : ", - 1, myComp.LastIndexOf(myStr, "Ü"c, [iS], CompareOptions.Ordinal))
PrintMarker(" ü : ", - 1, myComp.LastIndexOf(myStr, "ü"c, [iS], CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" U" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS], CompareOptions.IgnoreCase))
PrintMarker(" u" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS], CompareOptions.IgnoreCase))
PrintMarker(" Ü : ", - 1, myComp.LastIndexOf(myStr, "Ü"c, [iS], CompareOptions.IgnoreCase))
PrintMarker(" ü : ", - 1, myComp.LastIndexOf(myStr, "ü"c, [iS], CompareOptions.IgnoreCase))
End Sub
Public Shared Sub PrintMarker(Prefix As [String], First As Integer, Last As Integer)
' Determines the size of the array to create.
Dim mySize As Integer
If Last > First Then
mySize = Last
Else
mySize = First
End If
If mySize > - 1 Then
' Creates an array of Char to hold the markers.
Dim myCharArr(mySize + 1) As [Char]
' Inserts the appropriate markers.
If First > - 1 Then
myCharArr(First) = "f"c
End If
If Last > - 1 Then
myCharArr(Last) = "l"c
End If
If First = Last Then
myCharArr(First) = "b"c
End If
' Displays the array of Char as a String.
Console.WriteLine("{0}{1}", Prefix, New [String](myCharArr))
Else
Console.WriteLine(Prefix)
End If
End Sub
End Class
'This code produces the following output.
'
'IndexOf( String, *, 20, * )
'Original : Is AE or ae the same as Æ or æ?
'No options : -------------------- as Æ or æ?
' AE : f
' ae : f
' Æ : f
' æ : f
'Ordinal : -------------------- as Æ or æ?
' AE :
' ae :
' Æ : f
' æ : f
'IgnoreCase : -------------------- as Æ or æ?
' AE : f
' ae : f
' Æ : f
' æ : f
'LastIndexOf( String, *, 20, * )
'Original : Is AE or ae the same as Æ or æ?
'No options : Is AE or ae the same ----------
' AE : l
' ae : l
' Æ : l
' æ : l
'Ordinal : Is AE or ae the same ----------
' AE : l
' ae : l
' Æ :
' æ :
'IgnoreCase : Is AE or ae the same ----------
' AE : l
' ae : l
' Æ : l
' æ : l
'
'IndexOf( String, *, 20, * )
'Original : Is U" or u" the same as Ü or ü?
'No options : -------------------- as Ü or ü?
' U" : f
' u" : f
' Ü : f
' ü : f
'Ordinal : -------------------- as Ü or ü?
' U" :
' u" :
' Ü : f
' ü : f
'IgnoreCase : -------------------- as Ü or ü?
' U" : f
' u" : f
' Ü : f
' ü : f
'LastIndexOf( String, *, 20, * )
'Original : Is U" or u" the same as Ü or ü?
'No options : Is U" or u" the same ----------
' U" : l
' u" : l
' Ü : l
' ü : l
'Ordinal : Is U" or u" the same ----------
' U" : l
' u" : l
' Ü :
' ü :
'IgnoreCase : Is U" or u" the same ----------
' U" : l
' u" : l
' Ü : l
' ü : l
Remarks
The source string is searched forward starting at startIndex
and ending at the end of the string.
The CompareOptions.StringSort value is not valid for this method.
If options
does not include the Ordinal value, this overload performs a culture-sensitive search. A Unicode 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. If options
includes the Ordinal value, this overload performs an ordinal (culture-insensitive) search, where the Unicode values are compared.
Note
When possible, you should call string comparison methods that have a parameter of type CompareOptions to specify the kind of comparison expected. As a general rule, use linguistic options (using the current culture) for comparing strings displayed in the user interface and specify CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase for security comparisons.
Notes to Callers
Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive sort. 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. If value
consists only of one or more ignorable characters, the IndexOf(String, String, Int32, CompareOptions) method always returns startIndex
, which is the character position at which the search begins.
In the following example, the IndexOf(String, String, Int32, CompareOptions) method is used to find the position of a soft hyphen (U+00AD) followed by an "m" starting with the third character position in two strings. Only one of the strings contains the required substring. 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. Note that in the case of the first string, which includes the soft hyphen followed by an "m", the method fails to return the index of the soft hyphen but instead returns the index of the "m". The method returns the index of the soft hyphen in the first string only when it performs an ordinal comparison.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;
string searchString = "\u00ADm";
string s1 = "ani\u00ADmal" ;
string s2 = "animal";
Console.WriteLine(ci.IndexOf(s1, searchString, 2, CompareOptions.None));
Console.WriteLine(ci.IndexOf(s1, searchString, 2, CompareOptions.Ordinal));
Console.WriteLine(ci.IndexOf(s2, searchString, 2, CompareOptions.None));
Console.WriteLine(ci.IndexOf(s2, searchString, 2, CompareOptions.Ordinal));
}
}
// The example displays the following output:
// 4
// 3
// 3
// -1
Imports System.Globalization
Module Example
Public Sub Main()
Dim ci As CompareInfo = CultureInfo.CurrentCulture.CompareInfo
Dim searchString As String = Chrw(&h00AD) + "m"
Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
Dim s2 As String = "animal"
Console.WriteLine(ci.IndexOf(s1, searchString, 2, CompareOptions.None))
Console.WriteLine(ci.IndexOf(s1, searchString, 2, CompareOptions.Ordinal))
Console.WriteLine(ci.IndexOf(s2, searchString, 2, CompareOptions.None))
Console.WriteLine(ci.IndexOf(s2, searchString, 2, CompareOptions.Ordinal))
End Sub
End Module
' The example displays the following output:
' 4
' 3
' 3
' -1
See also
Applies to
IndexOf(String, Char, Int32, Int32)
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Searches for the specified character and returns the zero-based index of the first occurrence within the section of the source string that starts at the specified index and contains the specified number of elements.
public:
virtual int IndexOf(System::String ^ source, char value, int startIndex, int count);
public:
int IndexOf(System::String ^ source, char value, int startIndex, int count);
public virtual int IndexOf (string source, char value, int startIndex, int count);
public int IndexOf (string source, char value, int startIndex, int count);
abstract member IndexOf : string * char * int * int -> int
override this.IndexOf : string * char * int * int -> int
member this.IndexOf : string * char * int * int -> int
Public Overridable Function IndexOf (source As String, value As Char, startIndex As Integer, count As Integer) As Integer
Public Function IndexOf (source As String, value As Char, startIndex As Integer, count As Integer) As Integer
Parameters
- source
- String
The string to search.
- value
- Char
The character to locate within source
.
- startIndex
- Int32
The zero-based starting index of the search.
- count
- Int32
The number of elements in the section to search.
Returns
The zero-based index of the first occurrence of value
, if found, within the section of source
that starts at startIndex
and contains the number of elements specified by count
; otherwise, -1. Returns startIndex
if value
is an ignorable character.
Exceptions
source
is null
.
startIndex
is outside the range of valid indexes for source
.
-or-
count
is less than zero.
-or-
startIndex
and count
do not specify a valid section in source
.
Examples
The following example determines the indexes of the first and last occurrences of a character or a substring within a portion of a string.
using namespace System;
using namespace System::Globalization;
void PrintMarker( String^ Prefix, int First, int Last )
{
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 )
{
// Creates an array of Char to hold the markers.
array<Char>^myCharArr = gcnew array<Char>(mySize + 1);
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[ First ] = 'f';
if ( Last > -1 )
myCharArr[ Last ] = 'l';
if ( First == Last )
myCharArr[ First ] = 'b';
// Displays the array of Char as a String.
Console::WriteLine( "{0}{1}", Prefix, gcnew String( myCharArr ) );
}
else
Console::WriteLine( Prefix );
}
int main()
{
// Creates CompareInfo for the InvariantCulture.
CompareInfo^ myComp = CultureInfo::InvariantCulture->CompareInfo;
// iS is the starting index of the substring.
int iS = 8;
// iL is the length of the substring.
int iL = 18;
// myT1 and myT2 are the strings used for padding.
String^ myT1 = gcnew String( '-',iS );
String^ myT2;
// Searches for the ligature Æ.
String^ myStr = "Is AE or ae the same as Æ or æ?";
myT2 = gcnew String( '-',myStr->Length - iS - iL );
Console::WriteLine();
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, iL ), myComp->LastIndexOf( myStr, "AE", iS + iL - 1, iL ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, iL ), myComp->LastIndexOf( myStr, "ae", iS + iL - 1, iL ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, iL ), myComp->LastIndexOf( myStr, L'Æ', iS + iL - 1, iL ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, iL ), myComp->LastIndexOf( myStr, L'æ', iS + iL - 1, iL ) );
Console::WriteLine( "Ordinal : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "AE", iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "ae", iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'Æ', iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'æ', iS + iL - 1, iL, CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "AE", iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "ae", iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'Æ', iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'æ', iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is U\u0308 or u\u0308 the same as \u00DC or \u00FC?";
myT2 = gcnew String( '-',myStr->Length - iS - iL );
Console::WriteLine();
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, iL ), myComp->LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, iL ), myComp->LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, iL ), myComp->LastIndexOf( myStr, L'Ü', iS + iL - 1, iL ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, iL ), myComp->LastIndexOf( myStr, L'ü', iS + iL - 1, iL ) );
Console::WriteLine( "Ordinal : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'Ü', iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'ü', iS + iL - 1, iL, CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'Ü', iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'ü', iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
}
/*
This code produces the following output.
Original : Is AE or ae the same as Æ or æ?
No options : -------- ae the same as Æ -----
AE : b
ae : b
Æ : b
æ : b
Ordinal : -------- ae the same as Æ -----
AE :
ae : b
Æ : b
æ :
IgnoreCase : -------- ae the same as Æ -----
AE : f l
ae : f l
Æ : f l
æ : f l
Original : Is U" or u" the same as Ü or ü?
No options : -------- u" the same as Ü -----
U" : b
u" : b
Ü : b
ü : b
Ordinal : -------- u" the same as Ü -----
U" :
u" : b
Ü : b
ü :
IgnoreCase : -------- u" the same as Ü -----
U" : f l
u" : f l
Ü : f l
ü : f l
*/
using System;
using System.Globalization;
public class SamplesCompareInfo {
public static void Main() {
// Creates CompareInfo for the InvariantCulture.
CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;
// iS is the starting index of the substring.
int iS = 8;
// iL is the length of the substring.
int iL = 18;
// myT1 and myT2 are the strings used for padding.
String myT1 = new String( '-', iS );
String myT2;
// Searches for the ligature Æ.
String myStr = "Is AE or ae the same as Æ or æ?";
myT2 = new String( '-', myStr.Length - iS - iL );
Console.WriteLine();
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, iL ), myComp.LastIndexOf( myStr, "AE", iS + iL - 1, iL ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, iL ), myComp.LastIndexOf( myStr, "ae", iS + iL - 1, iL ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, iL ), myComp.LastIndexOf( myStr, 'Æ', iS + iL - 1, iL ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, iL ), myComp.LastIndexOf( myStr, 'æ', iS + iL - 1, iL ) );
Console.WriteLine( "Ordinal : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "AE", iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "ae", iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'Æ', iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'æ', iS + iL - 1, iL, CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "AE", iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "ae", iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'Æ', iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'æ', iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is \u0055\u0308 or \u0075\u0308 the same as \u00DC or \u00FC?";
myT2 = new String( '-', myStr.Length - iS - iL );
Console.WriteLine();
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, iL ), myComp.LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, iL ), myComp.LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, iL ), myComp.LastIndexOf( myStr, 'Ü', iS + iL - 1, iL ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, iL ), myComp.LastIndexOf( myStr, 'ü', iS + iL - 1, iL ) );
Console.WriteLine( "Ordinal : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'Ü', iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'ü', iS + iL - 1, iL, CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'Ü', iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'ü', iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
}
public static void PrintMarker( String Prefix, int First, int Last ) {
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 ) {
// Creates an array of Char to hold the markers.
Char[] myCharArr = new Char[mySize+1];
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[First] = 'f';
if ( Last > -1 )
myCharArr[Last] = 'l';
if ( First == Last )
myCharArr[First] = 'b';
// Displays the array of Char as a String.
Console.WriteLine( "{0}{1}", Prefix, new String( myCharArr ) );
}
else
{
Console.WriteLine( Prefix );
}
}
}
/*
This code produces the following output.
Original : Is AE or ae the same as Æ or æ?
No options : -------- ae the same as Æ -----
AE : b
ae : b
Æ : b
æ : b
Ordinal : -------- ae the same as Æ -----
AE :
ae : b
Æ : b
æ :
IgnoreCase : -------- ae the same as Æ -----
AE : f l
ae : f l
Æ : f l
æ : f l
Original : Is U" or u" the same as Ü or ü?
No options : -------- u" the same as Ü -----
U" : b
u" : b
Ü : b
ü : b
Ordinal : -------- u" the same as Ü -----
U" :
u" : b
Ü : b
ü :
IgnoreCase : -------- u" the same as Ü -----
U" : f l
u" : f l
Ü : f l
ü : f l
*/
Imports System.Globalization
Public Class SamplesCompareInfo
Public Shared Sub Main()
' Creates CompareInfo for the InvariantCulture.
Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
' iS is the starting index of the substring.
Dim [iS] As Integer = 8
' iL is the length of the substring.
Dim iL As Integer = 18
' myT1 and myT2 are the strings used for padding.
Dim myT1 As New [String]("-"c, [iS])
Dim myT2 As [String]
' Searches for the ligature Æ.
Dim myStr As [String] = "Is AE or ae the same as Æ or æ?"
myT2 = New [String]("-"c, myStr.Length - [iS] - iL)
Console.WriteLine()
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], iL), myComp.LastIndexOf(myStr, "AE", [iS] + iL - 1, iL))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], iL), myComp.LastIndexOf(myStr, "ae", [iS] + iL - 1, iL))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], iL), myComp.LastIndexOf(myStr, "Æ"c, [iS] + iL - 1, iL))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], iL), myComp.LastIndexOf(myStr, "æ"c, [iS] + iL - 1, iL))
Console.WriteLine("Ordinal : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "AE", [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "ae", [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "Æ"c, [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "æ"c, [iS] + iL - 1, iL, CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "AE", [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "ae", [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "Æ"c, [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "æ"c, [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
' Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is " & ChrW(&H0055) & ChrW(&H0308) & " or " & ChrW(&H0075) & ChrW(&H0308) & " the same as " & ChrW(&H00DC) & " or " & ChrW(&H00FC) & "?"
myT2 = New [String]("-"c, myStr.Length - [iS] - iL)
Console.WriteLine()
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], iL), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS] + iL - 1, iL))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], iL), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS] + iL - 1, iL))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], iL), myComp.LastIndexOf(myStr, "Ü"c, [iS] + iL - 1, iL))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], iL), myComp.LastIndexOf(myStr, "ü"c, [iS] + iL - 1, iL))
Console.WriteLine("Ordinal : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "Ü"c, [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "ü"c, [iS] + iL - 1, iL, CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "Ü"c, [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "ü"c, [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
End Sub
Public Shared Sub PrintMarker(Prefix As [String], First As Integer, Last As Integer)
' Determines the size of the array to create.
Dim mySize As Integer
If Last > First Then
mySize = Last
Else
mySize = First
End If
If mySize > - 1 Then
' Creates an array of Char to hold the markers.
Dim myCharArr(mySize + 1) As [Char]
' Inserts the appropriate markers.
If First > - 1 Then
myCharArr(First) = "f"c
End If
If Last > - 1 Then
myCharArr(Last) = "l"c
End If
If First = Last Then
myCharArr(First) = "b"c
End If
' Displays the array of Char as a String.
Console.WriteLine("{0}{1}", Prefix, New [String](myCharArr))
Else
Console.WriteLine(Prefix)
End If
End Sub
End Class
'This code produces the following output.
'
'Original : Is AE or ae the same as Æ or æ?
'No options : -------- ae the same as Æ -----
' AE : b
' ae : b
' Æ : b
' æ : b
'Ordinal : -------- ae the same as Æ -----
' AE :
' ae : b
' Æ : b
' æ :
'IgnoreCase : -------- ae the same as Æ -----
' AE : f l
' ae : f l
' Æ : f l
' æ : f l
'
'Original : Is U" or u" the same as Ü or ü?
'No options : -------- u" the same as Ü -----
' U" : b
' u" : b
' Ü : b
' ü : b
'Ordinal : -------- u" the same as Ü -----
' U" :
' u" : b
' Ü : b
' ü :
'IgnoreCase : -------- u" the same as Ü -----
' U" : f l
' u" : f l
' Ü : f l
' ü : f l
Remarks
The source string is searched forward starting at startIndex
and ending at startIndex
+ count
- 1.
This overload performs a culture-sensitive search. If the character is a Unicode value representing a precomposed character, such as the ligature "Æ" (U+00C6), it might be considered equivalent to any occurrence of its components in the correct sequence, such as "AE" (U+0041, U+0045), depending on the culture. To perform an ordinal (culture-insensitive) search, where a character is considered equivalent to another character only if the Unicode values are the same, you should call one of the overloads that has a parameter of type CompareOptions and use the Ordinal value. Overloads of String.IndexOf that search for a character perform an ordinal search, whereas those that search for a string perform a culture-sensitive search.
Note
When possible, you should call string comparison methods that have a parameter of type CompareOptions to specify the kind of comparison expected. As a general rule, use linguistic options (using the current culture) for comparing strings displayed in the user interface and specify CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase for security comparisons.
Notes to Callers
Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive sort. In a culture-sensitive search, if value
is an ignorable character, the result is equivalent to searching with that character removed. In this case, the IndexOf(String, Char, Int32, Int32) method always returns startIndex
, which is the character position at which the search first began. In the following example, the IndexOf(String, Char, Int32, Int32) method is used to find a soft hyphen (U+00AD) after an "n" in two strings. Only one of the strings contains a soft hyphen. In both cases, because the soft hyphen is an ignorable character, the method returns 1 to indicate that it has found a match at the position of the "n".
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;
string s1 = "ani\u00ADmal";
string s2 = "animal";
int position = 0;
// Find the index of the soft hyphen.
position = ci.IndexOf(s1, 'n');
Console.WriteLine("'n' at position {0}", position);
if (position >= 0)
Console.WriteLine(ci.IndexOf(s1, '\u00AD', position, s1.Length - position));
position = ci.IndexOf(s2, 'n');
Console.WriteLine("'n' at position {0}", position);
if (position >= 0)
Console.WriteLine(ci.IndexOf(s2, '\u00AD', position, s2.Length - position));
}
}
// The example displays the following output:
// 'n' at position 1
// 1
// 'n' at position 1
// 1
Imports System.Globalization
Module Example
Public Sub Main()
Dim ci As CompareInfo = CultureInfo.CurrentCulture.CompareInfo
Dim position As Integer
Dim softHyphen As Char = ChrW(&h00AD)
Dim s1 As String = "ani" + softHyphen + "mal"
Dim s2 As String = "animal"
' Find the index of the soft hyphen.
position = ci.IndexOf(s1, "n"c)
Console.WriteLine("'n' at position {0}", position)
If position >= 0 Then
Console.WriteLine(ci.IndexOf(s1, softHyphen, position, s1.Length - position))
End If
position = ci.IndexOf(s2, "n"c)
Console.WriteLine("'n' at position {0}", position)
If position >= 0 Then
Console.WriteLine(ci.IndexOf(s2, softHyphen, position, s2.Length - position))
End If
End Sub
End Module
' The example displays the following output:
' 'n' at position 1
' 1
' 'n' at position 1
' 1
See also
Applies to
IndexOf(String, Char, Int32, CompareOptions)
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Searches for the specified character and returns the zero-based index of the first occurrence within the section of the source string that extends from the specified index to the end of the string using the specified CompareOptions value.
public:
virtual int IndexOf(System::String ^ source, char value, int startIndex, System::Globalization::CompareOptions options);
public:
int IndexOf(System::String ^ source, char value, int startIndex, System::Globalization::CompareOptions options);
public virtual int IndexOf (string source, char value, int startIndex, System.Globalization.CompareOptions options);
public int IndexOf (string source, char value, int startIndex, System.Globalization.CompareOptions options);
abstract member IndexOf : string * char * int * System.Globalization.CompareOptions -> int
override this.IndexOf : string * char * int * System.Globalization.CompareOptions -> int
member this.IndexOf : string * char * int * System.Globalization.CompareOptions -> int
Public Overridable Function IndexOf (source As String, value As Char, startIndex As Integer, options As CompareOptions) As Integer
Public Function IndexOf (source As String, value As Char, startIndex As Integer, options As CompareOptions) As Integer
Parameters
- source
- String
The string to search.
- value
- Char
The character to locate within source
.
- startIndex
- Int32
The zero-based starting index of the search.
- options
- CompareOptions
A value that defines how source
and value
should be compared. options
is either the enumeration value Ordinal, or a bitwise combination of one or more of the following values: IgnoreCase, IgnoreSymbols, IgnoreNonSpace, IgnoreWidth, and IgnoreKanaType.
Returns
The zero-based index of the first occurrence of value
, if found, within the section of source
that extends from startIndex
to the end of source
, using the specified comparison options; otherwise, -1. Returns startIndex
if value
is an ignorable character.
Exceptions
source
is null
.
startIndex
is outside the range of valid indexes for source
.
options
contains an invalid CompareOptions value.
Examples
The following example determines the indexes of the first and last occurrences of a character or a substring within a portion of a string. Note that IndexOf and LastIndexOf are searching in different portions of the string, even with the same startIndex
parameter.
using namespace System;
using namespace System::Globalization;
void PrintMarker( String^ Prefix, int First, int Last )
{
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 )
{
// Creates an array of Char to hold the markers.
array<Char>^myCharArr = gcnew array<Char>(mySize + 1);
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[ First ] = 'f';
if ( Last > -1 )
myCharArr[ Last ] = 'l';
if ( First == Last )
myCharArr[ First ] = 'b';
// Displays the array of Char as a String.
Console::WriteLine( "{0}{1}", Prefix, gcnew String( myCharArr ) );
}
else
Console::WriteLine( Prefix );
}
int main()
{
// Creates CompareInfo for the InvariantCulture.
CompareInfo^ myComp = CultureInfo::InvariantCulture->CompareInfo;
// iS is the starting index of the substring.
int iS = 20;
// myT1 is the string used for padding.
String^ myT1;
// Searches for the ligature Æ.
String^ myStr = "Is AE or ae the same as Æ or æ?";
Console::WriteLine();
myT1 = gcnew String( '-',iS );
Console::WriteLine( "IndexOf( String, *, {0}, * )", iS );
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS ), -1 );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS ), -1 );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS ), -1 );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS ), -1 );
Console::WriteLine( "Ordinal : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, CompareOptions::Ordinal ), -1 );
Console::WriteLine( "IgnoreCase : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, CompareOptions::IgnoreCase ), -1 );
myT1 = gcnew String( '-',myStr->Length - iS - 1 );
Console::WriteLine( "LastIndexOf( String, *, {0}, * )", iS );
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp->LastIndexOf( myStr, "AE", iS ) );
PrintMarker( " ae : ", -1, myComp->LastIndexOf( myStr, "ae", iS ) );
PrintMarker( " Æ : ", -1, myComp->LastIndexOf( myStr, L'Æ', iS ) );
PrintMarker( " æ : ", -1, myComp->LastIndexOf( myStr, L'æ', iS ) );
Console::WriteLine( "Ordinal : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp->LastIndexOf( myStr, "AE", iS, CompareOptions::Ordinal ) );
PrintMarker( " ae : ", -1, myComp->LastIndexOf( myStr, "ae", iS, CompareOptions::Ordinal ) );
PrintMarker( " Æ : ", -1, myComp->LastIndexOf( myStr, L'Æ', iS, CompareOptions::Ordinal ) );
PrintMarker( " æ : ", -1, myComp->LastIndexOf( myStr, L'æ', iS, CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp->LastIndexOf( myStr, "AE", iS, CompareOptions::IgnoreCase ) );
PrintMarker( " ae : ", -1, myComp->LastIndexOf( myStr, "ae", iS, CompareOptions::IgnoreCase ) );
PrintMarker( " Æ : ", -1, myComp->LastIndexOf( myStr, L'Æ', iS, CompareOptions::IgnoreCase ) );
PrintMarker( " æ : ", -1, myComp->LastIndexOf( myStr, L'æ', iS, CompareOptions::IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is U\u0308 or u\u0308 the same as \u00DC or \u00FC?";
Console::WriteLine();
myT1 = gcnew String( '-',iS );
Console::WriteLine( "IndexOf( String, *, {0}, * )", iS );
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS ), -1 );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS ), -1 );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS ), -1 );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS ), -1 );
Console::WriteLine( "Ordinal : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, CompareOptions::Ordinal ), -1 );
Console::WriteLine( "IgnoreCase : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, CompareOptions::IgnoreCase ), -1 );
myT1 = gcnew String( '-',myStr->Length - iS - 1 );
Console::WriteLine( "LastIndexOf( String, *, {0}, * )", iS );
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp->LastIndexOf( myStr, "U\u0308", iS ) );
PrintMarker( " u\u0308 : ", -1, myComp->LastIndexOf( myStr, "u\u0308", iS ) );
PrintMarker( " Ü : ", -1, myComp->LastIndexOf( myStr, L'Ü', iS ) );
PrintMarker( " ü : ", -1, myComp->LastIndexOf( myStr, L'ü', iS ) );
Console::WriteLine( "Ordinal : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp->LastIndexOf( myStr, "U\u0308", iS, CompareOptions::Ordinal ) );
PrintMarker( " u\u0308 : ", -1, myComp->LastIndexOf( myStr, "u\u0308", iS, CompareOptions::Ordinal ) );
PrintMarker( " Ü : ", -1, myComp->LastIndexOf( myStr, L'Ü', iS, CompareOptions::Ordinal ) );
PrintMarker( " ü : ", -1, myComp->LastIndexOf( myStr, L'ü', iS, CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp->LastIndexOf( myStr, "U\u0308", iS, CompareOptions::IgnoreCase ) );
PrintMarker( " u\u0308 : ", -1, myComp->LastIndexOf( myStr, "u\u0308", iS, CompareOptions::IgnoreCase ) );
PrintMarker( " Ü : ", -1, myComp->LastIndexOf( myStr, L'Ü', iS, CompareOptions::IgnoreCase ) );
PrintMarker( " ü : ", -1, myComp->LastIndexOf( myStr, L'ü', iS, CompareOptions::IgnoreCase ) );
}
/*
This code produces the following output.
IndexOf( String, *, 20, * )
Original : Is AE or ae the same as Æ or æ?
No options : -------------------- as Æ or æ?
AE : f
ae : f
Æ : f
æ : f
Ordinal : -------------------- as Æ or æ?
AE :
ae :
Æ : f
æ : f
IgnoreCase : -------------------- as Æ or æ?
AE : f
ae : f
Æ : f
æ : f
LastIndexOf( String, *, 20, * )
Original : Is AE or ae the same as Æ or æ?
No options : Is AE or ae the same ----------
AE : l
ae : l
Æ : l
æ : l
Ordinal : Is AE or ae the same ----------
AE : l
ae : l
Æ :
æ :
IgnoreCase : Is AE or ae the same ----------
AE : l
ae : l
Æ : l
æ : l
IndexOf( String, *, 20, * )
Original : Is U" or u" the same as Ü or ü?
No options : -------------------- as Ü or ü?
U" : f
u" : f
Ü : f
ü : f
Ordinal : -------------------- as Ü or ü?
U" :
u" :
Ü : f
ü : f
IgnoreCase : -------------------- as Ü or ü?
U" : f
u" : f
Ü : f
ü : f
LastIndexOf( String, *, 20, * )
Original : Is U" or u" the same as Ü or ü?
No options : Is U" or u" the same ----------
U" : l
u" : l
Ü : l
ü : l
Ordinal : Is U" or u" the same ----------
U" : l
u" : l
Ü :
ü :
IgnoreCase : Is U" or u" the same ----------
U" : l
u" : l
Ü : l
ü : l
*/
using System;
using System.Globalization;
public class SamplesCompareInfo {
public static void Main() {
// Creates CompareInfo for the InvariantCulture.
CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;
// iS is the starting index of the substring.
int iS = 20;
// myT1 is the string used for padding.
String myT1;
// Searches for the ligature Æ.
String myStr = "Is AE or ae the same as Æ or æ?";
Console.WriteLine();
myT1 = new String( '-', iS );
Console.WriteLine( "IndexOf( String, *, {0}, * )", iS );
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS ), -1 );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS ), -1 );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS ), -1 );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS ), -1 );
Console.WriteLine( "Ordinal : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, CompareOptions.Ordinal ), -1 );
Console.WriteLine( "IgnoreCase : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, CompareOptions.IgnoreCase ), -1 );
myT1 = new String( '-', myStr.Length - iS - 1 );
Console.WriteLine( "LastIndexOf( String, *, {0}, * )", iS );
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp.LastIndexOf( myStr, "AE", iS ) );
PrintMarker( " ae : ", -1, myComp.LastIndexOf( myStr, "ae", iS ) );
PrintMarker( " Æ : ", -1, myComp.LastIndexOf( myStr, 'Æ', iS ) );
PrintMarker( " æ : ", -1, myComp.LastIndexOf( myStr, 'æ', iS ) );
Console.WriteLine( "Ordinal : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp.LastIndexOf( myStr, "AE", iS, CompareOptions.Ordinal ) );
PrintMarker( " ae : ", -1, myComp.LastIndexOf( myStr, "ae", iS, CompareOptions.Ordinal ) );
PrintMarker( " Æ : ", -1, myComp.LastIndexOf( myStr, 'Æ', iS, CompareOptions.Ordinal ) );
PrintMarker( " æ : ", -1, myComp.LastIndexOf( myStr, 'æ', iS, CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp.LastIndexOf( myStr, "AE", iS, CompareOptions.IgnoreCase ) );
PrintMarker( " ae : ", -1, myComp.LastIndexOf( myStr, "ae", iS, CompareOptions.IgnoreCase ) );
PrintMarker( " Æ : ", -1, myComp.LastIndexOf( myStr, 'Æ', iS, CompareOptions.IgnoreCase ) );
PrintMarker( " æ : ", -1, myComp.LastIndexOf( myStr, 'æ', iS, CompareOptions.IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is \u0055\u0308 or \u0075\u0308 the same as \u00DC or \u00FC?";
Console.WriteLine();
myT1 = new String( '-', iS );
Console.WriteLine( "IndexOf( String, *, {0}, * )", iS );
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS ), -1 );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS ), -1 );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS ), -1 );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS ), -1 );
Console.WriteLine( "Ordinal : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, CompareOptions.Ordinal ), -1 );
Console.WriteLine( "IgnoreCase : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, CompareOptions.IgnoreCase ), -1 );
myT1 = new String( '-', myStr.Length - iS - 1 );
Console.WriteLine( "LastIndexOf( String, *, {0}, * )", iS );
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp.LastIndexOf( myStr, "U\u0308", iS ) );
PrintMarker( " u\u0308 : ", -1, myComp.LastIndexOf( myStr, "u\u0308", iS ) );
PrintMarker( " Ü : ", -1, myComp.LastIndexOf( myStr, 'Ü', iS ) );
PrintMarker( " ü : ", -1, myComp.LastIndexOf( myStr, 'ü', iS ) );
Console.WriteLine( "Ordinal : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp.LastIndexOf( myStr, "U\u0308", iS, CompareOptions.Ordinal ) );
PrintMarker( " u\u0308 : ", -1, myComp.LastIndexOf( myStr, "u\u0308", iS, CompareOptions.Ordinal ) );
PrintMarker( " Ü : ", -1, myComp.LastIndexOf( myStr, 'Ü', iS, CompareOptions.Ordinal ) );
PrintMarker( " ü : ", -1, myComp.LastIndexOf( myStr, 'ü', iS, CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp.LastIndexOf( myStr, "U\u0308", iS, CompareOptions.IgnoreCase ) );
PrintMarker( " u\u0308 : ", -1, myComp.LastIndexOf( myStr, "u\u0308", iS, CompareOptions.IgnoreCase ) );
PrintMarker( " Ü : ", -1, myComp.LastIndexOf( myStr, 'Ü', iS, CompareOptions.IgnoreCase ) );
PrintMarker( " ü : ", -1, myComp.LastIndexOf( myStr, 'ü', iS, CompareOptions.IgnoreCase ) );
}
public static void PrintMarker( String Prefix, int First, int Last ) {
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 ) {
// Creates an array of Char to hold the markers.
Char[] myCharArr = new Char[mySize+1];
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[First] = 'f';
if ( Last > -1 )
myCharArr[Last] = 'l';
if ( First == Last )
myCharArr[First] = 'b';
// Displays the array of Char as a String.
Console.WriteLine( "{0}{1}", Prefix, new String( myCharArr ) );
}
else
{
Console.WriteLine( Prefix );
}
}
}
/*
This code produces the following output.
IndexOf( String, *, 20, * )
Original : Is AE or ae the same as Æ or æ?
No options : -------------------- as Æ or æ?
AE : f
ae : f
Æ : f
æ : f
Ordinal : -------------------- as Æ or æ?
AE :
ae :
Æ : f
æ : f
IgnoreCase : -------------------- as Æ or æ?
AE : f
ae : f
Æ : f
æ : f
LastIndexOf( String, *, 20, * )
Original : Is AE or ae the same as Æ or æ?
No options : Is AE or ae the same ----------
AE : l
ae : l
Æ : l
æ : l
Ordinal : Is AE or ae the same ----------
AE : l
ae : l
Æ :
æ :
IgnoreCase : Is AE or ae the same ----------
AE : l
ae : l
Æ : l
æ : l
IndexOf( String, *, 20, * )
Original : Is U" or u" the same as Ü or ü?
No options : -------------------- as Ü or ü?
U" : f
u" : f
Ü : f
ü : f
Ordinal : -------------------- as Ü or ü?
U" :
u" :
Ü : f
ü : f
IgnoreCase : -------------------- as Ü or ü?
U" : f
u" : f
Ü : f
ü : f
LastIndexOf( String, *, 20, * )
Original : Is U" or u" the same as Ü or ü?
No options : Is U" or u" the same ----------
U" : l
u" : l
Ü : l
ü : l
Ordinal : Is U" or u" the same ----------
U" : l
u" : l
Ü :
ü :
IgnoreCase : Is U" or u" the same ----------
U" : l
u" : l
Ü : l
ü : l
*/
Imports System.Globalization
Public Class SamplesCompareInfo
Public Shared Sub Main()
' Creates CompareInfo for the InvariantCulture.
Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
' iS is the starting index of the substring.
Dim [iS] As Integer = 20
' myT1 is the string used for padding.
Dim myT1 As [String]
' Searches for the ligature Æ.
Dim myStr As [String] = "Is AE or ae the same as Æ or æ?"
Console.WriteLine()
myT1 = New [String]("-"c, [iS])
Console.WriteLine("IndexOf( String, *, {0}, * )", [iS])
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS]), - 1)
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS]), - 1)
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS]), - 1)
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS]), - 1)
Console.WriteLine("Ordinal : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], CompareOptions.Ordinal), - 1)
Console.WriteLine("IgnoreCase : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], CompareOptions.IgnoreCase), - 1)
myT1 = New [String]("-"c, myStr.Length - [iS] - 1)
Console.WriteLine("LastIndexOf( String, *, {0}, * )", [iS])
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" AE : ", - 1, myComp.LastIndexOf(myStr, "AE", [iS]))
PrintMarker(" ae : ", - 1, myComp.LastIndexOf(myStr, "ae", [iS]))
PrintMarker(" Æ : ", - 1, myComp.LastIndexOf(myStr, "Æ"c, [iS]))
PrintMarker(" æ : ", - 1, myComp.LastIndexOf(myStr, "æ"c, [iS]))
Console.WriteLine("Ordinal : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" AE : ", - 1, myComp.LastIndexOf(myStr, "AE", [iS], CompareOptions.Ordinal))
PrintMarker(" ae : ", - 1, myComp.LastIndexOf(myStr, "ae", [iS], CompareOptions.Ordinal))
PrintMarker(" Æ : ", - 1, myComp.LastIndexOf(myStr, "Æ"c, [iS], CompareOptions.Ordinal))
PrintMarker(" æ : ", - 1, myComp.LastIndexOf(myStr, "æ"c, [iS], CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" AE : ", - 1, myComp.LastIndexOf(myStr, "AE", [iS], CompareOptions.IgnoreCase))
PrintMarker(" ae : ", - 1, myComp.LastIndexOf(myStr, "ae", [iS], CompareOptions.IgnoreCase))
PrintMarker(" Æ : ", - 1, myComp.LastIndexOf(myStr, "Æ"c, [iS], CompareOptions.IgnoreCase))
PrintMarker(" æ : ", - 1, myComp.LastIndexOf(myStr, "æ"c, [iS], CompareOptions.IgnoreCase))
' Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is " & ChrW(&H0055) & ChrW(&H0308) & " or " & ChrW(&H0075) & ChrW(&H0308) & " the same as " & ChrW(&H00DC) & " or " & ChrW(&H00FC) & "?"
Console.WriteLine()
myT1 = New [String]("-"c, [iS])
Console.WriteLine("IndexOf( String, *, {0}, * )", [iS])
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS]), - 1)
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS]), - 1)
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS]), - 1)
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS]), - 1)
Console.WriteLine("Ordinal : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], CompareOptions.Ordinal), - 1)
Console.WriteLine("IgnoreCase : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], CompareOptions.IgnoreCase), - 1)
myT1 = New [String]("-"c, myStr.Length - [iS] - 1)
Console.WriteLine("LastIndexOf( String, *, {0}, * )", [iS])
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" U" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS]))
PrintMarker(" u" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS]))
PrintMarker(" Ü : ", - 1, myComp.LastIndexOf(myStr, "Ü"c, [iS]))
PrintMarker(" ü : ", - 1, myComp.LastIndexOf(myStr, "ü"c, [iS]))
Console.WriteLine("Ordinal : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" U" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS], CompareOptions.Ordinal))
PrintMarker(" u" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS], CompareOptions.Ordinal))
PrintMarker(" Ü : ", - 1, myComp.LastIndexOf(myStr, "Ü"c, [iS], CompareOptions.Ordinal))
PrintMarker(" ü : ", - 1, myComp.LastIndexOf(myStr, "ü"c, [iS], CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" U" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS], CompareOptions.IgnoreCase))
PrintMarker(" u" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS], CompareOptions.IgnoreCase))
PrintMarker(" Ü : ", - 1, myComp.LastIndexOf(myStr, "Ü"c, [iS], CompareOptions.IgnoreCase))
PrintMarker(" ü : ", - 1, myComp.LastIndexOf(myStr, "ü"c, [iS], CompareOptions.IgnoreCase))
End Sub
Public Shared Sub PrintMarker(Prefix As [String], First As Integer, Last As Integer)
' Determines the size of the array to create.
Dim mySize As Integer
If Last > First Then
mySize = Last
Else
mySize = First
End If
If mySize > - 1 Then
' Creates an array of Char to hold the markers.
Dim myCharArr(mySize + 1) As [Char]
' Inserts the appropriate markers.
If First > - 1 Then
myCharArr(First) = "f"c
End If
If Last > - 1 Then
myCharArr(Last) = "l"c
End If
If First = Last Then
myCharArr(First) = "b"c
End If
' Displays the array of Char as a String.
Console.WriteLine("{0}{1}", Prefix, New [String](myCharArr))
Else
Console.WriteLine(Prefix)
End If
End Sub
End Class
'This code produces the following output.
'
'IndexOf( String, *, 20, * )
'Original : Is AE or ae the same as Æ or æ?
'No options : -------------------- as Æ or æ?
' AE : f
' ae : f
' Æ : f
' æ : f
'Ordinal : -------------------- as Æ or æ?
' AE :
' ae :
' Æ : f
' æ : f
'IgnoreCase : -------------------- as Æ or æ?
' AE : f
' ae : f
' Æ : f
' æ : f
'LastIndexOf( String, *, 20, * )
'Original : Is AE or ae the same as Æ or æ?
'No options : Is AE or ae the same ----------
' AE : l
' ae : l
' Æ : l
' æ : l
'Ordinal : Is AE or ae the same ----------
' AE : l
' ae : l
' Æ :
' æ :
'IgnoreCase : Is AE or ae the same ----------
' AE : l
' ae : l
' Æ : l
' æ : l
'
'IndexOf( String, *, 20, * )
'Original : Is U" or u" the same as Ü or ü?
'No options : -------------------- as Ü or ü?
' U" : f
' u" : f
' Ü : f
' ü : f
'Ordinal : -------------------- as Ü or ü?
' U" :
' u" :
' Ü : f
' ü : f
'IgnoreCase : -------------------- as Ü or ü?
' U" : f
' u" : f
' Ü : f
' ü : f
'LastIndexOf( String, *, 20, * )
'Original : Is U" or u" the same as Ü or ü?
'No options : Is U" or u" the same ----------
' U" : l
' u" : l
' Ü : l
' ü : l
'Ordinal : Is U" or u" the same ----------
' U" : l
' u" : l
' Ü :
' ü :
'IgnoreCase : Is U" or u" the same ----------
' U" : l
' u" : l
' Ü : l
' ü : l
Remarks
The source string is searched forward starting at startIndex
and ending at the end of the string.
The CompareOptions.StringSort value is not valid for this method.
If options
does not include the Ordinal value, this overload performs a culture-sensitive search. If the character is a Unicode value representing a precomposed character, such as the ligature "Æ" (U+00C6), it might be considered equivalent to any occurrence of its components in the correct sequence, such as "AE" (U+0041, U+0045), depending on the culture. If options
includes the Ordinal value, this overload performs an ordinal (culture-insensitive) search. A character is considered equivalent to another character only if the Unicode values are the same. Overloads of String.IndexOf that search for a character perform an ordinal search, whereas those that search for a string perform a culture-sensitive search.
Note
When possible, you should call string comparison methods that have a parameter of type CompareOptions to specify the kind of comparison expected. As a general rule, use linguistic options (using the current culture) for comparing strings displayed in the user interface and specify CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase for security comparisons.
Notes to Callers
Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive sort. In a culture-sensitive search, if value
is an ignorable character, the result is equivalent to searching with that character removed. In this case, the IndexOf(String, Char, Int32, CompareOptions) method always returns startIndex
, the character position at which the search first began. In the following example, the IndexOf(String, Char, Int32, CompareOptions) method is used to find the soft hyphen (U+00AD) after an "n" in two strings. Only one of the strings contains a soft hyphen. In both cases, because the soft hyphen is an ignorable character, a culture-sensitive search returns 1 to indicate that it has found a match at the position of the "n". An ordinal search, however, successfully finds the soft hyphen in one string and reports that it is absent from the second string.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;
string s1 = "ani\u00ADmal";
string s2 = "animal";
int position = 0;
// Find the index of the soft hyphen using culture-sensitive comparison.
position = ci.IndexOf(s1, 'n');
Console.WriteLine("'n' at position {0}", position);
if (position >= 0)
Console.WriteLine(ci.IndexOf(s1, '\u00AD', position, CompareOptions.IgnoreCase));
position = ci.IndexOf(s2, 'n');
Console.WriteLine("'n' at position {0}", position);
if (position >= 0)
Console.WriteLine(ci.IndexOf(s2, '\u00AD', position, CompareOptions.IgnoreCase));
// Find the index of the soft hyphen using ordinal comparison.
position = ci.IndexOf(s1, 'n');
Console.WriteLine("'n' at position {0}", position, CompareOptions.Ordinal);
if (position >= 0)
Console.WriteLine(ci.IndexOf(s1, '\u00AD', position, CompareOptions.Ordinal));
position = ci.IndexOf(s2, 'n');
Console.WriteLine("'n' at position {0}", position, CompareOptions.Ordinal);
if (position >= 0)
Console.WriteLine(ci.IndexOf(s2, '\u00AD', position, CompareOptions.Ordinal));
}
}
// The example displays the following output:
// 'n' at position 1
// 1
// 'n' at position 1
// 1
// 'n' at position 1
// 3
// 'n' at position 1
// -1
Imports System.Globalization
Module Example
Public Sub Main()
Dim ci As CompareInfo = CultureInfo.CurrentCulture.CompareInfo
Dim softHyphen As Char = ChrW(&h00AD)
Dim position As Integer
Dim s1 As String = "ani" + softHyphen + "mal"
Dim s2 As String = "animal"
' Find the index of the soft hyphen using culture-sensitive comparison.
position = ci.IndexOf(s1, "n"c)
Console.WriteLine("'n' at position {0}", position)
If position >= 0 Then
Console.WriteLine(ci.IndexOf(s1, softHyphen, position, CompareOptions.IgnoreCase))
End If
position = ci.IndexOf(s2, "n"c)
Console.WriteLine("'n' at position {0}", position)
If position >= 0 Then
Console.WriteLine(ci.IndexOf(s2, softHyphen, position, CompareOptions.IgnoreCase))
End If
' Find the index of the soft hyphen using ordinal comparison.
position = ci.IndexOf(s1, "n"c)
Console.WriteLine("'n' at position {0}", position)
If position >= 0 Then
Console.WriteLine(ci.IndexOf(s1, softHyphen, position, CompareOptions.Ordinal))
End If
position = ci.IndexOf(s2, "n"c)
Console.WriteLine("'n' at position {0}", position)
If position >= 0 Then
Console.WriteLine(ci.IndexOf(s2, softHyphen, position, CompareOptions.Ordinal))
End If
End Sub
End Module
' The example displays the following output:
' 'n' at position 1
' 1
' 'n' at position 1
' 1
' 'n' at position 1
' 3
' 'n' at position 1
' -1
See also
Applies to
IndexOf(String, String, Int32)
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Searches for the specified substring and returns the zero-based index of the first occurrence within the section of the source string that extends from the specified index to the end of the string.
public:
int IndexOf(System::String ^ source, System::String ^ value, int startIndex);
public:
virtual int IndexOf(System::String ^ source, System::String ^ value, int startIndex);
public int IndexOf (string source, string value, int startIndex);
public virtual int IndexOf (string source, string value, int startIndex);
member this.IndexOf : string * string * int -> int
abstract member IndexOf : string * string * int -> int
override this.IndexOf : string * string * int -> int
Public Function IndexOf (source As String, value As String, startIndex As Integer) As Integer
Public Overridable Function IndexOf (source As String, value As String, startIndex As Integer) As Integer
Parameters
- source
- String
The string to search.
- value
- String
The string to locate within source
.
- startIndex
- Int32
The zero-based starting index of the search.
Returns
The zero-based index of the first occurrence of value
, if found, within the section of source
that extends from startIndex
to the end of source
; otherwise, -1. Returns startIndex
if value
is an ignorable character.
Exceptions
startIndex
is outside the range of valid indexes for source
.
Examples
The following example determines the indexes of the first and last occurrences of a character or a substring within a portion of a string. Note that IndexOf and LastIndexOf are searching in different portions of the string, even with the same startIndex
parameter.
using namespace System;
using namespace System::Globalization;
void PrintMarker( String^ Prefix, int First, int Last )
{
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 )
{
// Creates an array of Char to hold the markers.
array<Char>^myCharArr = gcnew array<Char>(mySize + 1);
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[ First ] = 'f';
if ( Last > -1 )
myCharArr[ Last ] = 'l';
if ( First == Last )
myCharArr[ First ] = 'b';
// Displays the array of Char as a String.
Console::WriteLine( "{0}{1}", Prefix, gcnew String( myCharArr ) );
}
else
Console::WriteLine( Prefix );
}
int main()
{
// Creates CompareInfo for the InvariantCulture.
CompareInfo^ myComp = CultureInfo::InvariantCulture->CompareInfo;
// iS is the starting index of the substring.
int iS = 20;
// myT1 is the string used for padding.
String^ myT1;
// Searches for the ligature Æ.
String^ myStr = "Is AE or ae the same as Æ or æ?";
Console::WriteLine();
myT1 = gcnew String( '-',iS );
Console::WriteLine( "IndexOf( String, *, {0}, * )", iS );
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS ), -1 );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS ), -1 );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS ), -1 );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS ), -1 );
Console::WriteLine( "Ordinal : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, CompareOptions::Ordinal ), -1 );
Console::WriteLine( "IgnoreCase : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, CompareOptions::IgnoreCase ), -1 );
myT1 = gcnew String( '-',myStr->Length - iS - 1 );
Console::WriteLine( "LastIndexOf( String, *, {0}, * )", iS );
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp->LastIndexOf( myStr, "AE", iS ) );
PrintMarker( " ae : ", -1, myComp->LastIndexOf( myStr, "ae", iS ) );
PrintMarker( " Æ : ", -1, myComp->LastIndexOf( myStr, L'Æ', iS ) );
PrintMarker( " æ : ", -1, myComp->LastIndexOf( myStr, L'æ', iS ) );
Console::WriteLine( "Ordinal : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp->LastIndexOf( myStr, "AE", iS, CompareOptions::Ordinal ) );
PrintMarker( " ae : ", -1, myComp->LastIndexOf( myStr, "ae", iS, CompareOptions::Ordinal ) );
PrintMarker( " Æ : ", -1, myComp->LastIndexOf( myStr, L'Æ', iS, CompareOptions::Ordinal ) );
PrintMarker( " æ : ", -1, myComp->LastIndexOf( myStr, L'æ', iS, CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp->LastIndexOf( myStr, "AE", iS, CompareOptions::IgnoreCase ) );
PrintMarker( " ae : ", -1, myComp->LastIndexOf( myStr, "ae", iS, CompareOptions::IgnoreCase ) );
PrintMarker( " Æ : ", -1, myComp->LastIndexOf( myStr, L'Æ', iS, CompareOptions::IgnoreCase ) );
PrintMarker( " æ : ", -1, myComp->LastIndexOf( myStr, L'æ', iS, CompareOptions::IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is U\u0308 or u\u0308 the same as \u00DC or \u00FC?";
Console::WriteLine();
myT1 = gcnew String( '-',iS );
Console::WriteLine( "IndexOf( String, *, {0}, * )", iS );
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS ), -1 );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS ), -1 );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS ), -1 );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS ), -1 );
Console::WriteLine( "Ordinal : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, CompareOptions::Ordinal ), -1 );
Console::WriteLine( "IgnoreCase : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, CompareOptions::IgnoreCase ), -1 );
myT1 = gcnew String( '-',myStr->Length - iS - 1 );
Console::WriteLine( "LastIndexOf( String, *, {0}, * )", iS );
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp->LastIndexOf( myStr, "U\u0308", iS ) );
PrintMarker( " u\u0308 : ", -1, myComp->LastIndexOf( myStr, "u\u0308", iS ) );
PrintMarker( " Ü : ", -1, myComp->LastIndexOf( myStr, L'Ü', iS ) );
PrintMarker( " ü : ", -1, myComp->LastIndexOf( myStr, L'ü', iS ) );
Console::WriteLine( "Ordinal : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp->LastIndexOf( myStr, "U\u0308", iS, CompareOptions::Ordinal ) );
PrintMarker( " u\u0308 : ", -1, myComp->LastIndexOf( myStr, "u\u0308", iS, CompareOptions::Ordinal ) );
PrintMarker( " Ü : ", -1, myComp->LastIndexOf( myStr, L'Ü', iS, CompareOptions::Ordinal ) );
PrintMarker( " ü : ", -1, myComp->LastIndexOf( myStr, L'ü', iS, CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp->LastIndexOf( myStr, "U\u0308", iS, CompareOptions::IgnoreCase ) );
PrintMarker( " u\u0308 : ", -1, myComp->LastIndexOf( myStr, "u\u0308", iS, CompareOptions::IgnoreCase ) );
PrintMarker( " Ü : ", -1, myComp->LastIndexOf( myStr, L'Ü', iS, CompareOptions::IgnoreCase ) );
PrintMarker( " ü : ", -1, myComp->LastIndexOf( myStr, L'ü', iS, CompareOptions::IgnoreCase ) );
}
/*
This code produces the following output.
IndexOf( String, *, 20, * )
Original : Is AE or ae the same as Æ or æ?
No options : -------------------- as Æ or æ?
AE : f
ae : f
Æ : f
æ : f
Ordinal : -------------------- as Æ or æ?
AE :
ae :
Æ : f
æ : f
IgnoreCase : -------------------- as Æ or æ?
AE : f
ae : f
Æ : f
æ : f
LastIndexOf( String, *, 20, * )
Original : Is AE or ae the same as Æ or æ?
No options : Is AE or ae the same ----------
AE : l
ae : l
Æ : l
æ : l
Ordinal : Is AE or ae the same ----------
AE : l
ae : l
Æ :
æ :
IgnoreCase : Is AE or ae the same ----------
AE : l
ae : l
Æ : l
æ : l
IndexOf( String, *, 20, * )
Original : Is U" or u" the same as Ü or ü?
No options : -------------------- as Ü or ü?
U" : f
u" : f
Ü : f
ü : f
Ordinal : -------------------- as Ü or ü?
U" :
u" :
Ü : f
ü : f
IgnoreCase : -------------------- as Ü or ü?
U" : f
u" : f
Ü : f
ü : f
LastIndexOf( String, *, 20, * )
Original : Is U" or u" the same as Ü or ü?
No options : Is U" or u" the same ----------
U" : l
u" : l
Ü : l
ü : l
Ordinal : Is U" or u" the same ----------
U" : l
u" : l
Ü :
ü :
IgnoreCase : Is U" or u" the same ----------
U" : l
u" : l
Ü : l
ü : l
*/
using System;
using System.Globalization;
public class SamplesCompareInfo {
public static void Main() {
// Creates CompareInfo for the InvariantCulture.
CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;
// iS is the starting index of the substring.
int iS = 20;
// myT1 is the string used for padding.
String myT1;
// Searches for the ligature Æ.
String myStr = "Is AE or ae the same as Æ or æ?";
Console.WriteLine();
myT1 = new String( '-', iS );
Console.WriteLine( "IndexOf( String, *, {0}, * )", iS );
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS ), -1 );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS ), -1 );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS ), -1 );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS ), -1 );
Console.WriteLine( "Ordinal : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, CompareOptions.Ordinal ), -1 );
Console.WriteLine( "IgnoreCase : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, CompareOptions.IgnoreCase ), -1 );
myT1 = new String( '-', myStr.Length - iS - 1 );
Console.WriteLine( "LastIndexOf( String, *, {0}, * )", iS );
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp.LastIndexOf( myStr, "AE", iS ) );
PrintMarker( " ae : ", -1, myComp.LastIndexOf( myStr, "ae", iS ) );
PrintMarker( " Æ : ", -1, myComp.LastIndexOf( myStr, 'Æ', iS ) );
PrintMarker( " æ : ", -1, myComp.LastIndexOf( myStr, 'æ', iS ) );
Console.WriteLine( "Ordinal : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp.LastIndexOf( myStr, "AE", iS, CompareOptions.Ordinal ) );
PrintMarker( " ae : ", -1, myComp.LastIndexOf( myStr, "ae", iS, CompareOptions.Ordinal ) );
PrintMarker( " Æ : ", -1, myComp.LastIndexOf( myStr, 'Æ', iS, CompareOptions.Ordinal ) );
PrintMarker( " æ : ", -1, myComp.LastIndexOf( myStr, 'æ', iS, CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp.LastIndexOf( myStr, "AE", iS, CompareOptions.IgnoreCase ) );
PrintMarker( " ae : ", -1, myComp.LastIndexOf( myStr, "ae", iS, CompareOptions.IgnoreCase ) );
PrintMarker( " Æ : ", -1, myComp.LastIndexOf( myStr, 'Æ', iS, CompareOptions.IgnoreCase ) );
PrintMarker( " æ : ", -1, myComp.LastIndexOf( myStr, 'æ', iS, CompareOptions.IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is \u0055\u0308 or \u0075\u0308 the same as \u00DC or \u00FC?";
Console.WriteLine();
myT1 = new String( '-', iS );
Console.WriteLine( "IndexOf( String, *, {0}, * )", iS );
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS ), -1 );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS ), -1 );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS ), -1 );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS ), -1 );
Console.WriteLine( "Ordinal : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, CompareOptions.Ordinal ), -1 );
Console.WriteLine( "IgnoreCase : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, CompareOptions.IgnoreCase ), -1 );
myT1 = new String( '-', myStr.Length - iS - 1 );
Console.WriteLine( "LastIndexOf( String, *, {0}, * )", iS );
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp.LastIndexOf( myStr, "U\u0308", iS ) );
PrintMarker( " u\u0308 : ", -1, myComp.LastIndexOf( myStr, "u\u0308", iS ) );
PrintMarker( " Ü : ", -1, myComp.LastIndexOf( myStr, 'Ü', iS ) );
PrintMarker( " ü : ", -1, myComp.LastIndexOf( myStr, 'ü', iS ) );
Console.WriteLine( "Ordinal : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp.LastIndexOf( myStr, "U\u0308", iS, CompareOptions.Ordinal ) );
PrintMarker( " u\u0308 : ", -1, myComp.LastIndexOf( myStr, "u\u0308", iS, CompareOptions.Ordinal ) );
PrintMarker( " Ü : ", -1, myComp.LastIndexOf( myStr, 'Ü', iS, CompareOptions.Ordinal ) );
PrintMarker( " ü : ", -1, myComp.LastIndexOf( myStr, 'ü', iS, CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp.LastIndexOf( myStr, "U\u0308", iS, CompareOptions.IgnoreCase ) );
PrintMarker( " u\u0308 : ", -1, myComp.LastIndexOf( myStr, "u\u0308", iS, CompareOptions.IgnoreCase ) );
PrintMarker( " Ü : ", -1, myComp.LastIndexOf( myStr, 'Ü', iS, CompareOptions.IgnoreCase ) );
PrintMarker( " ü : ", -1, myComp.LastIndexOf( myStr, 'ü', iS, CompareOptions.IgnoreCase ) );
}
public static void PrintMarker( String Prefix, int First, int Last ) {
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 ) {
// Creates an array of Char to hold the markers.
Char[] myCharArr = new Char[mySize+1];
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[First] = 'f';
if ( Last > -1 )
myCharArr[Last] = 'l';
if ( First == Last )
myCharArr[First] = 'b';
// Displays the array of Char as a String.
Console.WriteLine( "{0}{1}", Prefix, new String( myCharArr ) );
}
else
{
Console.WriteLine( Prefix );
}
}
}
/*
This code produces the following output.
IndexOf( String, *, 20, * )
Original : Is AE or ae the same as Æ or æ?
No options : -------------------- as Æ or æ?
AE : f
ae : f
Æ : f
æ : f
Ordinal : -------------------- as Æ or æ?
AE :
ae :
Æ : f
æ : f
IgnoreCase : -------------------- as Æ or æ?
AE : f
ae : f
Æ : f
æ : f
LastIndexOf( String, *, 20, * )
Original : Is AE or ae the same as Æ or æ?
No options : Is AE or ae the same ----------
AE : l
ae : l
Æ : l
æ : l
Ordinal : Is AE or ae the same ----------
AE : l
ae : l
Æ :
æ :
IgnoreCase : Is AE or ae the same ----------
AE : l
ae : l
Æ : l
æ : l
IndexOf( String, *, 20, * )
Original : Is U" or u" the same as Ü or ü?
No options : -------------------- as Ü or ü?
U" : f
u" : f
Ü : f
ü : f
Ordinal : -------------------- as Ü or ü?
U" :
u" :
Ü : f
ü : f
IgnoreCase : -------------------- as Ü or ü?
U" : f
u" : f
Ü : f
ü : f
LastIndexOf( String, *, 20, * )
Original : Is U" or u" the same as Ü or ü?
No options : Is U" or u" the same ----------
U" : l
u" : l
Ü : l
ü : l
Ordinal : Is U" or u" the same ----------
U" : l
u" : l
Ü :
ü :
IgnoreCase : Is U" or u" the same ----------
U" : l
u" : l
Ü : l
ü : l
*/
Imports System.Globalization
Public Class SamplesCompareInfo
Public Shared Sub Main()
' Creates CompareInfo for the InvariantCulture.
Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
' iS is the starting index of the substring.
Dim [iS] As Integer = 20
' myT1 is the string used for padding.
Dim myT1 As [String]
' Searches for the ligature Æ.
Dim myStr As [String] = "Is AE or ae the same as Æ or æ?"
Console.WriteLine()
myT1 = New [String]("-"c, [iS])
Console.WriteLine("IndexOf( String, *, {0}, * )", [iS])
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS]), - 1)
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS]), - 1)
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS]), - 1)
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS]), - 1)
Console.WriteLine("Ordinal : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], CompareOptions.Ordinal), - 1)
Console.WriteLine("IgnoreCase : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], CompareOptions.IgnoreCase), - 1)
myT1 = New [String]("-"c, myStr.Length - [iS] - 1)
Console.WriteLine("LastIndexOf( String, *, {0}, * )", [iS])
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" AE : ", - 1, myComp.LastIndexOf(myStr, "AE", [iS]))
PrintMarker(" ae : ", - 1, myComp.LastIndexOf(myStr, "ae", [iS]))
PrintMarker(" Æ : ", - 1, myComp.LastIndexOf(myStr, "Æ"c, [iS]))
PrintMarker(" æ : ", - 1, myComp.LastIndexOf(myStr, "æ"c, [iS]))
Console.WriteLine("Ordinal : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" AE : ", - 1, myComp.LastIndexOf(myStr, "AE", [iS], CompareOptions.Ordinal))
PrintMarker(" ae : ", - 1, myComp.LastIndexOf(myStr, "ae", [iS], CompareOptions.Ordinal))
PrintMarker(" Æ : ", - 1, myComp.LastIndexOf(myStr, "Æ"c, [iS], CompareOptions.Ordinal))
PrintMarker(" æ : ", - 1, myComp.LastIndexOf(myStr, "æ"c, [iS], CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" AE : ", - 1, myComp.LastIndexOf(myStr, "AE", [iS], CompareOptions.IgnoreCase))
PrintMarker(" ae : ", - 1, myComp.LastIndexOf(myStr, "ae", [iS], CompareOptions.IgnoreCase))
PrintMarker(" Æ : ", - 1, myComp.LastIndexOf(myStr, "Æ"c, [iS], CompareOptions.IgnoreCase))
PrintMarker(" æ : ", - 1, myComp.LastIndexOf(myStr, "æ"c, [iS], CompareOptions.IgnoreCase))
' Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is " & ChrW(&H0055) & ChrW(&H0308) & " or " & ChrW(&H0075) & ChrW(&H0308) & " the same as " & ChrW(&H00DC) & " or " & ChrW(&H00FC) & "?"
Console.WriteLine()
myT1 = New [String]("-"c, [iS])
Console.WriteLine("IndexOf( String, *, {0}, * )", [iS])
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS]), - 1)
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS]), - 1)
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS]), - 1)
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS]), - 1)
Console.WriteLine("Ordinal : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], CompareOptions.Ordinal), - 1)
Console.WriteLine("IgnoreCase : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], CompareOptions.IgnoreCase), - 1)
myT1 = New [String]("-"c, myStr.Length - [iS] - 1)
Console.WriteLine("LastIndexOf( String, *, {0}, * )", [iS])
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" U" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS]))
PrintMarker(" u" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS]))
PrintMarker(" Ü : ", - 1, myComp.LastIndexOf(myStr, "Ü"c, [iS]))
PrintMarker(" ü : ", - 1, myComp.LastIndexOf(myStr, "ü"c, [iS]))
Console.WriteLine("Ordinal : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" U" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS], CompareOptions.Ordinal))
PrintMarker(" u" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS], CompareOptions.Ordinal))
PrintMarker(" Ü : ", - 1, myComp.LastIndexOf(myStr, "Ü"c, [iS], CompareOptions.Ordinal))
PrintMarker(" ü : ", - 1, myComp.LastIndexOf(myStr, "ü"c, [iS], CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" U" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS], CompareOptions.IgnoreCase))
PrintMarker(" u" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS], CompareOptions.IgnoreCase))
PrintMarker(" Ü : ", - 1, myComp.LastIndexOf(myStr, "Ü"c, [iS], CompareOptions.IgnoreCase))
PrintMarker(" ü : ", - 1, myComp.LastIndexOf(myStr, "ü"c, [iS], CompareOptions.IgnoreCase))
End Sub
Public Shared Sub PrintMarker(Prefix As [String], First As Integer, Last As Integer)
' Determines the size of the array to create.
Dim mySize As Integer
If Last > First Then
mySize = Last
Else
mySize = First
End If
If mySize > - 1 Then
' Creates an array of Char to hold the markers.
Dim myCharArr(mySize + 1) As [Char]
' Inserts the appropriate markers.
If First > - 1 Then
myCharArr(First) = "f"c
End If
If Last > - 1 Then
myCharArr(Last) = "l"c
End If
If First = Last Then
myCharArr(First) = "b"c
End If
' Displays the array of Char as a String.
Console.WriteLine("{0}{1}", Prefix, New [String](myCharArr))
Else
Console.WriteLine(Prefix)
End If
End Sub
End Class
'This code produces the following output.
'
'IndexOf( String, *, 20, * )
'Original : Is AE or ae the same as Æ or æ?
'No options : -------------------- as Æ or æ?
' AE : f
' ae : f
' Æ : f
' æ : f
'Ordinal : -------------------- as Æ or æ?
' AE :
' ae :
' Æ : f
' æ : f
'IgnoreCase : -------------------- as Æ or æ?
' AE : f
' ae : f
' Æ : f
' æ : f
'LastIndexOf( String, *, 20, * )
'Original : Is AE or ae the same as Æ or æ?
'No options : Is AE or ae the same ----------
' AE : l
' ae : l
' Æ : l
' æ : l
'Ordinal : Is AE or ae the same ----------
' AE : l
' ae : l
' Æ :
' æ :
'IgnoreCase : Is AE or ae the same ----------
' AE : l
' ae : l
' Æ : l
' æ : l
'
'IndexOf( String, *, 20, * )
'Original : Is U" or u" the same as Ü or ü?
'No options : -------------------- as Ü or ü?
' U" : f
' u" : f
' Ü : f
' ü : f
'Ordinal : -------------------- as Ü or ü?
' U" :
' u" :
' Ü : f
' ü : f
'IgnoreCase : -------------------- as Ü or ü?
' U" : f
' u" : f
' Ü : f
' ü : f
'LastIndexOf( String, *, 20, * )
'Original : Is U" or u" the same as Ü or ü?
'No options : Is U" or u" the same ----------
' U" : l
' u" : l
' Ü : l
' ü : l
'Ordinal : Is U" or u" the same ----------
' U" : l
' u" : l
' Ü :
' ü :
'IgnoreCase : Is U" or u" the same ----------
' U" : l
' u" : l
' Ü : l
' ü : l
Remarks
The source string is searched forward starting at startIndex
and ending at the end of the string.
This overload performs a culture-sensitive search. A Unicode 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. To perform an ordinal (culture-insensitive) search, where the Unicode values are compared, you should call one of the overloads that has a parameter of type CompareOptions and use the Ordinal value.
Note
When possible, you should call string comparison methods that have a parameter of type CompareOptions to specify the kind of comparison expected. As a general rule, use linguistic options (using the current culture) for comparing strings displayed in the user interface and specify CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase for security comparisons.
Notes to Callers
Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive sort. In a culture-sensitive search, if value
contains an ignorable character, the result is equivalent to searching with that character removed. If value
consists only of one or more ignorable characters, the IndexOf(String, String, Int32) method always returns startIndex
, which is the character position at which the search begins.
In the following example, the IndexOf(String, String, Int32) method is used to find the position of a soft hyphen (U+00AD) followed by an "m" in two strings. Only one of the strings contains the required substring. In both cases, because the soft hyphen is an ignorable character, the method returns the index of "m" in the string. 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;
using System.Globalization;
public class Example
{
public static void Main()
{
CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;
string searchString = "\u00ADm";
string s1 = "ani\u00ADmal" ;
string s2 = "animal";
Console.WriteLine(ci.IndexOf(s1, searchString, 2));
Console.WriteLine(ci.IndexOf(s2, searchString, 2));
}
}
// The example displays the following output:
// 4
// 3
Imports System.Globalization
Module Example
Public Sub Main()
Dim ci As CompareInfo = CultureInfo.CurrentCulture.CompareInfo
Dim searchString As String = Chrw(&h00AD) + "m"
Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
Dim s2 As String = "animal"
Console.WriteLine(ci.IndexOf(s1, searchString, 2))
Console.WriteLine(ci.IndexOf(s2, searchString, 2))
End Sub
End Module
' The example displays the following output:
' 4
' 3
See also
Applies to
IndexOf(String, Char, Int32, Int32, CompareOptions)
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Searches for the specified character and returns the zero-based index of the first occurrence within the section of the source string that starts at the specified index and contains the specified number of elements using the specified CompareOptions value.
public:
virtual int IndexOf(System::String ^ source, char value, int startIndex, int count, System::Globalization::CompareOptions options);
public:
int IndexOf(System::String ^ source, char value, int startIndex, int count, System::Globalization::CompareOptions options);
public virtual int IndexOf (string source, char value, int startIndex, int count, System.Globalization.CompareOptions options);
public int IndexOf (string source, char value, int startIndex, int count, System.Globalization.CompareOptions options);
abstract member IndexOf : string * char * int * int * System.Globalization.CompareOptions -> int
override this.IndexOf : string * char * int * int * System.Globalization.CompareOptions -> int
member this.IndexOf : string * char * int * int * System.Globalization.CompareOptions -> int
Public Overridable Function IndexOf (source As String, value As Char, startIndex As Integer, count As Integer, options As CompareOptions) As Integer
Public Function IndexOf (source As String, value As Char, startIndex As Integer, count As Integer, options As CompareOptions) As Integer
Parameters
- source
- String
The string to search.
- value
- Char
The character to locate within source
.
- startIndex
- Int32
The zero-based starting index of the search.
- count
- Int32
The number of elements in the section to search.
- options
- CompareOptions
A value that defines how source
and value
should be compared. options
is either the enumeration value Ordinal, or a bitwise combination of one or more of the following values: IgnoreCase, IgnoreSymbols, IgnoreNonSpace, IgnoreWidth, and IgnoreKanaType.
Returns
The zero-based index of the first occurrence of value
, if found, within the section of source
that starts at startIndex
and contains the number of elements specified by count
, using the specified comparison options; otherwise, -1. Returns startIndex
if value
is an ignorable character.
Exceptions
source
is null
.
startIndex
is outside the range of valid indexes for source
.
-or-
count
is less than zero.
-or-
startIndex
and count
do not specify a valid section in source
.
options
contains an invalid CompareOptions value.
Examples
The following example determines the indexes of the first and last occurrences of a character or a substring within a portion of a string.
using namespace System;
using namespace System::Globalization;
void PrintMarker( String^ Prefix, int First, int Last )
{
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 )
{
// Creates an array of Char to hold the markers.
array<Char>^myCharArr = gcnew array<Char>(mySize + 1);
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[ First ] = 'f';
if ( Last > -1 )
myCharArr[ Last ] = 'l';
if ( First == Last )
myCharArr[ First ] = 'b';
// Displays the array of Char as a String.
Console::WriteLine( "{0}{1}", Prefix, gcnew String( myCharArr ) );
}
else
Console::WriteLine( Prefix );
}
int main()
{
// Creates CompareInfo for the InvariantCulture.
CompareInfo^ myComp = CultureInfo::InvariantCulture->CompareInfo;
// iS is the starting index of the substring.
int iS = 8;
// iL is the length of the substring.
int iL = 18;
// myT1 and myT2 are the strings used for padding.
String^ myT1 = gcnew String( '-',iS );
String^ myT2;
// Searches for the ligature Æ.
String^ myStr = "Is AE or ae the same as Æ or æ?";
myT2 = gcnew String( '-',myStr->Length - iS - iL );
Console::WriteLine();
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, iL ), myComp->LastIndexOf( myStr, "AE", iS + iL - 1, iL ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, iL ), myComp->LastIndexOf( myStr, "ae", iS + iL - 1, iL ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, iL ), myComp->LastIndexOf( myStr, L'Æ', iS + iL - 1, iL ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, iL ), myComp->LastIndexOf( myStr, L'æ', iS + iL - 1, iL ) );
Console::WriteLine( "Ordinal : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "AE", iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "ae", iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'Æ', iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'æ', iS + iL - 1, iL, CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "AE", iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "ae", iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'Æ', iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'æ', iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is U\u0308 or u\u0308 the same as \u00DC or \u00FC?";
myT2 = gcnew String( '-',myStr->Length - iS - iL );
Console::WriteLine();
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, iL ), myComp->LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, iL ), myComp->LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, iL ), myComp->LastIndexOf( myStr, L'Ü', iS + iL - 1, iL ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, iL ), myComp->LastIndexOf( myStr, L'ü', iS + iL - 1, iL ) );
Console::WriteLine( "Ordinal : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'Ü', iS + iL - 1, iL, CompareOptions::Ordinal ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, iL, CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'ü', iS + iL - 1, iL, CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}{1}{2}", myT1, myStr->Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'Ü', iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, iL, CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'ü', iS + iL - 1, iL, CompareOptions::IgnoreCase ) );
}
/*
This code produces the following output.
Original : Is AE or ae the same as Æ or æ?
No options : -------- ae the same as Æ -----
AE : b
ae : b
Æ : b
æ : b
Ordinal : -------- ae the same as Æ -----
AE :
ae : b
Æ : b
æ :
IgnoreCase : -------- ae the same as Æ -----
AE : f l
ae : f l
Æ : f l
æ : f l
Original : Is U" or u" the same as Ü or ü?
No options : -------- u" the same as Ü -----
U" : b
u" : b
Ü : b
ü : b
Ordinal : -------- u" the same as Ü -----
U" :
u" : b
Ü : b
ü :
IgnoreCase : -------- u" the same as Ü -----
U" : f l
u" : f l
Ü : f l
ü : f l
*/
using System;
using System.Globalization;
public class SamplesCompareInfo {
public static void Main() {
// Creates CompareInfo for the InvariantCulture.
CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;
// iS is the starting index of the substring.
int iS = 8;
// iL is the length of the substring.
int iL = 18;
// myT1 and myT2 are the strings used for padding.
String myT1 = new String( '-', iS );
String myT2;
// Searches for the ligature Æ.
String myStr = "Is AE or ae the same as Æ or æ?";
myT2 = new String( '-', myStr.Length - iS - iL );
Console.WriteLine();
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, iL ), myComp.LastIndexOf( myStr, "AE", iS + iL - 1, iL ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, iL ), myComp.LastIndexOf( myStr, "ae", iS + iL - 1, iL ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, iL ), myComp.LastIndexOf( myStr, 'Æ', iS + iL - 1, iL ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, iL ), myComp.LastIndexOf( myStr, 'æ', iS + iL - 1, iL ) );
Console.WriteLine( "Ordinal : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "AE", iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "ae", iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'Æ', iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'æ', iS + iL - 1, iL, CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "AE", iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "ae", iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'Æ', iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'æ', iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is \u0055\u0308 or \u0075\u0308 the same as \u00DC or \u00FC?";
myT2 = new String( '-', myStr.Length - iS - iL );
Console.WriteLine();
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, iL ), myComp.LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, iL ), myComp.LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, iL ), myComp.LastIndexOf( myStr, 'Ü', iS + iL - 1, iL ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, iL ), myComp.LastIndexOf( myStr, 'ü', iS + iL - 1, iL ) );
Console.WriteLine( "Ordinal : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'Ü', iS + iL - 1, iL, CompareOptions.Ordinal ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, iL, CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'ü', iS + iL - 1, iL, CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}{1}{2}", myT1, myStr.Substring( iS, iL ), myT2 );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "U\u0308", iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "u\u0308", iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'Ü', iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, iL, CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'ü', iS + iL - 1, iL, CompareOptions.IgnoreCase ) );
}
public static void PrintMarker( String Prefix, int First, int Last ) {
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 ) {
// Creates an array of Char to hold the markers.
Char[] myCharArr = new Char[mySize+1];
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[First] = 'f';
if ( Last > -1 )
myCharArr[Last] = 'l';
if ( First == Last )
myCharArr[First] = 'b';
// Displays the array of Char as a String.
Console.WriteLine( "{0}{1}", Prefix, new String( myCharArr ) );
}
else
{
Console.WriteLine( Prefix );
}
}
}
/*
This code produces the following output.
Original : Is AE or ae the same as Æ or æ?
No options : -------- ae the same as Æ -----
AE : b
ae : b
Æ : b
æ : b
Ordinal : -------- ae the same as Æ -----
AE :
ae : b
Æ : b
æ :
IgnoreCase : -------- ae the same as Æ -----
AE : f l
ae : f l
Æ : f l
æ : f l
Original : Is U" or u" the same as Ü or ü?
No options : -------- u" the same as Ü -----
U" : b
u" : b
Ü : b
ü : b
Ordinal : -------- u" the same as Ü -----
U" :
u" : b
Ü : b
ü :
IgnoreCase : -------- u" the same as Ü -----
U" : f l
u" : f l
Ü : f l
ü : f l
*/
Imports System.Globalization
Public Class SamplesCompareInfo
Public Shared Sub Main()
' Creates CompareInfo for the InvariantCulture.
Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
' iS is the starting index of the substring.
Dim [iS] As Integer = 8
' iL is the length of the substring.
Dim iL As Integer = 18
' myT1 and myT2 are the strings used for padding.
Dim myT1 As New [String]("-"c, [iS])
Dim myT2 As [String]
' Searches for the ligature Æ.
Dim myStr As [String] = "Is AE or ae the same as Æ or æ?"
myT2 = New [String]("-"c, myStr.Length - [iS] - iL)
Console.WriteLine()
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], iL), myComp.LastIndexOf(myStr, "AE", [iS] + iL - 1, iL))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], iL), myComp.LastIndexOf(myStr, "ae", [iS] + iL - 1, iL))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], iL), myComp.LastIndexOf(myStr, "Æ"c, [iS] + iL - 1, iL))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], iL), myComp.LastIndexOf(myStr, "æ"c, [iS] + iL - 1, iL))
Console.WriteLine("Ordinal : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "AE", [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "ae", [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "Æ"c, [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "æ"c, [iS] + iL - 1, iL, CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "AE", [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "ae", [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "Æ"c, [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "æ"c, [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
' Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is " & ChrW(&H0055) & ChrW(&H0308) & " or " & ChrW(&H0075) & ChrW(&H0308) & " the same as " & ChrW(&H00DC) & " or " & ChrW(&H00FC) & "?"
myT2 = New [String]("-"c, myStr.Length - [iS] - iL)
Console.WriteLine()
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], iL), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS] + iL - 1, iL))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], iL), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS] + iL - 1, iL))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], iL), myComp.LastIndexOf(myStr, "Ü"c, [iS] + iL - 1, iL))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], iL), myComp.LastIndexOf(myStr, "ü"c, [iS] + iL - 1, iL))
Console.WriteLine("Ordinal : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "Ü"c, [iS] + iL - 1, iL, CompareOptions.Ordinal))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "ü"c, [iS] + iL - 1, iL, CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}{1}{2}", myT1, myStr.Substring([iS], iL), myT2)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "Ü"c, [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "ü"c, [iS] + iL - 1, iL, CompareOptions.IgnoreCase))
End Sub
Public Shared Sub PrintMarker(Prefix As [String], First As Integer, Last As Integer)
' Determines the size of the array to create.
Dim mySize As Integer
If Last > First Then
mySize = Last
Else
mySize = First
End If
If mySize > - 1 Then
' Creates an array of Char to hold the markers.
Dim myCharArr(mySize + 1) As [Char]
' Inserts the appropriate markers.
If First > - 1 Then
myCharArr(First) = "f"c
End If
If Last > - 1 Then
myCharArr(Last) = "l"c
End If
If First = Last Then
myCharArr(First) = "b"c
End If
' Displays the array of Char as a String.
Console.WriteLine("{0}{1}", Prefix, New [String](myCharArr))
Else
Console.WriteLine(Prefix)
End If
End Sub
End Class
'This code produces the following output.
'
'Original : Is AE or ae the same as Æ or æ?
'No options : -------- ae the same as Æ -----
' AE : b
' ae : b
' Æ : b
' æ : b
'Ordinal : -------- ae the same as Æ -----
' AE :
' ae : b
' Æ : b
' æ :
'IgnoreCase : -------- ae the same as Æ -----
' AE : f l
' ae : f l
' Æ : f l
' æ : f l
'
'Original : Is U" or u" the same as Ü or ü?
'No options : -------- u" the same as Ü -----
' U" : b
' u" : b
' Ü : b
' ü : b
'Ordinal : -------- u" the same as Ü -----
' U" :
' u" : b
' Ü : b
' ü :
'IgnoreCase : -------- u" the same as Ü -----
' U" : f l
' u" : f l
' Ü : f l
' ü : f l
Remarks
The source string is searched forward starting at startIndex
and ending at startIndex
+ count
- 1.
The CompareOptions.StringSort value is not valid for this method.
If options
does not include the Ordinal value, this overload performs a culture-sensitive search. If the character is a Unicode value representing a precomposed character, such as the ligature "Æ" (U+00C6), it might be considered equivalent to any occurrence of its components in the correct sequence, such as "AE" (U+0041, U+0045), depending on the culture. If options
includes the Ordinal value, this overload performs an ordinal (culture-insensitive) search. A character is considered equivalent to another character only if the Unicode values are the same. Overloads of String.IndexOf that search for a character perform an ordinal search, whereas those that search for a string perform a culture-sensitive search.
Note
When possible, you should call string comparison methods that have a parameter of type CompareOptions to specify the kind of comparison expected. As a general rule, use linguistic options (using the current culture) for comparing strings displayed in the user interface and specify CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase for security comparisons.
Notes to Callers
Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive sort. In a culture-sensitive search, if value
is an ignorable character, the result is equivalent to searching with that character removed. In this case, the IndexOf(String, Char, Int32, Int32, CompareOptions) method always returns startIndex
, which is the character position at which the search first began. In the following example, the IndexOf(String, Char, Int32, Int32, CompareOptions) method is used to find the soft hyphen (U+00AD) after an "n" in two strings. Only one of the strings contains a soft hyphen. In both cases, because the soft hyphen is an ignorable character, a culture-sensitive search returns 1 to indicate that it has found a match at the position of the "n". An ordinal search, however, successfully finds the soft hyphen in one string and reports that it is absent from the second string.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;
string s1 = "ani\u00ADmal";
string s2 = "animal";
int position = 0;
// Find the index of the soft hyphen using culture-sensitive comparison.
position = ci.IndexOf(s1, 'n');
Console.WriteLine("'n' at position {0}", position);
if (position >= 0)
Console.WriteLine(ci.IndexOf(s1, '\u00AD', position,
s1.Length - position, CompareOptions.IgnoreCase));
position = ci.IndexOf(s2, 'n');
Console.WriteLine("'n' at position {0}", position);
if (position >= 0)
Console.WriteLine(ci.IndexOf(s2, '\u00AD', position,
s2.Length - position, CompareOptions.IgnoreCase));
// Find the index of the soft hyphen using ordinal comparison.
position = ci.IndexOf(s1, 'n');
Console.WriteLine("'n' at position {0}", position, CompareOptions.Ordinal);
if (position >= 0)
Console.WriteLine(ci.IndexOf(s1, '\u00AD', position,
s1.Length - position, CompareOptions.Ordinal));
position = ci.IndexOf(s2, 'n');
Console.WriteLine("'n' at position {0}", position, CompareOptions.Ordinal);
if (position >= 0)
Console.WriteLine(ci.IndexOf(s2, '\u00AD', position,
s2.Length - position, CompareOptions.Ordinal));
}
}
// The example displays the following output:
// 'n' at position 1
// 1
// 'n' at position 1
// 1
// 'n' at position 1
// 3
// 'n' at position 1
// -1
Imports System.Globalization
Module Example
Public Sub Main()
Dim ci As CompareInfo = CultureInfo.CurrentCulture.CompareInfo
Dim softHyphen As Char = ChrW(&h00AD)
Dim position As Integer
Dim s1 As String = "ani" + softHyphen + "mal"
Dim s2 As String = "animal"
' Find the index of the soft hyphen using culture-sensitive comparison.
position = ci.IndexOf(s1, "n"c)
Console.WriteLine("'n' at position {0}", position)
If position >= 0 Then
Console.WriteLine(ci.IndexOf(s1, softHyphen, position, _
s1.Length - position, CompareOptions.IgnoreCase))
End If
position = ci.IndexOf(s2, "n"c)
Console.WriteLine("'n' at position {0}", position)
If position >= 0 Then
Console.WriteLine(ci.IndexOf(s2, softHyphen, position, _
s2.Length - position, CompareOptions.IgnoreCase))
End If
' Find the index of the soft hyphen using ordinal comparison.
position = ci.IndexOf(s1, "n"c)
Console.WriteLine("'n' at position {0}", position)
If position >= 0 Then
Console.WriteLine(ci.IndexOf(s1, softHyphen, position, _
s1.Length - position, CompareOptions.Ordinal))
End If
position = ci.IndexOf(s2, "n"c)
Console.WriteLine("'n' at position {0}", position)
If position >= 0 Then
Console.WriteLine(ci.IndexOf(s2, softHyphen, position, _
s2.Length - position, CompareOptions.Ordinal))
End If
End Sub
End Module
' The example displays the following output:
' 'n' at position 1
' 1
' 'n' at position 1
' 1
' 'n' at position 1
' -1
' 'n' at position 1
' -1
See also
Applies to
IndexOf(String, Char, Int32)
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Searches for the specified character and returns the zero-based index of the first occurrence within the section of the source string that extends from the specified index to the end of the string.
public:
int IndexOf(System::String ^ source, char value, int startIndex);
public:
virtual int IndexOf(System::String ^ source, char value, int startIndex);
public int IndexOf (string source, char value, int startIndex);
public virtual int IndexOf (string source, char value, int startIndex);
member this.IndexOf : string * char * int -> int
abstract member IndexOf : string * char * int -> int
override this.IndexOf : string * char * int -> int
Public Function IndexOf (source As String, value As Char, startIndex As Integer) As Integer
Public Overridable Function IndexOf (source As String, value As Char, startIndex As Integer) As Integer
Parameters
- source
- String
The string to search.
- value
- Char
The character to locate within source
.
- startIndex
- Int32
The zero-based starting index of the search.
Returns
The zero-based index of the first occurrence of value
, if found, within the section of source
that extends from startIndex
to the end of source
; otherwise, -1. Returns startIndex
if value
is an ignorable character.
Exceptions
source
is null
.
startIndex
is outside the range of valid indexes for source
.
Examples
The following example determines the indexes of the first and last occurrences of a character or a substring within a portion of a string. Note that IndexOf and LastIndexOf are searching in different portions of the string, even with the same startIndex
parameter.
using namespace System;
using namespace System::Globalization;
void PrintMarker( String^ Prefix, int First, int Last )
{
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 )
{
// Creates an array of Char to hold the markers.
array<Char>^myCharArr = gcnew array<Char>(mySize + 1);
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[ First ] = 'f';
if ( Last > -1 )
myCharArr[ Last ] = 'l';
if ( First == Last )
myCharArr[ First ] = 'b';
// Displays the array of Char as a String.
Console::WriteLine( "{0}{1}", Prefix, gcnew String( myCharArr ) );
}
else
Console::WriteLine( Prefix );
}
int main()
{
// Creates CompareInfo for the InvariantCulture.
CompareInfo^ myComp = CultureInfo::InvariantCulture->CompareInfo;
// iS is the starting index of the substring.
int iS = 20;
// myT1 is the string used for padding.
String^ myT1;
// Searches for the ligature Æ.
String^ myStr = "Is AE or ae the same as Æ or æ?";
Console::WriteLine();
myT1 = gcnew String( '-',iS );
Console::WriteLine( "IndexOf( String, *, {0}, * )", iS );
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS ), -1 );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS ), -1 );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS ), -1 );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS ), -1 );
Console::WriteLine( "Ordinal : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, CompareOptions::Ordinal ), -1 );
Console::WriteLine( "IgnoreCase : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', iS, CompareOptions::IgnoreCase ), -1 );
myT1 = gcnew String( '-',myStr->Length - iS - 1 );
Console::WriteLine( "LastIndexOf( String, *, {0}, * )", iS );
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp->LastIndexOf( myStr, "AE", iS ) );
PrintMarker( " ae : ", -1, myComp->LastIndexOf( myStr, "ae", iS ) );
PrintMarker( " Æ : ", -1, myComp->LastIndexOf( myStr, L'Æ', iS ) );
PrintMarker( " æ : ", -1, myComp->LastIndexOf( myStr, L'æ', iS ) );
Console::WriteLine( "Ordinal : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp->LastIndexOf( myStr, "AE", iS, CompareOptions::Ordinal ) );
PrintMarker( " ae : ", -1, myComp->LastIndexOf( myStr, "ae", iS, CompareOptions::Ordinal ) );
PrintMarker( " Æ : ", -1, myComp->LastIndexOf( myStr, L'Æ', iS, CompareOptions::Ordinal ) );
PrintMarker( " æ : ", -1, myComp->LastIndexOf( myStr, L'æ', iS, CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp->LastIndexOf( myStr, "AE", iS, CompareOptions::IgnoreCase ) );
PrintMarker( " ae : ", -1, myComp->LastIndexOf( myStr, "ae", iS, CompareOptions::IgnoreCase ) );
PrintMarker( " Æ : ", -1, myComp->LastIndexOf( myStr, L'Æ', iS, CompareOptions::IgnoreCase ) );
PrintMarker( " æ : ", -1, myComp->LastIndexOf( myStr, L'æ', iS, CompareOptions::IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is U\u0308 or u\u0308 the same as \u00DC or \u00FC?";
Console::WriteLine();
myT1 = gcnew String( '-',iS );
Console::WriteLine( "IndexOf( String, *, {0}, * )", iS );
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS ), -1 );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS ), -1 );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS ), -1 );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS ), -1 );
Console::WriteLine( "Ordinal : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, CompareOptions::Ordinal ), -1 );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, CompareOptions::Ordinal ), -1 );
Console::WriteLine( "IgnoreCase : {0}{1}", myT1, myStr->Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', iS, CompareOptions::IgnoreCase ), -1 );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', iS, CompareOptions::IgnoreCase ), -1 );
myT1 = gcnew String( '-',myStr->Length - iS - 1 );
Console::WriteLine( "LastIndexOf( String, *, {0}, * )", iS );
Console::WriteLine( "Original : {0}", myStr );
Console::WriteLine( "No options : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp->LastIndexOf( myStr, "U\u0308", iS ) );
PrintMarker( " u\u0308 : ", -1, myComp->LastIndexOf( myStr, "u\u0308", iS ) );
PrintMarker( " Ü : ", -1, myComp->LastIndexOf( myStr, L'Ü', iS ) );
PrintMarker( " ü : ", -1, myComp->LastIndexOf( myStr, L'ü', iS ) );
Console::WriteLine( "Ordinal : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp->LastIndexOf( myStr, "U\u0308", iS, CompareOptions::Ordinal ) );
PrintMarker( " u\u0308 : ", -1, myComp->LastIndexOf( myStr, "u\u0308", iS, CompareOptions::Ordinal ) );
PrintMarker( " Ü : ", -1, myComp->LastIndexOf( myStr, L'Ü', iS, CompareOptions::Ordinal ) );
PrintMarker( " ü : ", -1, myComp->LastIndexOf( myStr, L'ü', iS, CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}{1}", myStr->Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp->LastIndexOf( myStr, "U\u0308", iS, CompareOptions::IgnoreCase ) );
PrintMarker( " u\u0308 : ", -1, myComp->LastIndexOf( myStr, "u\u0308", iS, CompareOptions::IgnoreCase ) );
PrintMarker( " Ü : ", -1, myComp->LastIndexOf( myStr, L'Ü', iS, CompareOptions::IgnoreCase ) );
PrintMarker( " ü : ", -1, myComp->LastIndexOf( myStr, L'ü', iS, CompareOptions::IgnoreCase ) );
}
/*
This code produces the following output.
IndexOf( String, *, 20, * )
Original : Is AE or ae the same as Æ or æ?
No options : -------------------- as Æ or æ?
AE : f
ae : f
Æ : f
æ : f
Ordinal : -------------------- as Æ or æ?
AE :
ae :
Æ : f
æ : f
IgnoreCase : -------------------- as Æ or æ?
AE : f
ae : f
Æ : f
æ : f
LastIndexOf( String, *, 20, * )
Original : Is AE or ae the same as Æ or æ?
No options : Is AE or ae the same ----------
AE : l
ae : l
Æ : l
æ : l
Ordinal : Is AE or ae the same ----------
AE : l
ae : l
Æ :
æ :
IgnoreCase : Is AE or ae the same ----------
AE : l
ae : l
Æ : l
æ : l
IndexOf( String, *, 20, * )
Original : Is U" or u" the same as Ü or ü?
No options : -------------------- as Ü or ü?
U" : f
u" : f
Ü : f
ü : f
Ordinal : -------------------- as Ü or ü?
U" :
u" :
Ü : f
ü : f
IgnoreCase : -------------------- as Ü or ü?
U" : f
u" : f
Ü : f
ü : f
LastIndexOf( String, *, 20, * )
Original : Is U" or u" the same as Ü or ü?
No options : Is U" or u" the same ----------
U" : l
u" : l
Ü : l
ü : l
Ordinal : Is U" or u" the same ----------
U" : l
u" : l
Ü :
ü :
IgnoreCase : Is U" or u" the same ----------
U" : l
u" : l
Ü : l
ü : l
*/
using System;
using System.Globalization;
public class SamplesCompareInfo {
public static void Main() {
// Creates CompareInfo for the InvariantCulture.
CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;
// iS is the starting index of the substring.
int iS = 20;
// myT1 is the string used for padding.
String myT1;
// Searches for the ligature Æ.
String myStr = "Is AE or ae the same as Æ or æ?";
Console.WriteLine();
myT1 = new String( '-', iS );
Console.WriteLine( "IndexOf( String, *, {0}, * )", iS );
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS ), -1 );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS ), -1 );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS ), -1 );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS ), -1 );
Console.WriteLine( "Ordinal : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, CompareOptions.Ordinal ), -1 );
Console.WriteLine( "IgnoreCase : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', iS, CompareOptions.IgnoreCase ), -1 );
myT1 = new String( '-', myStr.Length - iS - 1 );
Console.WriteLine( "LastIndexOf( String, *, {0}, * )", iS );
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp.LastIndexOf( myStr, "AE", iS ) );
PrintMarker( " ae : ", -1, myComp.LastIndexOf( myStr, "ae", iS ) );
PrintMarker( " Æ : ", -1, myComp.LastIndexOf( myStr, 'Æ', iS ) );
PrintMarker( " æ : ", -1, myComp.LastIndexOf( myStr, 'æ', iS ) );
Console.WriteLine( "Ordinal : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp.LastIndexOf( myStr, "AE", iS, CompareOptions.Ordinal ) );
PrintMarker( " ae : ", -1, myComp.LastIndexOf( myStr, "ae", iS, CompareOptions.Ordinal ) );
PrintMarker( " Æ : ", -1, myComp.LastIndexOf( myStr, 'Æ', iS, CompareOptions.Ordinal ) );
PrintMarker( " æ : ", -1, myComp.LastIndexOf( myStr, 'æ', iS, CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " AE : ", -1, myComp.LastIndexOf( myStr, "AE", iS, CompareOptions.IgnoreCase ) );
PrintMarker( " ae : ", -1, myComp.LastIndexOf( myStr, "ae", iS, CompareOptions.IgnoreCase ) );
PrintMarker( " Æ : ", -1, myComp.LastIndexOf( myStr, 'Æ', iS, CompareOptions.IgnoreCase ) );
PrintMarker( " æ : ", -1, myComp.LastIndexOf( myStr, 'æ', iS, CompareOptions.IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is \u0055\u0308 or \u0075\u0308 the same as \u00DC or \u00FC?";
Console.WriteLine();
myT1 = new String( '-', iS );
Console.WriteLine( "IndexOf( String, *, {0}, * )", iS );
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS ), -1 );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS ), -1 );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS ), -1 );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS ), -1 );
Console.WriteLine( "Ordinal : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, CompareOptions.Ordinal ), -1 );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, CompareOptions.Ordinal ), -1 );
Console.WriteLine( "IgnoreCase : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', iS, CompareOptions.IgnoreCase ), -1 );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', iS, CompareOptions.IgnoreCase ), -1 );
myT1 = new String( '-', myStr.Length - iS - 1 );
Console.WriteLine( "LastIndexOf( String, *, {0}, * )", iS );
Console.WriteLine( "Original : {0}", myStr );
Console.WriteLine( "No options : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp.LastIndexOf( myStr, "U\u0308", iS ) );
PrintMarker( " u\u0308 : ", -1, myComp.LastIndexOf( myStr, "u\u0308", iS ) );
PrintMarker( " Ü : ", -1, myComp.LastIndexOf( myStr, 'Ü', iS ) );
PrintMarker( " ü : ", -1, myComp.LastIndexOf( myStr, 'ü', iS ) );
Console.WriteLine( "Ordinal : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp.LastIndexOf( myStr, "U\u0308", iS, CompareOptions.Ordinal ) );
PrintMarker( " u\u0308 : ", -1, myComp.LastIndexOf( myStr, "u\u0308", iS, CompareOptions.Ordinal ) );
PrintMarker( " Ü : ", -1, myComp.LastIndexOf( myStr, 'Ü', iS, CompareOptions.Ordinal ) );
PrintMarker( " ü : ", -1, myComp.LastIndexOf( myStr, 'ü', iS, CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker( " U\u0308 : ", -1, myComp.LastIndexOf( myStr, "U\u0308", iS, CompareOptions.IgnoreCase ) );
PrintMarker( " u\u0308 : ", -1, myComp.LastIndexOf( myStr, "u\u0308", iS, CompareOptions.IgnoreCase ) );
PrintMarker( " Ü : ", -1, myComp.LastIndexOf( myStr, 'Ü', iS, CompareOptions.IgnoreCase ) );
PrintMarker( " ü : ", -1, myComp.LastIndexOf( myStr, 'ü', iS, CompareOptions.IgnoreCase ) );
}
public static void PrintMarker( String Prefix, int First, int Last ) {
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 ) {
// Creates an array of Char to hold the markers.
Char[] myCharArr = new Char[mySize+1];
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[First] = 'f';
if ( Last > -1 )
myCharArr[Last] = 'l';
if ( First == Last )
myCharArr[First] = 'b';
// Displays the array of Char as a String.
Console.WriteLine( "{0}{1}", Prefix, new String( myCharArr ) );
}
else
{
Console.WriteLine( Prefix );
}
}
}
/*
This code produces the following output.
IndexOf( String, *, 20, * )
Original : Is AE or ae the same as Æ or æ?
No options : -------------------- as Æ or æ?
AE : f
ae : f
Æ : f
æ : f
Ordinal : -------------------- as Æ or æ?
AE :
ae :
Æ : f
æ : f
IgnoreCase : -------------------- as Æ or æ?
AE : f
ae : f
Æ : f
æ : f
LastIndexOf( String, *, 20, * )
Original : Is AE or ae the same as Æ or æ?
No options : Is AE or ae the same ----------
AE : l
ae : l
Æ : l
æ : l
Ordinal : Is AE or ae the same ----------
AE : l
ae : l
Æ :
æ :
IgnoreCase : Is AE or ae the same ----------
AE : l
ae : l
Æ : l
æ : l
IndexOf( String, *, 20, * )
Original : Is U" or u" the same as Ü or ü?
No options : -------------------- as Ü or ü?
U" : f
u" : f
Ü : f
ü : f
Ordinal : -------------------- as Ü or ü?
U" :
u" :
Ü : f
ü : f
IgnoreCase : -------------------- as Ü or ü?
U" : f
u" : f
Ü : f
ü : f
LastIndexOf( String, *, 20, * )
Original : Is U" or u" the same as Ü or ü?
No options : Is U" or u" the same ----------
U" : l
u" : l
Ü : l
ü : l
Ordinal : Is U" or u" the same ----------
U" : l
u" : l
Ü :
ü :
IgnoreCase : Is U" or u" the same ----------
U" : l
u" : l
Ü : l
ü : l
*/
Imports System.Globalization
Public Class SamplesCompareInfo
Public Shared Sub Main()
' Creates CompareInfo for the InvariantCulture.
Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
' iS is the starting index of the substring.
Dim [iS] As Integer = 20
' myT1 is the string used for padding.
Dim myT1 As [String]
' Searches for the ligature Æ.
Dim myStr As [String] = "Is AE or ae the same as Æ or æ?"
Console.WriteLine()
myT1 = New [String]("-"c, [iS])
Console.WriteLine("IndexOf( String, *, {0}, * )", [iS])
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS]), - 1)
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS]), - 1)
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS]), - 1)
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS]), - 1)
Console.WriteLine("Ordinal : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], CompareOptions.Ordinal), - 1)
Console.WriteLine("IgnoreCase : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, [iS], CompareOptions.IgnoreCase), - 1)
myT1 = New [String]("-"c, myStr.Length - [iS] - 1)
Console.WriteLine("LastIndexOf( String, *, {0}, * )", [iS])
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" AE : ", - 1, myComp.LastIndexOf(myStr, "AE", [iS]))
PrintMarker(" ae : ", - 1, myComp.LastIndexOf(myStr, "ae", [iS]))
PrintMarker(" Æ : ", - 1, myComp.LastIndexOf(myStr, "Æ"c, [iS]))
PrintMarker(" æ : ", - 1, myComp.LastIndexOf(myStr, "æ"c, [iS]))
Console.WriteLine("Ordinal : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" AE : ", - 1, myComp.LastIndexOf(myStr, "AE", [iS], CompareOptions.Ordinal))
PrintMarker(" ae : ", - 1, myComp.LastIndexOf(myStr, "ae", [iS], CompareOptions.Ordinal))
PrintMarker(" Æ : ", - 1, myComp.LastIndexOf(myStr, "Æ"c, [iS], CompareOptions.Ordinal))
PrintMarker(" æ : ", - 1, myComp.LastIndexOf(myStr, "æ"c, [iS], CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" AE : ", - 1, myComp.LastIndexOf(myStr, "AE", [iS], CompareOptions.IgnoreCase))
PrintMarker(" ae : ", - 1, myComp.LastIndexOf(myStr, "ae", [iS], CompareOptions.IgnoreCase))
PrintMarker(" Æ : ", - 1, myComp.LastIndexOf(myStr, "Æ"c, [iS], CompareOptions.IgnoreCase))
PrintMarker(" æ : ", - 1, myComp.LastIndexOf(myStr, "æ"c, [iS], CompareOptions.IgnoreCase))
' Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is " & ChrW(&H0055) & ChrW(&H0308) & " or " & ChrW(&H0075) & ChrW(&H0308) & " the same as " & ChrW(&H00DC) & " or " & ChrW(&H00FC) & "?"
Console.WriteLine()
myT1 = New [String]("-"c, [iS])
Console.WriteLine("IndexOf( String, *, {0}, * )", [iS])
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS]), - 1)
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS]), - 1)
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS]), - 1)
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS]), - 1)
Console.WriteLine("Ordinal : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], CompareOptions.Ordinal), - 1)
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], CompareOptions.Ordinal), - 1)
Console.WriteLine("IgnoreCase : {0}{1}", myT1, myStr.Substring([iS]))
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, [iS], CompareOptions.IgnoreCase), - 1)
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, [iS], CompareOptions.IgnoreCase), - 1)
myT1 = New [String]("-"c, myStr.Length - [iS] - 1)
Console.WriteLine("LastIndexOf( String, *, {0}, * )", [iS])
Console.WriteLine("Original : {0}", myStr)
Console.WriteLine("No options : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" U" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS]))
PrintMarker(" u" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS]))
PrintMarker(" Ü : ", - 1, myComp.LastIndexOf(myStr, "Ü"c, [iS]))
PrintMarker(" ü : ", - 1, myComp.LastIndexOf(myStr, "ü"c, [iS]))
Console.WriteLine("Ordinal : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" U" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS], CompareOptions.Ordinal))
PrintMarker(" u" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS], CompareOptions.Ordinal))
PrintMarker(" Ü : ", - 1, myComp.LastIndexOf(myStr, "Ü"c, [iS], CompareOptions.Ordinal))
PrintMarker(" ü : ", - 1, myComp.LastIndexOf(myStr, "ü"c, [iS], CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}{1}", myStr.Substring(0, [iS] + 1), myT1)
PrintMarker(" U" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), [iS], CompareOptions.IgnoreCase))
PrintMarker(" u" & ChrW(&H0308) & " : ", - 1, myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), [iS], CompareOptions.IgnoreCase))
PrintMarker(" Ü : ", - 1, myComp.LastIndexOf(myStr, "Ü"c, [iS], CompareOptions.IgnoreCase))
PrintMarker(" ü : ", - 1, myComp.LastIndexOf(myStr, "ü"c, [iS], CompareOptions.IgnoreCase))
End Sub
Public Shared Sub PrintMarker(Prefix As [String], First As Integer, Last As Integer)
' Determines the size of the array to create.
Dim mySize As Integer
If Last > First Then
mySize = Last
Else
mySize = First
End If
If mySize > - 1 Then
' Creates an array of Char to hold the markers.
Dim myCharArr(mySize + 1) As [Char]
' Inserts the appropriate markers.
If First > - 1 Then
myCharArr(First) = "f"c
End If
If Last > - 1 Then
myCharArr(Last) = "l"c
End If
If First = Last Then
myCharArr(First) = "b"c
End If
' Displays the array of Char as a String.
Console.WriteLine("{0}{1}", Prefix, New [String](myCharArr))
Else
Console.WriteLine(Prefix)
End If
End Sub
End Class
'This code produces the following output.
'
'IndexOf( String, *, 20, * )
'Original : Is AE or ae the same as Æ or æ?
'No options : -------------------- as Æ or æ?
' AE : f
' ae : f
' Æ : f
' æ : f
'Ordinal : -------------------- as Æ or æ?
' AE :
' ae :
' Æ : f
' æ : f
'IgnoreCase : -------------------- as Æ or æ?
' AE : f
' ae : f
' Æ : f
' æ : f
'LastIndexOf( String, *, 20, * )
'Original : Is AE or ae the same as Æ or æ?
'No options : Is AE or ae the same ----------
' AE : l
' ae : l
' Æ : l
' æ : l
'Ordinal : Is AE or ae the same ----------
' AE : l
' ae : l
' Æ :
' æ :
'IgnoreCase : Is AE or ae the same ----------
' AE : l
' ae : l
' Æ : l
' æ : l
'
'IndexOf( String, *, 20, * )
'Original : Is U" or u" the same as Ü or ü?
'No options : -------------------- as Ü or ü?
' U" : f
' u" : f
' Ü : f
' ü : f
'Ordinal : -------------------- as Ü or ü?
' U" :
' u" :
' Ü : f
' ü : f
'IgnoreCase : -------------------- as Ü or ü?
' U" : f
' u" : f
' Ü : f
' ü : f
'LastIndexOf( String, *, 20, * )
'Original : Is U" or u" the same as Ü or ü?
'No options : Is U" or u" the same ----------
' U" : l
' u" : l
' Ü : l
' ü : l
'Ordinal : Is U" or u" the same ----------
' U" : l
' u" : l
' Ü :
' ü :
'IgnoreCase : Is U" or u" the same ----------
' U" : l
' u" : l
' Ü : l
' ü : l
Remarks
The source string is searched forward starting at startIndex
and ending at the end of the string.
This overload performs a culture-sensitive search. If the character is a Unicode value representing a precomposed character, such as the ligature "Æ" (U+00C6), it might be considered equivalent to any occurrence of its components in the correct sequence, such as "AE" (U+0041, U+0045), depending on the culture. To perform an ordinal (culture-insensitive) search, where a character is considered equivalent to another character only if the Unicode values are the same, you should call one of the overloads that has a parameter of type CompareOptions and use the Ordinal value. Overloads of String.IndexOf that search for a character perform an ordinal search, whereas those that search for a string perform a culture-sensitive search.
Note
When possible, you should call string comparison methods that have a parameter of type CompareOptions to specify the kind of comparison expected. As a general rule, use linguistic options (using the current culture) for comparing strings displayed in the user interface and specify CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase for security comparisons.
Notes to Callers
Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive sort. In a culture-sensitive search, if value
is an ignorable character, the result is equivalent to searching with that character removed. In this case, the IndexOf(String, Char, Int32) method always returns startIndex
, which is the character position at which the search begins. In the following example, the IndexOf(String, Char, Int32) method is used to find a soft hyphen (U+00AD) after an "n" in two strings. Only one of the strings contains a soft hyphen. In both cases, because the soft hyphen is an ignorable character, the method returns 1 to indicate that it has found a match at the position of the "n".
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;
string s1 = "ani\u00ADmal";
string s2 = "animal";
int position = 0;
// Find the index of the soft hyphen.
position = ci.IndexOf(s1, 'n');
Console.WriteLine("'n' at position {0}", position);
if (position >= 0)
Console.WriteLine(ci.IndexOf(s1, '\u00AD', position));
position = ci.IndexOf(s2, 'n');
Console.WriteLine("'n' at position {0}", position);
if (position >= 0)
Console.WriteLine(ci.IndexOf(s2, '\u00AD', position));
}
}
// The example displays the following output:
// 'n' at position 1
// 1
// 'n' at position 1
// 1
Imports System.Globalization
Module Example
Public Sub Main()
Dim ci As CompareInfo = CultureInfo.CurrentCulture.CompareInfo
Dim position As Integer
Dim softHyphen As Char = ChrW(&h00AD)
Dim s1 As String = "ani" + softHyphen + "mal"
Dim s2 As String = "animal"
' Find the index of the soft hyphen.
position = ci.IndexOf(s1, "n"c)
Console.WriteLine("'n' at position {0}", position)
If position >= 0 Then
Console.WriteLine(ci.IndexOf(s1, softHyphen, position))
End If
position = ci.IndexOf(s2, "n"c)
Console.WriteLine("'n' at position {0}", position)
If position >= 0 Then
Console.WriteLine(ci.IndexOf(s2, softHyphen, position))
End If
End Sub
End Module
' The example displays the following output:
' 'n' at position 1
' 1
' 'n' at position 1
' 1
See also
Applies to
IndexOf(String, Char, CompareOptions)
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Searches for the specified character and returns the zero-based index of the first occurrence within the entire source string using the specified CompareOptions value.
public:
virtual int IndexOf(System::String ^ source, char value, System::Globalization::CompareOptions options);
public:
int IndexOf(System::String ^ source, char value, System::Globalization::CompareOptions options);
public virtual int IndexOf (string source, char value, System.Globalization.CompareOptions options);
public int IndexOf (string source, char value, System.Globalization.CompareOptions options);
abstract member IndexOf : string * char * System.Globalization.CompareOptions -> int
override this.IndexOf : string * char * System.Globalization.CompareOptions -> int
member this.IndexOf : string * char * System.Globalization.CompareOptions -> int
Public Overridable Function IndexOf (source As String, value As Char, options As CompareOptions) As Integer
Public Function IndexOf (source As String, value As Char, options As CompareOptions) As Integer
Parameters
- source
- String
The string to search.
- value
- Char
The character to locate within source
.
- options
- CompareOptions
A value that defines how the strings should be compared. options
is either the enumeration value Ordinal, or a bitwise combination of one or more of the following values: IgnoreCase, IgnoreSymbols, IgnoreNonSpace, IgnoreWidth, and IgnoreKanaType.
Returns
The zero-based index of the first occurrence of value
, if found, within source
, using the specified comparison options; otherwise, -1. Returns 0 (zero) if value
is an ignorable character.
Exceptions
source
is null
.
options
contains an invalid CompareOptions value.
Examples
The following example determines the indexes of the first and last occurrences of a character or a substring within a string.
using namespace System;
using namespace System::Globalization;
void PrintMarker( String^ Prefix, int First, int Last )
{
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 )
{
// Creates an array of Char to hold the markers.
array<Char>^myCharArr = gcnew array<Char>(mySize + 1);
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[ First ] = 'f';
if ( Last > -1 )
myCharArr[ Last ] = 'l';
if ( First == Last )
myCharArr[ First ] = 'b';
// Displays the array of Char as a String.
Console::WriteLine( "{0}{1}", Prefix, gcnew String( myCharArr ) );
}
else
Console::WriteLine( Prefix );
}
int main()
{
// Creates CompareInfo for the InvariantCulture.
CompareInfo^ myComp = CultureInfo::InvariantCulture->CompareInfo;
// Searches for the ligature Æ.
String^ myStr = "Is AE or ae the same as Æ or æ?";
Console::WriteLine();
Console::WriteLine( "No options : {0}", myStr );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE" ), myComp->LastIndexOf( myStr, "AE" ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae" ), myComp->LastIndexOf( myStr, "ae" ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ' ), myComp->LastIndexOf( myStr, L'Æ' ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ' ), myComp->LastIndexOf( myStr, L'æ' ) );
Console::WriteLine( "Ordinal : {0}", myStr );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "AE", CompareOptions::Ordinal ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "ae", CompareOptions::Ordinal ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'Æ', CompareOptions::Ordinal ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'æ', CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}", myStr );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "AE", CompareOptions::IgnoreCase ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "ae", CompareOptions::IgnoreCase ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'Æ', CompareOptions::IgnoreCase ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'æ', CompareOptions::IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is U\u0308 or u\u0308 the same as \u00DC or \u00FC?";
Console::WriteLine();
Console::WriteLine( "No options : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308" ), myComp->LastIndexOf( myStr, "U\u0308" ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308" ), myComp->LastIndexOf( myStr, "u\u0308" ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü' ), myComp->LastIndexOf( myStr, L'Ü' ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü' ), myComp->LastIndexOf( myStr, L'ü' ) );
Console::WriteLine( "Ordinal : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "U\u0308", CompareOptions::Ordinal ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "u\u0308", CompareOptions::Ordinal ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'Ü', CompareOptions::Ordinal ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'ü', CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "U\u0308", CompareOptions::IgnoreCase ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "u\u0308", CompareOptions::IgnoreCase ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'Ü', CompareOptions::IgnoreCase ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'ü', CompareOptions::IgnoreCase ) );
}
/*
This code produces the following output.
No options : Is AE or ae the same as Æ or æ?
AE : f l
ae : f l
Æ : f l
æ : f l
Ordinal : Is AE or ae the same as Æ or æ?
AE : b
ae : b
Æ : b
æ : b
IgnoreCase : Is AE or ae the same as Æ or æ?
AE : f l
ae : f l
Æ : f l
æ : f l
No options : Is U" or u" the same as Ü or ü?
U" : f l
u" : f l
Ü : f l
ü : f l
Ordinal : Is U" or u" the same as Ü or ü?
U" : b
u" : b
Ü : b
ü : b
IgnoreCase : Is U" or u" the same as Ü or ü?
U" : f l
u" : f l
Ü : f l
ü : f l
*/
using System;
using System.Globalization;
public class SamplesCompareInfo {
public static void Main() {
// Creates CompareInfo for the InvariantCulture.
CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;
// Searches for the ligature Æ.
String myStr = "Is AE or ae the same as Æ or æ?";
Console.WriteLine();
Console.WriteLine( "No options : {0}", myStr );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE" ), myComp.LastIndexOf( myStr, "AE" ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae" ), myComp.LastIndexOf( myStr, "ae" ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ' ), myComp.LastIndexOf( myStr, 'Æ' ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ' ), myComp.LastIndexOf( myStr, 'æ' ) );
Console.WriteLine( "Ordinal : {0}", myStr );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "AE", CompareOptions.Ordinal ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "ae", CompareOptions.Ordinal ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'Æ', CompareOptions.Ordinal ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'æ', CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}", myStr );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "AE", CompareOptions.IgnoreCase ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "ae", CompareOptions.IgnoreCase ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'Æ', CompareOptions.IgnoreCase ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'æ', CompareOptions.IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is \u0055\u0308 or \u0075\u0308 the same as \u00DC or \u00FC?";
Console.WriteLine();
Console.WriteLine( "No options : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308" ), myComp.LastIndexOf( myStr, "U\u0308" ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308" ), myComp.LastIndexOf( myStr, "u\u0308" ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü' ), myComp.LastIndexOf( myStr, 'Ü' ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü' ), myComp.LastIndexOf( myStr, 'ü' ) );
Console.WriteLine( "Ordinal : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "U\u0308", CompareOptions.Ordinal ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "u\u0308", CompareOptions.Ordinal ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'Ü', CompareOptions.Ordinal ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'ü', CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "U\u0308", CompareOptions.IgnoreCase ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "u\u0308", CompareOptions.IgnoreCase ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'Ü', CompareOptions.IgnoreCase ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'ü', CompareOptions.IgnoreCase ) );
}
public static void PrintMarker( String Prefix, int First, int Last ) {
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 ) {
// Creates an array of Char to hold the markers.
Char[] myCharArr = new Char[mySize+1];
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[First] = 'f';
if ( Last > -1 )
myCharArr[Last] = 'l';
if ( First == Last )
myCharArr[First] = 'b';
// Displays the array of Char as a String.
Console.WriteLine( "{0}{1}", Prefix, new String( myCharArr ) );
}
else
{
Console.WriteLine( Prefix );
}
}
}
/*
This code produces the following output.
No options : Is AE or ae the same as Æ or æ?
AE : f l
ae : f l
Æ : f l
æ : f l
Ordinal : Is AE or ae the same as Æ or æ?
AE : b
ae : b
Æ : b
æ : b
IgnoreCase : Is AE or ae the same as Æ or æ?
AE : f l
ae : f l
Æ : f l
æ : f l
No options : Is U" or u" the same as Ü or ü?
U" : f l
u" : f l
Ü : f l
ü : f l
Ordinal : Is U" or u" the same as Ü or ü?
U" : b
u" : b
Ü : b
ü : b
IgnoreCase : Is U" or u" the same as Ü or ü?
U" : f l
u" : f l
Ü : f l
ü : f l
*/
Imports System.Globalization
Public Class SamplesCompareInfo
Public Shared Sub Main()
' Creates CompareInfo for the InvariantCulture.
Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
' Searches for the ligature Æ.
Dim myStr As [String] = "Is AE or ae the same as Æ or æ?"
Console.WriteLine()
Console.WriteLine("No options : {0}", myStr)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE"), myComp.LastIndexOf(myStr, "AE"))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae"), myComp.LastIndexOf(myStr, "ae"))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c), myComp.LastIndexOf(myStr, "Æ"c))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c), myComp.LastIndexOf(myStr, "æ"c))
Console.WriteLine("Ordinal : {0}", myStr)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "AE", CompareOptions.Ordinal))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "ae", CompareOptions.Ordinal))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "Æ"c, CompareOptions.Ordinal))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "æ"c, CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}", myStr)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "AE", CompareOptions.IgnoreCase))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "ae", CompareOptions.IgnoreCase))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "Æ"c, CompareOptions.IgnoreCase))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "æ"c, CompareOptions.IgnoreCase))
' Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is " & ChrW(&H0055) & ChrW(&H0308) & " or " & ChrW(&H0075) & ChrW(&H0308) & " the same as " & ChrW(&H00DC) & " or " & ChrW(&H00FC) & "?"
Console.WriteLine()
Console.WriteLine("No options : {0}", myStr)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308)), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308)))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308)), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308)))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c), myComp.LastIndexOf(myStr, "Ü"c))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c), myComp.LastIndexOf(myStr, "ü"c))
Console.WriteLine("Ordinal : {0}", myStr)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), CompareOptions.Ordinal))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), CompareOptions.Ordinal))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "Ü"c, CompareOptions.Ordinal))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "ü"c, CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}", myStr)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), CompareOptions.IgnoreCase))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), CompareOptions.IgnoreCase))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "Ü"c, CompareOptions.IgnoreCase))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "ü"c, CompareOptions.IgnoreCase))
End Sub
Public Shared Sub PrintMarker(Prefix As [String], First As Integer, Last As Integer)
' Determines the size of the array to create.
Dim mySize As Integer
If Last > First Then
mySize = Last
Else
mySize = First
End If
If mySize > - 1 Then
' Creates an array of Char to hold the markers.
Dim myCharArr(mySize + 1) As [Char]
' Inserts the appropriate markers.
If First > - 1 Then
myCharArr(First) = "f"c
End If
If Last > - 1 Then
myCharArr(Last) = "l"c
End If
If First = Last Then
myCharArr(First) = "b"c
End If
' Displays the array of Char as a String.
Console.WriteLine("{0}{1}", Prefix, New [String](myCharArr))
Else
Console.WriteLine(Prefix)
End If
End Sub
End Class
'This code produces the following output.
'
'No options : Is AE or ae the same as Æ or æ?
' AE : f l
' ae : f l
' Æ : f l
' æ : f l
'Ordinal : Is AE or ae the same as Æ or æ?
' AE : b
' ae : b
' Æ : b
' æ : b
'IgnoreCase : Is AE or ae the same as Æ or æ?
' AE : f l
' ae : f l
' Æ : f l
' æ : f l
'
'No options : Is U" or u" the same as Ü or ü?
' U" : f l
' u" : f l
' Ü : f l
' ü : f l
'Ordinal : Is U" or u" the same as Ü or ü?
' U" : b
' u" : b
' Ü : b
' ü : b
'IgnoreCase : Is U" or u" the same as Ü or ü?
' U" : f l
' u" : f l
' Ü : f l
' ü : f l
Remarks
The source string is searched forward starting at the beginning of the string and ending at the end of the string.
The CompareOptions.StringSort value is not valid for this method.
If options
does not include the Ordinal value, this overload performs a culture-sensitive search. If the character is a Unicode value representing a precomposed character, such as the ligature "Æ" (U+00C6), it might be considered equivalent to any occurrence of its components in the correct sequence, such as "AE" (U+0041, U+0045), depending on the culture. If options
includes the Ordinal value, this overload performs an ordinal (culture-insensitive) search. A character is considered equivalent to another character only if the Unicode values are the same. Overloads of String.IndexOf that search for a character perform an ordinal search, whereas those that search for a string perform a culture-sensitive search.
Note
When possible, you should use string comparison methods that have a parameter of type CompareOptions to specify the kind of comparison expected. As a general rule, use linguistic options (using the current culture) for comparing strings displayed in the user interface and specify CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase for security comparisons.
Notes to Callers
Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive sort. In a culture-sensitive search, if value
is an ignorable character, the result is equivalent to searching with that character removed. In this case, the IndexOf(String, Char, CompareOptions) method always returns 0 (zero) to indicate that the match is found at the beginning of source
. In the following example, the IndexOf(String, Char, CompareOptions) method is used to search for a soft hyphen (U+00AD) in two strings. Only one of the strings contains a soft hyphen. In both cases, because the soft hyphen is an ignorable character, a culture-sensitive search returns 0 (zero) to indicate that it has found a match at the beginning of the string. An ordinal search, however, successfully finds the soft hyphen in one string and reports that it is absent from the second string.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;
string s1 = "ani\u00ADmal";
string s2 = "animal";
// Find the index of the soft hyphen using culture-sensitive comparison.
Console.WriteLine(ci.IndexOf(s1, '\u00AD', CompareOptions.IgnoreCase));
Console.WriteLine(ci.IndexOf(s2, '\u00AD', CompareOptions.IgnoreCase));
// Find the index of the soft hyphen using ordinal comparison.
Console.WriteLine(ci.IndexOf(s1, '\u00AD', CompareOptions.Ordinal));
Console.WriteLine(ci.IndexOf(s2, '\u00AD', CompareOptions.Ordinal));
}
}
// The example displays the following output:
// 0
// 0
// 3
// -1
Imports System.Globalization
Module Example
Public Sub Main()
Dim ci As CompareInfo = CultureInfo.CurrentCulture.CompareInfo
Dim softHyphen As Char = ChrW(&h00AD)
Dim s1 As String = "ani" + softHyphen + "mal"
Dim s2 As String = "animal"
' Find the index of the soft hyphen using culture-sensitive comparison.
Console.WriteLine(ci.IndexOf(s1, softHyphen, CompareOptions.IgnoreCase))
Console.WriteLine(ci.IndexOf(s2, softHyphen, CompareOptions.IgnoreCase))
' Find the index of the soft hyphen using ordinal comparison.
Console.WriteLine(ci.IndexOf(s1, softHyphen, CompareOptions.Ordinal))
Console.WriteLine(ci.IndexOf(s2, softHyphen, CompareOptions.Ordinal))
End Sub
End Module
' The example displays the following output:
' 0
' 0
' 3
' -1
See also
Applies to
IndexOf(ReadOnlySpan<Char>, Rune, CompareOptions)
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Searches for the first occurrence of a Rune within the specified read-only span of characters.
public int IndexOf (ReadOnlySpan<char> source, System.Text.Rune value, System.Globalization.CompareOptions options = System.Globalization.CompareOptions.None);
member this.IndexOf : ReadOnlySpan<char> * System.Text.Rune * System.Globalization.CompareOptions -> int
Public Function IndexOf (source As ReadOnlySpan(Of Char), value As Rune, Optional options As CompareOptions = System.Globalization.CompareOptions.None) As Integer
Parameters
- source
- ReadOnlySpan<Char>
The read-only span of characters to search within.
- options
- CompareOptions
An optional combination of CompareOptions enumeration values to use during the search. The default value is None.
Returns
The zero-based index into source
where value
first appears; or a negative value if value
cannot be found within source
.
Exceptions
options
contains an unsupported combination of flags.
Applies to
IndexOf(ReadOnlySpan<Char>, ReadOnlySpan<Char>, CompareOptions)
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Searches for the first occurrence of a substring within the specified read-only span of characters.
public int IndexOf (ReadOnlySpan<char> source, ReadOnlySpan<char> value, System.Globalization.CompareOptions options = System.Globalization.CompareOptions.None);
member this.IndexOf : ReadOnlySpan<char> * ReadOnlySpan<char> * System.Globalization.CompareOptions -> int
Public Function IndexOf (source As ReadOnlySpan(Of Char), value As ReadOnlySpan(Of Char), Optional options As CompareOptions = System.Globalization.CompareOptions.None) As Integer
Parameters
- source
- ReadOnlySpan<Char>
The string to search within.
- value
- ReadOnlySpan<Char>
The substring to locate within source
.
- options
- CompareOptions
An optional combination of CompareOptions enumeration values to use during the search. The default value is None.
Returns
The zero-based index into source
where the substring value
first appears; or a negative value if value
cannot be found within source
.
Exceptions
options
contains an unsupported combination of flags.
Applies to
IndexOf(String, String)
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Searches for the specified substring and returns the zero-based index of the first occurrence within the entire source string.
public:
virtual int IndexOf(System::String ^ source, System::String ^ value);
public:
int IndexOf(System::String ^ source, System::String ^ value);
public virtual int IndexOf (string source, string value);
public int IndexOf (string source, string value);
abstract member IndexOf : string * string -> int
override this.IndexOf : string * string -> int
member this.IndexOf : string * string -> int
Public Overridable Function IndexOf (source As String, value As String) As Integer
Public Function IndexOf (source As String, value As String) As Integer
Parameters
- source
- String
The string to search.
- value
- String
The string to locate within source
.
Returns
The zero-based index of the first occurrence of value
, if found, within source
; otherwise, -1. Returns 0 (zero) if value
is an ignorable character.
Exceptions
Examples
The following example determines the indexes of the first and last occurrences of a character or a substring within a string.
using namespace System;
using namespace System::Globalization;
void PrintMarker( String^ Prefix, int First, int Last )
{
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 )
{
// Creates an array of Char to hold the markers.
array<Char>^myCharArr = gcnew array<Char>(mySize + 1);
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[ First ] = 'f';
if ( Last > -1 )
myCharArr[ Last ] = 'l';
if ( First == Last )
myCharArr[ First ] = 'b';
// Displays the array of Char as a String.
Console::WriteLine( "{0}{1}", Prefix, gcnew String( myCharArr ) );
}
else
Console::WriteLine( Prefix );
}
int main()
{
// Creates CompareInfo for the InvariantCulture.
CompareInfo^ myComp = CultureInfo::InvariantCulture->CompareInfo;
// Searches for the ligature Æ.
String^ myStr = "Is AE or ae the same as Æ or æ?";
Console::WriteLine();
Console::WriteLine( "No options : {0}", myStr );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE" ), myComp->LastIndexOf( myStr, "AE" ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae" ), myComp->LastIndexOf( myStr, "ae" ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ' ), myComp->LastIndexOf( myStr, L'Æ' ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ' ), myComp->LastIndexOf( myStr, L'æ' ) );
Console::WriteLine( "Ordinal : {0}", myStr );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "AE", CompareOptions::Ordinal ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "ae", CompareOptions::Ordinal ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'Æ', CompareOptions::Ordinal ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'æ', CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}", myStr );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "AE", CompareOptions::IgnoreCase ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "ae", CompareOptions::IgnoreCase ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'Æ', CompareOptions::IgnoreCase ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'æ', CompareOptions::IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is U\u0308 or u\u0308 the same as \u00DC or \u00FC?";
Console::WriteLine();
Console::WriteLine( "No options : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308" ), myComp->LastIndexOf( myStr, "U\u0308" ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308" ), myComp->LastIndexOf( myStr, "u\u0308" ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü' ), myComp->LastIndexOf( myStr, L'Ü' ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü' ), myComp->LastIndexOf( myStr, L'ü' ) );
Console::WriteLine( "Ordinal : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "U\u0308", CompareOptions::Ordinal ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "u\u0308", CompareOptions::Ordinal ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'Ü', CompareOptions::Ordinal ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'ü', CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "U\u0308", CompareOptions::IgnoreCase ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "u\u0308", CompareOptions::IgnoreCase ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'Ü', CompareOptions::IgnoreCase ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'ü', CompareOptions::IgnoreCase ) );
}
/*
This code produces the following output.
No options : Is AE or ae the same as Æ or æ?
AE : f l
ae : f l
Æ : f l
æ : f l
Ordinal : Is AE or ae the same as Æ or æ?
AE : b
ae : b
Æ : b
æ : b
IgnoreCase : Is AE or ae the same as Æ or æ?
AE : f l
ae : f l
Æ : f l
æ : f l
No options : Is U" or u" the same as Ü or ü?
U" : f l
u" : f l
Ü : f l
ü : f l
Ordinal : Is U" or u" the same as Ü or ü?
U" : b
u" : b
Ü : b
ü : b
IgnoreCase : Is U" or u" the same as Ü or ü?
U" : f l
u" : f l
Ü : f l
ü : f l
*/
using System;
using System.Globalization;
public class SamplesCompareInfo {
public static void Main() {
// Creates CompareInfo for the InvariantCulture.
CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;
// Searches for the ligature Æ.
String myStr = "Is AE or ae the same as Æ or æ?";
Console.WriteLine();
Console.WriteLine( "No options : {0}", myStr );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE" ), myComp.LastIndexOf( myStr, "AE" ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae" ), myComp.LastIndexOf( myStr, "ae" ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ' ), myComp.LastIndexOf( myStr, 'Æ' ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ' ), myComp.LastIndexOf( myStr, 'æ' ) );
Console.WriteLine( "Ordinal : {0}", myStr );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "AE", CompareOptions.Ordinal ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "ae", CompareOptions.Ordinal ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'Æ', CompareOptions.Ordinal ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'æ', CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}", myStr );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "AE", CompareOptions.IgnoreCase ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "ae", CompareOptions.IgnoreCase ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'Æ', CompareOptions.IgnoreCase ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'æ', CompareOptions.IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is \u0055\u0308 or \u0075\u0308 the same as \u00DC or \u00FC?";
Console.WriteLine();
Console.WriteLine( "No options : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308" ), myComp.LastIndexOf( myStr, "U\u0308" ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308" ), myComp.LastIndexOf( myStr, "u\u0308" ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü' ), myComp.LastIndexOf( myStr, 'Ü' ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü' ), myComp.LastIndexOf( myStr, 'ü' ) );
Console.WriteLine( "Ordinal : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "U\u0308", CompareOptions.Ordinal ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "u\u0308", CompareOptions.Ordinal ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'Ü', CompareOptions.Ordinal ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'ü', CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "U\u0308", CompareOptions.IgnoreCase ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "u\u0308", CompareOptions.IgnoreCase ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'Ü', CompareOptions.IgnoreCase ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'ü', CompareOptions.IgnoreCase ) );
}
public static void PrintMarker( String Prefix, int First, int Last ) {
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 ) {
// Creates an array of Char to hold the markers.
Char[] myCharArr = new Char[mySize+1];
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[First] = 'f';
if ( Last > -1 )
myCharArr[Last] = 'l';
if ( First == Last )
myCharArr[First] = 'b';
// Displays the array of Char as a String.
Console.WriteLine( "{0}{1}", Prefix, new String( myCharArr ) );
}
else
{
Console.WriteLine( Prefix );
}
}
}
/*
This code produces the following output.
No options : Is AE or ae the same as Æ or æ?
AE : f l
ae : f l
Æ : f l
æ : f l
Ordinal : Is AE or ae the same as Æ or æ?
AE : b
ae : b
Æ : b
æ : b
IgnoreCase : Is AE or ae the same as Æ or æ?
AE : f l
ae : f l
Æ : f l
æ : f l
No options : Is U" or u" the same as Ü or ü?
U" : f l
u" : f l
Ü : f l
ü : f l
Ordinal : Is U" or u" the same as Ü or ü?
U" : b
u" : b
Ü : b
ü : b
IgnoreCase : Is U" or u" the same as Ü or ü?
U" : f l
u" : f l
Ü : f l
ü : f l
*/
Imports System.Globalization
Public Class SamplesCompareInfo
Public Shared Sub Main()
' Creates CompareInfo for the InvariantCulture.
Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
' Searches for the ligature Æ.
Dim myStr As [String] = "Is AE or ae the same as Æ or æ?"
Console.WriteLine()
Console.WriteLine("No options : {0}", myStr)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE"), myComp.LastIndexOf(myStr, "AE"))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae"), myComp.LastIndexOf(myStr, "ae"))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c), myComp.LastIndexOf(myStr, "Æ"c))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c), myComp.LastIndexOf(myStr, "æ"c))
Console.WriteLine("Ordinal : {0}", myStr)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "AE", CompareOptions.Ordinal))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "ae", CompareOptions.Ordinal))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "Æ"c, CompareOptions.Ordinal))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "æ"c, CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}", myStr)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "AE", CompareOptions.IgnoreCase))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "ae", CompareOptions.IgnoreCase))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "Æ"c, CompareOptions.IgnoreCase))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "æ"c, CompareOptions.IgnoreCase))
' Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is " & ChrW(&H0055) & ChrW(&H0308) & " or " & ChrW(&H0075) & ChrW(&H0308) & " the same as " & ChrW(&H00DC) & " or " & ChrW(&H00FC) & "?"
Console.WriteLine()
Console.WriteLine("No options : {0}", myStr)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308)), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308)))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308)), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308)))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c), myComp.LastIndexOf(myStr, "Ü"c))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c), myComp.LastIndexOf(myStr, "ü"c))
Console.WriteLine("Ordinal : {0}", myStr)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), CompareOptions.Ordinal))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), CompareOptions.Ordinal))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "Ü"c, CompareOptions.Ordinal))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "ü"c, CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}", myStr)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), CompareOptions.IgnoreCase))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), CompareOptions.IgnoreCase))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "Ü"c, CompareOptions.IgnoreCase))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "ü"c, CompareOptions.IgnoreCase))
End Sub
Public Shared Sub PrintMarker(Prefix As [String], First As Integer, Last As Integer)
' Determines the size of the array to create.
Dim mySize As Integer
If Last > First Then
mySize = Last
Else
mySize = First
End If
If mySize > - 1 Then
' Creates an array of Char to hold the markers.
Dim myCharArr(mySize + 1) As [Char]
' Inserts the appropriate markers.
If First > - 1 Then
myCharArr(First) = "f"c
End If
If Last > - 1 Then
myCharArr(Last) = "l"c
End If
If First = Last Then
myCharArr(First) = "b"c
End If
' Displays the array of Char as a String.
Console.WriteLine("{0}{1}", Prefix, New [String](myCharArr))
Else
Console.WriteLine(Prefix)
End If
End Sub
End Class
'This code produces the following output.
'
'No options : Is AE or ae the same as Æ or æ?
' AE : f l
' ae : f l
' Æ : f l
' æ : f l
'Ordinal : Is AE or ae the same as Æ or æ?
' AE : b
' ae : b
' Æ : b
' æ : b
'IgnoreCase : Is AE or ae the same as Æ or æ?
' AE : f l
' ae : f l
' Æ : f l
' æ : f l
'
'No options : Is U" or u" the same as Ü or ü?
' U" : f l
' u" : f l
' Ü : f l
' ü : f l
'Ordinal : Is U" or u" the same as Ü or ü?
' U" : b
' u" : b
' Ü : b
' ü : b
'IgnoreCase : Is U" or u" the same as Ü or ü?
' U" : f l
' u" : f l
' Ü : f l
' ü : f l
Remarks
The source string is searched forward starting at the beginning of the string and ending at the end of the string.
This overload performs a culture-sensitive search. A Unicode 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. To perform an ordinal (culture-insensitive) search, where the Unicode values are compared, you should use one of the overloads that has a parameter of type CompareOptions and use the Ordinal value.
Note
When possible, you should call string comparison methods that have a parameter of type CompareOptions to specify the kind of comparison expected. As a general rule, use linguistic options (using the current culture) for comparing strings displayed in the user interface and specify CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase for security comparisons.
Notes to Callers
Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive sort. In a culture-sensitive search, if value
contains an ignorable character, the result is equivalent to searching with that character removed. If value
consists only of one or more ignorable characters, the IndexOf(String, String) method always returns 0 (zero) to indicate that the match is found at the beginning of source
. In the following example, the IndexOf(String, String) method is used to find three substrings (a soft hyphen (U+00AD), a soft hyphen followed by "n", and a soft hyphen followed by "m") in two strings. Only one of the strings contains a soft hyphen. 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
. When searching for a soft hyphen only, the method returns 0 (zero) to indicate that it has found a match at the beginning of the string.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;
string s1 = "ani\u00ADmal";
string s2 = "animal";
// Find the index of the soft hyphen.
Console.WriteLine(ci.IndexOf(s1, "\u00AD"));
Console.WriteLine(ci.IndexOf(s2, "\u00AD"));
// Find the index of the soft hyphen followed by "n".
Console.WriteLine(ci.IndexOf(s1, "\u00ADn"));
Console.WriteLine(ci.IndexOf(s2, "\u00ADn"));
// Find the index of the soft hyphen followed by "m".
Console.WriteLine(ci.IndexOf(s1, "\u00ADm"));
Console.WriteLine(ci.IndexOf(s2, "\u00ADm"));
}
}
// The example displays the following output:
// 0
// 0
// 1
// 1
// 4
// 3
Imports System.Globalization
Module Example
Public Sub Main()
Dim ci As CompareInfo = CultureInfo.CurrentCulture.CompareInfo
Dim softHyphen As String = ChrW(&h00AD)
Dim s1 As String = "ani" + softHyphen + "mal"
Dim s2 As String = "animal"
' Find the index of the soft hyphen.
Console.WriteLine(ci.IndexOf(s1, softHyphen))
Console.WriteLine(ci.IndexOf(s2, softHyphen))
' Find the index of the soft hyphen followed by "n".
Console.WriteLine(ci.IndexOf(s1, softHyphen + "n"))
Console.WriteLine(ci.IndexOf(s2, softHyphen + "n"))
' Find the index of the soft hyphen followed by "m".
Console.WriteLine(ci.IndexOf(s1, softHyphen + "m"))
Console.WriteLine(ci.IndexOf(s2, softHyphen + "m"))
End Sub
End Module
' The example displays the following output:
' 0
' 0
' 1
' 1
' 4
' 3
See also
Applies to
IndexOf(String, String, CompareOptions)
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Searches for the specified substring and returns the zero-based index of the first occurrence within the entire source string using the specified CompareOptions value.
public:
virtual int IndexOf(System::String ^ source, System::String ^ value, System::Globalization::CompareOptions options);
public:
int IndexOf(System::String ^ source, System::String ^ value, System::Globalization::CompareOptions options);
public virtual int IndexOf (string source, string value, System.Globalization.CompareOptions options);
public int IndexOf (string source, string value, System.Globalization.CompareOptions options);
abstract member IndexOf : string * string * System.Globalization.CompareOptions -> int
override this.IndexOf : string * string * System.Globalization.CompareOptions -> int
member this.IndexOf : string * string * System.Globalization.CompareOptions -> int
Public Overridable Function IndexOf (source As String, value As String, options As CompareOptions) As Integer
Public Function IndexOf (source As String, value As String, options As CompareOptions) As Integer
Parameters
- source
- String
The string to search.
- value
- String
The string to locate within source
.
- options
- CompareOptions
A value that defines how source
and value
should be compared. options
is either the enumeration value Ordinal, or a bitwise combination of one or more of the following values: IgnoreCase, IgnoreSymbols, IgnoreNonSpace, IgnoreWidth, and IgnoreKanaType.
Returns
The zero-based index of the first occurrence of value
, if found, within source
, using the specified comparison options; otherwise, -1. Returns 0 (zero) if value
is an ignorable character.
Exceptions
options
contains an invalid CompareOptions value.
Examples
The following example determines the indexes of the first and last occurrences of a character or a substring within a string.
using namespace System;
using namespace System::Globalization;
void PrintMarker( String^ Prefix, int First, int Last )
{
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 )
{
// Creates an array of Char to hold the markers.
array<Char>^myCharArr = gcnew array<Char>(mySize + 1);
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[ First ] = 'f';
if ( Last > -1 )
myCharArr[ Last ] = 'l';
if ( First == Last )
myCharArr[ First ] = 'b';
// Displays the array of Char as a String.
Console::WriteLine( "{0}{1}", Prefix, gcnew String( myCharArr ) );
}
else
Console::WriteLine( Prefix );
}
int main()
{
// Creates CompareInfo for the InvariantCulture.
CompareInfo^ myComp = CultureInfo::InvariantCulture->CompareInfo;
// Searches for the ligature Æ.
String^ myStr = "Is AE or ae the same as Æ or æ?";
Console::WriteLine();
Console::WriteLine( "No options : {0}", myStr );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE" ), myComp->LastIndexOf( myStr, "AE" ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae" ), myComp->LastIndexOf( myStr, "ae" ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ' ), myComp->LastIndexOf( myStr, L'Æ' ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ' ), myComp->LastIndexOf( myStr, L'æ' ) );
Console::WriteLine( "Ordinal : {0}", myStr );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "AE", CompareOptions::Ordinal ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "ae", CompareOptions::Ordinal ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'Æ', CompareOptions::Ordinal ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'æ', CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}", myStr );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "AE", CompareOptions::IgnoreCase ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "ae", CompareOptions::IgnoreCase ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'Æ', CompareOptions::IgnoreCase ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'æ', CompareOptions::IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is U\u0308 or u\u0308 the same as \u00DC or \u00FC?";
Console::WriteLine();
Console::WriteLine( "No options : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308" ), myComp->LastIndexOf( myStr, "U\u0308" ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308" ), myComp->LastIndexOf( myStr, "u\u0308" ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü' ), myComp->LastIndexOf( myStr, L'Ü' ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü' ), myComp->LastIndexOf( myStr, L'ü' ) );
Console::WriteLine( "Ordinal : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "U\u0308", CompareOptions::Ordinal ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "u\u0308", CompareOptions::Ordinal ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'Ü', CompareOptions::Ordinal ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'ü', CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "U\u0308", CompareOptions::IgnoreCase ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "u\u0308", CompareOptions::IgnoreCase ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'Ü', CompareOptions::IgnoreCase ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'ü', CompareOptions::IgnoreCase ) );
}
/*
This code produces the following output.
No options : Is AE or ae the same as Æ or æ?
AE : f l
ae : f l
Æ : f l
æ : f l
Ordinal : Is AE or ae the same as Æ or æ?
AE : b
ae : b
Æ : b
æ : b
IgnoreCase : Is AE or ae the same as Æ or æ?
AE : f l
ae : f l
Æ : f l
æ : f l
No options : Is U" or u" the same as Ü or ü?
U" : f l
u" : f l
Ü : f l
ü : f l
Ordinal : Is U" or u" the same as Ü or ü?
U" : b
u" : b
Ü : b
ü : b
IgnoreCase : Is U" or u" the same as Ü or ü?
U" : f l
u" : f l
Ü : f l
ü : f l
*/
using System;
using System.Globalization;
public class SamplesCompareInfo {
public static void Main() {
// Creates CompareInfo for the InvariantCulture.
CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;
// Searches for the ligature Æ.
String myStr = "Is AE or ae the same as Æ or æ?";
Console.WriteLine();
Console.WriteLine( "No options : {0}", myStr );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE" ), myComp.LastIndexOf( myStr, "AE" ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae" ), myComp.LastIndexOf( myStr, "ae" ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ' ), myComp.LastIndexOf( myStr, 'Æ' ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ' ), myComp.LastIndexOf( myStr, 'æ' ) );
Console.WriteLine( "Ordinal : {0}", myStr );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "AE", CompareOptions.Ordinal ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "ae", CompareOptions.Ordinal ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'Æ', CompareOptions.Ordinal ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'æ', CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}", myStr );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "AE", CompareOptions.IgnoreCase ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "ae", CompareOptions.IgnoreCase ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'Æ', CompareOptions.IgnoreCase ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'æ', CompareOptions.IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is \u0055\u0308 or \u0075\u0308 the same as \u00DC or \u00FC?";
Console.WriteLine();
Console.WriteLine( "No options : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308" ), myComp.LastIndexOf( myStr, "U\u0308" ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308" ), myComp.LastIndexOf( myStr, "u\u0308" ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü' ), myComp.LastIndexOf( myStr, 'Ü' ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü' ), myComp.LastIndexOf( myStr, 'ü' ) );
Console.WriteLine( "Ordinal : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "U\u0308", CompareOptions.Ordinal ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "u\u0308", CompareOptions.Ordinal ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'Ü', CompareOptions.Ordinal ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'ü', CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "U\u0308", CompareOptions.IgnoreCase ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "u\u0308", CompareOptions.IgnoreCase ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'Ü', CompareOptions.IgnoreCase ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'ü', CompareOptions.IgnoreCase ) );
}
public static void PrintMarker( String Prefix, int First, int Last ) {
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 ) {
// Creates an array of Char to hold the markers.
Char[] myCharArr = new Char[mySize+1];
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[First] = 'f';
if ( Last > -1 )
myCharArr[Last] = 'l';
if ( First == Last )
myCharArr[First] = 'b';
// Displays the array of Char as a String.
Console.WriteLine( "{0}{1}", Prefix, new String( myCharArr ) );
}
else
{
Console.WriteLine( Prefix );
}
}
}
/*
This code produces the following output.
No options : Is AE or ae the same as Æ or æ?
AE : f l
ae : f l
Æ : f l
æ : f l
Ordinal : Is AE or ae the same as Æ or æ?
AE : b
ae : b
Æ : b
æ : b
IgnoreCase : Is AE or ae the same as Æ or æ?
AE : f l
ae : f l
Æ : f l
æ : f l
No options : Is U" or u" the same as Ü or ü?
U" : f l
u" : f l
Ü : f l
ü : f l
Ordinal : Is U" or u" the same as Ü or ü?
U" : b
u" : b
Ü : b
ü : b
IgnoreCase : Is U" or u" the same as Ü or ü?
U" : f l
u" : f l
Ü : f l
ü : f l
*/
Imports System.Globalization
Public Class SamplesCompareInfo
Public Shared Sub Main()
' Creates CompareInfo for the InvariantCulture.
Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
' Searches for the ligature Æ.
Dim myStr As [String] = "Is AE or ae the same as Æ or æ?"
Console.WriteLine()
Console.WriteLine("No options : {0}", myStr)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE"), myComp.LastIndexOf(myStr, "AE"))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae"), myComp.LastIndexOf(myStr, "ae"))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c), myComp.LastIndexOf(myStr, "Æ"c))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c), myComp.LastIndexOf(myStr, "æ"c))
Console.WriteLine("Ordinal : {0}", myStr)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "AE", CompareOptions.Ordinal))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "ae", CompareOptions.Ordinal))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "Æ"c, CompareOptions.Ordinal))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "æ"c, CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}", myStr)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "AE", CompareOptions.IgnoreCase))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "ae", CompareOptions.IgnoreCase))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "Æ"c, CompareOptions.IgnoreCase))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "æ"c, CompareOptions.IgnoreCase))
' Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is " & ChrW(&H0055) & ChrW(&H0308) & " or " & ChrW(&H0075) & ChrW(&H0308) & " the same as " & ChrW(&H00DC) & " or " & ChrW(&H00FC) & "?"
Console.WriteLine()
Console.WriteLine("No options : {0}", myStr)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308)), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308)))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308)), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308)))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c), myComp.LastIndexOf(myStr, "Ü"c))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c), myComp.LastIndexOf(myStr, "ü"c))
Console.WriteLine("Ordinal : {0}", myStr)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), CompareOptions.Ordinal))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), CompareOptions.Ordinal))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "Ü"c, CompareOptions.Ordinal))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "ü"c, CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}", myStr)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), CompareOptions.IgnoreCase))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), CompareOptions.IgnoreCase))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "Ü"c, CompareOptions.IgnoreCase))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "ü"c, CompareOptions.IgnoreCase))
End Sub
Public Shared Sub PrintMarker(Prefix As [String], First As Integer, Last As Integer)
' Determines the size of the array to create.
Dim mySize As Integer
If Last > First Then
mySize = Last
Else
mySize = First
End If
If mySize > - 1 Then
' Creates an array of Char to hold the markers.
Dim myCharArr(mySize + 1) As [Char]
' Inserts the appropriate markers.
If First > - 1 Then
myCharArr(First) = "f"c
End If
If Last > - 1 Then
myCharArr(Last) = "l"c
End If
If First = Last Then
myCharArr(First) = "b"c
End If
' Displays the array of Char as a String.
Console.WriteLine("{0}{1}", Prefix, New [String](myCharArr))
Else
Console.WriteLine(Prefix)
End If
End Sub
End Class
'This code produces the following output.
'
'No options : Is AE or ae the same as Æ or æ?
' AE : f l
' ae : f l
' Æ : f l
' æ : f l
'Ordinal : Is AE or ae the same as Æ or æ?
' AE : b
' ae : b
' Æ : b
' æ : b
'IgnoreCase : Is AE or ae the same as Æ or æ?
' AE : f l
' ae : f l
' Æ : f l
' æ : f l
'
'No options : Is U" or u" the same as Ü or ü?
' U" : f l
' u" : f l
' Ü : f l
' ü : f l
'Ordinal : Is U" or u" the same as Ü or ü?
' U" : b
' u" : b
' Ü : b
' ü : b
'IgnoreCase : Is U" or u" the same as Ü or ü?
' U" : f l
' u" : f l
' Ü : f l
' ü : f l
Remarks
The source string is searched forward starting at the beginning of the string and ending at the end of the string.
The CompareOptions.StringSort value is not valid for this method.
If options
does not include the Ordinal value, this overload performs a culture-sensitive search. A Unicode 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. If options
includes the Ordinal value, this overload performs an ordinal (culture-insensitive) search, where the Unicode values are compared.
Note
When possible, you should call string comparison methods that have a parameter of type CompareOptions to specify the kind of comparison expected. As a general rule, use linguistic options (using the current culture) for comparing strings displayed in the user interface and specify CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase for security comparisons.
Notes to Callers
Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive sort. 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. If value
consists only of one or more ignorable characters, the IndexOf(String, String, CompareOptions) method always returns 0 (zero) to indicate that the match is found at the beginning of source
. In the following example, the IndexOf(String, String, CompareOptions) method is used to find three substrings (a soft hyphen (U+00AD), a soft hyphen followed by "n", and a soft hyphen followed by "m") in two strings. Only one of the strings contains a soft hyphen. Because the soft hyphen is an ignorable character, a culture-sensitive search returns the same value that it would return if the soft hyphen were not included in the search string. An ordinal search, however, successfully finds the soft hyphen in one string and reports that it is absent from the second string.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;
string s1 = "ani\u00ADmal";
string s2 = "animal";
Console.WriteLine("Culture-sensitive comparison:");
// Use culture-sensitive comparison to find the soft hyphen.
Console.WriteLine(ci.IndexOf(s1, "\u00AD", CompareOptions.None));
Console.WriteLine(ci.IndexOf(s2, "\u00AD", CompareOptions.None));
// Use culture-sensitive comparison to find the soft hyphen followed by "n".
Console.WriteLine(ci.IndexOf(s1, "\u00ADn", CompareOptions.None));
Console.WriteLine(ci.IndexOf(s2, "\u00ADn", CompareOptions.None));
// Use culture-sensitive comparison to find the soft hyphen followed by "m".
Console.WriteLine(ci.IndexOf(s1, "\u00ADm", CompareOptions.None));
Console.WriteLine(ci.IndexOf(s2, "\u00ADm", CompareOptions.None));
Console.WriteLine("Ordinal comparison:");
// Use ordinal comparison to find the soft hyphen.
Console.WriteLine(ci.IndexOf(s1, "\u00AD", CompareOptions.Ordinal));
Console.WriteLine(ci.IndexOf(s2, "\u00AD", CompareOptions.Ordinal));
// Use ordinal comparison to find the soft hyphen followed by "n".
Console.WriteLine(ci.IndexOf(s1, "\u00ADn", CompareOptions.Ordinal));
Console.WriteLine(ci.IndexOf(s2, "\u00ADn", CompareOptions.Ordinal));
// Use ordinal comparison to find the soft hyphen followed by "m".
Console.WriteLine(ci.IndexOf(s1, "\u00ADm", CompareOptions.Ordinal));
Console.WriteLine(ci.IndexOf(s2, "\u00ADm", CompareOptions.Ordinal));
}
}
// The example displays the following output:
// Culture-sensitive comparison:
// 0
// 0
// 1
// 1
// 4
// 3
// Ordinal comparison:
// 3
// -1
// -1
// -1
// 3
// -1
Imports System.Globalization
Module Example
Public Sub Main()
Dim ci As CompareInfo = CultureInfo.CurrentCulture.CompareInfo
Dim softHyphen As String = ChrW(&h00AD)
Dim s1 As String = "ani" + softHyphen + "mal"
Dim s2 As String = "animal"
Console.WriteLine("Culture-sensitive comparison:")
' Use culture-sensitive comparison to find the soft hyphen.
Console.WriteLine(ci.IndexOf(s1, softHyphen, CompareOptions.None))
Console.WriteLine(ci.IndexOf(s2, softHyphen, CompareOptions.None))
' Use culture-sensitive comparison to find the soft hyphen followed by "n".
Console.WriteLine(ci.IndexOf(s1, softHyphen + "n", CompareOptions.None))
Console.WriteLine(ci.IndexOf(s2, softHyphen + "n", CompareOptions.None))
' Use culture-sensitive comparison to find the soft hyphen followed by "m".
Console.WriteLine(ci.IndexOf(s1, softHyphen + "m", CompareOptions.None))
Console.WriteLine(ci.IndexOf(s2, softHyphen + "m", CompareOptions.None))
Console.WriteLine("Ordinal comparison:")
' Use ordinal comparison to find the soft hyphen.
Console.WriteLine(ci.IndexOf(s1, softHyphen, CompareOptions.Ordinal))
Console.WriteLine(ci.IndexOf(s2, softHyphen, CompareOptions.Ordinal))
' Use ordinal comparison to find the soft hyphen followed by "n".
Console.WriteLine(ci.IndexOf(s1, softHyphen + "n", CompareOptions.Ordinal))
Console.WriteLine(ci.IndexOf(s2, softHyphen + "n", CompareOptions.Ordinal))
' Use ordinal comparison to find the soft hyphen followed by "m".
Console.WriteLine(ci.IndexOf(s1, softHyphen + "m", CompareOptions.Ordinal))
Console.WriteLine(ci.IndexOf(s2, softHyphen + "m", CompareOptions.Ordinal))
End Sub
End Module
' The example displays the following output:
' Culture-sensitive comparison:
' 0
' 0
' 1
' 1
' 4
' 3
' Ordinal comparison:
' 3
' -1
' -1
' -1
' 3
' -1
See also
Applies to
IndexOf(String, Char)
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Searches for the specified character and returns the zero-based index of the first occurrence within the entire source string.
public:
virtual int IndexOf(System::String ^ source, char value);
public:
int IndexOf(System::String ^ source, char value);
public virtual int IndexOf (string source, char value);
public int IndexOf (string source, char value);
abstract member IndexOf : string * char -> int
override this.IndexOf : string * char -> int
member this.IndexOf : string * char -> int
Public Overridable Function IndexOf (source As String, value As Char) As Integer
Public Function IndexOf (source As String, value As Char) As Integer
Parameters
- source
- String
The string to search.
- value
- Char
The character to locate within source
.
Returns
The zero-based index of the first occurrence of value
, if found, within source
; otherwise, -1. Returns 0 (zero) if value
is an ignorable character.
Exceptions
source
is null
.
Examples
The following example determines the indexes of the first and last occurrences of a character or a substring within a string.
using namespace System;
using namespace System::Globalization;
void PrintMarker( String^ Prefix, int First, int Last )
{
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 )
{
// Creates an array of Char to hold the markers.
array<Char>^myCharArr = gcnew array<Char>(mySize + 1);
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[ First ] = 'f';
if ( Last > -1 )
myCharArr[ Last ] = 'l';
if ( First == Last )
myCharArr[ First ] = 'b';
// Displays the array of Char as a String.
Console::WriteLine( "{0}{1}", Prefix, gcnew String( myCharArr ) );
}
else
Console::WriteLine( Prefix );
}
int main()
{
// Creates CompareInfo for the InvariantCulture.
CompareInfo^ myComp = CultureInfo::InvariantCulture->CompareInfo;
// Searches for the ligature Æ.
String^ myStr = "Is AE or ae the same as Æ or æ?";
Console::WriteLine();
Console::WriteLine( "No options : {0}", myStr );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE" ), myComp->LastIndexOf( myStr, "AE" ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae" ), myComp->LastIndexOf( myStr, "ae" ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ' ), myComp->LastIndexOf( myStr, L'Æ' ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ' ), myComp->LastIndexOf( myStr, L'æ' ) );
Console::WriteLine( "Ordinal : {0}", myStr );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "AE", CompareOptions::Ordinal ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "ae", CompareOptions::Ordinal ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'Æ', CompareOptions::Ordinal ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'æ', CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}", myStr );
PrintMarker( " AE : ", myComp->IndexOf( myStr, "AE", CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "AE", CompareOptions::IgnoreCase ) );
PrintMarker( " ae : ", myComp->IndexOf( myStr, "ae", CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "ae", CompareOptions::IgnoreCase ) );
PrintMarker( " Æ : ", myComp->IndexOf( myStr, L'Æ', CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'Æ', CompareOptions::IgnoreCase ) );
PrintMarker( " æ : ", myComp->IndexOf( myStr, L'æ', CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'æ', CompareOptions::IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is U\u0308 or u\u0308 the same as \u00DC or \u00FC?";
Console::WriteLine();
Console::WriteLine( "No options : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308" ), myComp->LastIndexOf( myStr, "U\u0308" ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308" ), myComp->LastIndexOf( myStr, "u\u0308" ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü' ), myComp->LastIndexOf( myStr, L'Ü' ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü' ), myComp->LastIndexOf( myStr, L'ü' ) );
Console::WriteLine( "Ordinal : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "U\u0308", CompareOptions::Ordinal ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, "u\u0308", CompareOptions::Ordinal ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'Ü', CompareOptions::Ordinal ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', CompareOptions::Ordinal ), myComp->LastIndexOf( myStr, L'ü', CompareOptions::Ordinal ) );
Console::WriteLine( "IgnoreCase : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp->IndexOf( myStr, "U\u0308", CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "U\u0308", CompareOptions::IgnoreCase ) );
PrintMarker( " u\u0308 : ", myComp->IndexOf( myStr, "u\u0308", CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, "u\u0308", CompareOptions::IgnoreCase ) );
PrintMarker( " Ü : ", myComp->IndexOf( myStr, L'Ü', CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'Ü', CompareOptions::IgnoreCase ) );
PrintMarker( " ü : ", myComp->IndexOf( myStr, L'ü', CompareOptions::IgnoreCase ), myComp->LastIndexOf( myStr, L'ü', CompareOptions::IgnoreCase ) );
}
/*
This code produces the following output.
No options : Is AE or ae the same as Æ or æ?
AE : f l
ae : f l
Æ : f l
æ : f l
Ordinal : Is AE or ae the same as Æ or æ?
AE : b
ae : b
Æ : b
æ : b
IgnoreCase : Is AE or ae the same as Æ or æ?
AE : f l
ae : f l
Æ : f l
æ : f l
No options : Is U" or u" the same as Ü or ü?
U" : f l
u" : f l
Ü : f l
ü : f l
Ordinal : Is U" or u" the same as Ü or ü?
U" : b
u" : b
Ü : b
ü : b
IgnoreCase : Is U" or u" the same as Ü or ü?
U" : f l
u" : f l
Ü : f l
ü : f l
*/
using System;
using System.Globalization;
public class SamplesCompareInfo {
public static void Main() {
// Creates CompareInfo for the InvariantCulture.
CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;
// Searches for the ligature Æ.
String myStr = "Is AE or ae the same as Æ or æ?";
Console.WriteLine();
Console.WriteLine( "No options : {0}", myStr );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE" ), myComp.LastIndexOf( myStr, "AE" ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae" ), myComp.LastIndexOf( myStr, "ae" ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ' ), myComp.LastIndexOf( myStr, 'Æ' ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ' ), myComp.LastIndexOf( myStr, 'æ' ) );
Console.WriteLine( "Ordinal : {0}", myStr );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "AE", CompareOptions.Ordinal ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "ae", CompareOptions.Ordinal ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'Æ', CompareOptions.Ordinal ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'æ', CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}", myStr );
PrintMarker( " AE : ", myComp.IndexOf( myStr, "AE", CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "AE", CompareOptions.IgnoreCase ) );
PrintMarker( " ae : ", myComp.IndexOf( myStr, "ae", CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "ae", CompareOptions.IgnoreCase ) );
PrintMarker( " Æ : ", myComp.IndexOf( myStr, 'Æ', CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'Æ', CompareOptions.IgnoreCase ) );
PrintMarker( " æ : ", myComp.IndexOf( myStr, 'æ', CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'æ', CompareOptions.IgnoreCase ) );
// Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is \u0055\u0308 or \u0075\u0308 the same as \u00DC or \u00FC?";
Console.WriteLine();
Console.WriteLine( "No options : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308" ), myComp.LastIndexOf( myStr, "U\u0308" ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308" ), myComp.LastIndexOf( myStr, "u\u0308" ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü' ), myComp.LastIndexOf( myStr, 'Ü' ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü' ), myComp.LastIndexOf( myStr, 'ü' ) );
Console.WriteLine( "Ordinal : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "U\u0308", CompareOptions.Ordinal ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, "u\u0308", CompareOptions.Ordinal ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'Ü', CompareOptions.Ordinal ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', CompareOptions.Ordinal ), myComp.LastIndexOf( myStr, 'ü', CompareOptions.Ordinal ) );
Console.WriteLine( "IgnoreCase : {0}", myStr );
PrintMarker( " U\u0308 : ", myComp.IndexOf( myStr, "U\u0308", CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "U\u0308", CompareOptions.IgnoreCase ) );
PrintMarker( " u\u0308 : ", myComp.IndexOf( myStr, "u\u0308", CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, "u\u0308", CompareOptions.IgnoreCase ) );
PrintMarker( " Ü : ", myComp.IndexOf( myStr, 'Ü', CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'Ü', CompareOptions.IgnoreCase ) );
PrintMarker( " ü : ", myComp.IndexOf( myStr, 'ü', CompareOptions.IgnoreCase ), myComp.LastIndexOf( myStr, 'ü', CompareOptions.IgnoreCase ) );
}
public static void PrintMarker( String Prefix, int First, int Last ) {
// Determines the size of the array to create.
int mySize;
if ( Last > First )
mySize = Last;
else
mySize = First;
if ( mySize > -1 ) {
// Creates an array of Char to hold the markers.
Char[] myCharArr = new Char[mySize+1];
// Inserts the appropriate markers.
if ( First > -1 )
myCharArr[First] = 'f';
if ( Last > -1 )
myCharArr[Last] = 'l';
if ( First == Last )
myCharArr[First] = 'b';
// Displays the array of Char as a String.
Console.WriteLine( "{0}{1}", Prefix, new String( myCharArr ) );
}
else
{
Console.WriteLine( Prefix );
}
}
}
/*
This code produces the following output.
No options : Is AE or ae the same as Æ or æ?
AE : f l
ae : f l
Æ : f l
æ : f l
Ordinal : Is AE or ae the same as Æ or æ?
AE : b
ae : b
Æ : b
æ : b
IgnoreCase : Is AE or ae the same as Æ or æ?
AE : f l
ae : f l
Æ : f l
æ : f l
No options : Is U" or u" the same as Ü or ü?
U" : f l
u" : f l
Ü : f l
ü : f l
Ordinal : Is U" or u" the same as Ü or ü?
U" : b
u" : b
Ü : b
ü : b
IgnoreCase : Is U" or u" the same as Ü or ü?
U" : f l
u" : f l
Ü : f l
ü : f l
*/
Imports System.Globalization
Public Class SamplesCompareInfo
Public Shared Sub Main()
' Creates CompareInfo for the InvariantCulture.
Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
' Searches for the ligature Æ.
Dim myStr As [String] = "Is AE or ae the same as Æ or æ?"
Console.WriteLine()
Console.WriteLine("No options : {0}", myStr)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE"), myComp.LastIndexOf(myStr, "AE"))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae"), myComp.LastIndexOf(myStr, "ae"))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c), myComp.LastIndexOf(myStr, "Æ"c))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c), myComp.LastIndexOf(myStr, "æ"c))
Console.WriteLine("Ordinal : {0}", myStr)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "AE", CompareOptions.Ordinal))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "ae", CompareOptions.Ordinal))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "Æ"c, CompareOptions.Ordinal))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "æ"c, CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}", myStr)
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "AE", CompareOptions.IgnoreCase))
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "ae", CompareOptions.IgnoreCase))
PrintMarker(" Æ : ", myComp.IndexOf(myStr, "Æ"c, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "Æ"c, CompareOptions.IgnoreCase))
PrintMarker(" æ : ", myComp.IndexOf(myStr, "æ"c, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "æ"c, CompareOptions.IgnoreCase))
' Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis.
myStr = "Is " & ChrW(&H0055) & ChrW(&H0308) & " or " & ChrW(&H0075) & ChrW(&H0308) & " the same as " & ChrW(&H00DC) & " or " & ChrW(&H00FC) & "?"
Console.WriteLine()
Console.WriteLine("No options : {0}", myStr)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308)), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308)))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308)), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308)))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c), myComp.LastIndexOf(myStr, "Ü"c))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c), myComp.LastIndexOf(myStr, "ü"c))
Console.WriteLine("Ordinal : {0}", myStr)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), CompareOptions.Ordinal))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), CompareOptions.Ordinal))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "Ü"c, CompareOptions.Ordinal))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "ü"c, CompareOptions.Ordinal))
Console.WriteLine("IgnoreCase : {0}", myStr)
PrintMarker(" U" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "U" & ChrW(&H0308), CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "U" & ChrW(&H0308), CompareOptions.IgnoreCase))
PrintMarker(" u" & ChrW(&H0308) & " : ", myComp.IndexOf(myStr, "u" & ChrW(&H0308), CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "u" & ChrW(&H0308), CompareOptions.IgnoreCase))
PrintMarker(" Ü : ", myComp.IndexOf(myStr, "Ü"c, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "Ü"c, CompareOptions.IgnoreCase))
PrintMarker(" ü : ", myComp.IndexOf(myStr, "ü"c, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "ü"c, CompareOptions.IgnoreCase))
End Sub
Public Shared Sub PrintMarker(Prefix As [String], First As Integer, Last As Integer)
' Determines the size of the array to create.
Dim mySize As Integer
If Last > First Then
mySize = Last
Else
mySize = First
End If
If mySize > - 1 Then
' Creates an array of Char to hold the markers.
Dim myCharArr(mySize + 1) As [Char]
' Inserts the appropriate markers.
If First > - 1 Then
myCharArr(First) = "f"c
End If
If Last > - 1 Then
myCharArr(Last) = "l"c
End If
If First = Last Then
myCharArr(First) = "b"c
End If
' Displays the array of Char as a String.
Console.WriteLine("{0}{1}", Prefix, New [String](myCharArr))
Else
Console.WriteLine(Prefix)
End If
End Sub
End Class
'This code produces the following output.
'
'No options : Is AE or ae the same as Æ or æ?
' AE : f l
' ae : f l
' Æ : f l
' æ : f l
'Ordinal : Is AE or ae the same as Æ or æ?
' AE : b
' ae : b
' Æ : b
' æ : b
'IgnoreCase : Is AE or ae the same as Æ or æ?
' AE : f l
' ae : f l
' Æ : f l
' æ : f l
'
'No options : Is U" or u" the same as Ü or ü?
' U" : f l
' u" : f l
' Ü : f l
' ü : f l
'Ordinal : Is U" or u" the same as Ü or ü?
' U" : b
' u" : b
' Ü : b
' ü : b
'IgnoreCase : Is U" or u" the same as Ü or ü?
' U" : f l
' u" : f l
' Ü : f l
' ü : f l
Remarks
This method searches the source string from the beginning of the string to the end of the string.
This overload performs a culture-sensitive search. If value
represents a precomposed Unicode character, such as the ligature "Æ" (U+00C6), it might be considered equivalent to any occurrence of its components in the correct sequence, such as "AE" (U+0041, U+0045), depending on the culture. To perform an ordinal (culture-insensitive) search, where a character is considered equivalent to another character only if their Unicode code points are the same, you should call an overload that has a parameter of type CompareOptions and use the CompareOptions.Ordinal value. Unlike CompareInfo.IndexOf, which performs a culture-sensitive comparison, overloads of the String.IndexOf method that search for a character perform an ordinal comparison and overloads that search for a string perform a culture-sensitive comparison.
Note
When possible, you should use string comparison methods that have a parameter of type CompareOptions to specify the kind of comparison expected. As a general rule, use linguistic options (using the current culture) for comparing strings displayed in the user interface and specify CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase for security comparisons.
Notes to Callers
Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive sort. In a culture-sensitive search, if value
is an ignorable character, the result is equivalent to searching with that character removed. In this case, the IndexOf(String, Char) method always returns 0 (zero) to indicate that the match is found at the beginning of source
. In the following example, the IndexOf(String, Char) method is used to find the soft hyphen (U+00AD) in two strings. Only one of the strings contains a soft hyphen. In both cases, because the soft hyphen is an ignorable character, the method returns 0 (zero) to indicate that it has found a match at the beginning of the string.
using System;
using System.Globalization;
public class Example
{
public static void Main()
{
CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;
string s1 = "ani\u00ADmal";
string s2 = "animal";
// Find the index of the soft hyphen.
Console.WriteLine(ci.IndexOf(s1, '\u00AD'));
Console.WriteLine(ci.IndexOf(s2, '\u00AD'));
}
}
// The example displays the following output:
// 0
// 0
Imports System.Globalization
Module Example
Public Sub Main()
Dim ci As CompareInfo = CultureInfo.CurrentCulture.CompareInfo
Dim softHyphen As Char = ChrW(&h00AD)
Dim s1 As String = "ani" + softHyphen + "mal"
Dim s2 As String = "animal"
' Find the index of the soft hyphen.
Console.WriteLine(ci.IndexOf(s1, softHyphen))
Console.WriteLine(ci.IndexOf(s2, softHyphen))
End Sub
End Module
' The example displays the following output:
' 0
' 0
See also
Applies to
Pripomienky
https://aka.ms/ContentUserFeedback.
Pripravujeme: V priebehu roka 2024 postupne zrušíme službu Problémy v službe GitHub ako mechanizmus pripomienok týkajúcich sa obsahu a nahradíme ju novým systémom pripomienok. Ďalšie informácie nájdete na stránke:Odoslať a zobraziť pripomienky pre