String.IndexOf Yöntem

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Runtime.dll

Bu örnekte belirtilen Unicode karakterinin veya dizesinin ilk oluşumunun sıfır tabanlı dizinini raporlar. Bu örnekte karakter veya dize bulunamazsa yöntemi -1 döndürür.

Aşırı Yüklemeler

Name	Description
IndexOf(String, Int32, Int32, StringComparison)	Geçerli String nesnede belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar. Parametreler geçerli dizedeki başlangıç arama konumunu, aranacak geçerli dizedeki karakter sayısını ve belirtilen dize için kullanılacak arama türünü belirtir.
IndexOf(String, Int32, StringComparison)	Geçerli String nesnede belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar. Parametreler geçerli dizedeki başlangıç arama konumunu ve belirtilen dize için kullanılacak arama türünü belirtir.
IndexOf(String, Int32, Int32)	Bu örnekte belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar. Arama belirtilen karakter konumunda başlar ve belirtilen sayıda karakter konumunu inceler.
IndexOf(Char, Int32, Int32)	Bu örnekte belirtilen karakterin ilk oluşumunun sıfır tabanlı dizinini raporlar. Arama belirtilen karakter konumunda başlar ve belirtilen sayıda karakter konumunu inceler.
IndexOf(Char)	Bu dizede belirtilen Unicode karakterinin ilk oluşumunun sıfır tabanlı dizinini raporlar.
IndexOf(String, StringComparison)	Geçerli String nesnede belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar. Parametresi, belirtilen dize için kullanılacak arama türünü belirtir.
IndexOf(String, Int32)	Bu örnekte belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar. Arama belirtilen karakter konumunda başlar.
IndexOf(Char, StringComparison)	Bu dizede belirtilen Unicode karakterinin ilk oluşumunun sıfır tabanlı dizinini raporlar. Parametre, belirtilen karakter için kullanılacak arama türünü belirtir.
IndexOf(Char, Int32)	Bu dizede belirtilen Unicode karakterinin ilk oluşumunun sıfır tabanlı dizinini raporlar. Arama belirtilen karakter konumunda başlar.
IndexOf(String)	Bu örnekte belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar.

IndexOf(String, Int32, Int32, StringComparison)

Kaynak:

String.Searching.cs

Geçerli String nesnede belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar. Parametreler geçerli dizedeki başlangıç arama konumunu, aranacak geçerli dizedeki karakter sayısını ve belirtilen dize için kullanılacak arama türünü belirtir.

public:
 int IndexOf(System::String ^ value, int startIndex, int count, StringComparison comparisonType);

public int IndexOf(string value, int startIndex, int count, StringComparison comparisonType);

member this.IndexOf : string * int * int * StringComparison -> int

Public Function IndexOf (value As String, startIndex As Integer, count As Integer, comparisonType As StringComparison) As Integer

Parametreler

value

String

Aranacak dize.

startIndex

Int32

Arama başlangıç konumu.

count

Int32

İncelenecek karakter konumlarının sayısı.

comparisonType

StringComparison

Arama kurallarını belirten numaralandırma değerlerinden biri.

Döndürülenler

Int32

Bu dize bulunursa geçerli örneğin başlangıcından value parametrenin sıfır tabanlı dizin konumu veya bulunamazsa -1. ise valueEmpty, dönüş değeri olur startIndex.

Özel durumlar

ArgumentNullException

value, null'e eşittir.

ArgumentOutOfRangeException

count veya startIndex negatiftir.

-veya-

startIndex bu örneğin uzunluğundan büyük.

-veya-

count , bu dizenin uzunluğundan büyük eksidir startIndex.

ArgumentException

comparisonType geçerli StringComparison bir değer değil.

Örnekler

Aşağıdaki örnekte, bir dizenin IndexOf başka bir dizede ilk oluşumunu bulan yöntemin, numaralandırmanın farklı değerlerini kullanan üç aşırı yüklemesi gösterilmektedir StringComparison .

// This code example demonstrates the 
// System.String.IndexOf(String, ..., StringComparison) methods.

using System;
using System.Threading;
using System.Globalization;

class Sample 
{
    public static void Main() 
    {
    string intro = "Find the first occurrence of a character using different " + 
                   "values of StringComparison.";
    string resultFmt = "Comparison: {0,-28} Location: {1,3}";

// Define a string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
    string CapitalAWithRing = "\u00c5"; 

// Define a string to search. 
// The result of combining the characters LATIN SMALL LETTER A and COMBINING 
// RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character 
// LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
    string cat = "A Cheshire c" + "\u0061\u030a" + "t";

    int loc = 0;
    StringComparison[] scValues = {
        StringComparison.CurrentCulture,
        StringComparison.CurrentCultureIgnoreCase,
        StringComparison.InvariantCulture,
        StringComparison.InvariantCultureIgnoreCase,
        StringComparison.Ordinal,
        StringComparison.OrdinalIgnoreCase };

// Clear the screen and display an introduction.
    Console.Clear();
    Console.WriteLine(intro);

// Display the current culture because culture affects the result. For example, 
// try this code example with the "sv-SE" (Swedish-Sweden) culture.

    Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
    Console.WriteLine("The current culture is \"{0}\" - {1}.", 
                       Thread.CurrentThread.CurrentCulture.Name,
                       Thread.CurrentThread.CurrentCulture.DisplayName);

// Display the string to search for and the string to search.
    Console.WriteLine("Search for the string \"{0}\" in the string \"{1}\"", 
                       CapitalAWithRing, cat);
    Console.WriteLine();

// Note that in each of the following searches, we look for 
// LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains 
// LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates 
// the string was not found.
// Search using different values of StringComparison. Specify the start 
// index and count. 

    Console.WriteLine("Part 1: Start index and count are specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparison. Specify the 
// start index. 
    Console.WriteLine("\nPart 2: Start index is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(CapitalAWithRing, 0, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparison. 
    Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(CapitalAWithRing, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }
    }
}

/*
Note: This code example was executed on a console whose user interface 
culture is "en-US" (English-United States).

This code example produces the following results:

Find the first occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"

Part 1: Start index and count are specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 2: Start index is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 3: Neither start index nor count is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

*/

// This code example demonstrates the
// System.String.IndexOf(String, ..., StringComparison) methods.

open System
open System.Threading
open System.Globalization

let intro = "Find the first occurrence of a character using different values of StringComparison."

// Define a string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
let CapitalAWithRing = "\u00c5"

// Define a string to search.
// The result of combining the characters LATIN SMALL LETTER A and COMBINING
// RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character
// LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
let cat = "A Cheshire c" + "\u0061\u030a" + "t"

let scValues = 
    [| StringComparison.CurrentCulture
       StringComparison.CurrentCultureIgnoreCase
       StringComparison.InvariantCulture
       StringComparison.InvariantCultureIgnoreCase
       StringComparison.Ordinal
       StringComparison.OrdinalIgnoreCase |]

// Clear the screen and display an introduction.
Console.Clear()
printfn $"{intro}"

// Display the current culture because culture affects the result. For example,
// try this code example with the "sv-SE" (Swedish-Sweden) culture.

Thread.CurrentThread.CurrentCulture <- CultureInfo "en-US"
printfn $"The current culture is \"{Thread.CurrentThread.CurrentCulture.Name}\" - {Thread.CurrentThread.CurrentCulture.DisplayName}."

// Display the string to search for and the string to search.
printfn $"Search for the string \"{CapitalAWithRing}\" in the string \"{cat}\"\n"

// Note that in each of the following searches, we look for
// LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains
// LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates
// the string was not found.
// Search using different values of StringComparison. Specify the start
// index and count.

printfn "Part 1: Start index and count are specified."
for sc in scValues do
    let loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc)
    printfn $"Comparison: {sc,-28} Location: {loc,3}"

// Search using different values of StringComparison. Specify the
// start index.
printfn "\nPart 2: Start index is specified."
for sc in scValues do
    let loc = cat.IndexOf(CapitalAWithRing, 0, sc)
    printfn $"Comparison: {sc,-28} Location: {loc,3}"

// Search using different values of StringComparison.
Console.WriteLine("\nPart 3: Neither start index nor count is specified.")
for sc in scValues do
    let loc = cat.IndexOf(CapitalAWithRing, sc)
    Console.WriteLine("Comparison: {0,-28} Location: {1,3}", sc, loc)

(*
Note: This code example was executed on a console whose user interface
culture is "en-US" (English-United States).

This code example produces the following results:

Find the first occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"

Part 1: Start index and count are specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 2: Start index is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 3: Neither start index nor count is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

*)

' This code example demonstrates the 
' System.String.IndexOf(String, ..., StringComparison) methods.

Imports System.Threading
Imports System.Globalization

Class Sample
    Public Shared Sub Main() 
        Dim intro As String = "Find the first occurrence of a character using different " & _
                              "values of StringComparison."
        Dim resultFmt As String = "Comparison: {0,-28} Location: {1,3}"
        
        ' Define a string to search for.
        ' U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
        Dim CapitalAWithRing As String = "Å"
        
        ' Define a string to search. 
        ' The result of combining the characters LATIN SMALL LETTER A and COMBINING 
        ' RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character 
        ' LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
        Dim cat As String = "A Cheshire c" & "å" & "t"
        
        Dim loc As Integer = 0
        Dim scValues As StringComparison() =  { _
                        StringComparison.CurrentCulture, _
                        StringComparison.CurrentCultureIgnoreCase, _
                        StringComparison.InvariantCulture, _
                        StringComparison.InvariantCultureIgnoreCase, _
                        StringComparison.Ordinal, _
                        StringComparison.OrdinalIgnoreCase }
        Dim sc As StringComparison
        
        ' Clear the screen and display an introduction.
        Console.Clear()
        Console.WriteLine(intro)
        
        ' Display the current culture because culture affects the result. For example, 
        ' try this code example with the "sv-SE" (Swedish-Sweden) culture.
        Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
        Console.WriteLine("The current culture is ""{0}"" - {1}.", _
                           Thread.CurrentThread.CurrentCulture.Name, _ 
                           Thread.CurrentThread.CurrentCulture.DisplayName)
        
        ' Display the string to search for and the string to search.
        Console.WriteLine("Search for the string ""{0}"" in the string ""{1}""", _
                           CapitalAWithRing, cat)
        Console.WriteLine()
        
        ' Note that in each of the following searches, we look for 
        ' LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains 
        ' LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates 
        ' the string was not found.
        ' Search using different values of StringComparison. Specify the start 
        ' index and count.

        Console.WriteLine("Part 1: Start index and count are specified.")
        For Each sc In  scValues
            loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparison. Specify the 
        ' start index. 

