CompareInfo.IndexOf Metoda
Definicja
Ważne
Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.
Zwraca indeks od zera pierwszego wystąpienia wartości w ciągu lub w jego części.
Przeciążenia
IndexOf(ReadOnlySpan<Char>, ReadOnlySpan<Char>, CompareOptions, Int32) |
Wyszukuje pierwsze wystąpienie podciągu w ciągu źródłowym. |
IndexOf(String, String, Int32, Int32, CompareOptions) |
Wyszukuje określony podciąg i zwraca indeks od zera pierwszego wystąpienia w sekcji ciągu źródłowego, który rozpoczyna się od określonego indeksu i zawiera określoną liczbę elementów przy użyciu określonej CompareOptions wartości. |
IndexOf(String, String, Int32, Int32) |
Wyszukuje określony podciąg i zwraca indeks od zera pierwszego wystąpienia w sekcji ciągu źródłowego, który rozpoczyna się od określonego indeksu i zawiera określoną liczbę elementów. |
IndexOf(String, String, Int32, CompareOptions) |
Wyszukuje określony podciąg i zwraca indeks od zera pierwszego wystąpienia w sekcji ciągu źródłowego, który rozciąga się od określonego indeksu do końca ciągu przy użyciu określonej CompareOptions wartości. |
IndexOf(String, Char, Int32, Int32) |
Wyszukuje określony znak i zwraca indeks od zera pierwszego wystąpienia w sekcji ciągu źródłowego, która rozpoczyna się od określonego indeksu i zawiera określoną liczbę elementów. |
IndexOf(String, Char, Int32, CompareOptions) |
Wyszukuje określony znak i zwraca indeks od zera pierwszego wystąpienia w sekcji ciągu źródłowego, który rozciąga się od określonego indeksu do końca ciągu przy użyciu określonej CompareOptions wartości. |
IndexOf(String, String, Int32) |
Wyszukuje określony podciąg i zwraca indeks od zera pierwszego wystąpienia w sekcji ciągu źródłowego, który rozciąga się od określonego indeksu do końca ciągu. |
IndexOf(String, Char, Int32, Int32, CompareOptions) |
Wyszukuje określony znak i zwraca indeks od zera pierwszego wystąpienia w sekcji ciągu źródłowego, który rozpoczyna się od określonego indeksu i zawiera określoną liczbę elementów przy użyciu określonej CompareOptions wartości. |
IndexOf(String, Char, Int32) |
Wyszukuje określony znak i zwraca indeks od zera pierwszego wystąpienia w sekcji ciągu źródłowego, który rozciąga się od określonego indeksu do końca ciągu. |
IndexOf(String, Char, CompareOptions) |
Wyszukuje określony znak i zwraca indeks od zera pierwszego wystąpienia w ciągu źródłowym przy użyciu określonej CompareOptions wartości. |
IndexOf(ReadOnlySpan<Char>, Rune, CompareOptions) |
Wyszukuje pierwsze wystąpienie ciągu Rune w określonym zakresie znaków tylko do odczytu. |
IndexOf(ReadOnlySpan<Char>, ReadOnlySpan<Char>, CompareOptions) |
Wyszukuje pierwsze wystąpienie podciągu w określonym zakresie znaków tylko do odczytu. |
IndexOf(String, String) |
Wyszukuje określony podciąg i zwraca indeks od zera pierwszego wystąpienia w całym ciągu źródłowym. |
IndexOf(String, String, CompareOptions) |
Wyszukuje określony podciąg i zwraca indeks pierwszego wystąpienia w ciągu źródłowym od zera przy użyciu określonej CompareOptions wartości. |
IndexOf(String, Char) |
Wyszukuje określony znak i zwraca indeks od zera pierwszego wystąpienia w całym ciągu źródłowym. |
IndexOf(ReadOnlySpan<Char>, ReadOnlySpan<Char>, CompareOptions, Int32)
Wyszukuje pierwsze wystąpienie podciągu w ciągu źródłowym.
public:
int IndexOf(ReadOnlySpan<char> source, ReadOnlySpan<char> value, System::Globalization::CompareOptions options, [Runtime::InteropServices::Out] int % matchLength);
public int IndexOf (ReadOnlySpan<char> source, ReadOnlySpan<char> value, System.Globalization.CompareOptions options, out int matchLength);
member this.IndexOf : ReadOnlySpan<char> * ReadOnlySpan<char> * System.Globalization.CompareOptions * int -> int
Public Function IndexOf (source As ReadOnlySpan(Of Char), value As ReadOnlySpan(Of Char), options As CompareOptions, ByRef matchLength As Integer) As Integer
Parametry
- source
- ReadOnlySpan<Char>
Zakres znaków tylko do odczytu, w których ma być wyszukiwany.
- value
- ReadOnlySpan<Char>
Zakres tylko do odczytu znaków zawierających podciąg do zlokalizowania w source
.
- options
- CompareOptions
Do CompareOptions użycia podczas wyszukiwania.
- matchLength
- Int32
Gdy ta metoda zwraca wartość , zawiera liczbę znaków, source
które pasują do żądanej wartości. Może to różnić się od długości value
w przypadku wykonania porównania językowego. Ustaw wartość 0, jeśli value
nie zostanie odnaleziona w . source
Zwraca
Indeks oparty na zeru, w którym pierwszy raz pojawia się podciąg, lub wartość ujemną, jeśli nie source
value
można znaleźć w value
. source
Wyjątki
options
Zawiera nieobsługiwaną kombinację flag.
Uwagi
Ta metoda ma większe obciążenie niż inne IndexOf przeciążenia, które nie przyjmą matchLength
argumentu. Wywołaj to przeciążenie tylko wtedy, gdy wymagane są informacje o długości dopasowania.
Dotyczy
IndexOf(String, String, Int32, Int32, CompareOptions)
Wyszukuje określony podciąg i zwraca indeks od zera pierwszego wystąpienia w sekcji ciągu źródłowego, który rozpoczyna się od określonego indeksu i zawiera określoną liczbę elementów przy użyciu określonej CompareOptions wartości.
public:
virtual int IndexOf(System::String ^ source, System::String ^ value, int startIndex, int count, System::Globalization::CompareOptions options);
public:
int IndexOf(System::String ^ source, System::String ^ value, int startIndex, int count, System::Globalization::CompareOptions options);
public virtual int IndexOf (string source, string value, int startIndex, int count, System.Globalization.CompareOptions options);
public int IndexOf (string source, string value, int startIndex, int count, System.Globalization.CompareOptions options);
abstract member IndexOf : string * string * int * int * System.Globalization.CompareOptions -> int
override this.IndexOf : string * string * int * int * System.Globalization.CompareOptions -> int
member this.IndexOf : string * string * int * int * System.Globalization.CompareOptions -> int
Public Overridable Function IndexOf (source As String, value As String, startIndex As Integer, count As Integer, options As CompareOptions) As Integer
Public Function IndexOf (source As String, value As String, startIndex As Integer, count As Integer, options As CompareOptions) As Integer
Parametry
- source
- String
Ciąg do wyszukania.
- value
- String
Ciąg do zlokalizowania source
w .
- startIndex
- Int32
Wartość początkowa indeksu zaczynającego się od zera dla wyszukiwania.
- count
- Int32
Liczba elementów w sekcji do wyszukania.
- options
- CompareOptions
Wartość, która definiuje sposób source
value
porównywania wartości i . options
jest wartością wyliczenia lub bitową kombinacją co najmniej jednej z Ordinal następujących wartości: IgnoreCase , , , i IgnoreSymbols IgnoreNonSpace IgnoreWidth IgnoreKanaType .
Zwraca
Indeks od zera pierwszego wystąpienia funkcji , jeśli został znaleziony, w sekcji , która rozpoczyna się od i zawiera liczbę elementów określoną przez element , przy użyciu określonych opcji porównania. W przeciwnym razie value
source
wartość startIndex
count
-1. Zwraca startIndex
wartość , jeśli jest value
znakiem do zignorowania.
Wyjątki
startIndex
znajduje się poza zakresem prawidłowych indeksów dla source
.
-lub-
Parametr count
ma wartość niższą niż zero.
-lub-
startIndex
i count
nie określaj prawidłowej sekcji w source
.
options
zawiera nieprawidłową CompareOptions wartość.
Przykłady
Poniższy przykład określa indeksy pierwszego i ostatniego wystąpienia znaku lub podciągu w części ciągu.
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
Uwagi
Ciąg źródłowy jest wyszukiwany do przodu, zaczynając od i startIndex
kończąc na startIndex
+ count
- 1.
Wartość CompareOptions.StringSort nie jest prawidłowa dla tej metody.
Jeśli options
ta wartość nie jest Ordinal uwzględniana, to przeciążenie wykonuje wyszukiwanie z uwzględnianą kulturą. Wartość Unicode reprezentująca wstępnie skompilowany znak, na przykład wartość " PODCZAS" (U+00C6), może być uważana za równoważną dowolne wystąpienie składników znaku w prawidłowej sekwencji, takie jak "AE" (U+0041, U+0045), w zależności od kultury. Jeśli element zawiera wartość , to przeciążenie wykonuje wyszukiwanie porządkowe (bez uwzględniania kultury), w którym porównywane options
Ordinal są wartości Unicode.
Uwaga
Jeśli to możliwe, należy wywołać metody porównania ciągów, które mają parametr typu , aby określić CompareOptions rodzaj oczekiwanego porównania. Ogólną regułą jest używanie opcji językowych (przy użyciu bieżącej kultury) do porównywania ciągów wyświetlanych w interfejsie użytkownika i określania lub CompareOptions.Ordinal CompareOptions.OrdinalIgnoreCase porównywania zabezpieczeń.
Uwagi dotyczące wywoływania
Zestawy znaków zawierają znaki ignorowane, które są znakami, które nie są rozważane podczas wykonywania sortowania językowego lub wrażliwego na kulturę. W wyszukiwaniu z rozróżnianą kulturą (to oznacza, że jeśli nie jest znakiem lub ), jeśli zawiera znak do zignorowania, wynik jest odpowiednikiem wyszukiwania za pomocą options
Ordinal tego znaku OrdinalIgnoreCase value
usuniętego. Jeśli składa się tylko z jednego lub większej liczby ignorowanych znaków, metoda zawsze zwraca wartość , czyli pozycję znaku, value
od której rozpoczyna się IndexOf(String, String, Int32, Int32, CompareOptions) startIndex
wyszukiwanie.
W poniższym przykładzie metoda służy do znalezienia pozycji łącznika programowego IndexOf(String, String, Int32, Int32, CompareOptions) (U+00AD), po którym następuje znak "m", zaczynając od trzeciej do szóstej pozycji znaku w dwóch ciągach. Tylko jeden z ciągów zawiera wymagany podciąg. W obu przypadkach, ponieważ łącznik nietrwały jest znakiem do pominięcia, metoda ta zwraca indeks „m” w ciągu podczas przeprowadzania porównania z uwzględnieniem ustawień kulturowych Jednak podczas wykonywania porównania porządkowego znajduje podciąg tylko w pierwszym ciągu. Należy pamiętać, że w przypadku pierwszego ciągu, który zawiera łącznik nieciągły, po którym następuje "m", metoda nie zwraca indeksu łącznika programowego, ale zamiast tego zwraca indeks "m" podczas wykonywania porównania z uwzględnianą kulturą. Metoda ta zwraca indeks łącznika nietrwałego w pierwszym ciągu tylko wtedy, gdy wykonuje porównanie porządkowe.
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
Zobacz też
Dotyczy
IndexOf(String, String, Int32, Int32)
Wyszukuje określony podciąg i zwraca indeks od zera pierwszego wystąpienia w sekcji ciągu źródłowego, który rozpoczyna się od określonego indeksu i zawiera określoną liczbę elementów.
public:
virtual int IndexOf(System::String ^ source, System::String ^ value, int startIndex, int count);
public:
int IndexOf(System::String ^ source, System::String ^ value, int startIndex, int count);
public virtual int IndexOf (string source, string value, int startIndex, int count);
public int IndexOf (string source, string value, int startIndex, int count);
abstract member IndexOf : string * string * int * int -> int
override this.IndexOf : string * string * int * int -> int
member this.IndexOf : string * string * int * int -> int
Public Overridable Function IndexOf (source As String, value As String, startIndex As Integer, count As Integer) As Integer
Public Function IndexOf (source As String, value As String, startIndex As Integer, count As Integer) As Integer
Parametry
- source
- String
Ciąg do wyszukania.
- value
- String
Ciąg do zlokalizowania source
w .
- startIndex
- Int32
Wartość początkowa indeksu zaczynającego się od zera dla wyszukiwania.
- count
- Int32
Liczba elementów w sekcji do wyszukania.
Zwraca
Indeks od zera pierwszego wystąpienia ciągu , jeśli został znaleziony, w sekcji , która rozpoczyna się od i zawiera liczbę elementów określoną przez ; w przeciwnym razie value
source
wartość startIndex
count
-1. Zwraca startIndex
wartość , jeśli jest value
znakiem do zignorowania.
Wyjątki
startIndex
znajduje się poza zakresem prawidłowych indeksów dla source
.
-lub-
Parametr count
ma wartość niższą niż zero.
-lub-
startIndex
i count
nie określaj prawidłowej sekcji w source
.
Przykłady
Poniższy przykład określa indeksy pierwszego i ostatniego wystąpienia znaku lub podciągu w części ciągu.
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
Uwagi
Ciąg źródłowy jest wyszukiwany do przodu, zaczynając od i startIndex
kończąc na startIndex
+ count
- 1.
To przeciążenie wykonuje wyszukiwanie wrażliwe na kulturę. Wartość Unicode reprezentująca wstępnie skompilowany znak, na przykład wartość " PODCZAS" (U+00C6), może być uważana za równoważną dowolne wystąpienie składników znaku w prawidłowej sekwencji, takie jak "AE" (U+0041, U+0045), w zależności od kultury. Aby przeprowadzić wyszukiwanie porządkowe (bez uwzględniania kultury), w którym porównywane są wartości Unicode, należy wywołać jedno z przeciążeń, które ma parametr typu i użyć CompareOptions Ordinal wartości .
Uwaga
Jeśli to możliwe, należy wywołać metody porównania ciągów, które mają parametr typu , aby określić CompareOptions rodzaj oczekiwanego porównania. Ogólną regułą jest używanie opcji językowych (przy użyciu bieżącej kultury) do porównywania ciągów wyświetlanych w interfejsie użytkownika i określania lub CompareOptions.Ordinal CompareOptions.OrdinalIgnoreCase porównywania zabezpieczeń.
Uwagi dotyczące wywoływania
Zestawy znaków zawierają znaki ignorowane, które są znakami, które nie są rozważane podczas wykonywania sortowania językowego lub wrażliwego na kulturę. W wyszukiwaniu z rozróżnianą kulturą, jeśli zawiera znak ignorowany, wynik jest odpowiednikiem wyszukiwania z value
usuniętym znakiem. Jeśli składa się tylko z jednego lub większej liczby ignorowanych znaków, metoda zawsze zwraca wartość , czyli pozycję znaku, value
od której rozpoczyna się IndexOf(String, String, Int32, Int32) startIndex
wyszukiwanie.
W poniższym przykładzie metoda służy do znalezienia pozycji łącznika programowego IndexOf(String, String, Int32, Int32) (U+00AD), po którym następuje znak "m", zaczynając od trzeciej do szóstej pozycji znaku w dwóch ciągach. Tylko jeden z ciągów zawiera wymagany podciąg. W obu przypadkach, ponieważ łącznik nietrwały jest znakiem do pominięcia, metoda ta zwraca indeks „m” w ciągu podczas przeprowadzania porównania z uwzględnieniem ustawień kulturowych Należy pamiętać, że w przypadku pierwszego ciągu, który zawiera łącznik nietrwały, a po nim „m”, metoda nie zwraca indeksu łącznika nietrwałego, ale zamiast tego zwraca indeks „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
Zobacz też
Dotyczy
IndexOf(String, String, Int32, CompareOptions)
Wyszukuje określony podciąg i zwraca indeks od zera pierwszego wystąpienia w sekcji ciągu źródłowego, który rozciąga się od określonego indeksu do końca ciągu przy użyciu określonej CompareOptions wartości.
public:
virtual int IndexOf(System::String ^ source, System::String ^ value, int startIndex, System::Globalization::CompareOptions options);
public:
int IndexOf(System::String ^ source, System::String ^ value, int startIndex, System::Globalization::CompareOptions options);
public virtual int IndexOf (string source, string value, int startIndex, System.Globalization.CompareOptions options);
public int IndexOf (string source, string value, int startIndex, System.Globalization.CompareOptions options);
abstract member IndexOf : string * string * int * System.Globalization.CompareOptions -> int
override this.IndexOf : string * string * int * System.Globalization.CompareOptions -> int
member this.IndexOf : string * string * int * System.Globalization.CompareOptions -> int
Public Overridable Function IndexOf (source As String, value As String, startIndex As Integer, options As CompareOptions) As Integer
Public Function IndexOf (source As String, value As String, startIndex As Integer, options As CompareOptions) As Integer
Parametry
- source
- String
Ciąg do wyszukania.
- value
- String
Ciąg do zlokalizowania source
w .
- startIndex
- Int32
Wartość początkowa indeksu zaczynającego się od zera dla wyszukiwania.
- options
- CompareOptions
Wartość, która definiuje sposób source
value
porównywania wartości i . options
jest wartością wyliczenia lub bitową kombinacją co najmniej jednej z Ordinal następujących wartości: IgnoreCase , , , i IgnoreSymbols IgnoreNonSpace IgnoreWidth IgnoreKanaType .
Zwraca
Indeks od zera pierwszego wystąpienia klasy , jeśli został znaleziony, w sekcji , która rozciąga się od do końca , przy użyciu określonych opcji porównania; w przeciwnym razie value
source
wartość startIndex
source
-1. Zwraca startIndex
wartość , jeśli jest value
znakiem do zignorowania.
Wyjątki
startIndex
znajduje się poza zakresem prawidłowych indeksów dla source
.
options
zawiera nieprawidłową CompareOptions wartość.
Przykłady
Poniższy przykład określa indeksy pierwszego i ostatniego wystąpienia znaku lub podciągu w części ciągu. Zwróć IndexOf uwagę, że elementy i LastIndexOf wyszukują różne części ciągu, nawet przy użyciu tego samego startIndex
parametru.
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
Uwagi
Ciąg źródłowy jest wyszukiwany do przodu, począwszy od i startIndex
kończąc na końcu ciągu.
Wartość CompareOptions.StringSort nie jest prawidłowa dla tej metody.
Jeśli options
ta wartość nie jest Ordinal uwzględniana, to przeciążenie wykonuje wyszukiwanie z uwzględnianą kulturą. Wartość Unicode reprezentująca wstępnie skompilowany znak, na przykład wartość " PODCZAS" (U+00C6), może być uważana za równoważną dowolne wystąpienie składników znaku w prawidłowej sekwencji, takie jak "AE" (U+0041, U+0045), w zależności od kultury. Jeśli element zawiera wartość , to przeciążenie wykonuje wyszukiwanie porządkowe (bez uwzględniania kultury), w którym porównywane options
Ordinal są wartości Unicode.
Uwaga
Jeśli to możliwe, należy wywołać metody porównania ciągów, które mają parametr typu , aby określić CompareOptions rodzaj oczekiwanego porównania. Ogólną regułą jest używanie opcji językowych (przy użyciu bieżącej kultury) do porównywania ciągów wyświetlanych w interfejsie użytkownika i określania lub CompareOptions.Ordinal CompareOptions.OrdinalIgnoreCase porównywania zabezpieczeń.
Uwagi dotyczące wywoływania
Zestawy znaków zawierają znaki ignorowane, które są znakami, które nie są rozważane podczas wykonywania sortowania językowego lub wrażliwego na kulturę. W wyszukiwaniu z rozróżnianą kulturą (to oznacza, że jeśli nie jest znakiem lub ), jeśli zawiera znak do zignorowania, wynik jest odpowiednikiem wyszukiwania za pomocą options
Ordinal tego znaku OrdinalIgnoreCase value
usuniętego. Jeśli składa się tylko z jednego lub większej liczby ignorowanych znaków, metoda zawsze zwraca wartość , czyli pozycję znaku, value
od której rozpoczyna się IndexOf(String, String, Int32, CompareOptions) startIndex
wyszukiwanie.
W poniższym przykładzie metoda służy do znalezienia pozycji łącznika programowego (U+00AD), po którym następuje znak "m" rozpoczynający się od trzeciej pozycji znaku w dwóch IndexOf(String, String, Int32, CompareOptions) ciągach. Tylko jeden z ciągów zawiera wymagany podciąg. W obu przypadkach, ponieważ łącznik nietrwały jest znakiem do pominięcia, metoda ta zwraca indeks „m” w ciągu podczas przeprowadzania porównania z uwzględnieniem ustawień kulturowych Należy pamiętać, że w przypadku pierwszego ciągu, który zawiera łącznik nietrwały, a po nim „m”, metoda nie zwraca indeksu łącznika nietrwałego, ale zamiast tego zwraca indeks „m”. Metoda ta zwraca indeks łącznika nietrwałego w pierwszym ciągu tylko wtedy, gdy wykonuje porównanie porządkowe.
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
Zobacz też
Dotyczy
IndexOf(String, Char, Int32, Int32)
Wyszukuje określony znak i zwraca indeks od zera pierwszego wystąpienia w sekcji ciągu źródłowego, która rozpoczyna się od określonego indeksu i zawiera określoną liczbę elementów.
public:
virtual int IndexOf(System::String ^ source, char value, int startIndex, int count);
public:
int IndexOf(System::String ^ source, char value, int startIndex, int count);
public virtual int IndexOf (string source, char value, int startIndex, int count);
public int IndexOf (string source, char value, int startIndex, int count);
abstract member IndexOf : string * char * int * int -> int
override this.IndexOf : string * char * int * int -> int
member this.IndexOf : string * char * int * int -> int
Public Overridable Function IndexOf (source As String, value As Char, startIndex As Integer, count As Integer) As Integer
Public Function IndexOf (source As String, value As Char, startIndex As Integer, count As Integer) As Integer
Parametry
- source
- String
Ciąg do wyszukania.
- value
- Char
Znak do zlokalizowania source
w .
- startIndex
- Int32
Wartość początkowa indeksu zaczynającego się od zera dla wyszukiwania.
- count
- Int32
Liczba elementów w sekcji do wyszukania.
Zwraca
Indeks od zera pierwszego wystąpienia ciągu , jeśli został znaleziony, w sekcji , która rozpoczyna się od i zawiera liczbę elementów określoną przez ; w przeciwnym razie value
source
wartość startIndex
count
-1. Zwraca startIndex
wartość , jeśli jest value
znakiem do zignorowania.
Wyjątki
source
to null
.
startIndex
znajduje się poza zakresem prawidłowych indeksów dla source
.
-lub-
Parametr count
ma wartość niższą niż zero.
-lub-
startIndex
i count
nie określaj prawidłowej sekcji w source
.
Przykłady
Poniższy przykład określa indeksy pierwszego i ostatniego wystąpienia znaku lub podciągu w części ciągu.
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
Uwagi
Ciąg źródłowy jest wyszukiwany do przodu, zaczynając od i startIndex
kończąc na startIndex
+ count
- 1.
To przeciążenie wykonuje wyszukiwanie wrażliwe na kulturę. Jeśli znak jest wartością Unicode reprezentującą wstępnie skompilowany znak, na przykład znak " PODCZAS" (U+00C6), może być uznawany za równoważny z każdym wystąpieniem jego składników w prawidłowej sekwencji, takim jak "AE" (U+0041, U+0045), w zależności od kultury. Aby przeprowadzić wyszukiwanie porządkowe (bez uwzględniania kultury), w którym znak jest uznawany za równoważny iniekcjom tylko wtedy, gdy wartości Unicode są takie same, należy wywołać jedno z przeciążeń, które ma parametr typu i użyć CompareOptions Ordinal wartości . Przeciążenia, które wyszukuje znak, wykonują wyszukiwanie porządkowe, natomiast te, które wyszukuje ciąg, wykonują wyszukiwanie String.IndexOf uwzględniające kulturę.
Uwaga
Jeśli to możliwe, należy wywołać metody porównania ciągów, które mają parametr typu , aby określić CompareOptions rodzaj oczekiwanego porównania. Ogólną regułą jest używanie opcji językowych (przy użyciu bieżącej kultury) do porównywania ciągów wyświetlanych w interfejsie użytkownika i określania lub CompareOptions.Ordinal CompareOptions.OrdinalIgnoreCase porównywania zabezpieczeń.
Uwagi dotyczące wywoływania
Zestawy znaków zawierają znaki ignorowane, które są znakami, które nie są rozważane podczas wykonywania sortowania językowego lub wrażliwego na kulturę. W wyszukiwaniu z rozróżnianą kulturą, jeśli jest to znak do zignorowania, wynik jest odpowiednikiem wyszukiwania z value
usuniętym znakiem. W tym przypadku metoda zawsze zwraca wartość , czyli pozycję znaku, od IndexOf(String, Char, Int32, Int32) startIndex
której rozpoczęto wyszukiwanie. W poniższym przykładzie metoda jest używana do znalezienia łącznika programowego IndexOf(String, Char, Int32, Int32) (U+00AD) po "n" w dwóch ciągach. Tylko jeden z ciągów zawiera łącznik nietrwały. W obu przypadkach, ponieważ łącznik nieukończalny jest znakiem do zignorowania, metoda zwraca wartość 1, aby wskazać, że znaleziono dopasowanie w pozycji "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
Zobacz też
Dotyczy
IndexOf(String, Char, Int32, CompareOptions)
Wyszukuje określony znak i zwraca indeks od zera pierwszego wystąpienia w sekcji ciągu źródłowego, który rozciąga się od określonego indeksu do końca ciągu przy użyciu określonej CompareOptions wartości.
public:
virtual int IndexOf(System::String ^ source, char value, int startIndex, System::Globalization::CompareOptions options);
public:
int IndexOf(System::String ^ source, char value, int startIndex, System::Globalization::CompareOptions options);
public virtual int IndexOf (string source, char value, int startIndex, System.Globalization.CompareOptions options);
public int IndexOf (string source, char value, int startIndex, System.Globalization.CompareOptions options);
abstract member IndexOf : string * char * int * System.Globalization.CompareOptions -> int
override this.IndexOf : string * char * int * System.Globalization.CompareOptions -> int
member this.IndexOf : string * char * int * System.Globalization.CompareOptions -> int
Public Overridable Function IndexOf (source As String, value As Char, startIndex As Integer, options As CompareOptions) As Integer
Public Function IndexOf (source As String, value As Char, startIndex As Integer, options As CompareOptions) As Integer
Parametry
- source
- String
Ciąg do wyszukania.
- value
- Char
Znak do zlokalizowania source
w .
- startIndex
- Int32
Wartość początkowa indeksu zaczynającego się od zera dla wyszukiwania.
- options
- CompareOptions
Wartość, która definiuje, source
jak i powinny być value
porównywane. options
jest wartością wyliczenia lub bitową kombinacją co najmniej jednej z Ordinal następujących wartości: IgnoreCase , , , i IgnoreSymbols IgnoreNonSpace IgnoreWidth IgnoreKanaType .
Zwraca
Indeks od zera pierwszego wystąpienia klasy , jeśli został znaleziony, w sekcji , która rozciąga się od do końca , przy użyciu określonych opcji porównania; w przeciwnym razie value
source
wartość startIndex
source
-1. Zwraca startIndex
wartość , jeśli jest value
znakiem do zignorowania.
Wyjątki
source
to null
.
startIndex
znajduje się poza zakresem prawidłowych indeksów dla source
.
options
zawiera nieprawidłową CompareOptions wartość.
Przykłady
Poniższy przykład określa indeksy pierwszego i ostatniego wystąpienia znaku lub podciągu w części ciągu. Zwróć IndexOf uwagę, że elementy i LastIndexOf wyszukują różne części ciągu, nawet przy użyciu tego samego startIndex
parametru.
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
Uwagi
Ciąg źródłowy jest wyszukiwany do przodu, począwszy od i startIndex
kończąc na końcu ciągu.
Wartość CompareOptions.StringSort nie jest prawidłowa dla tej metody.
Jeśli options
ta wartość nie jest Ordinal uwzględniana, to przeciążenie wykonuje wyszukiwanie z uwzględnianą kulturą. Jeśli znak jest wartością Unicode reprezentującą wstępnie skompilowany znak, na przykład znak " PODCZAS" (U+00C6), może być uznawany za równoważny z każdym wystąpieniem jego składników w prawidłowej sekwencji, takim jak "AE" (U+0041, U+0045), w zależności od kultury. Jeśli options
element zawiera wartość , to Ordinal przeciążenie wykonuje wyszukiwanie porządkowe (bez uwzględniania kultury). Znak jest uznawany za równoważny iniekcjom tylko wtedy, gdy wartości Unicode są takie same. Przeciążenia, które wyszukuje znak, wykonują wyszukiwanie porządkowe, natomiast te, które wyszukuje ciąg, wykonują wyszukiwanie String.IndexOf uwzględniające kulturę.
Uwaga
Jeśli to możliwe, należy wywołać metody porównania ciągów, które mają parametr typu , aby określić CompareOptions rodzaj oczekiwanego porównania. Ogólną regułą jest używanie opcji językowych (przy użyciu bieżącej kultury) do porównywania ciągów wyświetlanych w interfejsie użytkownika i określania lub CompareOptions.Ordinal CompareOptions.OrdinalIgnoreCase porównywania zabezpieczeń.
Uwagi dotyczące wywoływania
Zestawy znaków zawierają znaki ignorowane, które są znakami, które nie są rozważane podczas wykonywania sortowania językowego lub wrażliwego na kulturę. W wyszukiwaniu z rozróżnianą kulturą, jeśli jest to znak do zignorowania, wynik jest odpowiednikiem wyszukiwania z value
usuniętym znakiem. W tym przypadku metoda zawsze zwraca pozycję znaku , od IndexOf(String, Char, Int32, CompareOptions) startIndex
której rozpoczęto wyszukiwanie. W poniższym przykładzie metoda jest używana do znalezienia łącznika programowego IndexOf(String, Char, Int32, CompareOptions) (U+00AD) po literze "n" w dwóch ciągach. Tylko jeden z ciągów zawiera łącznik nietrwały. W obu przypadkach, ponieważ łącznik nieukończalny jest znakiem do zignorowania, wyszukiwanie z rozróżnianą kulturą zwraca wartość 1, aby wskazać, że znaleziono dopasowanie w pozycji "n". Jednak wyszukiwanie porządkowe pomyślnie znajduje łącznik nieciągły w jednym ciągu i zgłasza, że jest on nieobecny w drugim ciągu.
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
Zobacz też
Dotyczy
IndexOf(String, String, Int32)
Wyszukuje określony podciąg i zwraca indeks od zera pierwszego wystąpienia w sekcji ciągu źródłowego, który rozciąga się od określonego indeksu do końca ciągu.
public:
int IndexOf(System::String ^ source, System::String ^ value, int startIndex);
public:
virtual int IndexOf(System::String ^ source, System::String ^ value, int startIndex);
public int IndexOf (string source, string value, int startIndex);
public virtual int IndexOf (string source, string value, int startIndex);
member this.IndexOf : string * string * int -> int
abstract member IndexOf : string * string * int -> int
override this.IndexOf : string * string * int -> int
Public Function IndexOf (source As String, value As String, startIndex As Integer) As Integer
Public Overridable Function IndexOf (source As String, value As String, startIndex As Integer) As Integer
Parametry
- source
- String
Ciąg do wyszukania.
- value
- String
Ciąg do zlokalizowania source
w .
- startIndex
- Int32
Wartość początkowa indeksu zaczynającego się od zera dla wyszukiwania.
Zwraca
Indeks od zera pierwszego wystąpienia ciągu , jeśli zostanie znaleziony, w sekcji , która rozciąga się od do końca ; w przeciwnym razie value
source
wartość startIndex
source
-1. Zwraca startIndex
wartość , jeśli jest value
znakiem do zignorowania.
Wyjątki
startIndex
znajduje się poza zakresem prawidłowych indeksów dla source
.
Przykłady
Poniższy przykład określa indeksy pierwszego i ostatniego wystąpienia znaku lub podciągu w części ciągu. Zwróć IndexOf uwagę, że elementy i LastIndexOf są wyszukiwane w różnych fragmentach ciągu, nawet przy użyciu tego samego startIndex
parametru.
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
Uwagi
Ciąg źródłowy jest przeszukiwany do przodu, począwszy od i startIndex
kończąc na końcu ciągu.
To przeciążenie wykonuje wyszukiwanie w sposób wrażliwy na kulturę. Wartość Unicode reprezentująca wstępnie skomponowany znak, taką jak " PODCZAS" (U+00C6), może być uważana za równoważną dowolne wystąpienie składników znaku w prawidłowej sekwencji, takie jak "AE" (U+0041, U+0045), w zależności od kultury. Aby przeprowadzić wyszukiwanie porządkowe (bez uwzględniania kultury), w którym porównywane są wartości Unicode, należy wywołać jedno z przeciążeń, które ma parametr typu i użyć CompareOptions Ordinal wartości .
Uwaga
Jeśli to możliwe, należy wywołać metody porównania ciągów, które mają parametr typu , aby CompareOptions określić rodzaj oczekiwanego porównania. Ogólną regułą jest używanie opcji językowych (przy użyciu bieżącej kultury) do porównywania ciągów wyświetlanych w interfejsie użytkownika i określanie lub dla CompareOptions.Ordinal CompareOptions.OrdinalIgnoreCase porównań zabezpieczeń.
Uwagi dotyczące wywoływania
Zestawy znaków zawierają znaki do pominiania, które są znakami, które nie są rozważane podczas wykonywania sortowania językowego lub wrażliwego na kulturę. W wyszukiwaniu z rozróżnianą kulturą, jeśli zawiera znak do zignorowania, wynik jest odpowiednikiem wyszukiwania z value
usuniętym tym znakiem. Jeśli składa się tylko z jednego lub większej liczby znaków do zignorowania, metoda zawsze zwraca wartość , czyli pozycję value
IndexOf(String, String, Int32) startIndex
znaku, od której rozpoczyna się wyszukiwanie.
W poniższym przykładzie metoda służy do znalezienia pozycji łącznika nie programowego IndexOf(String, String, Int32) (U+00AD), po którym następuje "m" w dwóch ciągach. Tylko jeden z ciągów zawiera wymagany podciąg. W obu przypadkach, ponieważ łącznik nieciągły jest znakiem do zignorowania, metoda zwraca indeks "m" w ciągu. Należy pamiętać, że w przypadku pierwszego ciągu, który zawiera łącznik nietrwały, a po nim „m”, metoda nie zwraca indeksu łącznika nietrwałego, ale zamiast tego zwraca indeks „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
Zobacz też
Dotyczy
IndexOf(String, Char, Int32, Int32, CompareOptions)
Wyszukuje określony znak i zwraca indeks od zera pierwszego wystąpienia w sekcji ciągu źródłowego, który rozpoczyna się od określonego indeksu i zawiera określoną liczbę elementów przy użyciu określonej CompareOptions wartości.
public:
virtual int IndexOf(System::String ^ source, char value, int startIndex, int count, System::Globalization::CompareOptions options);
public:
int IndexOf(System::String ^ source, char value, int startIndex, int count, System::Globalization::CompareOptions options);
public virtual int IndexOf (string source, char value, int startIndex, int count, System.Globalization.CompareOptions options);
public int IndexOf (string source, char value, int startIndex, int count, System.Globalization.CompareOptions options);
abstract member IndexOf : string * char * int * int * System.Globalization.CompareOptions -> int
override this.IndexOf : string * char * int * int * System.Globalization.CompareOptions -> int
member this.IndexOf : string * char * int * int * System.Globalization.CompareOptions -> int
Public Overridable Function IndexOf (source As String, value As Char, startIndex As Integer, count As Integer, options As CompareOptions) As Integer
Public Function IndexOf (source As String, value As Char, startIndex As Integer, count As Integer, options As CompareOptions) As Integer
Parametry
- source
- String
Ciąg do wyszukania.
- value
- Char
Znak do zlokalizowania source
w .
- startIndex
- Int32
Wartość początkowa indeksu zaczynającego się od zera dla wyszukiwania.
- count
- Int32
Liczba elementów w sekcji do wyszukania.
- options
- CompareOptions
Wartość, która definiuje sposób source
value
porównywania wartości i . options
jest wartością wyliczenia lub bitową kombinacją co najmniej jednej z Ordinal następujących wartości: IgnoreCase , , , i IgnoreSymbols IgnoreNonSpace IgnoreWidth IgnoreKanaType .
Zwraca
Indeks od zera pierwszego wystąpienia funkcji , jeśli został znaleziony, w sekcji , która rozpoczyna się od i zawiera liczbę elementów określoną przez element , przy użyciu określonych opcji porównania. W przeciwnym razie value
source
wartość startIndex
count
-1. Zwraca startIndex
wartość , jeśli jest value
znakiem do zignorowania.
Wyjątki
source
to null
.
startIndex
znajduje się poza zakresem prawidłowych indeksów dla source
.
-lub-
Parametr count
ma wartość niższą niż zero.
-lub-
startIndex
i count
nie określaj prawidłowej sekcji w source
.
options
zawiera nieprawidłową CompareOptions wartość.
Przykłady
Poniższy przykład określa indeksy pierwszego i ostatniego wystąpienia znaku lub podciągu w części ciągu.
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
Uwagi
Ciąg źródłowy jest wyszukiwany do przodu, zaczynając od i startIndex
kończąc na startIndex
+ count
- 1.
Wartość CompareOptions.StringSort nie jest prawidłowa dla tej metody.
Jeśli options
ta wartość nie jest Ordinal uwzględniana, to przeciążenie wykonuje wyszukiwanie z uwzględnianą kulturą. Jeśli znak jest wartością Unicode reprezentującą wstępnie skompilowany znak, na przykład znak " PODCZAS" (U+00C6), może być uznawany za równoważny z każdym wystąpieniem jego składników w prawidłowej sekwencji, takim jak "AE" (U+0041, U+0045), w zależności od kultury. Jeśli options
element zawiera wartość , to Ordinal przeciążenie wykonuje wyszukiwanie porządkowe (bez uwzględniania kultury). Znak jest uznawany za równoważny iniekcjom tylko wtedy, gdy wartości Unicode są takie same. Przeciążenia, które wyszukuje znak, wykonują wyszukiwanie porządkowe, natomiast te, które wyszukuje ciąg, wykonują wyszukiwanie String.IndexOf uwzględniające kulturę.
Uwaga
Jeśli to możliwe, należy wywołać metody porównania ciągów, które mają parametr typu , aby określić CompareOptions rodzaj oczekiwanego porównania. Ogólną regułą jest używanie opcji językowych (przy użyciu bieżącej kultury) do porównywania ciągów wyświetlanych w interfejsie użytkownika i określania lub CompareOptions.Ordinal CompareOptions.OrdinalIgnoreCase porównywania zabezpieczeń.
Uwagi dotyczące wywoływania
Zestawy znaków zawierają znaki ignorowane, które są znakami, które nie są rozważane podczas wykonywania sortowania językowego lub wrażliwego na kulturę. W wyszukiwaniu z rozróżnianą kulturą, jeśli jest to znak do zignorowania, wynik jest odpowiednikiem wyszukiwania z value
usuniętym znakiem. W tym przypadku metoda zawsze zwraca wartość , czyli pozycję znaku, od IndexOf(String, Char, Int32, Int32, CompareOptions) startIndex
której rozpoczęto wyszukiwanie. W poniższym przykładzie metoda jest używana do znalezienia łącznika programowego IndexOf(String, Char, Int32, Int32, CompareOptions) (U+00AD) po literze "n" w dwóch ciągach. Tylko jeden z ciągów zawiera łącznik nietrwały. W obu przypadkach, ponieważ łącznik nieukończalny jest znakiem do zignorowania, wyszukiwanie z rozróżnianą kulturą zwraca wartość 1, aby wskazać, że znaleziono dopasowanie w pozycji "n". Jednak wyszukiwanie porządkowe pomyślnie znajduje łącznik nieciągły w jednym ciągu i zgłasza, że jest on nieobecny w drugim ciągu.
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
Zobacz też
Dotyczy
IndexOf(String, Char, Int32)
Wyszukuje określony znak i zwraca indeks od zera pierwszego wystąpienia w sekcji ciągu źródłowego, który rozciąga się od określonego indeksu do końca ciągu.
public:
int IndexOf(System::String ^ source, char value, int startIndex);
public:
virtual int IndexOf(System::String ^ source, char value, int startIndex);
public int IndexOf (string source, char value, int startIndex);
public virtual int IndexOf (string source, char value, int startIndex);
member this.IndexOf : string * char * int -> int
abstract member IndexOf : string * char * int -> int
override this.IndexOf : string * char * int -> int
Public Function IndexOf (source As String, value As Char, startIndex As Integer) As Integer
Public Overridable Function IndexOf (source As String, value As Char, startIndex As Integer) As Integer
Parametry
- source
- String
Ciąg do wyszukania.
- value
- Char
Znak do zlokalizowania source
w .
- startIndex
- Int32
Wartość początkowa indeksu zaczynającego się od zera dla wyszukiwania.
Zwraca
Indeks od zera pierwszego wystąpienia ciągu , jeśli zostanie znaleziony, w sekcji , która rozciąga się od do końca ; w przeciwnym razie value
source
wartość startIndex
source
-1. Zwraca startIndex
wartość , jeśli jest value
znakiem do zignorowania.
Wyjątki
source
to null
.
startIndex
znajduje się poza zakresem prawidłowych indeksów dla source
.
Przykłady
Poniższy przykład określa indeksy pierwszego i ostatniego wystąpienia znaku lub podciągu w części ciągu. Zwróć IndexOf uwagę, że elementy i LastIndexOf są wyszukiwane w różnych fragmentach ciągu, nawet przy użyciu tego samego startIndex
parametru.
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
Uwagi
Ciąg źródłowy jest przeszukiwany do przodu, począwszy od i startIndex
kończąc na końcu ciągu.
To przeciążenie wykonuje wyszukiwanie w sposób wrażliwy na kulturę. Jeśli znak jest wartością Unicode reprezentującą wstępnie skompilowany znak, taki jak znak " PODCZAS" (U+00C6), może być uznawany za równoważny dowolnemu wystąpieniu jego składników w prawidłowej sekwencji, takim jak "AE" (U+0041, U+0045), w zależności od kultury. Aby przeprowadzić wyszukiwanie porządkowe (bez uwzględniania kultury), w którym znak jest uznawany za równoważny iniekcjom tylko wtedy, gdy wartości Unicode są takie same, należy wywołać jedno z przeciążeń, które ma parametr typu i użyć CompareOptions Ordinal wartości . Przeciążenia, które wyszukuje znak, wykonują wyszukiwanie porządkowe, natomiast te, które wyszukają ciąg, wykonują wyszukiwanie uwzględniające String.IndexOf kulturę.
Uwaga
Jeśli to możliwe, należy wywołać metody porównania ciągów, które mają parametr typu , aby CompareOptions określić rodzaj oczekiwanego porównania. Ogólną regułą jest używanie opcji językowych (przy użyciu bieżącej kultury) do porównywania ciągów wyświetlanych w interfejsie użytkownika i określanie lub dla CompareOptions.Ordinal CompareOptions.OrdinalIgnoreCase porównań zabezpieczeń.
Uwagi dotyczące wywoływania
Zestawy znaków zawierają znaki do pominiania, które są znakami, które nie są rozważane podczas wykonywania sortowania językowego lub wrażliwego na kulturę. W wyszukiwaniu z rozróżnianą kulturą, jeśli jest znakiem do zignorowania, wynik jest odpowiednikiem wyszukiwania z value
usuniętym znakiem. W tym przypadku metoda IndexOf(String, Char, Int32) zawsze zwraca wartość , czyli pozycję startIndex
znaku, od której rozpoczyna się wyszukiwanie. W poniższym przykładzie metoda jest używana do znalezienia łącznika programowego IndexOf(String, Char, Int32) (U+00AD) po "n" w dwóch ciągach. Tylko jeden z ciągów zawiera łącznik nietrwały. W obu przypadkach, ponieważ łącznik nie jest znakiem do zignorowania, metoda zwraca wartość 1, aby wskazać, że znaleziono dopasowanie w pozycji "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
Zobacz też
Dotyczy
IndexOf(String, Char, CompareOptions)
Wyszukuje określony znak i zwraca indeks od zera pierwszego wystąpienia w ciągu źródłowym przy użyciu określonej CompareOptions wartości.
public:
virtual int IndexOf(System::String ^ source, char value, System::Globalization::CompareOptions options);
public:
int IndexOf(System::String ^ source, char value, System::Globalization::CompareOptions options);
public virtual int IndexOf (string source, char value, System.Globalization.CompareOptions options);
public int IndexOf (string source, char value, System.Globalization.CompareOptions options);
abstract member IndexOf : string * char * System.Globalization.CompareOptions -> int
override this.IndexOf : string * char * System.Globalization.CompareOptions -> int
member this.IndexOf : string * char * System.Globalization.CompareOptions -> int
Public Overridable Function IndexOf (source As String, value As Char, options As CompareOptions) As Integer
Public Function IndexOf (source As String, value As Char, options As CompareOptions) As Integer
Parametry
- source
- String
Ciąg do wyszukania.
- value
- Char
Znak do zlokalizowania source
w .
- options
- CompareOptions
Wartość definiująca sposób porównywania ciągów. options
jest wartością wyliczenia lub bitową kombinacją co najmniej jednej z Ordinal następujących wartości: IgnoreCase , , , i IgnoreSymbols IgnoreNonSpace IgnoreWidth IgnoreKanaType .
Zwraca
Indeks od zera pierwszego wystąpienia ciągu , jeśli został znaleziony, w programie przy użyciu określonych opcji porównania; w przeciwnym razie value
source
wartość -1. Zwraca 0 (zero), jeśli value
jest znakiem do zignorowania.
Wyjątki
source
to null
.
options
zawiera nieprawidłową CompareOptions wartość.
Przykłady
Poniższy przykład określa indeksy pierwszego i ostatniego wystąpienia znaku lub podciągu w ciągu.
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
Uwagi
Ciąg źródłowy jest przeszukiwany do przodu, począwszy od początku ciągu i kończąc na końcu ciągu.
Wartość CompareOptions.StringSort nie jest prawidłowa dla tej metody.
Jeśli options
ta wartość nie jest Ordinal uwzględniana, to przeciążenie wykonuje wyszukiwanie z uwzględnianą kulturą. Jeśli znak jest wartością Unicode reprezentującą wstępnie skompilowany znak, na przykład znak " PODCZAS" (U+00C6), może być uznawany za równoważny z każdym wystąpieniem jego składników w prawidłowej sekwencji, takim jak "AE" (U+0041, U+0045), w zależności od kultury. Jeśli options
element zawiera wartość , to Ordinal przeciążenie wykonuje wyszukiwanie porządkowe (bez uwzględniania kultury). Znak jest uznawany za równoważny iniekcjom tylko wtedy, gdy wartości Unicode są takie same. Przeciążenia, które wyszukuje znak, wykonują wyszukiwanie porządkowe, natomiast te, które wyszukuje ciąg, wykonują wyszukiwanie String.IndexOf uwzględniające kulturę.
Uwaga
Jeśli to możliwe, należy użyć metod porównywania ciągów, które mają parametr typu , aby określić CompareOptions rodzaj oczekiwanego porównania. Ogólną regułą jest używanie opcji językowych (przy użyciu bieżącej kultury) do porównywania ciągów wyświetlanych w interfejsie użytkownika i określania lub CompareOptions.Ordinal CompareOptions.OrdinalIgnoreCase porównywania zabezpieczeń.
Uwagi dotyczące wywoływania
Zestawy znaków zawierają znaki ignorowane, które są znakami, które nie są rozważane podczas wykonywania sortowania językowego lub wrażliwego na kulturę. W wyszukiwaniu z rozróżnianą kulturą, jeśli jest znakiem do zignorowania, wynik jest odpowiednikiem wyszukiwania z value
usuniętym znakiem. W takim przypadku metoda IndexOf(String, Char, CompareOptions) zawsze zwraca wartość 0 (zero), aby wskazać, że dopasowanie znajduje się na początku . source
W poniższym przykładzie metoda służy do wyszukiwania łącznika nie programowego IndexOf(String, Char, CompareOptions) (U+00AD) w dwóch ciągach. Tylko jeden z ciągów zawiera łącznik nietrwały. W obu przypadkach, ponieważ łącznik nieciągły jest znakiem do zignorowania, wyszukiwanie z rozróżnianą kulturą zwraca wartość 0 (zero), aby wskazać, że znaleziono dopasowanie na początku ciągu. Jednak wyszukiwanie porządkowe pomyślnie znajduje łącznik nieciągły w jednym ciągu i zgłasza, że nie ma go w drugim ciągu.
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
Zobacz też
Dotyczy
IndexOf(ReadOnlySpan<Char>, Rune, CompareOptions)
Wyszukuje pierwsze wystąpienie ciągu Rune w określonym zakresie znaków tylko do odczytu.
public int IndexOf (ReadOnlySpan<char> source, System.Text.Rune value, System.Globalization.CompareOptions options = System.Globalization.CompareOptions.None);
member this.IndexOf : ReadOnlySpan<char> * System.Text.Rune * System.Globalization.CompareOptions -> int
Public Function IndexOf (source As ReadOnlySpan(Of Char), value As Rune, Optional options As CompareOptions = System.Globalization.CompareOptions.None) As Integer
Parametry
- source
- ReadOnlySpan<Char>
Zakres znaków tylko do odczytu, w których ma być wyszukiwany.
- options
- CompareOptions
Opcjonalna kombinacja wartości CompareOptions wyliczenia do użycia podczas wyszukiwania. Wartość domyślna to None.
Zwraca
Indeks od zera w miejscu, w którym pojawia się source
value
po raz pierwszy, lub wartość ujemną, jeśli value
nie można znaleźć w . source
Wyjątki
options
Zawiera nieobsługiwaną kombinację flag.
Dotyczy
IndexOf(ReadOnlySpan<Char>, ReadOnlySpan<Char>, CompareOptions)
Wyszukuje pierwsze wystąpienie podciągu w określonym zakresie znaków tylko do odczytu.
public int IndexOf (ReadOnlySpan<char> source, ReadOnlySpan<char> value, System.Globalization.CompareOptions options = System.Globalization.CompareOptions.None);
member this.IndexOf : ReadOnlySpan<char> * ReadOnlySpan<char> * System.Globalization.CompareOptions -> int
Public Function IndexOf (source As ReadOnlySpan(Of Char), value As ReadOnlySpan(Of Char), Optional options As CompareOptions = System.Globalization.CompareOptions.None) As Integer
Parametry
- source
- ReadOnlySpan<Char>
Ciąg do przeszukania.
- value
- ReadOnlySpan<Char>
Podciąg do zlokalizowania source
w .
- options
- CompareOptions
Opcjonalna kombinacja wartości CompareOptions wyliczenia do użycia podczas wyszukiwania. Wartość domyślna to None.
Zwraca
Indeks od zera, w którym pojawia się pierwszy podciąg, lub wartość ujemną, jeśli source
nie można znaleźć w value
value
. source
Wyjątki
options
Zawiera nieobsługiwaną kombinację flag.
Dotyczy
IndexOf(String, String)
Wyszukuje określony podciąg i zwraca indeks od zera pierwszego wystąpienia w całym ciągu źródłowym.
public:
virtual int IndexOf(System::String ^ source, System::String ^ value);
public:
int IndexOf(System::String ^ source, System::String ^ value);
public virtual int IndexOf (string source, string value);
public int IndexOf (string source, string value);
abstract member IndexOf : string * string -> int
override this.IndexOf : string * string -> int
member this.IndexOf : string * string -> int
Public Overridable Function IndexOf (source As String, value As String) As Integer
Public Function IndexOf (source As String, value As String) As Integer
Parametry
- source
- String
Ciąg do wyszukania.
- value
- String
Ciąg do zlokalizowania source
w .
Zwraca
Indeks od zera pierwszego wystąpienia ciągu value
, jeśli został znaleziony, w source
obrębie ; w przeciwnym razie wartość -1. Zwraca 0 (zero), jeśli value
jest znakiem do zignorowania.
Wyjątki
Przykłady
Poniższy przykład określa indeksy pierwszego i ostatniego wystąpienia znaku lub podciągu w ciągu.
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
Uwagi
Ciąg źródłowy jest przeszukiwany do przodu, począwszy od początku ciągu i kończąc na końcu ciągu.
To przeciążenie wykonuje wyszukiwanie wrażliwe na kulturę. Wartość Unicode reprezentująca wstępnie skompilowany znak, na przykład wartość " PODCZAS" (U+00C6), może być uważana za równoważną dowolne wystąpienie składników znaku w prawidłowej sekwencji, takie jak "AE" (U+0041, U+0045), w zależności od kultury. Aby przeprowadzić wyszukiwanie porządkowe (bez uwzględniania kultury), w którym porównywane są wartości Unicode, należy użyć jednego z przeciążeń, które ma parametr typu i użyć CompareOptions Ordinal wartości .
Uwaga
Jeśli to możliwe, należy wywołać metody porównania ciągów, które mają parametr typu , aby określić CompareOptions rodzaj oczekiwanego porównania. Ogólną regułą jest używanie opcji językowych (przy użyciu bieżącej kultury) do porównywania ciągów wyświetlanych w interfejsie użytkownika i określania lub CompareOptions.Ordinal CompareOptions.OrdinalIgnoreCase porównywania zabezpieczeń.
Uwagi dotyczące wywoływania
Zestawy znaków zawierają znaki ignorowane, które są znakami, które nie są rozważane podczas wykonywania sortowania językowego lub wrażliwego na kulturę. W wyszukiwaniu z rozróżnianą kulturą, jeśli zawiera znak ignorowany, wynik jest odpowiednikiem wyszukiwania z value
usuniętym znakiem. Jeśli składa się tylko z jednego lub większej liczby ignorowanych znaków, metoda zawsze zwraca value
IndexOf(String, String) wartość 0 (zero), aby wskazać, że dopasowanie znajduje się na początku source
. W poniższym przykładzie metoda jest używana do znalezienia trzech podciągów (łącznika programowego (U+00AD), łącznika programowego, po którym następuje "n" i łącznika programowego, po którym następuje "m") w dwóch IndexOf(String, String) ciągach. Tylko jeden z ciągów zawiera łącznik nietrwały. W każdym przypadku, ponieważ łącznik nieukończalny jest znakiem do zignorowania, wynik jest taki sam, jak gdyby łącznik nie został uwzględniony w value
. Podczas wyszukiwania tylko łącznika programowego metoda zwraca wartość 0 (zero), aby wskazać, że znaleziono dopasowanie na początku ciągu.
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
Zobacz też
Dotyczy
IndexOf(String, String, CompareOptions)
Wyszukuje określony podciąg i zwraca indeks pierwszego wystąpienia w ciągu źródłowym od zera przy użyciu określonej CompareOptions wartości.
public:
virtual int IndexOf(System::String ^ source, System::String ^ value, System::Globalization::CompareOptions options);
public:
int IndexOf(System::String ^ source, System::String ^ value, System::Globalization::CompareOptions options);
public virtual int IndexOf (string source, string value, System.Globalization.CompareOptions options);
public int IndexOf (string source, string value, System.Globalization.CompareOptions options);
abstract member IndexOf : string * string * System.Globalization.CompareOptions -> int
override this.IndexOf : string * string * System.Globalization.CompareOptions -> int
member this.IndexOf : string * string * System.Globalization.CompareOptions -> int
Public Overridable Function IndexOf (source As String, value As String, options As CompareOptions) As Integer
Public Function IndexOf (source As String, value As String, options As CompareOptions) As Integer
Parametry
- source
- String
Ciąg do wyszukania.
- value
- String
Ciąg do zlokalizowania source
w .
- options
- CompareOptions
Wartość, która definiuje, source
jak i powinny być value
porównywane. options
jest wartością wyliczenia lub bitową kombinacją co najmniej jednej z Ordinal następujących wartości: IgnoreCase , , , i IgnoreSymbols IgnoreNonSpace IgnoreWidth IgnoreKanaType .
Zwraca
Indeks od zera pierwszego wystąpienia ciągu , jeśli został znaleziony, w ramach , przy użyciu określonych opcji porównania; w przeciwnym razie value
source
wartość -1. Zwraca wartość 0 (zero), jeśli value
jest znakiem do zignorowania.
Wyjątki
options
Zawiera nieprawidłową CompareOptions wartość.
Przykłady
Poniższy przykład określa indeksy pierwszego i ostatniego wystąpienia znaku lub podciągu w ciągu.
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
Uwagi
Ciąg źródłowy jest przeszukiwany do przodu, począwszy od początku ciągu i kończąc na końcu ciągu.
Wartość CompareOptions.StringSort nie jest prawidłowa dla tej metody.
Jeśli options
wartość nie jest Ordinal uwzględniana, to przeciążenie wykonuje wyszukiwanie z uwzględnianą kulturą. Wartość Unicode reprezentująca wstępnie skomponowany znak, taką jak " PODCZAS" (U+00C6), może być uważana za równoważną dowolne wystąpienie składników znaku w prawidłowej sekwencji, takie jak "AE" (U+0041, U+0045), w zależności od kultury. Jeśli element zawiera wartość , to przeciążenie wykonuje wyszukiwanie porządkowe (bez uwzględniania kultury), w którym porównywane options
Ordinal są wartości Unicode.
Uwaga
Jeśli to możliwe, należy wywołać metody porównania ciągów, które mają parametr typu , aby CompareOptions określić rodzaj oczekiwanego porównania. Ogólną regułą jest używanie opcji językowych (przy użyciu bieżącej kultury) do porównywania ciągów wyświetlanych w interfejsie użytkownika i określanie lub dla CompareOptions.Ordinal CompareOptions.OrdinalIgnoreCase porównań zabezpieczeń.
Uwagi dotyczące wywoływania
Zestawy znaków zawierają znaki do pominiania, które są znakami, które nie są rozważane podczas wykonywania sortowania językowego lub wrażliwego na kulturę. W wyszukiwaniu z rozróżnianą kulturą (czyli jeśli element nie ma znaku lub ), jeśli zawiera znak do zignorowania, wynik jest odpowiednikiem wyszukiwania za pomocą options
Ordinal OrdinalIgnoreCase value
usuniętego znaku. Jeśli znak składa się tylko z jednego lub większej liczby znaków do zignorowania, metoda zawsze zwraca value
IndexOf(String, String, CompareOptions) wartość 0 (zero), aby wskazać, że dopasowanie znajduje się na początku . source
W poniższym przykładzie metoda jest używana do znalezienia trzech podciągów (łącznika nieciągłego (U+00AD), łącznika programowego, po którym następuje "n" i łącznika nieciągłego, po którym następuje "m") w dwóch IndexOf(String, String, CompareOptions) ciągach. Tylko jeden z ciągów zawiera łącznik nietrwały. Ponieważ łącznik nieciągły jest znakiem do zignorowania, wyszukiwanie z uwzględnianą kulturą zwraca tę samą wartość, która zostanie zwrócona, jeśli łącznik nie jest uwzględniony w ciągu wyszukiwania. Jednak wyszukiwanie porządkowe pomyślnie znajduje łącznik nieciągły w jednym ciągu i zgłasza, że nie ma go w drugim ciągu.
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
Zobacz też
Dotyczy
IndexOf(String, Char)
Wyszukuje określony znak i zwraca indeks od zera pierwszego wystąpienia w całym ciągu źródłowym.
public:
virtual int IndexOf(System::String ^ source, char value);
public:
int IndexOf(System::String ^ source, char value);
public virtual int IndexOf (string source, char value);
public int IndexOf (string source, char value);
abstract member IndexOf : string * char -> int
override this.IndexOf : string * char -> int
member this.IndexOf : string * char -> int
Public Overridable Function IndexOf (source As String, value As Char) As Integer
Public Function IndexOf (source As String, value As Char) As Integer
Parametry
- source
- String
Ciąg do wyszukania.
- value
- Char
Znak do zlokalizowania source
w .
Zwraca
Indeks od zera pierwszego wystąpienia ciągu value
, jeśli został znaleziony, w source
obrębie ; w przeciwnym razie wartość -1. Zwraca 0 (zero), jeśli value
jest znakiem do zignorowania.
Wyjątki
source
to null
.
Przykłady
Poniższy przykład określa indeksy pierwszego i ostatniego wystąpienia znaku lub podciągu w ciągu.
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
Uwagi
Ta metoda wyszukuje ciąg źródłowy od początku ciągu do końca ciągu.
To przeciążenie wykonuje wyszukiwanie wrażliwe na kulturę. Jeśli reprezentuje wstępnie skompilowany znak Unicode, taki jak " PODCZAS" (U+00C6), może być uznawany za równoważny dowolnemu wystąpieniu jego składników w prawidłowej sekwencji, takim jak value
"AE" (U+0041, U+0045), w zależności od kultury. Aby przeprowadzić wyszukiwanie porządkowe (bez uwzględniania kultury), w którym znak jest uznawany za równoważny innej postaci tylko wtedy, gdy punkty kodu Unicode są takie same, należy wywołać przeciążenie, które ma parametr typu i użyć CompareOptions CompareOptions.Ordinal wartości . W przeciwieństwie do metody , która wykonuje porównanie z rozróżnianą kulturą, przeciążenia metody, które wyszukuje znak, wykonują porównanie porządkowe, i przeciążenia, które wyszukuje ciąg, wykonują porównanie z wrażliwymi CompareInfo.IndexOf String.IndexOf na kulturę.
Uwaga
Jeśli to możliwe, należy użyć metod porównywania ciągów, które mają parametr typu , aby określić CompareOptions rodzaj oczekiwanego porównania. Ogólną regułą jest używanie opcji językowych (przy użyciu bieżącej kultury) do porównywania ciągów wyświetlanych w interfejsie użytkownika i określania lub CompareOptions.Ordinal CompareOptions.OrdinalIgnoreCase porównywania zabezpieczeń.
Uwagi dotyczące wywoływania
Zestawy znaków zawierają znaki ignorowane, które są znakami, które nie są rozważane podczas wykonywania sortowania językowego lub wrażliwego na kulturę. W wyszukiwaniu z rozróżnianą kulturą, jeśli jest to znak do zignorowania, wynik jest odpowiednikiem wyszukiwania z value
usuniętym znakiem. W takim przypadku metoda IndexOf(String, Char) zawsze zwraca wartość 0 (zero), aby wskazać, że dopasowanie znajduje się na początku . source
W poniższym przykładzie metoda służy do znalezienia łącznika programowego IndexOf(String, Char) (U+00AD) w dwóch ciągach. Tylko jeden z ciągów zawiera łącznik nietrwały. W obu przypadkach, ponieważ łącznik nieciągły jest znakiem do zignorowania, metoda zwraca wartość 0 (zero), aby wskazać, że znaleziono dopasowanie na początku ciągu.
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