CompareInfo.IndexOf Método
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Retorna o índice baseado em zero da primeira ocorrência de um valor dentro de uma cadeia de caracteres ou dentro de parte dela.
Sobrecargas
| IndexOf(ReadOnlySpan<Char>, ReadOnlySpan<Char>, CompareOptions, Int32) |
Pesquisa pela primeira ocorrência de uma substring dentro de uma cadeia de caracteres de origem. |
| IndexOf(String, String, Int32, Int32, CompareOptions) |
Pesquisa a subcadeia de caracteres especificada e retorna o índice baseado em zero da primeira ocorrência dentro de uma seção da cadeia de caracteres de origem que começa no índice especificado e contém o número de elementos especificado usando o valor CompareOptions especificado. |
| IndexOf(String, String, Int32, Int32) |
Pesquisa a subcadeia de caracteres especificadas e retorna o índice baseado em zero da primeira ocorrência dentro da seção da cadeia de caracteres de origem, que começa no índice especificado e contém o número de elementos especificado. |
| IndexOf(String, String, Int32, CompareOptions) |
Pesquisa a subcadeia de caracteres especificada e retorna o índice baseado em zero da primeira ocorrência dentro da seção da cadeia de caracteres de origem que se estende do índice especificado ao final da cadeia de caracteres usando o valor de CompareOptions especificado. |
| IndexOf(String, Char, Int32, Int32) |
Pesquisa o caractere especificado e retorna o índice baseado em zero da primeira ocorrência dentro da seção da cadeia de caracteres de origem, que começa no índice especificado e contém o número de elementos especificado. |
| IndexOf(String, Char, Int32, CompareOptions) |
Pesquisa o caractere especificado e retorna o índice baseado em zero da primeira ocorrência dentro da seção da cadeia de caracteres de origem que se estende do índice especificado ao final da cadeia de caracteres usando o valor de CompareOptions especificado. |
| IndexOf(String, String, Int32) |
Pesquisa a subcadeia de caracteres especificada e retorna o índice baseado em zero da primeira ocorrência dentro da seção da cadeia de caracteres que se estende do índice especificado para o final da cadeia de caracteres. |
| IndexOf(String, Char, Int32, Int32, CompareOptions) |
Pesquisa o caractere especificado e retorna o índice baseado em zero da primeira ocorrência dentro de uma seção da cadeia de caracteres de origem que começa no índice especificado e contém o número de elementos especificado usando o valor CompareOptions especificado. |
| IndexOf(String, Char, Int32) |
Pesquisa o caractere especificado e retorna o índice baseado em zero da primeira ocorrência dentro da seção da cadeia de caracteres de origem que se estende do índice especificado ao final da cadeia de caracteres. |
| IndexOf(String, Char, CompareOptions) |
Pesquisa a cadeia de caracteres especificada e retorna o índice baseado em zero da primeira ocorrência em toda a cadeia de caracteres de origem usando o valor CompareOptions especificado. |
| IndexOf(ReadOnlySpan<Char>, Rune, CompareOptions) |
Pesquisa a primeira ocorrência de um Rune dentro do intervalo de caracteres somente leitura especificado. |
| IndexOf(ReadOnlySpan<Char>, ReadOnlySpan<Char>, CompareOptions) |
Pesquisa a primeira ocorrência de uma substring dentro do intervalo de caracteres somente leitura especificado. |
| IndexOf(String, String) |
Pesquisa a subcadeia de caracteres especificada e retorna o índice baseado em zero da primeira ocorrência em toda a cadeia de caracteres de origem. |
| IndexOf(String, String, CompareOptions) |
Pesquisa a subcadeia de caracteres especificada e retorna o índice com base em zero da primeira ocorrência dentro de toda a cadeia de caracteres de origem usando o valor CompareOptions especificado. |
| IndexOf(String, Char) |
Pesquisa a cadeia de caracteres especificada e retorna o índice baseado em zero da primeira ocorrência em toda a cadeia de caracteres de origem. |
IndexOf(ReadOnlySpan<Char>, ReadOnlySpan<Char>, CompareOptions, Int32)
Pesquisa pela primeira ocorrência de uma substring dentro de uma cadeia de caracteres de origem.
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 -> intPublic Function IndexOf (source As ReadOnlySpan(Of Char), value As ReadOnlySpan(Of Char), options As CompareOptions, ByRef matchLength As Integer) As IntegerParâmetros
- source
- ReadOnlySpan<Char>
O intervalo somente leitura de caracteres a ser pesquisado.
- value
- ReadOnlySpan<Char>
O intervalo de caracteres somente leitura que contém a substring a ser localizada em source.
- options
- CompareOptions
O CompareOptions a ser usado durante a pesquisa.
- matchLength
- Int32
Quando este método retorna, ele contém o número de caracteres de source correspondentes ao valor desejado. Ele poderá ser diferente do comprimento de value se uma comparação linguística for executada. Defina como 0 se value não for encontrado em source.
Retornos
O índice baseado em zero em source em que a substring value aparece primeiro; ou um valor negativo se value não puder ser encontrado em source.
Exceções
options contém uma combinação não compatível de sinalizadores.
Comentários
Esse método tem uma sobrecarga maior do que outras IndexOf sobrecargas que não levam a um matchLength argumento. Chame essa sobrecarga somente se você precisar das informações de comprimento da correspondência.
Aplica-se a
IndexOf(String, String, Int32, Int32, CompareOptions)
Pesquisa a subcadeia de caracteres especificada e retorna o índice baseado em zero da primeira ocorrência dentro de uma seção da cadeia de caracteres de origem que começa no índice especificado e contém o número de elementos especificado usando o valor CompareOptions especificado.
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 -> intmember this.IndexOf : string * string * int * int * System.Globalization.CompareOptions -> intPublic Overridable Function IndexOf (source As String, value As String, startIndex As Integer, count As Integer, options As CompareOptions) As IntegerPublic Function IndexOf (source As String, value As String, startIndex As Integer, count As Integer, options As CompareOptions) As IntegerParâmetros
- source
- String
A cadeia de caracteres a ser pesquisada.
- value
- String
A cadeia de caracteres a ser localizada dentro de source.
- startIndex
- Int32
O índice inicial com base em zero da pesquisa.
- count
- Int32
O número de elementos na seção a ser pesquisada.
- options
- CompareOptions
Um valor que define como source e value devem ser comparados. options é o valor de enumeração Ordinal ou uma combinação bit a bit de um ou mais dos seguintes valores: IgnoreCase, IgnoreSymbols, IgnoreNonSpace, IgnoreWidth e IgnoreKanaType.
Retornos
O índice baseado em zero da primeira ocorrência de value, se encontrado, dentro da seção de source que começa em startIndex e contém o número de elementos especificado por count, usando as opções de comparação especificadas; caso contrário, -1. Retorna startIndex se value é um caractere ignorável.
Exceções
startIndex está fora do intervalo de índices válidos para source.
- ou -
count é menor que zero.
- ou -
startIndex e count não especificam uma seção válida em source.
options contém um valor CompareOptions inválido.
Exemplos
O exemplo a seguir determina os índices das primeiras e últimas ocorrências de um caractere ou uma subcadeia de caracteres dentro de uma parte de uma cadeia de caracteres.
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
Comentários
A cadeia de caracteres de origem é pesquisada para startIndex frente começando e terminando em startIndex + count - 1.
O CompareOptions.StringSort valor não é válido para este método.
Se options não incluir o Ordinal valor, essa sobrecarga executará uma pesquisa sensível à cultura. Um valor Unicode que representa um caractere pré-colocado, como a ligatura "Æ" (U+00C6), pode ser considerado equivalente a qualquer ocorrência dos componentes do caractere na sequência correta, como "AE" (U+0041, U+0045), dependendo da cultura. Se options incluir o Ordinal valor, essa sobrecarga executará uma pesquisa ordinal (sem diferenciação de cultura), em que os valores Unicode são comparados.
Observação
Quando possível, você deve chamar métodos de comparação de cadeia de caracteres que têm um parâmetro de tipo CompareOptions para especificar o tipo de comparação esperado. Como regra geral, use opções linguísticas (usando a cultura atual) para comparar cadeias de caracteres exibidas na interface do usuário e especificar CompareOptions.Ordinal ou CompareOptions.OrdinalIgnoreCase para comparações de segurança.
Notas aos Chamadores
Os conjuntos de caracteres incluem caracteres ignoráveis, que são caracteres que não são considerados ao executar uma classificação linguística ou sensível à cultura. Em uma pesquisa sensível à cultura (ou seja, caso options não seja Ordinal ou OrdinalIgnoreCase), caso value contenha um caractere ignorável, o resultado é equivalente à pesquisa com esse caractere removido. Se value consistir apenas em um ou mais caracteres ignoráveis, o IndexOf(String, String, Int32, Int32, CompareOptions) método sempre retornará startIndex, que é a posição de caractere na qual a pesquisa começa.
No exemplo a seguir, o IndexOf(String, String, Int32, Int32, CompareOptions) método é usado para localizar a posição de um hífen macio (U+00AD) seguido por um "m" começando na terceira a sexta posições de caracteres em duas cadeias de caracteres. Apenas uma das cadeias de caracteres contém a subcadeia de caracteres necessária. Em ambos os casos, como o hífen condicional é um caractere ignorável, o método retorna o índice de "m" na cadeia de caracteres ao realizar uma comparação sensível à cultura. No entanto, quando ele executa uma comparação ordinal, ele localiza a subcadeia de caracteres apenas na primeira cadeia de caracteres. Observe que, no caso da primeira cadeia de caracteres, que inclui o hífen macio seguido por um "m", o método não retorna o índice do hífen macio, mas retorna o índice do "m" quando executa uma comparação sensível à cultura. O método só retorna o índice do hífen condicional na primeira cadeia de caracteres quando executa uma comparação ordinal.
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
Confira também
Aplica-se a
IndexOf(String, String, Int32, Int32)
Pesquisa a subcadeia de caracteres especificadas e retorna o índice baseado em zero da primeira ocorrência dentro da seção da cadeia de caracteres de origem, que começa no índice especificado e contém o número de elementos especificado.
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 -> intmember this.IndexOf : string * string * int * int -> intPublic Overridable Function IndexOf (source As String, value As String, startIndex As Integer, count As Integer) As IntegerPublic Function IndexOf (source As String, value As String, startIndex As Integer, count As Integer) As IntegerParâmetros
- source
- String
A cadeia de caracteres a ser pesquisada.
- value
- String
A cadeia de caracteres a ser localizada dentro de source.
- startIndex
- Int32
O índice inicial com base em zero da pesquisa.
- count
- Int32
O número de elementos na seção a ser pesquisada.
Retornos
O índice baseado em zero da primeira ocorrência de value, se encontrado, dentro da seção de source que começa em startIndex e contém o número de elementos especificado por count; caso contrário, -1. Retorna startIndex se value é um caractere ignorável.
Exceções
startIndex está fora do intervalo de índices válidos para source.
- ou -
count é menor que zero.
- ou -
startIndex e count não especificam uma seção válida em source.
Exemplos
O exemplo a seguir determina os índices das primeiras e últimas ocorrências de um caractere ou uma subcadeia de caracteres dentro de uma parte de uma cadeia de caracteres.
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
Comentários
A cadeia de caracteres de origem é pesquisada para startIndex frente começando e terminando em startIndex + count - 1.
Essa sobrecarga executa uma pesquisa sensível à cultura. Um valor Unicode que representa um caractere pré-colocado, como a ligatura "Æ" (U+00C6), pode ser considerado equivalente a qualquer ocorrência dos componentes do caractere na sequência correta, como "AE" (U+0041, U+0045), dependendo da cultura. Para executar uma pesquisa ordinal (sem diferenciação de cultura), em que os valores Unicode são comparados, você deve chamar uma das sobrecargas que tem um parâmetro de tipo CompareOptions e usar o Ordinal valor.
Observação
Quando possível, você deve chamar métodos de comparação de cadeia de caracteres que têm um parâmetro de tipo CompareOptions para especificar o tipo de comparação esperado. Como regra geral, use opções linguísticas (usando a cultura atual) para comparar cadeias de caracteres exibidas na interface do usuário e especificar CompareOptions.Ordinal ou CompareOptions.OrdinalIgnoreCase para comparações de segurança.
Notas aos Chamadores
Os conjuntos de caracteres incluem caracteres ignoráveis, que são caracteres que não são considerados ao executar uma classificação linguística ou sensível à cultura. Em uma pesquisa sensível à cultura, caso value contenha um caractere ignorável, o resultado é equivalente à pesquisa com esse caractere removido. Se value consistir apenas em um ou mais caracteres ignoráveis, o IndexOf(String, String, Int32, Int32) método sempre retornará startIndex, que é a posição de caractere na qual a pesquisa começa.
No exemplo a seguir, o IndexOf(String, String, Int32, Int32) método é usado para localizar a posição de um hífen macio (U+00AD) seguido por um "m" começando na terceira a sexta posições de caracteres em duas cadeias de caracteres. Apenas uma das cadeias de caracteres contém a subcadeia de caracteres necessária. Em ambos os casos, como o hífen condicional é um caractere ignorável, o método retorna o índice de "m" na cadeia de caracteres ao realizar uma comparação sensível à cultura. No caso da primeira cadeia de caracteres, que inclui o hífen condicional seguido de um "m", o método não retorna o índice do hífen virtual, mas retorna o índice do "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
Confira também
Aplica-se a
IndexOf(String, String, Int32, CompareOptions)
Pesquisa a subcadeia de caracteres especificada e retorna o índice baseado em zero da primeira ocorrência dentro da seção da cadeia de caracteres de origem que se estende do índice especificado ao final da cadeia de caracteres usando o valor de CompareOptions especificado.
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 -> intmember this.IndexOf : string * string * int * System.Globalization.CompareOptions -> intPublic Overridable Function IndexOf (source As String, value As String, startIndex As Integer, options As CompareOptions) As IntegerPublic Function IndexOf (source As String, value As String, startIndex As Integer, options As CompareOptions) As IntegerParâmetros
- source
- String
A cadeia de caracteres a ser pesquisada.
- value
- String
A cadeia de caracteres a ser localizada dentro de source.
- startIndex
- Int32
O índice inicial com base em zero da pesquisa.
- options
- CompareOptions
Um valor que define como source e value devem ser comparados. options é o valor de enumeração Ordinal ou uma combinação bit a bit de um ou mais dos seguintes valores: IgnoreCase, IgnoreSymbols, IgnoreNonSpace, IgnoreWidth e IgnoreKanaType.
Retornos
O índice baseado em zero da primeira ocorrência de value, se encontrado, dentro da seção de source que se estende de startIndex até o final de source, usando as opções de comparação especificadas; caso contrário, -1. Retorna startIndex se value é um caractere ignorável.
Exceções
startIndex está fora do intervalo de índices válidos para source.
options contém um valor CompareOptions inválido.
Exemplos
O exemplo a seguir determina os índices das primeiras e últimas ocorrências de um caractere ou uma subcadeia de caracteres dentro de uma parte de uma cadeia de caracteres. Observe isso IndexOf e LastIndexOf está pesquisando em partes diferentes da cadeia de caracteres, mesmo com o mesmo startIndex parâmetro.
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
Comentários
A cadeia de caracteres de origem é pesquisada para startIndex frente começando e terminando no final da cadeia de caracteres.
O CompareOptions.StringSort valor não é válido para este método.
Se options não incluir o Ordinal valor, essa sobrecarga executará uma pesquisa sensível à cultura. Um valor Unicode que representa um caractere pré-colocado, como a ligatura "Æ" (U+00C6), pode ser considerado equivalente a qualquer ocorrência dos componentes do caractere na sequência correta, como "AE" (U+0041, U+0045), dependendo da cultura. Se options incluir o Ordinal valor, essa sobrecarga executará uma pesquisa ordinal (sem diferenciação de cultura), em que os valores Unicode são comparados.
Observação
Quando possível, você deve chamar métodos de comparação de cadeia de caracteres que têm um parâmetro de tipo CompareOptions para especificar o tipo de comparação esperado. Como regra geral, use opções linguísticas (usando a cultura atual) para comparar cadeias de caracteres exibidas na interface do usuário e especificar CompareOptions.Ordinal ou CompareOptions.OrdinalIgnoreCase para comparações de segurança.
Notas aos Chamadores
Os conjuntos de caracteres incluem caracteres ignoráveis, que são caracteres que não são considerados ao executar uma classificação linguística ou sensível à cultura. Em uma pesquisa sensível à cultura (ou seja, caso options não seja Ordinal ou OrdinalIgnoreCase), caso value contenha um caractere ignorável, o resultado é equivalente à pesquisa com esse caractere removido. Se value consistir apenas em um ou mais caracteres ignoráveis, o IndexOf(String, String, Int32, CompareOptions) método sempre retornará startIndex, que é a posição de caractere na qual a pesquisa começa.
No exemplo a seguir, o IndexOf(String, String, Int32, CompareOptions) método é usado para localizar a posição de um hífen macio (U+00AD) seguido por um "m" começando com a posição do terceiro caractere em duas cadeias de caracteres. Apenas uma das cadeias de caracteres contém a subcadeia de caracteres necessária. Em ambos os casos, como o hífen condicional é um caractere ignorável, o método retorna o índice de "m" na cadeia de caracteres ao realizar uma comparação sensível à cultura. No caso da primeira cadeia de caracteres, que inclui o hífen condicional seguido de um "m", o método não retorna o índice do hífen virtual, mas retorna o índice do "m". O método só retorna o índice do hífen condicional na primeira cadeia de caracteres quando executa uma comparação ordinal.
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
Confira também
Aplica-se a
IndexOf(String, Char, Int32, Int32)
Pesquisa o caractere especificado e retorna o índice baseado em zero da primeira ocorrência dentro da seção da cadeia de caracteres de origem, que começa no índice especificado e contém o número de elementos especificado.
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 -> intmember this.IndexOf : string * char * int * int -> intPublic Overridable Function IndexOf (source As String, value As Char, startIndex As Integer, count As Integer) As IntegerPublic Function IndexOf (source As String, value As Char, startIndex As Integer, count As Integer) As IntegerParâmetros
- source
- String
A cadeia de caracteres a ser pesquisada.
- value
- Char
O caractere a ser localizado no source.
- startIndex
- Int32
O índice inicial com base em zero da pesquisa.
- count
- Int32
O número de elementos na seção a ser pesquisada.
Retornos
O índice baseado em zero da primeira ocorrência de value, se encontrado, dentro da seção de source que começa em startIndex e contém o número de elementos especificado por count; caso contrário, -1. Retorna startIndex se value é um caractere ignorável.
Exceções
source é null.
startIndex está fora do intervalo de índices válidos para source.
- ou -
count é menor que zero.
- ou -
startIndex e count não especificam uma seção válida em source.
Exemplos
O exemplo a seguir determina os índices das primeiras e últimas ocorrências de um caractere ou uma subcadeia de caracteres dentro de uma parte de uma cadeia de caracteres.
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
Comentários
A cadeia de caracteres de origem é pesquisada para startIndex frente começando e terminando em startIndex + count - 1.
Essa sobrecarga executa uma pesquisa sensível à cultura. Se o caractere for um valor Unicode que representa um caractere pré-colocado, como a ligatura "Æ" (U+00C6), ele poderá ser considerado equivalente a qualquer ocorrência de seus componentes na sequência correta, como "AE" (U+0041, U+0045), dependendo da cultura. Para executar uma pesquisa ordinal (que não diferencia cultura), em que um caractere é considerado equivalente a outro caractere somente se os valores Unicode forem iguais, você deverá chamar uma das sobrecargas que tem um parâmetro de tipo CompareOptions e usar o Ordinal valor. As sobrecargas dessa String.IndexOf pesquisa de um caractere executam uma pesquisa ordinal, enquanto as que pesquisam uma cadeia de caracteres executam uma pesquisa sensível à cultura.
Observação
Quando possível, você deve chamar métodos de comparação de cadeia de caracteres que têm um parâmetro de tipo CompareOptions para especificar o tipo de comparação esperado. Como regra geral, use opções linguísticas (usando a cultura atual) para comparar cadeias de caracteres exibidas na interface do usuário e especificar CompareOptions.Ordinal ou CompareOptions.OrdinalIgnoreCase para comparações de segurança.
Notas aos Chamadores
Os conjuntos de caracteres incluem caracteres ignoráveis, que são caracteres que não são considerados ao executar uma classificação linguística ou sensível à cultura. Em uma pesquisa sensível à cultura, se value for um caractere ignorável, o resultado será equivalente à pesquisa com esse caractere removido. Nesse caso, o IndexOf(String, Char, Int32, Int32) método sempre retorna startIndex, que é a posição de caractere na qual a pesquisa foi iniciada pela primeira vez. No exemplo a seguir, o IndexOf(String, Char, Int32, Int32) método é usado para localizar um hífen macio (U+00AD) após um "n" em duas cadeias de caracteres. Apenas uma das cadeias de caracteres contém um hífen condicional. Em ambos os casos, como o hífen macio é um caractere ignorável, o método retorna 1 para indicar que encontrou uma correspondência na posição do "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
Confira também
Aplica-se a
IndexOf(String, Char, Int32, CompareOptions)
Pesquisa o caractere especificado e retorna o índice baseado em zero da primeira ocorrência dentro da seção da cadeia de caracteres de origem que se estende do índice especificado ao final da cadeia de caracteres usando o valor de CompareOptions especificado.
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 -> intmember this.IndexOf : string * char * int * System.Globalization.CompareOptions -> intPublic Overridable Function IndexOf (source As String, value As Char, startIndex As Integer, options As CompareOptions) As IntegerPublic Function IndexOf (source As String, value As Char, startIndex As Integer, options As CompareOptions) As IntegerParâmetros
- source
- String
A cadeia de caracteres a ser pesquisada.
- value
- Char
O caractere a ser localizado no source.
- startIndex
- Int32
O índice inicial com base em zero da pesquisa.
- options
- CompareOptions
Um valor que define como source e value devem ser comparados. options é o valor de enumeração Ordinal ou uma combinação bit a bit de um ou mais dos seguintes valores: IgnoreCase, IgnoreSymbols, IgnoreNonSpace, IgnoreWidth e IgnoreKanaType.
Retornos
O índice baseado em zero da primeira ocorrência de value, se encontrado, dentro da seção de source que se estende de startIndex até o final de source, usando as opções de comparação especificadas; caso contrário, -1. Retorna startIndex se value é um caractere ignorável.
Exceções
source é null.
startIndex está fora do intervalo de índices válidos para source.
options contém um valor CompareOptions inválido.
Exemplos
O exemplo a seguir determina os índices das primeiras e últimas ocorrências de um caractere ou uma subcadeia de caracteres dentro de uma parte de uma cadeia de caracteres. Observe isso IndexOf e LastIndexOf está pesquisando em partes diferentes da cadeia de caracteres, mesmo com o mesmo startIndex parâmetro.
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
Comentários
A cadeia de caracteres de origem é pesquisada para startIndex frente começando e terminando no final da cadeia de caracteres.
O CompareOptions.StringSort valor não é válido para este método.
Se options não incluir o Ordinal valor, essa sobrecarga executará uma pesquisa sensível à cultura. Se o caractere for um valor Unicode que representa um caractere pré-colocado, como a ligatura "Æ" (U+00C6), ele poderá ser considerado equivalente a qualquer ocorrência de seus componentes na sequência correta, como "AE" (U+0041, U+0045), dependendo da cultura. Se options incluir o Ordinal valor, essa sobrecarga executará uma pesquisa ordinal (sem diferenciação de cultura). Um caractere será considerado equivalente a outro caractere somente se os valores Unicode forem os mesmos. As sobrecargas dessa String.IndexOf pesquisa de um caractere executam uma pesquisa ordinal, enquanto as que pesquisam uma cadeia de caracteres executam uma pesquisa sensível à cultura.
Observação
Quando possível, você deve chamar métodos de comparação de cadeia de caracteres que têm um parâmetro de tipo CompareOptions para especificar o tipo de comparação esperado. Como regra geral, use opções linguísticas (usando a cultura atual) para comparar cadeias de caracteres exibidas na interface do usuário e especificar CompareOptions.Ordinal ou CompareOptions.OrdinalIgnoreCase para comparações de segurança.
Notas aos Chamadores
Os conjuntos de caracteres incluem caracteres ignoráveis, que são caracteres que não são considerados ao executar uma classificação linguística ou sensível à cultura. Em uma pesquisa sensível à cultura, se value for um caractere ignorável, o resultado será equivalente à pesquisa com esse caractere removido. Nesse caso, o IndexOf(String, Char, Int32, CompareOptions) método sempre retorna startIndexa posição do caractere na qual a pesquisa começou. No exemplo a seguir, o IndexOf(String, Char, Int32, CompareOptions) método é usado para localizar o hífen macio (U+00AD) após um "n" em duas cadeias de caracteres. Apenas uma das cadeias de caracteres contém um hífen condicional. Em ambos os casos, como o hífen macio é um caractere ignorável, uma pesquisa sensível à cultura retorna 1 para indicar que encontrou uma correspondência na posição do "n". Uma pesquisa ordinal, no entanto, encontra com êxito o hífen macio em uma cadeia de caracteres e relata que ele está ausente da segunda cadeia de caracteres.
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
Confira também
Aplica-se a
IndexOf(String, String, Int32)
Pesquisa a subcadeia de caracteres especificada e retorna o índice baseado em zero da primeira ocorrência dentro da seção da cadeia de caracteres que se estende do índice especificado para o final da cadeia de caracteres.
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 -> intabstract member IndexOf : string * string * int -> int
override this.IndexOf : string * string * int -> intPublic Function IndexOf (source As String, value As String, startIndex As Integer) As IntegerPublic Overridable Function IndexOf (source As String, value As String, startIndex As Integer) As IntegerParâmetros
- source
- String
A cadeia de caracteres a ser pesquisada.
- value
- String
A cadeia de caracteres a ser localizada dentro de source.
- startIndex
- Int32
O índice inicial com base em zero da pesquisa.
Retornos
O índice baseado em zero da primeira ocorrência de value, se for encontrado, na seção de source que se estende de startIndex até o final de source; caso contrário, -1. Retorna startIndex se value é um caractere ignorável.
Exceções
startIndex está fora do intervalo de índices válidos para source.
Exemplos
O exemplo a seguir determina os índices das primeiras e últimas ocorrências de um caractere ou uma subcadeia de caracteres dentro de uma parte de uma cadeia de caracteres. Observe isso IndexOf e LastIndexOf está pesquisando em diferentes partes da cadeia de caracteres, mesmo com o mesmo startIndex parâmetro.
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
Comentários
A cadeia de caracteres de origem é pesquisada para frente começando startIndex e terminando no final da cadeia de caracteres.
Essa sobrecarga executa uma pesquisa que diferencia a cultura. Um valor Unicode que representa um caractere pré-compilado, como a ligadura "Æ" (U+00C6), pode ser considerado equivalente a qualquer ocorrência dos componentes do caractere na sequência correta, como "AE" (U+0041, U+0045), dependendo da cultura. Para executar uma pesquisa ordinal (que não diferencia cultura), em que os valores Unicode são comparados, você deve chamar uma das sobrecargas que tem um parâmetro de tipo CompareOptions e usar o Ordinal valor.
Observação
Quando possível, você deve chamar métodos de comparação de cadeia de caracteres que têm um parâmetro de tipo CompareOptions para especificar o tipo de comparação esperado. Como regra geral, use opções linguísticas (usando a cultura atual) para comparar cadeias de caracteres exibidas na interface do usuário e especificar CompareOptions.Ordinal ou CompareOptions.OrdinalIgnoreCase para comparações de segurança.
Notas aos Chamadores
Os conjuntos de caracteres incluem caracteres ignoráveis, que são caracteres que não são considerados ao executar uma classificação linguística ou sensível à cultura. Em uma pesquisa sensível à cultura, caso value contenha um caractere ignorável, o resultado é equivalente à pesquisa com esse caractere removido. Se value consistir apenas em um ou mais caracteres ignoráveis, o IndexOf(String, String, Int32) método sempre retornará startIndex, que é a posição do caractere na qual a pesquisa começa.
No exemplo a seguir, o IndexOf(String, String, Int32) método é usado para localizar a posição de um hífen macio (U+00AD) seguido por um "m" em duas cadeias de caracteres. Apenas uma das cadeias de caracteres contém a subcadeia de caracteres necessária. Em ambos os casos, como o hífen macio é um caractere ignorável, o método retorna o índice de "m" na cadeia de caracteres. No caso da primeira cadeia de caracteres, que inclui o hífen condicional seguido de um "m", o método não retorna o índice do hífen virtual, mas retorna o índice do "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
Confira também
Aplica-se a
IndexOf(String, Char, Int32, Int32, CompareOptions)
Pesquisa o caractere especificado e retorna o índice baseado em zero da primeira ocorrência dentro de uma seção da cadeia de caracteres de origem que começa no índice especificado e contém o número de elementos especificado usando o valor CompareOptions especificado.
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 -> intmember this.IndexOf : string * char * int * int * System.Globalization.CompareOptions -> intPublic Overridable Function IndexOf (source As String, value As Char, startIndex As Integer, count As Integer, options As CompareOptions) As IntegerPublic Function IndexOf (source As String, value As Char, startIndex As Integer, count As Integer, options As CompareOptions) As IntegerParâmetros
- source
- String
A cadeia de caracteres a ser pesquisada.
- value
- Char
O caractere a ser localizado no source.
- startIndex
- Int32
O índice inicial com base em zero da pesquisa.
- count
- Int32
O número de elementos na seção a ser pesquisada.
- options
- CompareOptions
Um valor que define como source e value devem ser comparados. options é o valor de enumeração Ordinal ou uma combinação bit a bit de um ou mais dos seguintes valores: IgnoreCase, IgnoreSymbols, IgnoreNonSpace, IgnoreWidth e IgnoreKanaType.
Retornos
O índice baseado em zero da primeira ocorrência de value, se encontrado, dentro da seção de source que começa em startIndex e contém o número de elementos especificado por count, usando as opções de comparação especificadas; caso contrário, -1. Retorna startIndex se value é um caractere ignorável.
Exceções
source é null.
startIndex está fora do intervalo de índices válidos para source.
- ou -
count é menor que zero.
- ou -
startIndex e count não especificam uma seção válida em source.
options contém um valor CompareOptions inválido.
Exemplos
O exemplo a seguir determina os índices das primeiras e últimas ocorrências de um caractere ou uma subcadeia de caracteres dentro de uma parte de uma cadeia de caracteres.
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
Comentários
A cadeia de caracteres de origem é pesquisada para startIndex frente começando e terminando em startIndex + count - 1.
O CompareOptions.StringSort valor não é válido para este método.
Se options não incluir o Ordinal valor, essa sobrecarga executará uma pesquisa sensível à cultura. Se o caractere for um valor Unicode que representa um caractere pré-colocado, como a ligatura "Æ" (U+00C6), ele poderá ser considerado equivalente a qualquer ocorrência de seus componentes na sequência correta, como "AE" (U+0041, U+0045), dependendo da cultura. Se options incluir o Ordinal valor, essa sobrecarga executará uma pesquisa ordinal (sem diferenciação de cultura). Um caractere será considerado equivalente a outro caractere somente se os valores Unicode forem os mesmos. As sobrecargas dessa String.IndexOf pesquisa de um caractere executam uma pesquisa ordinal, enquanto as que pesquisam uma cadeia de caracteres executam uma pesquisa sensível à cultura.
Observação
Quando possível, você deve chamar métodos de comparação de cadeia de caracteres que têm um parâmetro de tipo CompareOptions para especificar o tipo de comparação esperado. Como regra geral, use opções linguísticas (usando a cultura atual) para comparar cadeias de caracteres exibidas na interface do usuário e especificar CompareOptions.Ordinal ou CompareOptions.OrdinalIgnoreCase para comparações de segurança.
Notas aos Chamadores
Os conjuntos de caracteres incluem caracteres ignoráveis, que são caracteres que não são considerados ao executar uma classificação linguística ou sensível à cultura. Em uma pesquisa sensível à cultura, se value for um caractere ignorável, o resultado será equivalente à pesquisa com esse caractere removido. Nesse caso, o IndexOf(String, Char, Int32, Int32, CompareOptions) método sempre retorna startIndex, que é a posição de caractere na qual a pesquisa foi iniciada pela primeira vez. No exemplo a seguir, o IndexOf(String, Char, Int32, Int32, CompareOptions) método é usado para localizar o hífen macio (U+00AD) após um "n" em duas cadeias de caracteres. Apenas uma das cadeias de caracteres contém um hífen condicional. Em ambos os casos, como o hífen macio é um caractere ignorável, uma pesquisa sensível à cultura retorna 1 para indicar que encontrou uma correspondência na posição do "n". Uma pesquisa ordinal, no entanto, encontra com êxito o hífen macio em uma cadeia de caracteres e relata que ele está ausente da segunda cadeia de caracteres.
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
Confira também
Aplica-se a
IndexOf(String, Char, Int32)
Pesquisa o caractere especificado e retorna o índice baseado em zero da primeira ocorrência dentro da seção da cadeia de caracteres de origem que se estende do índice especificado ao final da cadeia de caracteres.
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 -> intabstract member IndexOf : string * char * int -> int
override this.IndexOf : string * char * int -> intPublic Function IndexOf (source As String, value As Char, startIndex As Integer) As IntegerPublic Overridable Function IndexOf (source As String, value As Char, startIndex As Integer) As IntegerParâmetros
- source
- String
A cadeia de caracteres a ser pesquisada.
- value
- Char
O caractere a ser localizado no source.
- startIndex
- Int32
O índice inicial com base em zero da pesquisa.
Retornos
O índice baseado em zero da primeira ocorrência de value, se for encontrado, na seção de source que se estende de startIndex até o final de source; caso contrário, -1. Retorna startIndex se value é um caractere ignorável.
Exceções
source é null.
startIndex está fora do intervalo de índices válidos para source.
Exemplos
O exemplo a seguir determina os índices das primeiras e últimas ocorrências de um caractere ou uma subcadeia de caracteres dentro de uma parte de uma cadeia de caracteres. Observe isso IndexOf e LastIndexOf está pesquisando em diferentes partes da cadeia de caracteres, mesmo com o mesmo startIndex parâmetro.
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
Comentários
A cadeia de caracteres de origem é pesquisada para frente começando startIndex e terminando no final da cadeia de caracteres.
Essa sobrecarga executa uma pesquisa que diferencia a cultura. Se o caractere for um valor Unicode que representa um caractere pré-compilado, como a ligatura "Æ" (U+00C6), ele poderá ser considerado equivalente a qualquer ocorrência de seus componentes na sequência correta, como "AE" (U+0041, U+0045), dependendo da cultura. Para executar uma pesquisa ordinal (que não diferencia cultura), em que um caractere é considerado equivalente a outro caractere somente se os valores Unicode forem iguais, você deverá chamar uma das sobrecargas que tem um parâmetro de tipo CompareOptions e usar o Ordinal valor. As sobrecargas dessa String.IndexOf pesquisa por um caractere executam uma pesquisa ordinal, enquanto as que pesquisam uma cadeia de caracteres executam uma pesquisa sensível à cultura.
Observação
Quando possível, você deve chamar métodos de comparação de cadeia de caracteres que têm um parâmetro de tipo CompareOptions para especificar o tipo de comparação esperado. Como regra geral, use opções linguísticas (usando a cultura atual) para comparar cadeias de caracteres exibidas na interface do usuário e especificar CompareOptions.Ordinal ou CompareOptions.OrdinalIgnoreCase para comparações de segurança.
Notas aos Chamadores
Os conjuntos de caracteres incluem caracteres ignoráveis, que são caracteres que não são considerados ao executar uma classificação linguística ou sensível à cultura. Em uma pesquisa sensível à cultura, se value for um caractere ignorável, o resultado será equivalente à pesquisa com esse caractere removido. Nesse caso, o IndexOf(String, Char, Int32) método sempre retorna startIndex, que é a posição do caractere na qual a pesquisa começa. No exemplo a seguir, o IndexOf(String, Char, Int32) método é usado para encontrar um hífen macio (U+00AD) após um "n" em duas cadeias de caracteres. Apenas uma das cadeias de caracteres contém um hífen condicional. Em ambos os casos, como o hífen macio é um caractere ignorável, o método retorna 1 para indicar que encontrou uma correspondência na posição do "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
Confira também
Aplica-se a
IndexOf(String, Char, CompareOptions)
Pesquisa a cadeia de caracteres especificada e retorna o índice baseado em zero da primeira ocorrência em toda a cadeia de caracteres de origem usando o valor CompareOptions especificado.
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 -> intmember this.IndexOf : string * char * System.Globalization.CompareOptions -> intPublic Overridable Function IndexOf (source As String, value As Char, options As CompareOptions) As IntegerPublic Function IndexOf (source As String, value As Char, options As CompareOptions) As IntegerParâmetros
- source
- String
A cadeia de caracteres a ser pesquisada.
- value
- Char
O caractere a ser localizado no source.
- options
- CompareOptions
Um valor que define como as cadeias de caracteres devem ser comparadas. options é o valor de enumeração Ordinal ou uma combinação bit a bit de um ou mais dos seguintes valores: IgnoreCase, IgnoreSymbols, IgnoreNonSpace, IgnoreWidth e IgnoreKanaType.
Retornos
O índice baseado em zero da primeira ocorrência de value, se encontrado, em source, usando as opções de comparação especificadas; caso contrário, -1. Retornará 0 (zero) se value for um caractere ignorável.
Exceções
source é null.
options contém um valor CompareOptions inválido.
Exemplos
O exemplo a seguir determina os índices das primeiras e últimas ocorrências de um caractere ou uma subcadeia de caracteres dentro de uma cadeia de caracteres.
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
Comentários
A cadeia de caracteres de origem é pesquisada no início da cadeia de caracteres e termina no final da cadeia de caracteres.
O CompareOptions.StringSort valor não é válido para esse método.
Se options não incluir o Ordinal valor, essa sobrecarga executará uma pesquisa que diferencia a cultura. Se o caractere for um valor Unicode que representa um caractere pré-compilado, como a ligatura "Æ" (U+00C6), ele poderá ser considerado equivalente a qualquer ocorrência de seus componentes na sequência correta, como "AE" (U+0041, U+0045), dependendo da cultura. Se options incluir o Ordinal valor, essa sobrecarga executará uma pesquisa ordinal (que não diferencia cultura). Um caractere será considerado equivalente a outro caractere somente se os valores Unicode forem os mesmos. As sobrecargas dessa String.IndexOf pesquisa por um caractere executam uma pesquisa ordinal, enquanto as que pesquisam uma cadeia de caracteres executam uma pesquisa sensível à cultura.
Observação
Quando possível, você deve usar métodos de comparação de cadeia de caracteres que têm um parâmetro de tipo CompareOptions para especificar o tipo de comparação esperado. Como regra geral, use opções linguísticas (usando a cultura atual) para comparar cadeias de caracteres exibidas na interface do usuário e especificar CompareOptions.Ordinal ou CompareOptions.OrdinalIgnoreCase para comparações de segurança.
Notas aos Chamadores
Os conjuntos de caracteres incluem caracteres ignoráveis, que são caracteres que não são considerados ao executar uma classificação linguística ou sensível à cultura. Em uma pesquisa sensível à cultura, se value for um caractere ignorável, o resultado será equivalente à pesquisa com esse caractere removido. Nesse caso, o IndexOf(String, Char, CompareOptions) método sempre retorna 0 (zero) para indicar que a correspondência foi encontrada no início de source. No exemplo a seguir, o IndexOf(String, Char, CompareOptions) método é usado para pesquisar um hífen macio (U+00AD) em duas cadeias de caracteres. Apenas uma das cadeias de caracteres contém um hífen condicional. Em ambos os casos, como o hífen macio é um caractere ignorável, uma pesquisa sensível à cultura retorna 0 (zero) para indicar que encontrou uma correspondência no início da cadeia de caracteres. Uma pesquisa ordinal, no entanto, encontra com êxito o hífen macio em uma cadeia de caracteres e relata que ele está ausente da segunda cadeia de caracteres.
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
Confira também
Aplica-se a
IndexOf(ReadOnlySpan<Char>, Rune, CompareOptions)
Pesquisa a primeira ocorrência de um Rune dentro do intervalo de caracteres somente leitura especificado.
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 -> intPublic Function IndexOf (source As ReadOnlySpan(Of Char), value As Rune, Optional options As CompareOptions = System.Globalization.CompareOptions.None) As IntegerParâmetros
- source
- ReadOnlySpan<Char>
O intervalo somente leitura de caracteres a ser pesquisado.
- options
- CompareOptions
Uma combinação opcional de valores de enumeração CompareOptions a serem usados durante a pesquisa. O valor padrão é None.
Retornos
O índice baseado em zero em source em que value aparece primeiro; ou um valor negativo se value não puder ser encontrado em source.
Exceções
options contém uma combinação não compatível de sinalizadores.
Aplica-se a
IndexOf(ReadOnlySpan<Char>, ReadOnlySpan<Char>, CompareOptions)
Pesquisa a primeira ocorrência de uma substring dentro do intervalo de caracteres somente leitura especificado.
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 -> intPublic Function IndexOf (source As ReadOnlySpan(Of Char), value As ReadOnlySpan(Of Char), Optional options As CompareOptions = System.Globalization.CompareOptions.None) As IntegerParâmetros
- source
- ReadOnlySpan<Char>
A cadeia de caracteres a ser pesquisada.
- value
- ReadOnlySpan<Char>
A substring a ser localizada em source.
- options
- CompareOptions
Uma combinação opcional de valores de enumeração CompareOptions a serem usados durante a pesquisa. O valor padrão é None.
Retornos
O índice baseado em zero em source em que a substring value aparece primeiro; ou um valor negativo se value não puder ser encontrado em source.
Exceções
options contém uma combinação não compatível de sinalizadores.
Aplica-se a
IndexOf(String, String)
Pesquisa a subcadeia de caracteres especificada e retorna o índice baseado em zero da primeira ocorrência em toda a cadeia de caracteres de origem.
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 -> intmember this.IndexOf : string * string -> intPublic Overridable Function IndexOf (source As String, value As String) As IntegerPublic Function IndexOf (source As String, value As String) As IntegerParâmetros
- source
- String
A cadeia de caracteres a ser pesquisada.
- value
- String
A cadeia de caracteres a ser localizada dentro de source.
Retornos
O índice baseado em zero da primeira ocorrência de value, se encontrado, dentro do source, caso contrário, -1. Retornará 0 (zero) se value for um caractere ignorável.
Exceções
Exemplos
O exemplo a seguir determina os índices das primeiras e últimas ocorrências de um caractere ou uma subcadeia de caracteres dentro de uma cadeia de caracteres.
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
Comentários
A cadeia de caracteres de origem é pesquisada no início da cadeia de caracteres e termina no final da cadeia de caracteres.
Essa sobrecarga executa uma pesquisa que diferencia a cultura. Um valor Unicode que representa um caractere pré-compilado, como a ligadura "Æ" (U+00C6), pode ser considerado equivalente a qualquer ocorrência dos componentes do caractere na sequência correta, como "AE" (U+0041, U+0045), dependendo da cultura. Para executar uma pesquisa ordinal (que não diferencia cultura), em que os valores Unicode são comparados, você deve usar uma das sobrecargas que tem um parâmetro de tipo CompareOptions e usar o Ordinal valor.
Observação
Quando possível, você deve chamar métodos de comparação de cadeia de caracteres que têm um parâmetro de tipo CompareOptions para especificar o tipo de comparação esperado. Como regra geral, use opções linguísticas (usando a cultura atual) para comparar cadeias de caracteres exibidas na interface do usuário e especificar CompareOptions.Ordinal ou CompareOptions.OrdinalIgnoreCase para comparações de segurança.
Notas aos Chamadores
Os conjuntos de caracteres incluem caracteres ignoráveis, que são caracteres que não são considerados ao executar uma classificação linguística ou sensível à cultura. Em uma pesquisa sensível à cultura, caso value contenha um caractere ignorável, o resultado é equivalente à pesquisa com esse caractere removido. Se value consistir apenas em um ou mais caracteres ignoráveis, o IndexOf(String, String) método sempre retornará 0 (zero) para indicar que a correspondência foi encontrada no início de source. No exemplo a seguir, o IndexOf(String, String) método é usado para localizar três subcadeias de caracteres (um hífen macio (U+00AD), um hífen macio seguido de "n" e um hífen macio seguido por "m") em duas cadeias de caracteres. Apenas uma das cadeias de caracteres contém um hífen condicional. Em cada caso, como o hífen macio é um caractere ignorável, o resultado é o mesmo que se o hífen macio não tivesse sido incluído em value. Ao procurar apenas um hífen macio, o método retorna 0 (zero) para indicar que encontrou uma correspondência no início da cadeia de caracteres.
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
Confira também
Aplica-se a
IndexOf(String, String, CompareOptions)
Pesquisa a subcadeia de caracteres especificada e retorna o índice com base em zero da primeira ocorrência dentro de toda a cadeia de caracteres de origem usando o valor CompareOptions especificado.
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 -> intmember this.IndexOf : string * string * System.Globalization.CompareOptions -> intPublic Overridable Function IndexOf (source As String, value As String, options As CompareOptions) As IntegerPublic Function IndexOf (source As String, value As String, options As CompareOptions) As IntegerParâmetros
- source
- String
A cadeia de caracteres a ser pesquisada.
- value
- String
A cadeia de caracteres a ser localizada dentro de source.
- options
- CompareOptions
Um valor que define como source e value devem ser comparados. options é o valor de enumeração Ordinal ou uma combinação bit a bit de um ou mais dos seguintes valores: IgnoreCase, IgnoreSymbols, IgnoreNonSpace, IgnoreWidth e IgnoreKanaType.
Retornos
O índice baseado em zero da primeira ocorrência de value, se encontrado, em source, usando as opções de comparação especificadas; caso contrário, -1. Retornará 0 (zero) se value for um caractere ignorável.
Exceções
options contém um valor CompareOptions inválido.
Exemplos
O exemplo a seguir determina os índices das primeiras e últimas ocorrências de um caractere ou uma subcadeia de caracteres dentro de uma cadeia de caracteres.
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
Comentários
A cadeia de caracteres de origem é pesquisada no início da cadeia de caracteres e termina no final da cadeia de caracteres.
O CompareOptions.StringSort valor não é válido para esse método.
Se options não incluir o Ordinal valor, essa sobrecarga executará uma pesquisa que diferencia a cultura. Um valor Unicode que representa um caractere pré-compilado, como a ligadura "Æ" (U+00C6), pode ser considerado equivalente a qualquer ocorrência dos componentes do caractere na sequência correta, como "AE" (U+0041, U+0045), dependendo da cultura. Se options incluir o Ordinal valor, essa sobrecarga executará uma pesquisa ordinal (que não diferencia cultura), em que os valores Unicode são comparados.
Observação
Quando possível, você deve chamar métodos de comparação de cadeia de caracteres que têm um parâmetro de tipo CompareOptions para especificar o tipo de comparação esperado. Como regra geral, use opções linguísticas (usando a cultura atual) para comparar cadeias de caracteres exibidas na interface do usuário e especificar CompareOptions.Ordinal ou CompareOptions.OrdinalIgnoreCase para comparações de segurança.
Notas aos Chamadores
Os conjuntos de caracteres incluem caracteres ignoráveis, que são caracteres que não são considerados ao executar uma classificação linguística ou sensível à cultura. Em uma pesquisa sensível à cultura (ou seja, caso options não seja Ordinal ou OrdinalIgnoreCase), caso value contenha um caractere ignorável, o resultado é equivalente à pesquisa com esse caractere removido. Se value consistir apenas em um ou mais caracteres ignoráveis, o IndexOf(String, String, CompareOptions) método sempre retornará 0 (zero) para indicar que a correspondência foi encontrada no início de source. No exemplo a seguir, o IndexOf(String, String, CompareOptions) método é usado para localizar três subcadeias de caracteres (um hífen macio (U+00AD), um hífen macio seguido de "n" e um hífen macio seguido por "m") em duas cadeias de caracteres. Apenas uma das cadeias de caracteres contém um hífen condicional. Como o hífen macio é um caractere ignorável, uma pesquisa sensível à cultura retorna o mesmo valor que retornaria se o hífen macio não fosse incluído na cadeia de caracteres de pesquisa. Uma pesquisa ordinal, no entanto, encontra com êxito o hífen macio em uma cadeia de caracteres e relata que ele está ausente da segunda cadeia de caracteres.
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
Confira também
Aplica-se a
IndexOf(String, Char)
Pesquisa a cadeia de caracteres especificada e retorna o índice baseado em zero da primeira ocorrência em toda a cadeia de caracteres de origem.
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 -> intmember this.IndexOf : string * char -> intPublic Overridable Function IndexOf (source As String, value As Char) As IntegerPublic Function IndexOf (source As String, value As Char) As IntegerParâmetros
- source
- String
A cadeia de caracteres a ser pesquisada.
- value
- Char
O caractere a ser localizado no source.
Retornos
O índice baseado em zero da primeira ocorrência de value, se encontrado, dentro do source, caso contrário, -1. Retornará 0 (zero) se value for um caractere ignorável.
Exceções
source é null.
Exemplos
O exemplo a seguir determina os índices das primeiras e últimas ocorrências de um caractere ou uma subcadeia de caracteres dentro de uma cadeia de caracteres.
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
Comentários
Esse método pesquisa a cadeia de caracteres de origem desde o início da cadeia de caracteres até o final da cadeia de caracteres.
Essa sobrecarga executa uma pesquisa que diferencia a cultura. Se value representar um caractere Unicode pré-compilado, como a ligatura "Æ" (U+00C6), ele poderá ser considerado equivalente a qualquer ocorrência de seus componentes na sequência correta, como "AE" (U+0041, U+0045), dependendo da cultura. Para executar uma pesquisa ordinal (que não diferencia cultura), em que um caractere é considerado equivalente a outro caractere somente se seus pontos de código Unicode forem iguais, você deverá chamar uma sobrecarga que tenha um parâmetro de tipo CompareOptions e use o CompareOptions.Ordinal valor. Ao contrário CompareInfo.IndexOfde , que executa uma comparação que diferencia a cultura, as String.IndexOf sobrecargas do método que pesquisam um caractere executam uma comparação ordinal e sobrecargas que pesquisam uma cadeia de caracteres executam uma comparação sensível à cultura.
Observação
Quando possível, você deve usar métodos de comparação de cadeia de caracteres que têm um parâmetro de tipo CompareOptions para especificar o tipo de comparação esperado. Como regra geral, use opções linguísticas (usando a cultura atual) para comparar cadeias de caracteres exibidas na interface do usuário e especificar CompareOptions.Ordinal ou CompareOptions.OrdinalIgnoreCase para comparações de segurança.
Notas aos Chamadores
Os conjuntos de caracteres incluem caracteres ignoráveis, que são caracteres que não são considerados ao executar uma classificação linguística ou sensível à cultura. Em uma pesquisa sensível à cultura, se value for um caractere ignorável, o resultado será equivalente à pesquisa com esse caractere removido. Nesse caso, o IndexOf(String, Char) método sempre retorna 0 (zero) para indicar que a correspondência foi encontrada no início de source. No exemplo a seguir, o IndexOf(String, Char) método é usado para localizar o hífen macio (U+00AD) em duas cadeias de caracteres. Apenas uma das cadeias de caracteres contém um hífen condicional. Em ambos os casos, como o hífen macio é um caractere ignorável, o método retorna 0 (zero) para indicar que encontrou uma correspondência no início da cadeia de caracteres.
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