        Console.WriteLine(vbCrLf & "Part 2: Start index is specified.")
        For Each sc In  scValues
            loc = cat.IndexOf(CapitalAWithRing, 0, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparison. 

        Console.WriteLine(vbCrLf & "Part 3: Neither start index nor count is specified.")
        For Each sc In  scValues
            loc = cat.IndexOf(CapitalAWithRing, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
    
    End Sub
End Class

'
'Note: This code example was executed on a console whose user interface 
'culture is "en-US" (English-United States).
'
'This code example produces the following results:
'
'Find the first occurrence of a character using different values of StringComparison.
'The current culture is "en-US" - English (United States).
'Search for the string "Å" in the string "A Cheshire ca°t"
'
'Part 1: Start index and count are specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'
'Part 2: Start index is specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'
'Part 3: Neither start index nor count is specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'

Açıklamalar

Dizin numaralandırma 0'dan (sıfır) başlar. startIndex parametresi 0 ile dize örneğinin uzunluğu arasında değişebilir.

Arama şu konumda startIndex başlar ve -1'e startIndex + count devam eder. konumundaki startIndex + count karakter aramaya dahil değildir.

parametresi, comparisonType geçerli veya sabit kültürü kullanarak, büyük/küçük harfe duyarlı veya büyük/küçük harfe duyarlı olmayan bir arama kullanarak ve sözcük veya sıralı karşılaştırma kuralları kullanarak parametreyi aramayı value belirtir.

Arayanlara Notlar

Karakter kümeleri, dilsel veya kültüre duyarlı karşılaştırma yapılırken dikkate alınmayan karakterler olan yoksayılabilir karakterler içerir. Kültüre duyarlı bir aramada (veya değilse comparisonTypeOrdinalOrdinalIgnoreCase), value yoksayılabilir bir karakter içeriyorsa, sonuç bu karakter kaldırılmış olarak aramaya eşdeğerdir. Yalnızca bir veya daha fazla yoksayılabilir karakterden oluşuyorsa value , IndexOf(String, Int32, Int32, StringComparison) yöntemi her zaman aramanın başladığı karakter konumu olan değerini döndürür startIndex.

Aşağıdaki örnekte yöntemi, IndexOf(String, Int32, Int32, StringComparison) iki dizedeki üçüncü ile altıncı karakter konumları arasında başlayan bir yumuşak kısa çizgi (U+00AD) ve ardından "m" konumunu bulmak için kullanılır. Dizelerden yalnızca biri gerekli alt dizeyi içerir. Örnek .NET Framework 4 veya sonraki sürümlerinde çalıştırılıyorsa, her iki durumda da yumuşak kısa çizgi yoksayılabilir bir karakter olduğundan, yöntem kültüre duyarlı bir karşılaştırma gerçekleştirdiğinde dizede "m" dizinini döndürür. Ancak sıralı bir karşılaştırma gerçekleştirdiğinde, alt dizeyi yalnızca ilk dizede bulur. Yumuşak kısa çizgi ve ardından "m" içeren ilk dize söz konusu olduğunda, yöntemin yumuşak kısa çizginin dizinini döndüremediğine, bunun yerine kültüre duyarlı bir karşılaştırma gerçekleştirdiğinde "m" dizini döndürdüğüne dikkat edin. yöntemi, yalnızca sıralı bir karşılaştırma gerçekleştirdiğinde ilk dizedeki geçici kısa çizginin dizinini döndürür.

using System;

public class Example
{
    public static void Main()
    {

        string searchString = "\u00ADm";
        string s1 = "ani\u00ADmal" ;
        string s2 = "animal";

        Console.WriteLine(s1.IndexOf(searchString, 2, 4, StringComparison.CurrentCulture));
        Console.WriteLine(s1.IndexOf(searchString, 2, 4, StringComparison.Ordinal));
        Console.WriteLine(s2.IndexOf(searchString, 2, 4, StringComparison.CurrentCulture));
        Console.WriteLine(s2.IndexOf(searchString, 2, 4, StringComparison.Ordinal));

        // The example displays the following output:
        //       4
        //       3
        //       3
        //       -1
    }
}

open System

let searchString = "\u00ADm"
let s1 = "ani\u00ADmal"
let s2 = "animal"

printfn $"{s1.IndexOf(searchString, 2, 4, StringComparison.CurrentCulture)}"
printfn $"{s1.IndexOf(searchString, 2, 4, StringComparison.Ordinal)}"
printfn $"{s2.IndexOf(searchString, 2, 4, StringComparison.CurrentCulture)}"
printfn $"{s2.IndexOf(searchString, 2, 4, StringComparison.Ordinal)}"

// The example displays the following output:
//       4
//       3
//       3
//       -1

Module Example
   Public Sub Main()
      Dim searchString As String = Chrw(&h00AD) + "m"
      Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
      Dim s2 As String = "animal"

      Console.WriteLine(s1.IndexOf(searchString, 2, 4, StringComparison.CurrentCulture))
      Console.WriteLine(s1.IndexOf(searchString, 2, 4, StringComparison.Ordinal))
      Console.WriteLine(s2.IndexOf(searchString, 2, 4, StringComparison.CurrentCulture))
      Console.WriteLine(s2.IndexOf(searchString, 2, 4, StringComparison.Ordinal))
   End Sub
End Module
' The example displays the following output:
'       4
'       3
'       3
'       -1

IndexOf(String, Int32, StringComparison)

Kaynak:

String.Searching.cs

Geçerli String nesnede belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar. Parametreler geçerli dizedeki başlangıç arama konumunu ve belirtilen dize için kullanılacak arama türünü belirtir.

public:
 int IndexOf(System::String ^ value, int startIndex, StringComparison comparisonType);

public int IndexOf(string value, int startIndex, StringComparison comparisonType);

member this.IndexOf : string * int * StringComparison -> int

Public Function IndexOf (value As String, startIndex As Integer, comparisonType As StringComparison) As Integer

Parametreler

value

String

Aranacak dize.

startIndex

Int32

Arama başlangıç konumu.

comparisonType

StringComparison

Arama kurallarını belirten numaralandırma değerlerinden biri.

Döndürülenler

Int32

Bu dize bulunursa geçerli örneğin başlangıcından value parametrenin sıfır tabanlı dizin konumu veya bulunamazsa -1. ise valueEmpty, dönüş değeri olur startIndex.

Özel durumlar

ArgumentNullException

value, null'e eşittir.

ArgumentOutOfRangeException

startIndex 0'dan küçük (sıfır) veya bu dizenin uzunluğundan büyük.

ArgumentException

comparisonType geçerli StringComparison bir değer değil.

Örnekler

Aşağıdaki örnekte, bir dizenin IndexOf başka bir dizede ilk oluşumunu bulan yöntemin, numaralandırmanın farklı değerlerini kullanan üç aşırı yüklemesi gösterilmektedir StringComparison .

// This code example demonstrates the 
// System.String.IndexOf(String, ..., StringComparison) methods.

using System;
using System.Threading;
using System.Globalization;

class Sample 
{
    public static void Main() 
    {
    string intro = "Find the first occurrence of a character using different " + 
                   "values of StringComparison.";
    string resultFmt = "Comparison: {0,-28} Location: {1,3}";

// Define a string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
    string CapitalAWithRing = "\u00c5"; 

// Define a string to search. 
// The result of combining the characters LATIN SMALL LETTER A and COMBINING 
// RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character 
// LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
    string cat = "A Cheshire c" + "\u0061\u030a" + "t";

    int loc = 0;
    StringComparison[] scValues = {
        StringComparison.CurrentCulture,
        StringComparison.CurrentCultureIgnoreCase,
        StringComparison.InvariantCulture,
        StringComparison.InvariantCultureIgnoreCase,
        StringComparison.Ordinal,
        StringComparison.OrdinalIgnoreCase };

// Clear the screen and display an introduction.
    Console.Clear();
    Console.WriteLine(intro);

// Display the current culture because culture affects the result. For example, 
// try this code example with the "sv-SE" (Swedish-Sweden) culture.

    Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
    Console.WriteLine("The current culture is \"{0}\" - {1}.", 
                       Thread.CurrentThread.CurrentCulture.Name,
                       Thread.CurrentThread.CurrentCulture.DisplayName);

// Display the string to search for and the string to search.
    Console.WriteLine("Search for the string \"{0}\" in the string \"{1}\"", 
                       CapitalAWithRing, cat);
    Console.WriteLine();

// Note that in each of the following searches, we look for 
// LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains 
// LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates 
// the string was not found.
// Search using different values of StringComparison. Specify the start 
// index and count. 

    Console.WriteLine("Part 1: Start index and count are specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparison. Specify the 
// start index. 
    Console.WriteLine("\nPart 2: Start index is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(CapitalAWithRing, 0, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparison. 
    Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(CapitalAWithRing, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }
    }
}

/*
Note: This code example was executed on a console whose user interface 
culture is "en-US" (English-United States).

This code example produces the following results:

Find the first occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"

Part 1: Start index and count are specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 2: Start index is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 3: Neither start index nor count is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

*/

// This code example demonstrates the
// System.String.IndexOf(String, ..., StringComparison) methods.

open System
open System.Threading
open System.Globalization

let intro = "Find the first occurrence of a character using different values of StringComparison."

// Define a string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
let CapitalAWithRing = "\u00c5"

// Define a string to search.
// The result of combining the characters LATIN SMALL LETTER A and COMBINING
// RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character
// LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
let cat = "A Cheshire c" + "\u0061\u030a" + "t"

let scValues = 
    [| StringComparison.CurrentCulture
       StringComparison.CurrentCultureIgnoreCase
       StringComparison.InvariantCulture
       StringComparison.InvariantCultureIgnoreCase
       StringComparison.Ordinal
       StringComparison.OrdinalIgnoreCase |]

// Clear the screen and display an introduction.
Console.Clear()
printfn $"{intro}"

// Display the current culture because culture affects the result. For example,
// try this code example with the "sv-SE" (Swedish-Sweden) culture.

Thread.CurrentThread.CurrentCulture <- CultureInfo "en-US"
printfn $"The current culture is \"{Thread.CurrentThread.CurrentCulture.Name}\" - {Thread.CurrentThread.CurrentCulture.DisplayName}."

// Display the string to search for and the string to search.
printfn $"Search for the string \"{CapitalAWithRing}\" in the string \"{cat}\"\n"

// Note that in each of the following searches, we look for
// LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains
// LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates
// the string was not found.
// Search using different values of StringComparison. Specify the start
// index and count.

printfn "Part 1: Start index and count are specified."
for sc in scValues do
    let loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc)
    printfn $"Comparison: {sc,-28} Location: {loc,3}"

// Search using different values of StringComparison. Specify the
// start index.
printfn "\nPart 2: Start index is specified."
for sc in scValues do
    let loc = cat.IndexOf(CapitalAWithRing, 0, sc)
    printfn $"Comparison: {sc,-28} Location: {loc,3}"

// Search using different values of StringComparison.
Console.WriteLine("\nPart 3: Neither start index nor count is specified.")
for sc in scValues do
    let loc = cat.IndexOf(CapitalAWithRing, sc)
    Console.WriteLine("Comparison: {0,-28} Location: {1,3}", sc, loc)

(*
Note: This code example was executed on a console whose user interface
culture is "en-US" (English-United States).

This code example produces the following results:

Find the first occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"

Part 1: Start index and count are specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 2: Start index is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 3: Neither start index nor count is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

*)

' This code example demonstrates the 
' System.String.IndexOf(String, ..., StringComparison) methods.

Imports System.Threading
Imports System.Globalization

Class Sample
    Public Shared Sub Main() 
        Dim intro As String = "Find the first occurrence of a character using different " & _
                              "values of StringComparison."
        Dim resultFmt As String = "Comparison: {0,-28} Location: {1,3}"
        
        ' Define a string to search for.
        ' U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
        Dim CapitalAWithRing As String = "Å"
        
        ' Define a string to search. 
        ' The result of combining the characters LATIN SMALL LETTER A and COMBINING 
        ' RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character 
        ' LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
        Dim cat As String = "A Cheshire c" & "å" & "t"
        
        Dim loc As Integer = 0
        Dim scValues As StringComparison() =  { _
                        StringComparison.CurrentCulture, _
                        StringComparison.CurrentCultureIgnoreCase, _
                        StringComparison.InvariantCulture, _
                        StringComparison.InvariantCultureIgnoreCase, _
                        StringComparison.Ordinal, _
                        StringComparison.OrdinalIgnoreCase }
        Dim sc As StringComparison
        
        ' Clear the screen and display an introduction.
        Console.Clear()
        Console.WriteLine(intro)
        
        ' Display the current culture because culture affects the result. For example, 
        ' try this code example with the "sv-SE" (Swedish-Sweden) culture.
        Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
        Console.WriteLine("The current culture is ""{0}"" - {1}.", _
                           Thread.CurrentThread.CurrentCulture.Name, _ 
                           Thread.CurrentThread.CurrentCulture.DisplayName)
        
        ' Display the string to search for and the string to search.
        Console.WriteLine("Search for the string ""{0}"" in the string ""{1}""", _
                           CapitalAWithRing, cat)
        Console.WriteLine()
        
        ' Note that in each of the following searches, we look for 
        ' LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains 
        ' LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates 
        ' the string was not found.
        ' Search using different values of StringComparison. Specify the start 
        ' index and count.

        Console.WriteLine("Part 1: Start index and count are specified.")
        For Each sc In  scValues
            loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparison. Specify the 
        ' start index. 

        Console.WriteLine(vbCrLf & "Part 2: Start index is specified.")
        For Each sc In  scValues
            loc = cat.IndexOf(CapitalAWithRing, 0, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparison. 

        Console.WriteLine(vbCrLf & "Part 3: Neither start index nor count is specified.")
        For Each sc In  scValues
            loc = cat.IndexOf(CapitalAWithRing, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
    
    End Sub
End Class

'
'Note: This code example was executed on a console whose user interface 
'culture is "en-US" (English-United States).
'
'This code example produces the following results:
'
'Find the first occurrence of a character using different values of StringComparison.
'The current culture is "en-US" - English (United States).
'Search for the string "Å" in the string "A Cheshire ca°t"
'
'Part 1: Start index and count are specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'
'Part 2: Start index is specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'
'Part 3: Neither start index nor count is specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'

Açıklamalar

Dizin numaralandırma 0'dan başlar. startIndex parametresi 0 ile dize örneğinin uzunluğu arasında değişebilir. Dize örneğinin uzunluğuna eşitse startIndex , yöntemi -1 döndürür.

parametresi, comparisonType geçerli veya sabit kültürü kullanarak, büyük/küçük harfe duyarlı veya büyük/küçük harfe duyarlı olmayan bir arama kullanarak ve sözcük veya sıralı karşılaştırma kuralları kullanarak parametreyi aramayı value belirtir.

Arayanlara Notlar

Karakter kümeleri, dilsel veya kültüre duyarlı karşılaştırma yapılırken dikkate alınmayan karakterler olan yoksayılabilir karakterler içerir. Kültüre duyarlı bir aramada (veya değilse comparisonTypeOrdinalOrdinalIgnoreCase), value yoksayılabilir bir karakter içeriyorsa, sonuç bu karakter kaldırılmış olarak aramaya eşdeğerdir. Yalnızca bir veya daha fazla yoksayılabilir karakterden oluşuyorsa value , IndexOf(String, Int32, StringComparison) yöntemi her zaman aramanın başladığı karakter konumu olan değerini döndürür startIndex.

Aşağıdaki örnekte yöntemi, IndexOf(String, Int32, StringComparison) yumuşak kısa çizginin (U+00AD) konumunu ve ardından iki dizedeki üçüncü karakter konumuyla başlayan bir "m" bulmak için kullanılır. Dizelerden yalnızca biri gerekli alt dizeyi içerir. Örnek .NET Framework 4 veya sonraki sürümlerinde çalıştırılıyorsa, her iki durumda da yumuşak kısa çizgi yoksayılabilir bir karakter olduğundan, yöntem kültüre duyarlı bir karşılaştırma gerçekleştirdiğinde dizede "m" dizinini döndürür. Yumuşak kısa çizgi ve ardından bir "m" içeren ilk dize söz konusu olduğunda, yöntemin yumuşak kısa çizginin dizinini döndüremezse , bunun yerine "m" dizini döndürdüğünü unutmayın. yöntemi, yalnızca sıralı bir karşılaştırma gerçekleştirdiğinde ilk dizedeki geçici kısa çizginin dizinini döndürür.

using System;

public class Example
{
    public static void Main()
    {
      
        string searchString = "\u00ADm";
        string s1 = "ani\u00ADmal" ;
        string s2 = "animal";

        Console.WriteLine(s1.IndexOf(searchString, 2, StringComparison.CurrentCulture));
        Console.WriteLine(s1.IndexOf(searchString, 2, StringComparison.Ordinal));
        Console.WriteLine(s2.IndexOf(searchString, 2, StringComparison.CurrentCulture));
        Console.WriteLine(s2.IndexOf(searchString, 2, StringComparison.Ordinal));

        // The example displays the following output:
        //       4
        //       3
        //       3
        //       -1
    }
}

open System

let searchString = "\u00ADm"
let s1 = "ani\u00ADmal"
let s2 = "animal"

printfn $"{s1.IndexOf(searchString, 2, StringComparison.CurrentCulture)}"
printfn $"{s1.IndexOf(searchString, 2, StringComparison.Ordinal)}"
printfn $"{s2.IndexOf(searchString, 2, StringComparison.CurrentCulture)}"
printfn $"{s2.IndexOf(searchString, 2, StringComparison.Ordinal)}"

// The example displays the following output:
//       4
//       3
//       3
//       -1

Module Example
   Public Sub Main()
      Dim searchString As String = Chrw(&h00AD) + "m"
      Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
      Dim s2 As String = "animal"

      Console.WriteLine(s1.IndexOf(searchString, 2, StringComparison.CurrentCulture))
      Console.WriteLine(s1.IndexOf(searchString, 2, StringComparison.Ordinal))
      Console.WriteLine(s2.IndexOf(searchString, 2, StringComparison.CurrentCulture))
      Console.WriteLine(s2.IndexOf(searchString, 2, StringComparison.Ordinal))
   End Sub
End Module
' The example displays the following output:
'       4
'       3
'       3
'       -1

IndexOf(String, Int32, Int32)

Kaynak:

String.Searching.cs

Bu örnekte belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar. Arama belirtilen karakter konumunda başlar ve belirtilen sayıda karakter konumunu inceler.

public:
 int IndexOf(System::String ^ value, int startIndex, int count);

public int IndexOf(string value, int startIndex, int count);

member this.IndexOf : string * int * int -> int

Public Function IndexOf (value As String, startIndex As Integer, count As Integer) As Integer

Parametreler

value

String

Aranacak dize.

startIndex

Int32

Arama başlangıç konumu.

count

Int32

İncelenecek karakter konumlarının sayısı.

Döndürülenler

Int32

Dize bulunursa geçerli örneğin başlangıcından sıfır tabanlı dizin konumu value veya bulunamazsa -1. ise valueEmpty, dönüş değeri olur startIndex.

Özel durumlar

ArgumentNullException

value, null'e eşittir.

ArgumentOutOfRangeException

count veya startIndex negatiftir.

-veya-

startIndex bu dizenin uzunluğundan büyük.

-veya-

count , bu dizenin uzunluğundan büyük eksidir startIndex.

Örnekler

Aşağıdaki örnek, başka bir dizenin alt dizesi içinde "he" dizesinin tüm oluşumlarının dizinini bulur. Aranacak karakter sayısının her arama yinelemesi için yeniden hesaplanması gerektiğini unutmayın.

string br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+---";
string br2 = "012345678901234567890123456789012345678901234567890123456789012345678";
string str = "Now is the time for all good men to come to the aid of their country.";
int start;
int at;
int end;
int count;

end = str.Length;
start = end/2;
Console.WriteLine();
Console.WriteLine("All occurrences of 'he' from position {0} to {1}.", start, end-1);
Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str);
Console.Write("The string 'he' occurs at position(s): ");

count = 0;
at = 0;
while((start <= end) && (at > -1))
{
    // start+count must be a position within -str-.
    count = end - start;
    at = str.IndexOf("he", start, count);
    if (at == -1) break;
    Console.Write("{0} ", at);
    start = at+1;
}
Console.WriteLine();

/*
This example produces the following results:

All occurrences of 'he' from position 34 to 68.
0----+----1----+----2----+----3----+----4----+----5----+----6----+---
012345678901234567890123456789012345678901234567890123456789012345678
Now is the time for all good men to come to the aid of their country.

The string 'he' occurs at position(s): 45 56

*/

let br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+---"
let br2 = "012345678901234567890123456789012345678901234567890123456789012345678"
let str = "Now is the time for all good men to come to the aid of their country."

let last = str.Length
let mutable start = last / 2
printfn $"\nAll occurrences of 'he' from position {start} to {last - 1}."
printfn $"{br1}{Environment.NewLine}{br2}{Environment.NewLine}{str}{Environment.NewLine}"
printf "The string 'he' occurs at position(s): "

let mutable broken = false
let mutable at = 0
while (start <= last) && (at > -1) do
    // start+count must be a position within -str-.
    let count = last - start
    at <- str.IndexOf("he", start, count)
    if at = -1 then
        broken <- true
    else
        printf $"{at} "
        start <- at + 1
printfn ""

(*
This example produces the following results:

All occurrences of 'he' from position 34 to 68.
0----+----1----+----2----+----3----+----4----+----5----+----6----+---
012345678901234567890123456789012345678901234567890123456789012345678
Now is the time for all good men to come to the aid of their country.

The string 'he' occurs at position(s): 45 56

*)

' Sample for String.IndexOf(String, Int32, Int32)
Class Sample
   
   Public Shared Sub Main()
      
      Dim br1 As String = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-"
      Dim br2 As String = "0123456789012345678901234567890123456789012345678901234567890123456"
      Dim str As String = "Now is the time for all good men to come to the aid of their party."
      Dim start As Integer
      Dim at As Integer
      Dim [end] As Integer
      Dim count As Integer
      
      [end] = str.Length
      start = [end] / 2
      Console.WriteLine()
      Console.WriteLine("All occurrences of 'he' from position {0} to {1}.", start, [end] - 1)
      Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str)
      Console.Write("The string 'he' occurs at position(s): ")
      
      count = 0
      at = 0
      While start <= [end] AndAlso at > - 1
         ' start+count must be a position within -str-.
         count = [end] - start
         at = str.IndexOf("he", start, count)
         If at = - 1 Then
            Exit While
         End If
         Console.Write("{0} ", at)
         start = at + 1
      End While
      Console.WriteLine()
   End Sub
End Class
'
'This example produces the following results:
'
'All occurrences of 'he' from position 33 to 66.
'0----+----1----+----2----+----3----+----4----+----5----+----6----+-
'0123456789012345678901234567890123456789012345678901234567890123456
'Now is the time for all good men to come to the aid of their party.
'
'The string 'he' occurs at position(s): 45 56
'
'

Açıklamalar

Dizin numaralandırma 0'dan (sıfır) başlar. startIndex parametresi 0 ile dize örneğinin uzunluğu arasında değişebilir.

Bu yöntem, geçerli kültürü kullanarak bir sözcük (büyük/küçük harfe duyarlı ve kültüre duyarlı) arama gerçekleştirir. Arama şu konumda startIndex başlar ve -1'e startIndex + count devam eder. konumundaki startIndex + count karakter aramaya dahil değildir.

Karakter kümeleri, dilsel veya kültüre duyarlı karşılaştırma yapılırken dikkate alınmayan karakterler olan yoksayılabilir karakterler içerir. Kültüre duyarlı bir aramada, yoksayılabilir bir karakter içeriyorsa value sonuç, bu karakter kaldırılmış olarak aramaya eşdeğerdir. Yalnızca bir veya daha fazla yoksayılabilir karakterden oluşuyorsa value , IndexOf(String, Int32, Int32) yöntemi her zaman aramanın başladığı karakter konumu olan değerini döndürür startIndex. Aşağıdaki örnekte yöntemi, IndexOf(String, Int32, Int32) iki dizedeki üçüncü ile altıncı karakter konumları arasında başlayan bir yumuşak kısa çizgi (U+00AD) ve ardından "m" konumunu bulmak için kullanılır. Dizelerden yalnızca biri gerekli alt dizeyi içerir. Örnek .NET Framework 4 veya sonraki sürümlerinde çalıştırılıyorsa, her iki durumda da yumuşak kısa çizgi yoksayılabilir bir karakter olduğundan, yöntem kültüre duyarlı bir karşılaştırma gerçekleştirdiğinde dizede "m" dizinini döndürür. Yumuşak kısa çizgi ve ardından bir "m" içeren ilk dize söz konusu olduğunda, yöntemin yumuşak kısa çizginin dizinini döndüremezse , bunun yerine "m" dizini döndürdüğünü unutmayın.

using System;

public class Example
{
    public static void Main()
    {
        string searchString = "\u00ADm";
        string s1 = "ani\u00ADmal" ;
        string s2 = "animal";

        Console.WriteLine(s1.IndexOf(searchString, 2, 4));
        Console.WriteLine(s2.IndexOf(searchString, 2, 4));

        // The example displays the following output:
        //       4
        //       3
    }
}

let searchString = "\u00ADm"
let s1 = "ani\u00ADmal"
let s2 = "animal"

printfn $"{s1.IndexOf(searchString, 2, 4)}"
printfn $"{s2.IndexOf(searchString, 2, 4)}"

// The example displays the following output:
//       4
//       3

Module Example
   Public Sub Main()
      Dim searchString As String = Chrw(&h00AD) + "m"
      Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
      Dim s2 As String = "animal"

      Console.WriteLine(s1.IndexOf(searchString, 2, 4))
      Console.WriteLine(s2.IndexOf(searchString, 2, 4))
   End Sub
End Module
' The example displays the following output:
'       4
'       3

Arayanlara Notlar

Dizeleri Kullanmak için En İyi Yöntemler bölümünde açıklandığı gibi, varsayılan değerlerin yerini alan dize karşılaştırma yöntemlerini çağırmaktan kaçınmanızı ve bunun yerine parametrelerin açıkça belirtilmesi gereken yöntemleri çağırmanızı öneririz. Bu işlemi gerçekleştirmek için geçerli kültürün karşılaştırma kurallarını kullanmak için yöntemi aşırı yüklemesini parametresi için değeriyle CurrentCulture çağırarak IndexOf(String, Int32, Int32, StringComparison) amacınıza açıkça işaret verincomparisonType. Dil bilgili karşılaştırmaya ihtiyacınız yoksa kullanmayı Ordinalgöz önünde bulundurun.

Ayrıca bkz.

• Int32
• CultureInfo
• IndexOfAny(Char[])
• LastIndexOf(Char)
• LastIndexOfAny(Char[])

IndexOf(Char, Int32, Int32)

Kaynak:

String.Searching.cs

Bu örnekte belirtilen karakterin ilk oluşumunun sıfır tabanlı dizinini raporlar. Arama belirtilen karakter konumunda başlar ve belirtilen sayıda karakter konumunu inceler.

public:
 int IndexOf(char value, int startIndex, int count);

public int IndexOf(char value, int startIndex, int count);

member this.IndexOf : char * int * int -> int

Public Function IndexOf (value As Char, startIndex As Integer, count As Integer) As Integer

Parametreler

value

Char

Aranacak Unicode karakteri.

startIndex

Int32

Arama başlangıç konumu.

count

Int32

İncelenecek karakter konumlarının sayısı.

Döndürülenler

Int32

Sıfır tabanlı dizin konumu value , karakter bulunursa dizenin başlangıcından veya bulunamazsa -1.

Özel durumlar

ArgumentOutOfRangeException

count veya startIndex negatiftir.

-veya-

startIndex bu dizenin uzunluğundan büyük.

-veya-

count , bu dizenin uzunluğundan büyük eksidir startIndex.

Örnekler

Aşağıdaki örnekte yöntemi gösterilmektedir IndexOf .

// Example for the String.IndexOf( char, int, int ) method.
using System;

class IndexOfCII 
{
    public static void Main() 
    {
        string br1 = 
            "0----+----1----+----2----+----3----+----" +
            "4----+----5----+----6----+----7";
        string br2 = 
            "0123456789012345678901234567890123456789" +
            "0123456789012345678901234567890";
        string str = 
            "ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi " +
            "ABCDEFGHI abcdefghi ABCDEFGHI";

        Console.WriteLine( 
            "This example of String.IndexOf( char, int, int )\n" +
            "generates the following output." );
        Console.WriteLine( 
            "{0}{1}{0}{2}{0}{3}{0}", 
            Environment.NewLine, br1, br2, str );

        FindAllChar( 'A', str );
        FindAllChar( 'a', str );
        FindAllChar( 'I', str );
        FindAllChar( 'i', str );
        FindAllChar( '@', str );
        FindAllChar( ' ', str );
    }

    static void FindAllChar( Char target, String searched )
    {
        Console.Write( 
            "The character '{0}' occurs at position(s): ", 
            target );

        int     startIndex = -1;
        int     hitCount = 0;

        // Search for all occurrences of the target.
        while( true )
        {
            startIndex = searched.IndexOf( 
                target, startIndex + 1, 
                searched.Length - startIndex - 1 );

            // Exit the loop if the target is not found.
            if( startIndex < 0 )
                break;

            Console.Write( "{0}, ", startIndex );
            hitCount++;
        }

        Console.WriteLine( "occurrences: {0}", hitCount );
    }
}

/*
This example of String.IndexOf( char, int, int )
generates the following output.

0----+----1----+----2----+----3----+----4----+----5----+----6----+----7
01234567890123456789012345678901234567890123456789012345678901234567890
ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI

The character 'A' occurs at position(s): 0, 20, 40, 60, occurrences: 4
The character 'a' occurs at position(s): 10, 30, 50, occurrences: 3
The character 'I' occurs at position(s): 8, 28, 48, 68, occurrences: 4
The character 'i' occurs at position(s): 18, 38, 58, occurrences: 3
The character '@' occurs at position(s): occurrences: 0
The character ' ' occurs at position(s): 9, 19, 29, 39, 49, 59, occurrences: 6
*/

// Example for the String.IndexOf( char, int, int ) method.
open System

let br1 =
    "0----+----1----+----2----+----3----+----" +
    "4----+----5----+----6----+----7"
let br2 =
    "0123456789012345678901234567890123456789" +
    "0123456789012345678901234567890"
let str =
    "ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi " +
    "ABCDEFGHI abcdefghi ABCDEFGHI"

printfn "This example of String.IndexOf( char, int, int )\ngenerates the following output."
printfn $"{Environment.NewLine}{br1}{Environment.NewLine}{br2}{Environment.NewLine}{str}{Environment.NewLine}"

let findAllChar (target: char) (searched: string) =
    printf $"The character '{target}' occurs at position(s): "

    let mutable hitCount = 0
    let mutable startIndex = -1
    let mutable broken = false
    // Search for all occurrences of the target.
    while not broken do
        startIndex <- searched.IndexOf(target, startIndex + 1, searched.Length - startIndex - 1)

        // Exit the loop if the target is not found.
        if startIndex < 0 then
            broken <- true
        else

        printf $"{startIndex}, "
        hitCount <- hitCount + 1

    printfn $"occurrences: {hitCount}"

findAllChar 'A' str
findAllChar 'a' str
findAllChar 'I' str
findAllChar 'i' str
findAllChar '@' str
findAllChar ' ' str


(*
This example of String.IndexOf( char, int, int )
generates the following output.

0----+----1----+----2----+----3----+----4----+----5----+----6----+----7
01234567890123456789012345678901234567890123456789012345678901234567890
ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI

The character 'A' occurs at position(s): 0, 20, 40, 60, occurrences: 4
The character 'a' occurs at position(s): 10, 30, 50, occurrences: 3
The character 'I' occurs at position(s): 8, 28, 48, 68, occurrences: 4
The character 'i' occurs at position(s): 18, 38, 58, occurrences: 3
The character '@' occurs at position(s): occurrences: 0
The character ' ' occurs at position(s): 9, 19, 29, 39, 49, 59, occurrences: 6
*)

' Example for the String.IndexOf( Char, Integer, Integer ) method.
Module IndexOfCII
   
    Sub Main()
        Dim br1 As String = _
            "0----+----1----+----2----+----3----+----" & _
            "4----+----5----+----6----+----7"
        Dim br2 As String = _
            "0123456789012345678901234567890123456789" & _
            "0123456789012345678901234567890"
        Dim str As String = _
            "ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi " & _
            "ABCDEFGHI abcdefghi ABCDEFGHI"
          
        Console.WriteLine( _
            "This example of String.IndexOf( Char, Integer, Integer )" & _
            vbCrLf & "generates the following output." )
        Console.WriteLine( _
            "{0}{1}{0}{2}{0}{3}{0}", _
            Environment.NewLine, br1, br2, str)

        FindAllChar("A"c, str)
        FindAllChar("a"c, str)
        FindAllChar("I"c, str)
        FindAllChar("i"c, str)
        FindAllChar("@"c, str)
        FindAllChar(" "c, str)
    End Sub
       
    Sub FindAllChar(target As Char, searched As String)

        Console.Write( _
            "The character ""{0}"" occurs at position(s): ", target)
          
        Dim startIndex As Integer = - 1
        Dim hitCount As Integer = 0
          
        ' Search for all occurrences of the target.
        While True
            startIndex = searched.IndexOf( _
                target, startIndex + 1, _
                searched.Length - startIndex - 1)

            ' Exit the loop if the target is not found.
            If startIndex < 0 Then
                Exit While
            End If 

            Console.Write("{0}, ", startIndex)
            hitCount += 1
        End While
          
        Console.WriteLine("occurrences: {0}", hitCount)

    End Sub
End Module 'IndexOfCII

' This example of String.IndexOf( Char, Integer, Integer )
' generates the following output.
' 
' 0----+----1----+----2----+----3----+----4----+----5----+----6----+----7
' 01234567890123456789012345678901234567890123456789012345678901234567890
' ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI
' 
' The character "A" occurs at position(s): 0, 20, 40, 60, occurrences: 4
' The character "a" occurs at position(s): 10, 30, 50, occurrences: 3
' The character "I" occurs at position(s): 8, 28, 48, 68, occurrences: 4
' The character "i" occurs at position(s): 18, 38, 58, occurrences: 3
' The character "@" occurs at position(s): occurrences: 0
' The character " " occurs at position(s): 9, 19, 29, 39, 49, 59, occurrences: 6

Açıklamalar

Arama şu konumda startIndex başlar ve -1'e startIndex + count devam eder. konumundaki startIndex + count karakter aramaya dahil değildir.

Dizin numaralandırma 0'dan (sıfır) başlar. startIndex parametresi 0 ile dize örneğinin uzunluğu arasında değişebilir.

Bu yöntem, yalnızca Unicode skaler değerleri aynı olduğunda bir karakterin başka bir karaktere eşdeğer olarak kabul edildiği sıralı (kültüre duyarsız) bir arama gerçekleştirir. Kültüre duyarlı bir arama gerçekleştirmek için, "Æ" (U+00C6) ligatürü gibi önceden derlenmiş bir karakteri temsil eden Unicode skaler değerinin, kültüre bağlı olarak "AE" (U+0041, U+0045) gibi doğru dizideki karakter bileşenlerinin herhangi bir örneğine eşdeğer olarak kabul edilebileceği yöntemini kullanın CompareInfo.IndexOf .

Ayrıca bkz.

• Char
• Int32
• IndexOfAny(Char[])
• LastIndexOf(Char)
• LastIndexOfAny(Char[])

IndexOf(Char)

Kaynak:

String.Searching.cs

Bu dizede belirtilen Unicode karakterinin ilk oluşumunun sıfır tabanlı dizinini raporlar.

public:
 int IndexOf(char value);

public int IndexOf(char value);

member this.IndexOf : char -> int

Public Function IndexOf (value As Char) As Integer

Parametreler

value

Char

Aranacak Unicode karakteri.

Döndürülenler

Int32

Bu karakter bulunursa sıfır tabanlı dizin konumu value veya bulunamazsa -1.

Örnekler

Aşağıdaki örnek, yöntemini kullanarak bir String karakteri nasıl arayabileceğinizi IndexOf gösterir.

// Create a Unicode string with 5 Greek Alpha characters.
String szGreekAlpha = new String('\u0391',5);

// Create a Unicode string with 3 Greek Omega characters.
String szGreekOmega = "\u03A9\u03A9\u03A9";

String szGreekLetters = String.Concat(szGreekOmega, szGreekAlpha, 
                                    szGreekOmega.Clone());

// Display the entire string.
Console.WriteLine("The string: {0}", szGreekLetters);

// The first index of Alpha.
int ialpha = szGreekLetters.IndexOf('\u0391');
// The first index of Omega.
int iomega = szGreekLetters.IndexOf('\u03A9');

Console.WriteLine("First occurrence of the Greek letter Alpha: Index {0}", 
                ialpha);
Console.WriteLine("First occurrence of the Greek letter Omega: Index {0}", 
                iomega);

// The example displays the following output:
//    The string: ΩΩΩΑΑΑΑΑΩΩΩ
//    First occurrence of the Greek letter Alpha: Index 3
//    First occurrence of the Greek letter Omega: Index 0

open System

// Create a Unicode string with 5 Greek Alpha characters.
let szGreekAlpha = String('\u0391',5)

// Create a Unicode string with 3 Greek Omega characters.
let szGreekOmega = "\u03A9\u03A9\u03A9"

let szGreekLetters = String.Concat(szGreekOmega, szGreekAlpha, szGreekOmega.Clone())

// Display the entire string.
printfn $"The string: {szGreekLetters}"

// The first index of Alpha.
let ialpha = szGreekLetters.IndexOf '\u0391'
// The first index of Omega.
let iomega = szGreekLetters.IndexOf '\u03A9'

printfn "First occurrence of the Greek letter Alpha: Index {ialpha}"
printfn "First occurrence of the Greek letter Omega: Index {iomega}"

// The example displays the following output:
//    The string: ΩΩΩΑΑΑΑΑΩΩΩ
//    First occurrence of the Greek letter Alpha: Index 3
//    First occurrence of the Greek letter Omega: Index 0

Public Module Example
   Public Sub Main()
      ' Create a Unicode string with 5 Greek Alpha characters.
      Dim szGreekAlpha As New String(ChrW(&H0391), 5)

      ' Create a Unicode string with 3 Greek Omega characters.
      Dim szGreekOmega As String = ChrW(&H03A9) + ChrW(&H03A9)+
                                   ChrW(&H03A9)

      Dim szGreekLetters As String = String.Concat(szGreekOmega, szGreekAlpha, _
                                                   szGreekOmega.Clone())

      ' Display the entire string.
      Console.WriteLine(szGreekLetters)

      ' The first index of Alpha.
      Dim iAlpha As Integer = szGreekLetters.IndexOf(ChrW(&H0391))
      ' The first index of Omega.
      Dim iomega As Integer = szGreekLetters.IndexOf(ChrW(&H03A9))

      Console.WriteLine("First occurrence of the Greek letter Alpha: Index {0}", 
                        ialpha)
      Console.WriteLine("First occurrence of the Greek letter Omega: Index {0}", 
                        iomega)
   End Sub
End Module
' The example displays the following output:
'       The string: OOO?????OOO
'       First occurrence of the Greek letter Alpha: Index 3
'       First occurrence of the Greek letter Omega: Index 0

Açıklamalar

Dizin numaralandırma sıfırdan başlar.

Bu yöntem, yalnızca Unicode skaler değerleri aynı olduğunda bir karakterin başka bir karaktere eşdeğer olarak kabul edildiği sıralı (kültüre duyarsız) bir arama gerçekleştirir. Kültüre duyarlı bir arama gerçekleştirmek için, "Æ" (U+00C6) ligatürü gibi önceden derlenmiş bir karakteri temsil eden Unicode skaler değerinin, kültüre bağlı olarak "AE" (U+0041, U+0045) gibi doğru dizideki karakter bileşenlerinin herhangi bir örneğine eşdeğer olarak kabul edilebileceği yöntemini kullanın CompareInfo.IndexOf .

Ayrıca bkz.

• Char
• IndexOfAny(Char[])
• LastIndexOf(Char)
• LastIndexOfAny(Char[])

IndexOf(String, StringComparison)

Kaynak:

String.Searching.cs

Geçerli String nesnede belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar. Parametresi, belirtilen dize için kullanılacak arama türünü belirtir.

public:
 int IndexOf(System::String ^ value, StringComparison comparisonType);

public int IndexOf(string value, StringComparison comparisonType);

member this.IndexOf : string * StringComparison -> int

Public Function IndexOf (value As String, comparisonType As StringComparison) As Integer

Parametreler

value

String

Aranacak dize.

comparisonType

StringComparison

Arama kurallarını belirten numaralandırma değerlerinden biri.

Döndürülenler

Int32

Bu dize bulunursa parametrenin value dizin konumu veya bulunamazsa -1. ise valueEmpty, dönüş değeri 0'dır.

Özel durumlar

ArgumentNullException

value, null'e eşittir.

ArgumentException

comparisonType geçerli StringComparison bir değer değil.

Örnekler

Aşağıdaki örnekte, bir dizenin IndexOf başka bir dizede ilk oluşumunu bulan yöntemin, numaralandırmanın farklı değerlerini kullanan üç aşırı yüklemesi gösterilmektedir StringComparison .

// This code example demonstrates the 
// System.String.IndexOf(String, ..., StringComparison) methods.

using System;
using System.Threading;
using System.Globalization;

class Sample 
{
    public static void Main() 
    {
    string intro = "Find the first occurrence of a character using different " + 
                   "values of StringComparison.";
    string resultFmt = "Comparison: {0,-28} Location: {1,3}";

// Define a string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
    string CapitalAWithRing = "\u00c5"; 

// Define a string to search. 
// The result of combining the characters LATIN SMALL LETTER A and COMBINING 
// RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character 
// LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
    string cat = "A Cheshire c" + "\u0061\u030a" + "t";

    int loc = 0;
    StringComparison[] scValues = {
        StringComparison.CurrentCulture,
        StringComparison.CurrentCultureIgnoreCase,
        StringComparison.InvariantCulture,
        StringComparison.InvariantCultureIgnoreCase,
        StringComparison.Ordinal,
        StringComparison.OrdinalIgnoreCase };

// Clear the screen and display an introduction.
    Console.Clear();
    Console.WriteLine(intro);

// Display the current culture because culture affects the result. For example, 
// try this code example with the "sv-SE" (Swedish-Sweden) culture.

    Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
    Console.WriteLine("The current culture is \"{0}\" - {1}.", 
                       Thread.CurrentThread.CurrentCulture.Name,
                       Thread.CurrentThread.CurrentCulture.DisplayName);

// Display the string to search for and the string to search.
    Console.WriteLine("Search for the string \"{0}\" in the string \"{1}\"", 
                       CapitalAWithRing, cat);
    Console.WriteLine();

// Note that in each of the following searches, we look for 
// LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains 
// LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates 
// the string was not found.
// Search using different values of StringComparison. Specify the start 
// index and count. 

    Console.WriteLine("Part 1: Start index and count are specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparison. Specify the 
// start index. 
    Console.WriteLine("\nPart 2: Start index is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(CapitalAWithRing, 0, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparison. 
    Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(CapitalAWithRing, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }
    }
}

/*
Note: This code example was executed on a console whose user interface 
culture is "en-US" (English-United States).

This code example produces the following results:

Find the first occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"

Part 1: Start index and count are specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 2: Start index is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 3: Neither start index nor count is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

*/

// This code example demonstrates the
// System.String.IndexOf(String, ..., StringComparison) methods.

open System
open System.Threading
open System.Globalization

let intro = "Find the first occurrence of a character using different values of StringComparison."

// Define a string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
let CapitalAWithRing = "\u00c5"

// Define a string to search.
// The result of combining the characters LATIN SMALL LETTER A and COMBINING
// RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character
// LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
let cat = "A Cheshire c" + "\u0061\u030a" + "t"

let scValues = 
    [| StringComparison.CurrentCulture
       StringComparison.CurrentCultureIgnoreCase
       StringComparison.InvariantCulture
       StringComparison.InvariantCultureIgnoreCase
       StringComparison.Ordinal
       StringComparison.OrdinalIgnoreCase |]

// Clear the screen and display an introduction.
Console.Clear()
printfn $"{intro}"

// Display the current culture because culture affects the result. For example,
// try this code example with the "sv-SE" (Swedish-Sweden) culture.

Thread.CurrentThread.CurrentCulture <- CultureInfo "en-US"
printfn $"The current culture is \"{Thread.CurrentThread.CurrentCulture.Name}\" - {Thread.CurrentThread.CurrentCulture.DisplayName}."

// Display the string to search for and the string to search.
printfn $"Search for the string \"{CapitalAWithRing}\" in the string \"{cat}\"\n"

// Note that in each of the following searches, we look for
// LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains
// LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates
// the string was not found.
// Search using different values of StringComparison. Specify the start
// index and count.

printfn "Part 1: Start index and count are specified."
for sc in scValues do
    let loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc)
    printfn $"Comparison: {sc,-28} Location: {loc,3}"

// Search using different values of StringComparison. Specify the
// start index.
printfn "\nPart 2: Start index is specified."
for sc in scValues do
    let loc = cat.IndexOf(CapitalAWithRing, 0, sc)
    printfn $"Comparison: {sc,-28} Location: {loc,3}"

// Search using different values of StringComparison.
Console.WriteLine("\nPart 3: Neither start index nor count is specified.")
for sc in scValues do
    let loc = cat.IndexOf(CapitalAWithRing, sc)
    Console.WriteLine("Comparison: {0,-28} Location: {1,3}", sc, loc)

(*
Note: This code example was executed on a console whose user interface
culture is "en-US" (English-United States).

This code example produces the following results:

Find the first occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"

Part 1: Start index and count are specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 2: Start index is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 3: Neither start index nor count is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

*)

' This code example demonstrates the 
' System.String.IndexOf(String, ..., StringComparison) methods.

Imports System.Threading
Imports System.Globalization

Class Sample
    Public Shared Sub Main() 
        Dim intro As String = "Find the first occurrence of a character using different " & _
                              "values of StringComparison."
        Dim resultFmt As String = "Comparison: {0,-28} Location: {1,3}"
        
        ' Define a string to search for.
        ' U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
        Dim CapitalAWithRing As String = "Å"
        
        ' Define a string to search. 
        ' The result of combining the characters LATIN SMALL LETTER A and COMBINING 
        ' RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character 
        ' LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
        Dim cat As String = "A Cheshire c" & "å" & "t"
        
        Dim loc As Integer = 0
        Dim scValues As StringComparison() =  { _
                        StringComparison.CurrentCulture, _
                        StringComparison.CurrentCultureIgnoreCase, _
                        StringComparison.InvariantCulture, _
                        StringComparison.InvariantCultureIgnoreCase, _
                        StringComparison.Ordinal, _
                        StringComparison.OrdinalIgnoreCase }
        Dim sc As StringComparison
        
        ' Clear the screen and display an introduction.
        Console.Clear()
        Console.WriteLine(intro)
        
        ' Display the current culture because culture affects the result. For example, 
        ' try this code example with the "sv-SE" (Swedish-Sweden) culture.
        Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
        Console.WriteLine("The current culture is ""{0}"" - {1}.", _
                           Thread.CurrentThread.CurrentCulture.Name, _ 
                           Thread.CurrentThread.CurrentCulture.DisplayName)
        
        ' Display the string to search for and the string to search.
        Console.WriteLine("Search for the string ""{0}"" in the string ""{1}""", _
                           CapitalAWithRing, cat)
        Console.WriteLine()
        
        ' Note that in each of the following searches, we look for 
        ' LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains 
        ' LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates 
        ' the string was not found.
        ' Search using different values of StringComparison. Specify the start 
        ' index and count.

        Console.WriteLine("Part 1: Start index and count are specified.")
        For Each sc In  scValues
            loc = cat.IndexOf(CapitalAWithRing, 0, cat.Length, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparison. Specify the 
        ' start index. 

        Console.WriteLine(vbCrLf & "Part 2: Start index is specified.")
        For Each sc In  scValues
            loc = cat.IndexOf(CapitalAWithRing, 0, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparison. 

        Console.WriteLine(vbCrLf & "Part 3: Neither start index nor count is specified.")
        For Each sc In  scValues
            loc = cat.IndexOf(CapitalAWithRing, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
    
    End Sub
End Class

'
'Note: This code example was executed on a console whose user interface 
'culture is "en-US" (English-United States).
'
'This code example produces the following results:
'
'Find the first occurrence of a character using different values of StringComparison.
'The current culture is "en-US" - English (United States).
'Search for the string "Å" in the string "A Cheshire ca°t"
'
'Part 1: Start index and count are specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'
'Part 2: Start index is specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'
'Part 3: Neither start index nor count is specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'

Açıklamalar

Dizin numaralandırma sıfırdan başlar.

parametresi, comparisonType geçerli veya sabit kültürü kullanarak, büyük/küçük harfe duyarlı veya büyük/küçük harfe duyarlı olmayan bir arama kullanarak ve sözcük veya sıralı karşılaştırma kuralları kullanarak parametreyi aramayı value belirtir.

Arayanlara Notlar

Karakter kümeleri, dilsel veya kültüre duyarlı karşılaştırma yapılırken dikkate alınmayan karakterler olan yoksayılabilir karakterler içerir. Kültüre duyarlı bir aramada (veya değilse comparisonTypeOrdinalOrdinalIgnoreCase), value yoksayılabilir bir karakter içeriyorsa, sonuç bu karakter kaldırılmış olarak aramaya eşdeğerdir. Yalnızca bir veya daha fazla yoksayılabilir karakterden oluşuyorsa value , IndexOf(String, StringComparison) yöntemi her zaman eşleşmenin geçerli örneğin başında bulunduğunu belirtmek için 0 (sıfır) döndürür.

Aşağıdaki örnekte yöntemi, IndexOf(String, StringComparison) iki dizede üç alt dize (bir yumuşak kısa çizgi (U+00AD), ardından "n" ve ardından "m" gelen yumuşak kısa çizgi bulmak için kullanılır. Dizelerden yalnızca biri yumuşak kısa çizgi içerir. Örnek .NET Framework 4 veya sonraki sürümlerinde çalıştırılıyorsa, yumuşak kısa çizgi yoksayılabilir bir karakter olduğundan, kültüre duyarlı bir arama, geçici kısa çizgi arama dizesine dahil edilmezse döndüreceği değeri döndürür. Ancak sıralı arama, bir dizedeki geçici kısa çizgiyi başarıyla bulur ve ikinci dizede bulunmadığını bildirir.

using System;

public class Example
{
    public static void Main()
    {
        string s1 = "ani\u00ADmal";
        string s2 = "animal";
      
        Console.WriteLine("Culture-sensitive comparison:");
        // Use culture-sensitive comparison to find the soft hyphen.
        Console.WriteLine(s1.IndexOf("\u00AD", StringComparison.CurrentCulture));
        Console.WriteLine(s2.IndexOf("\u00AD", StringComparison.CurrentCulture));
      
        // Use culture-sensitive comparison to find the soft hyphen followed by "n".
        Console.WriteLine(s1.IndexOf("\u00ADn", StringComparison.CurrentCulture));
        Console.WriteLine(s2.IndexOf("\u00ADn", StringComparison.CurrentCulture));
      
        // Use culture-sensitive comparison to find the soft hyphen followed by "m".
        Console.WriteLine(s1.IndexOf("\u00ADm", StringComparison.CurrentCulture));
        Console.WriteLine(s2.IndexOf("\u00ADm", StringComparison.CurrentCulture));
      
        Console.WriteLine("Ordinal comparison:");
        // Use ordinal comparison to find the soft hyphen.
        Console.WriteLine(s1.IndexOf("\u00AD", StringComparison.Ordinal));
        Console.WriteLine(s2.IndexOf("\u00AD", StringComparison.Ordinal));
      
        // Use ordinal comparison to find the soft hyphen followed by "n".
        Console.WriteLine(s1.IndexOf("\u00ADn", StringComparison.Ordinal));
        Console.WriteLine(s2.IndexOf("\u00ADn", StringComparison.Ordinal));
      
        // Use ordinal comparison to find the soft hyphen followed by "m".
        Console.WriteLine(s1.IndexOf("\u00ADm", StringComparison.Ordinal));
        Console.WriteLine(s2.IndexOf("\u00ADm", StringComparison.Ordinal));

        // The example displays the following output:
        //       Culture-sensitive comparison:
        //       0
        //       0
        //       1
        //       1
        //       4
        //       3
        //       Ordinal comparison:
        //       3
        //       -1
        //       -1
        //       -1
        //       3
        //       -1
    }
}

open System

let s1 = "ani\u00ADmal"
let s2 = "animal"

printfn "Culture-sensitive comparison:"
// Use culture-sensitive comparison to find the soft hyphen.
printfn $"""{s1.IndexOf("\u00AD", StringComparison.CurrentCulture)}"""
printfn $"""{s2.IndexOf("\u00AD", StringComparison.CurrentCulture)}"""

// Use culture-sensitive comparison to find the soft hyphen followed by "n".
printfn $"""{s1.IndexOf("\u00ADn", StringComparison.CurrentCulture)}"""
printfn $"""{s2.IndexOf("\u00ADn", StringComparison.CurrentCulture)}"""

// Use culture-sensitive comparison to find the soft hyphen followed by "m".
printfn $"""{s1.IndexOf("\u00ADm", StringComparison.CurrentCulture)}"""
printfn $"""{s2.IndexOf("\u00ADm", StringComparison.CurrentCulture)}"""

printfn "Ordinal comparison:"
// Use ordinal comparison to find the soft hyphen.
printfn $"""{s1.IndexOf("\u00AD", StringComparison.Ordinal)}"""
printfn $"""{s2.IndexOf("\u00AD", StringComparison.Ordinal)}"""

// Use ordinal comparison to find the soft hyphen followed by "n".
printfn $"""{s1.IndexOf("\u00ADn", StringComparison.Ordinal)}"""
printfn $"""{s2.IndexOf("\u00ADn", StringComparison.Ordinal)}"""

// Use ordinal comparison to find the soft hyphen followed by "m".
printfn $"""{s1.IndexOf("\u00ADm", StringComparison.Ordinal)}"""
printfn $"""{s2.IndexOf("\u00ADm", StringComparison.Ordinal)}"""

// The example displays the following output:
//       Culture-sensitive comparison:
//       0
//       0
//       1
//       1
//       4
//       3
//       Ordinal comparison:
//       3
//       -1
//       -1
//       -1
//       3
//       -1

Module Example
   Public Sub Main()
      Dim softHyphen As String = ChrW(&h00AD)
      Dim s1 As String = "ani" + softHyphen + "mal"
      Dim s2 As String = "animal"
      
      Console.WriteLine("Culture-sensitive comparison:")
      ' Use culture-sensitive comparison to find the soft hyphen.
      Console.WriteLine(s1.IndexOf(softHyphen, StringComparison.CurrentCulture))
      Console.WriteLine(s2.IndexOf(softHyphen, StringComparison.CurrentCulture))
      
      ' Use culture-sensitive comparison to find the soft hyphen followed by "n".
      Console.WriteLine(s1.IndexOf(softHyphen + "n", StringComparison.CurrentCulture))
      Console.WriteLine(s2.IndexOf(softHyphen + "n", StringComparison.CurrentCulture))
      
      ' Use culture-sensitive comparison to find the soft hyphen followed by "m".
      Console.WriteLine(s1.IndexOf(softHyphen + "m", StringComparison.CurrentCulture))
      Console.WriteLine(s2.IndexOf(softHyphen + "m", StringComparison.CurrentCulture))
      
      Console.WriteLine("Ordinal comparison:")
      ' Use ordinal comparison to find the soft hyphen.
      Console.WriteLine(s1.IndexOf(softHyphen, StringComparison.Ordinal))
      Console.WriteLine(s2.IndexOf(softHyphen, StringComparison.Ordinal))
      
      ' Use ordinal comparison to find the soft hyphen followed by "n".
      Console.WriteLine(s1.IndexOf(softHyphen + "n", StringComparison.Ordinal))
      Console.WriteLine(s2.IndexOf(softHyphen + "n", StringComparison.Ordinal))
      
      ' Use ordinal comparison to find the soft hyphen followed by "m".
      Console.WriteLine(s1.IndexOf(softHyphen + "m", StringComparison.Ordinal))
      Console.WriteLine(s2.IndexOf(softHyphen + "m", StringComparison.Ordinal))
   End Sub
End Module
' The example displays the following output:
'       Culture-sensitive comparison:
'       0
'       0
'       1
'       1
'       4
'       3
'       Ordinal comparison:
'       3
'       -1
'       -1
'       -1
'       3
'       -1

IndexOf(String, Int32)

Kaynak:

String.Searching.cs

Bu örnekte belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar. Arama belirtilen karakter konumunda başlar.

public:
 int IndexOf(System::String ^ value, int startIndex);

public int IndexOf(string value, int startIndex);

member this.IndexOf : string * int -> int

Public Function IndexOf (value As String, startIndex As Integer) As Integer

Parametreler

value

String

Aranacak dize.

startIndex

Int32

Arama başlangıç konumu.

Döndürülenler

Int32

Dize bulunursa geçerli örneğin başlangıcından sıfır tabanlı dizin konumu value veya bulunamazsa -1. ise valueEmpty, dönüş değeri olur startIndex.

Özel durumlar

ArgumentNullException

value, null'e eşittir.

ArgumentOutOfRangeException

startIndex 0'dan küçük (sıfır) veya bu dizenin uzunluğundan büyük.

Örnekler

Aşağıdaki örnek, bir hedef dize içinde belirtilen dizenin tüm oluşumlarını arar.

using System;

public class IndexOfTest {
    public static void Main() {

        string strSource = "This is the string which we will perform the search on";

        Console.WriteLine("The search string is:{0}\"{1}\"{0}", Environment.NewLine, strSource);

        string strTarget = "";
        int found = 0;
        int totFinds = 0;

        do {
            Console.Write("Please enter a search value to look for in the above string (hit Enter to exit) ==> ");

            strTarget = Console.ReadLine();

            if (strTarget != "") {

                for (int i = 0; i < strSource.Length; i++) {

                    found = strSource.IndexOf(strTarget, i);

                    if (found >= 0) {
                        totFinds++;
                        i = found;
                    }
                    else
                    {
                        break;
                    }
                }
            }
            else
            {
                return;
            }

            Console.WriteLine("{0}The search parameter '{1}' was found {2} times.{0}",
                    Environment.NewLine, strTarget, totFinds);

            totFinds = 0;
        } while ( true );
    }
}

open System

let strSource = "This is the string which we will perform the search on"

printfn $"The search string is:{Environment.NewLine}\"{strSource}\"{Environment.NewLine}"

let mutable broken = false
while not broken do
    let mutable totFinds = 0
    printf "Please enter a search value to look for in the above string (hit Enter to exit) => "

    let strTarget = stdin.ReadLine()

    if strTarget <> "" then
        let mutable i = 0
        let mutable broken = false
        while not broken && i <= strSource.Length - 1 do
            let found = strSource.IndexOf(strTarget, i)

            if found >= 0 then
                totFinds <- totFinds + 1
                i <- found
            else
                broken <- true
            i <- i + 1
    else
        broken <- true

    printfn $"{Environment.NewLine}The search parameter '{strTarget}' was found {totFinds} times.{Environment.NewLine}"

Public Class IndexOfTest
    
    Public Shared Sub Main()
        Dim strSource As String = "This is the string which we will perform the search on"
        
        Console.WriteLine("The search string is:{0}{1}{0}", Environment.NewLine, strSource)
        Dim strTarget As String = ""
        Dim found As Integer = 0
        Dim totFinds As Integer = 0
        
        Do
            Console.Write("Please enter a search value to look for in the above string (hit Enter to exit) ==> ")
            
            strTarget = Console.ReadLine()
            If strTarget <> "" Then
                Dim i As Integer
                
                
                For i = 0 To strSource.Length - 1
                    
                    found = strSource.IndexOf(strTarget, i)
                    If found >= 0 Then
                        
                        totFinds += 1
                        i = found
                    Else
                        Exit For
                    End If
                Next i
            Else
                Return
            
            End If
            Console.WriteLine("{0}The search parameter '{1}' was found {2} times.{0}", Environment.NewLine, strTarget, totFinds)
            
            totFinds = 0
        
        Loop While True
    End Sub
End Class

Açıklamalar

Dizin numaralandırma 0'dan başlar. startIndex parametresi 0 ile dize örneğinin uzunluğu arasında değişebilir. Dize örneğinin uzunluğuna eşitse startIndex , yöntemi -1 döndürür.

Bu yöntem, geçerli kültürü kullanarak bir sözcük (büyük/küçük harfe duyarlı ve kültüre duyarlı) arama gerçekleştirir. Arama bu örneğin karakter konumunda başlar startIndex ve son karakter konumuna kadar devam eder.

Karakter kümeleri, dilsel veya kültüre duyarlı karşılaştırma yapılırken dikkate alınmayan karakterler olan yoksayılabilir karakterler içerir. Kültüre duyarlı bir aramada, yoksayılabilir bir karakter içeriyorsa value sonuç, bu karakter kaldırılmış olarak aramaya eşdeğerdir. Yalnızca bir veya daha fazla yoksayılabilir karakterden oluşuyorsa value , IndexOf(String, Int32) yöntemi her zaman aramanın başladığı karakter konumu olan değerini döndürür startIndex. Aşağıdaki örnekte yöntemi, IndexOf(String, Int32) iki dizede bir yumuşak kısa çizgi (U+00AD) ve ardından "m" konumunu bulmak için kullanılır. Dizelerden yalnızca biri gerekli alt dizeyi içerir. Örnek .NET Framework 4 veya sonraki sürümlerinde çalıştırılıyorsa, her iki durumda da geçici kısa çizgi yoksayılabilir bir karakter olduğundan, yöntem dizede "m" dizinini döndürür. Yumuşak kısa çizgi ve ardından bir "m" içeren ilk dize söz konusu olduğunda, yöntemin yumuşak kısa çizginin dizinini döndüremezse , bunun yerine "m" dizini döndürdüğünü unutmayın.

using System;

public class Example
{
    public static void Main()
    {
        string searchString = "\u00ADm";
        string s1 = "ani\u00ADmal" ;
        string s2 = "animal";

        Console.WriteLine(s1.IndexOf(searchString, 2));
        Console.WriteLine(s2.IndexOf(searchString, 2));

        // The example displays the following output:
        //       4
        //       3
    }
}

let searchString = "\u00ADm"
let s1 = "ani\u00ADmal"
let s2 = "animal"

printfn $"{s1.IndexOf(searchString, 2)}"
printfn $"{s2.IndexOf(searchString, 2)}"

// The example displays the following output:
//       4
//       3

Module Example
   Public Sub Main()
      Dim searchString As String = Chrw(&h00AD) + "m"
      Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
      Dim s2 As String = "animal"

      Console.WriteLine(s1.IndexOf(searchString, 2))
      Console.WriteLine(s2.IndexOf(searchString, 2))
   End Sub
End Module
' The example displays the following output:
'       4
'       3

Arayanlara Notlar

Dizeleri Kullanmak için En İyi Yöntemler bölümünde açıklandığı gibi, varsayılan değerlerin yerini alan dize karşılaştırma yöntemlerini çağırmaktan kaçınmanızı ve bunun yerine parametrelerin açıkça belirtilmesi gereken yöntemleri çağırmanızı öneririz. Geçerli kültürün karşılaştırma kurallarını kullanarak belirli bir karakter konumundan sonra oluşan bir alt dizenin ilk dizinini bulmak için, yöntemi aşırı yüklemesini parametresi için değeriyle CurrentCulture çağırarak IndexOf(String, Int32, StringComparison) amacınıza açıkça işaret verincomparisonType. Dil bilgili karşılaştırmaya ihtiyacınız yoksa kullanmayı Ordinalgöz önünde bulundurun.

Ayrıca bkz.

• Int32
• CultureInfo
• IndexOfAny(Char[])
• LastIndexOf(Char)
• LastIndexOfAny(Char[])

IndexOf(Char, StringComparison)

Kaynak:

String.Searching.cs

Bu dizede belirtilen Unicode karakterinin ilk oluşumunun sıfır tabanlı dizinini raporlar. Parametre, belirtilen karakter için kullanılacak arama türünü belirtir.

public:
 int IndexOf(char value, StringComparison comparisonType);

public int IndexOf(char value, StringComparison comparisonType);

member this.IndexOf : char * StringComparison -> int

Public Function IndexOf (value As Char, comparisonType As StringComparison) As Integer

Parametreler

value

Char

Aranacak karakter.

comparisonType

StringComparison

Aramanın kurallarını belirten bir numaralandırma değeri.

Döndürülenler

Int32

Bu karakter bulunursa sıfır tabanlı dizini value veya bulunamazsa -1.

Özel durumlar

ArgumentException

comparisonType geçerli StringComparison bir değer değil.

Açıklamalar

Dizin numaralandırma sıfırdan başlar.

comparisonType parametresi, bağımsız değişken aramasının value geçerli veya sabit kültürü mü kullandığını, büyük/küçük harfe duyarlı mı yoksa büyük/küçük harfe duyarsız mı olduğunu ya da sözcük veya sıralı karşılaştırma kuralları kullanıp kullanmadığını belirten bir StringComparison numaralandırma üyesidir.

IndexOf(Char, Int32)

Kaynak:

String.Searching.cs

Bu dizede belirtilen Unicode karakterinin ilk oluşumunun sıfır tabanlı dizinini raporlar. Arama belirtilen karakter konumunda başlar.

public:
 int IndexOf(char value, int startIndex);

public int IndexOf(char value, int startIndex);

member this.IndexOf : char * int -> int

Public Function IndexOf (value As Char, startIndex As Integer) As Integer

Parametreler

value

Char

Aranacak Unicode karakteri.

startIndex

Int32

Arama başlangıç konumu.

Döndürülenler

Int32

Sıfır tabanlı dizin konumu value , karakter bulunursa dizenin başlangıcından veya bulunamazsa -1.

Özel durumlar

ArgumentOutOfRangeException

startIndex 0'dan küçük (sıfır) veya dizenin uzunluğundan büyük.

Örnekler

Aşağıdaki örnekte yöntemi gösterilmektedir IndexOf .

string br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+---";
string br2 = "012345678901234567890123456789012345678901234567890123456789012345678";
string str = "Now is the time for all good men to come to the aid of their country.";
int start;
int at;

Console.WriteLine();
Console.WriteLine("All occurrences of 't' from position 0 to {0}.", str.Length-1);
Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str);
Console.Write("The letter 't' occurs at position(s): ");

at = 0;
start = 0;
while((start < str.Length) && (at > -1))
{
    at = str.IndexOf('t', start);
    if (at == -1) break;
    Console.Write("{0} ", at);
    start = at+1;
}
Console.WriteLine();

/*
This example produces the following results:

All occurrences of 't' from position 0 to 68.
0----+----1----+----2----+----3----+----4----+----5----+----6----+---
012345678901234567890123456789012345678901234567890123456789012345678
Now is the time for all good men to come to the aid of their country.

The letter 't' occurs at position(s): 7 11 33 41 44 55 65

*/

let br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+---"
let br2 = "012345678901234567890123456789012345678901234567890123456789012345678"
let str = "Now is the time for all good men to come to the aid of their country."

printfn ""
printfn $"All occurrences of 't' from position 0 to {str.Length - 1}."
printfn $"{br1}{Environment.NewLine}{br2}{Environment.NewLine}{str}{Environment.NewLine}"
printf "The letter 't' occurs at position(s): "

let mutable at = 0
let mutable start = 0
let mutable broken = false
while not broken && (start < str.Length) && (at > -1) do
    at <- str.IndexOf('t', start)
    if at = -1 then broken <- true
    else
        printf $"{at} "
        start <- at + 1
    printfn ""

(*
This example produces the following results:

All occurrences of 't' from position 0 to 68.
0----+----1----+----2----+----3----+----4----+----5----+----6----+---
012345678901234567890123456789012345678901234567890123456789012345678
Now is the time for all good men to come to the aid of their country.

The letter 't' occurs at position(s): 7 11 33 41 44 55 65

*)

' Sample for String.IndexOf(Char, Int32)

Module Sample
    Sub Main()

        Dim br1 As String = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-"
        Dim br2 As String = "0123456789012345678901234567890123456789012345678901234567890123456"
        Dim str As String = "Now is the time for all good men to come to the aid of their party."
        Dim start As Integer
        Dim at As Integer

        Console.WriteLine()
        Console.WriteLine("All occurrences of 't' from position 0 to {0}.", str.Length - 1)
        Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str)
        Console.Write("The letter 't' occurs at position(s): ")

        at = 0
        start = 0
        While start < str.Length AndAlso at > -1
            at = str.IndexOf("t"c, start)
            If at = -1 Then
                Exit While
            End If
            Console.Write("{0} ", at)
            start = at + 1
        End While
        Console.WriteLine()
    End Sub
End Module
'
'This example produces the following results:
'
'All occurrences of 't' from position 0 to 66.
'0----+----1----+----2----+----3----+----4----+----5----+----6----+-
'0123456789012345678901234567890123456789012345678901234567890123456
'Now is the time for all good men to come to the aid of their party.
'
'The letter 't' occurs at position(s): 7 11 33 41 44 55 64
'
'

Açıklamalar

Dizin numaralandırma 0'dan başlar. startIndex parametresi 0 ile dize örneğinin uzunluğu arasında değişebilir. Dize örneğinin uzunluğuna eşitse startIndex , yöntemi -1 döndürür.

Arama, dizenin sonundan sonuna kadar değişir startIndex .

Bu yöntem, yalnızca Unicode skaler değerleri aynı olduğunda bir karakterin başka bir karaktere eşdeğer olarak kabul edildiği sıralı (kültüre duyarsız) bir arama gerçekleştirir. Kültüre duyarlı bir arama gerçekleştirmek için, "Æ" (U+00C6) ligatürü gibi önceden derlenmiş bir karakteri temsil eden Unicode skaler değerinin, kültüre bağlı olarak "AE" (U+0041, U+0045) gibi doğru dizideki karakter bileşenlerinin herhangi bir örneğine eşdeğer olarak kabul edilebileceği yöntemini kullanın CompareInfo.IndexOf .

Ayrıca bkz.

• Int32
• Char
• IndexOfAny(Char[])
• LastIndexOf(Char)
• LastIndexOfAny(Char[])

IndexOf(String)

Kaynak:

String.Searching.cs

Bu örnekte belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar.

public:
 int IndexOf(System::String ^ value);

public int IndexOf(string value);

member this.IndexOf : string -> int

Public Function IndexOf (value As String) As Integer

Parametreler

value

String

Aranacak dize.

Döndürülenler

Int32

Dize bulunursa sıfır tabanlı dizin konumu value veya bulunamazsa -1. ise valueEmpty, dönüş değeri 0'dır.

Özel durumlar

ArgumentNullException

value, null'e eşittir.

Örnekler

Aşağıdaki örnekte "animal" içinde "n" aranmaktadır. Dize dizinleri bir yerine sıfırdan başladığından IndexOf(String) , yöntemi "n" değerinin 1 konumunda olduğunu gösterir.

String str = "animal";
String toFind = "n";
int index = str.IndexOf("n");
Console.WriteLine("Found '{0}' in '{1}' at position {2}",
                toFind, str, index);

// The example displays the following output:
//        Found 'n' in 'animal' at position 1

open System

let str = "animal"
let toFind = "n"
let index = str.IndexOf "n"
printfn $"Found '{toFind}' in '{str}' at position {index}"

// The example displays the following output:
//        Found 'n' in 'animal' at position 1

Public Module Example
   Public Sub Main()
      Dim str As String = "animal"
      Dim toFind As String = "n"
      Dim index As Integer = str.IndexOf("n")
      Console.WriteLine("Found '{0}' in '{1}' at position {2}",
                        toFind, str, index)
   End Sub
End Module
' The example displays the following output:
'       Found 'n' in 'animal' at position 1

Aşağıdaki örnek, bir cümledeki IndexOf bir hayvan adının başlangıç konumunu belirlemek için yöntemini kullanır. Ardından bu konumu kullanarak hayvanı cümleye tanımlayan bir sıfat ekler.

using System;

public class Example {
    public static void Main()
    {
        string animal1 = "fox";
        string animal2 = "dog";

        string strTarget = String.Format("The {0} jumps over the {1}.",
                                         animal1, animal2);

        Console.WriteLine("The original string is:{0}{1}{0}",
                          Environment.NewLine, strTarget);

        Console.Write("Enter an adjective (or group of adjectives) " +
                      "to describe the {0}: ==> ", animal1);
        string adj1 = Console.ReadLine();

        Console.Write("Enter an adjective (or group of adjectives) " +
                      "to describe the {0}: ==> ", animal2);
        string adj2 = Console.ReadLine();

        adj1 = adj1.Trim() + " ";
        adj2 = adj2.Trim() + " ";

        strTarget = strTarget.Insert(strTarget.IndexOf(animal1), adj1);
        strTarget = strTarget.Insert(strTarget.IndexOf(animal2), adj2);

        Console.WriteLine("{0}The final string is:{0}{1}",
                          Environment.NewLine, strTarget);
    }
}
// Output from the example might appear as follows:
//       The original string is:
//       The fox jumps over the dog.
//
//       Enter an adjective (or group of adjectives) to describe the fox: ==> bold
//       Enter an adjective (or group of adjectives) to describe the dog: ==> lazy
//
//       The final string is:
//       The bold fox jumps over the lazy dog.

open System

let animal1 = "fox"
let animal2 = "dog"

let strTarget = String.Format("The {0} jumps over the {1}.", animal1, animal2)

do
    printfn $"The original string is:{Environment.NewLine}{strTarget}{Environment.NewLine}"

    printf $"Enter an adjective (or group of adjectives) to describe the {animal1}: => "
    let adj1 = stdin.ReadLine()

    printf $"Enter an adjective (or group of adjectives) to describe the {animal2}: => "
    let adj2 = stdin.ReadLine()

    let adj1 = adj1.Trim() + " "
    let adj2 = adj2.Trim() + " "

    let strTarget = strTarget.Insert(strTarget.IndexOf animal1, adj1)
    let strTarget = strTarget.Insert(strTarget.IndexOf animal2, adj2)

    printfn $"{Environment.NewLine}The final string is:{strTarget}{Environment.NewLine}"
// Output from the example might appear as follows:
//       The original string is:
//       The fox jumps over the dog.
//
//       Enter an adjective (or group of adjectives) to describe the fox: => bold
//       Enter an adjective (or group of adjectives) to describe the dog: => lazy
//
//       The final string is:
//       The bold fox jumps over the lazy dog.

Public Class Example
    Public Shared Sub Main()
        Dim animal1 As String = "fox"
        Dim animal2 As String = "dog"
        Dim strTarget As String = String.Format("The {0} jumps over the {1}.", 
                                                animal1, animal2)
        
        Console.WriteLine("The original string is: {0}{1}{0}", 
                          Environment.NewLine, strTarget)
        
        Console.Write("Enter an adjective (or group of adjectives) " +
                      "to describe the {0}: ==> ", animal1)
        Dim adj1 As String = Console.ReadLine()
        
        Console.Write("Enter an adjective (or group of adjectives) " + 
                      "to describe the {0}: ==> ", animal2)
        Dim adj2 As String = Console.ReadLine()
        
        adj1 = adj1.Trim() + " "
        adj2 = adj2.Trim() + " "
        
        strTarget = strTarget.Insert(strTarget.IndexOf(animal1), adj1)
        strTarget = strTarget.Insert(strTarget.IndexOf(animal2), adj2)
        
        Console.WriteLine("{0}The final string is:{0}{1}", 
                          Environment.NewLine, strTarget)
    End Sub 
End Class 
' Output from the example might appear as follows:
'       The original string is:
'       The fox jumps over the dog.
'       
'       Enter an adjective (or group of adjectives) to describe the fox: ==> bold
'       Enter an adjective (or group of adjectives) to describe the dog: ==> lazy
'       
'       The final string is:
'       The bold fox jumps over the lazy dog.

Açıklamalar

Dizin numaralandırma sıfırdan başlar.

Bu yöntem, geçerli kültürü kullanarak bir sözcük (büyük/küçük harfe duyarlı ve kültüre duyarlı) arama gerçekleştirir. Arama bu örneğin ilk karakter konumunda başlar ve son karakter konumuna kadar devam eder.

Karakter kümeleri, dilsel veya kültüre duyarlı karşılaştırma yapılırken dikkate alınmayan karakterler olan yoksayılabilir karakterler içerir. Kültüre duyarlı bir aramada, yoksayılabilir bir karakter içeriyorsa value sonuç, bu karakter kaldırılmış olarak aramaya eşdeğerdir. Yalnızca bir veya daha fazla yoksayılabilir karakterden oluşuyorsa value , IndexOf(String) yöntemi her zaman eşleşmenin geçerli örneğin başında bulunduğunu belirtmek için 0 (sıfır) döndürür. Aşağıdaki örnekte yöntemi, IndexOf(String) iki dizede üç alt dize (bir yumuşak kısa çizgi (U+00AD), ardından "n" ve ardından "m" gelen yumuşak kısa çizgi bulmak için kullanılır. Dizelerden yalnızca biri yumuşak kısa çizgi içerir. Örnek .NET Framework 4 veya sonraki sürümlerinde çalıştırılıyorsa, her durumda, yumuşak kısa çizgi yoksayılabilir bir karakter olduğundan, sonuç, geçici kısa çizginin içinde valueyer almamış olmasıyla aynıdır. Yalnızca yumuşak kısa çizgi ararken, yöntem dizenin başında bir eşleşme bulduğunu belirtmek için 0 (sıfır) döndürür.

using System;

public class Example
{
    public static void Main()
    {
        string s1 = "ani\u00ADmal";
        string s2 = "animal";
      
        // Find the index of the soft hyphen.
        Console.WriteLine(s1.IndexOf("\u00AD"));
        Console.WriteLine(s2.IndexOf("\u00AD"));
      
        // Find the index of the soft hyphen followed by "n".
        Console.WriteLine(s1.IndexOf("\u00ADn"));
        Console.WriteLine(s2.IndexOf("\u00ADn"));
      
        // Find the index of the soft hyphen followed by "m".
        Console.WriteLine(s1.IndexOf("\u00ADm"));
        Console.WriteLine(s2.IndexOf("\u00ADm"));

        // The example displays the following output
        // if run under the .NET Framework 4 or later:
        //       0
        //       0
        //       1
        //       1
        //       4
        //       3
    }
}

let s1 = "ani\u00ADmal"
let s2 = "animal"

// Find the index of the soft hyphen.
printfn $"""{s1.IndexOf "\u00AD"}"""
printfn $"""{s2.IndexOf "\u00AD"}"""

// Find the index of the soft hyphen followed by "n".
printfn $"""{s1.IndexOf "\u00ADn"}"""
printfn $"""{s2.IndexOf "\u00ADn"}"""

// Find the index of the soft hyphen followed by "m".
printfn $"""{s1.IndexOf "\u00ADm"}"""
printfn $"""{s2.IndexOf "\u00ADm"}"""

// The example displays the following output
// if run under the .NET Framework 4 or later:
//       0
//       0
//       1
//       1
//       4
//       3

Module Example
   Public Sub Main()
      Dim softHyphen As String = ChrW(&h00AD)
      Dim s1 As String = "ani" + softHyphen + "mal"
      Dim s2 As String = "animal"
      
      ' Find the index of the soft hyphen.
      Console.WriteLine(s1.IndexOf(softHyphen))
      Console.WriteLine(s2.IndexOf(softHyphen))
      
      ' Find the index of the soft hyphen followed by "n".
      Console.WriteLine(s1.IndexOf(softHyphen + "n"))
      Console.WriteLine(s2.IndexOf(softHyphen + "n"))
      
      ' Find the index of the soft hyphen followed by "m".
      Console.WriteLine(s1.IndexOf(softHyphen + "m"))
      Console.WriteLine(s2.IndexOf(softHyphen + "m"))
   End Sub
End Module
' The example displays the following output 
' if run under the .NET Framework 4 or later:
'       0
'       0
'       1
'       1
'       4
'       3

Arayanlara Notlar

Dizeleri Kullanmak için En İyi Yöntemler bölümünde açıklandığı gibi, varsayılan değerlerin yerini alan dize karşılaştırma yöntemlerini çağırmaktan kaçınmanızı ve bunun yerine parametrelerin açıkça belirtilmesi gereken yöntemleri çağırmanızı öneririz. Geçerli kültürün karşılaştırma kurallarını kullanarak bir dize örneğindeki bir alt dizenin ilk dizinini bulmak için, yöntemi aşırı yüklemesini parametresi için değeriyle CurrentCulture çağırarak IndexOf(String, StringComparison) amacınıza açıkça işaret verincomparisonType. Dil bilgili karşılaştırmaya ihtiyacınız yoksa kullanmayı Ordinalgöz önünde bulundurun.

Ayrıca bkz.

• Int32
• CultureInfo
• IndexOfAny(Char[])
• LastIndexOf(Char)
• LastIndexOfAny(Char[])