Array.IndexOf Array.IndexOf Array.IndexOf Array.IndexOf Method

Definition

Sucht das angegebene Objekt und gibt den Index seines ersten Auftretens in einem eindimensionalen Array oder in einem Elementbereich im Array zurück.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array or in a range of elements in the array.

Überlädt

IndexOf(Array, Object) IndexOf(Array, Object) IndexOf(Array, Object)

Sucht nach dem angegebenen Objekt und gibt den Index des ersten Vorkommens in einem eindimensionalen Array zurück.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

IndexOf(Array, Object, Int32) IndexOf(Array, Object, Int32) IndexOf(Array, Object, Int32)

Sucht das angegebene Objekt in einem Elementbereich eines eindimensionalen Arrays und gibt den Index seines ersten Auftretens zurück.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. Der Bereich erstreckt sich von einem angegebenen Index bis zum Ende des Arrays.The range extends from a specified index to the end of the array.

IndexOf(Array, Object, Int32, Int32) IndexOf(Array, Object, Int32, Int32) IndexOf(Array, Object, Int32, Int32)

Sucht das angegebene Objekt in einem Bereich von Elementen eines eindimensionalen Arrays und gibt den Index des ersten Vorkommens zurück.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of ifs first occurrence. Der Bereich erstreckt sich von einem angegebenen Index für eine angegebene Anzahl von Elementen.The range extends from a specified index for a specified number of elements.

IndexOf<T>(T[], T, Int32, Int32) IndexOf<T>(T[], T, Int32, Int32) IndexOf<T>(T[], T, Int32, Int32) IndexOf<T>(T[], T, Int32, Int32)

Sucht das angegebene Objekt in einem Elementbereich eines eindimensionalen Arrays und gibt den Index seines ersten Auftretens zurück.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. Der Bereich erstreckt sich von einem angegebenen Index für eine angegebene Anzahl von Elementen.The range extends from a specified index for a specified number of elements.

IndexOf<T>(T[], T) IndexOf<T>(T[], T) IndexOf<T>(T[], T) IndexOf<T>(T[], T)

Sucht nach dem angegebenen Objekt und gibt den Index des ersten Vorkommens in einem eindimensionalen Array zurück.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

IndexOf<T>(T[], T, Int32) IndexOf<T>(T[], T, Int32) IndexOf<T>(T[], T, Int32) IndexOf<T>(T[], T, Int32)

Sucht das angegebene Objekt in einem Bereich von Elementen eines eindimensionalen Arrays und gibt den Index des ersten Vorkommens zurück.Searches for the specified object in a range of elements of a one dimensional array, and returns the index of its first occurrence. Der Bereich erstreckt sich von einem angegebenen Index bis zum Ende des Arrays.The range extends from a specified index to the end of the array.

IndexOf(Array, Object) IndexOf(Array, Object) IndexOf(Array, Object)

Sucht nach dem angegebenen Objekt und gibt den Index des ersten Vorkommens in einem eindimensionalen Array zurück.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

public:
 static int IndexOf(Array ^ array, System::Object ^ value);
public static int IndexOf (Array array, object value);
static member IndexOf : Array * obj -> int

Parameter

array
Array Array Array Array

Das zu durchsuchende eindimensionale Array.The one-dimensional array to search.

value
Object Object Object Object

Das in array zu suchende Objekt.The object to locate in array.

Gibt zurück

Der Index des ersten Vorkommens von value in array, sofern gefunden, andernfalls die untere Grenze des Arrays minus 1.The index of the first occurrence of value in array, if found; otherwise, the lower bound of the array minus 1.

Ausnahmen

array ist mehrdimensional.array is multidimensional.

Beispiele

Im Beispiel werden die folgenden drei über Ladungen der IndexOf-Methode aufgerufen, um den Index einer Zeichenfolge in einem Zeichen folgen Array zu finden:The example calls the following three overloads of the IndexOf method to find the index of a string in a string array:

  • IndexOf(Array, Object), um das erste Vorkommen der Zeichenfolge "The" in einem Zeichen folgen Array zu bestimmen.IndexOf(Array, Object), to determine the first occurrence of the string "the" in a string array.

  • IndexOf(Array, Object, Int32), um das erste Vorkommen der Zeichenfolge "The" im vierten bis zu den letzten Elementen eines Zeichen folgen Arrays zu bestimmen.IndexOf(Array, Object, Int32), to determine the first occurrence of the string "the" in the fourth to the last elements of a string array.

  • IndexOf(Array, Object, Int32, Int32), um das erste Vorkommen der Zeichenfolge "The" in einem Zeichen folgen Array aus dem-Element zu bestimmen, das der letzten erfolgreichen Entsprechung bis zum Ende des Arrays folgt.IndexOf(Array, Object, Int32, Int32), to determine the first occurrence of the string "the" in a string array from the element that follows the last successful match to the end of the array.

using namespace System;

void main()
{
   // Create a string array with 3 elements having the same value.
   array<String^>^ strings = { "the", "quick", "brown", "fox",
                               "jumps", "over", "the", "lazy", "dog",
                               "in", "the", "barn" };

   // Display the elements of the array.
   Console::WriteLine("The array contains the following values:");
   for (int i = strings->GetLowerBound(0); i <= strings->GetUpperBound(0); i++)
      Console::WriteLine("   [{0,2}]: {1}", i, strings[i]);
      
   // Search for the first occurrence of the duplicated value.
   String^ searchString =  "the";
   int index = Array::IndexOf(strings, searchString);
   Console::WriteLine("The first occurrence of \"{0}\" is at index {1}.",
                      searchString, index);

   // Search for the first occurrence of the duplicated value in the last section of the array.
   index = Array::IndexOf( strings, searchString, 4);
   Console::WriteLine("The first occurrence of \"{0}\" between index 4 and the end is at index {1}.",
                      searchString, index);

   // Search for the first occurrence of the duplicated value in a section of the array.
   int position = index + 1;
   index = Array::IndexOf(strings, searchString, position, strings->GetUpperBound(0) - position + 1);
   Console::WriteLine("The first occurrence of \"{0}\" between index {1} and index {2} is at index {3}.",
                      searchString, position, strings->GetUpperBound(0), index);
}
// The example displays the following output:
//    The array contains the following values:
//       [ 0]: the
//       [ 1]: quick
//       [ 2]: brown
//       [ 3]: fox
//       [ 4]: jumps
//       [ 5]: over
//       [ 6]: the
//       [ 7]: lazy
//       [ 8]: dog
//       [ 9]: in
//       [10]: the
//       [11]: barn
//    The first occurrence of "the" is at index 0.
//    The first occurrence of "the" between index 4 and the end is at index 6.
//    The first occurrence of "the" between index 7 and index 11 is at index 10.
using System;

public class Example
{
    public static void Main()
    {
       // Create a string array with 3 elements having the same value.
       String[] strings = { "the", "quick", "brown", "fox", "jumps",
                            "over", "the", "lazy", "dog", "in", "the",
                            "barn" };

       // Display the elements of the array.
       Console.WriteLine("The array contains the following values:");
       for (int i = strings.GetLowerBound(0); i <= strings.GetUpperBound(0); i++)
          Console.WriteLine("   [{0,2}]: {1}", i, strings[i]);

       // Search for the first occurrence of the duplicated value.
       String searchString = "the";
       int index = Array.IndexOf(strings, searchString);
       Console.WriteLine("The first occurrence of \"{0}\" is at index {1}.",
                         searchString, index);
 
       // Search for the first occurrence of the duplicated value in the last section of the array.
       index = Array.IndexOf(strings, searchString, 4);
       Console.WriteLine("The first occurrence of \"{0}\" between index 4 and the end is at index {1}.",
                         searchString, index);
 
       // Search for the first occurrence of the duplicated value in a section of the array.
       int position = index + 1;
       index = Array.IndexOf(strings, searchString, position, strings.GetUpperBound(0) - position + 1);
       Console.WriteLine("The first occurrence of \"{0}\" between index {1} and index {2} is at index {3}.",
                         searchString, position, strings.GetUpperBound(0), index);
    }
 }
// The example displays the following output:
//    The array contains the following values:
//       [ 0]: the
//       [ 1]: quick
//       [ 2]: brown
//       [ 3]: fox
//       [ 4]: jumps
//       [ 5]: over
//       [ 6]: the
//       [ 7]: lazy
//       [ 8]: dog
//       [ 9]: in
//       [10]: the
//       [11]: barn
//    The first occurrence of "the" is at index 0.
//    The first occurrence of "the" between index 4 and the end is at index 6.
//    The first occurrence of "the" between index 7 and index 11 is at index 10.
Public Module Example
   Public Sub Main()
      ' Create a string array with 3 elements having the same value.
      Dim strings() As String = { "the", "quick", "brown", "fox",
                                  "jumps", "over", "the", "lazy",
                                  "dog", "in", "the", "barn" }

      ' Display the values of the array.
      Console.WriteLine("The array contains the following values:")
      For i As Integer = strings.GetLowerBound(0) To strings.GetUpperBound(0)
         Console.WriteLine("   [{0,2}]: {1}", i, strings(i))
      Next

      ' Search for the first occurrence of the duplicated value.
      Dim searchString As String = "the"
      Dim index As Integer = Array.IndexOf(strings, searchString)
      Console.WriteLine("The first occurrence of ""{0}"" is at index {1}.",
                        searchString, index)
        
      ' Search for the first occurrence of the duplicated value in the last section of the array.
      index = Array.IndexOf(strings, searchString, 4)
      Console.WriteLine("The first occurrence of ""{0}"" between index 4 and the end is at index {1}.",
                        searchString, index)
        
      ' Search for the first occurrence of the duplicated value in a section of the array.
       Dim position As Integer = index + 1
       index = Array.IndexOf(strings, searchString, position, strings.GetUpperBound(0) - position + 1)
       Console.WriteLine("The first occurrence of ""{0}"" between index {1} and index {2} is at index {3}.",
                         searchString, position, strings.GetUpperBound(0), index)
    End Sub
End Module
' The example displays the following output:
'    The array contains the following values:
'       [ 0]: the
'       [ 1]: quick
'       [ 2]: brown
'       [ 3]: fox
'       [ 4]: jumps
'       [ 5]: over
'       [ 6]: the
'       [ 7]: lazy
'       [ 8]: dog
'       [ 9]: in
'       [10]: the
'       [11]: barn
'    The first occurrence of "the" is at index 0.
'    The first occurrence of "the" between index 4 and the end is at index 6.
'    The first occurrence of "the" between index 7 and index 11 is at index 10.

Hinweise

Diese Methode durchsucht alle Elemente eines eindimensionalen Arrays nach value.This method searches all the elements of a one-dimensional array for value. Um zu ermitteln, ob value in array vorhanden ist, führt die-Methode einen Gleichheits Vergleich durch, indem die Equals-Methode jedes Elements aufgerufen wird, bis eine Übereinstimmung gefunden wird.To determine whether value exists in array, the method performs an equality comparison by calling each element's Equals method until it finds a match. Dies bedeutet, dass, wenn das Element die Object.Equals(Object)-Methode überschreibt, diese außer Kraft Setzung aufgerufen wird.This means that if the element overrides the Object.Equals(Object) method, that override is called.

Da die meisten Arrays eine untere Grenze von NULL aufweisen, gibt diese Methode in der Regel-1 zurück, wenn @ no__t-0 nicht gefunden wird.Because most arrays have a lower bound of zero, this method generally returns -1 ifvalue isn't found. In dem seltenen Fall, dass die untere Grenze des Arrays gleich Int32.MinValue (0x80000000) und value nicht gefunden wird, gibt diese Methode Int32.MaxValue (0x7FFFFFFF) zurück.In the rare case that the lower bound of the array is equal to Int32.MinValue(0x80000000) and value isn't found, this method returns Int32.MaxValue (0x7FFFFFFF).

Bei dieser Methode handelt es sich um einen O (n)-Vorgang, bei dem n der Length von array ist.This method is an O(n) operation, where n is the Length of array.

Siehe auch

IndexOf(Array, Object, Int32) IndexOf(Array, Object, Int32) IndexOf(Array, Object, Int32)

Sucht das angegebene Objekt in einem Elementbereich eines eindimensionalen Arrays und gibt den Index seines ersten Auftretens zurück.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. Der Bereich erstreckt sich von einem angegebenen Index bis zum Ende des Arrays.The range extends from a specified index to the end of the array.

public:
 static int IndexOf(Array ^ array, System::Object ^ value, int startIndex);
public static int IndexOf (Array array, object value, int startIndex);
static member IndexOf : Array * obj * int -> int

Parameter

array
Array Array Array Array

Das zu durchsuchende eindimensionale Array.The one-dimensional array to search.

value
Object Object Object Object

Das in array zu suchende Objekt.The object to locate in array.

startIndex
Int32 Int32 Int32 Int32

Der Startindex für die Suche.The starting index of the search. 0 (null) ist in einem leeren Array gültig.0 (zero) is valid in an empty array.

Gibt zurück

Der Index des ersten Vorkommens von value, sofern gefunden, innerhalb des Bereichs von Elementen in array, der sich von startIndex bis zum letzten Element erstreckt; andernfalls die untere Grenze des Arrays minus 1.The index of the first occurrence of value, if it's found, within the range of elements in array that extends from startIndex to the last element; otherwise, the lower bound of the array minus 1.

Ausnahmen

startIndex liegt außerhalb des Bereichs der gültigen Indizes für array.startIndex is outside the range of valid indexes for array.

array ist mehrdimensional.array is multidimensional.

Beispiele

Im Beispiel werden die folgenden drei über Ladungen der IndexOf-Methode aufgerufen, um den Index einer Zeichenfolge in einem Zeichen folgen Array zu finden:The example calls the following three overloads of the IndexOf method to find the index of a string in a string array:

  • IndexOf(Array, Object), um das erste Vorkommen der Zeichenfolge "The" in einem Zeichen folgen Array zu bestimmen.IndexOf(Array, Object), to determine the first occurrence of the string "the" in a string array.

  • IndexOf(Array, Object, Int32), um das erste Vorkommen der Zeichenfolge "The" im vierten bis zu den letzten Elementen eines Zeichen folgen Arrays zu bestimmen.IndexOf(Array, Object, Int32), to determine the first occurrence of the string "the" in the fourth to the last elements of a string array.

  • IndexOf(Array, Object, Int32, Int32), um das erste Vorkommen der Zeichenfolge "The" in einem Zeichen folgen Array aus dem-Element zu bestimmen, das der letzten erfolgreichen Entsprechung bis zum Ende des Arrays folgt.IndexOf(Array, Object, Int32, Int32), to determine the first occurrence of the string "the" in a string array from the element that follows the last successful match to the end of the array.

using namespace System;

void main()
{
   // Create a string array with 3 elements having the same value.
   array<String^>^ strings = { "the", "quick", "brown", "fox",
                               "jumps", "over", "the", "lazy", "dog",
                               "in", "the", "barn" };

   // Display the elements of the array.
   Console::WriteLine("The array contains the following values:");
   for (int i = strings->GetLowerBound(0); i <= strings->GetUpperBound(0); i++)
      Console::WriteLine("   [{0,2}]: {1}", i, strings[i]);
      
   // Search for the first occurrence of the duplicated value.
   String^ searchString =  "the";
   int index = Array::IndexOf(strings, searchString);
   Console::WriteLine("The first occurrence of \"{0}\" is at index {1}.",
                      searchString, index);

   // Search for the first occurrence of the duplicated value in the last section of the array.
   index = Array::IndexOf( strings, searchString, 4);
   Console::WriteLine("The first occurrence of \"{0}\" between index 4 and the end is at index {1}.",
                      searchString, index);

   // Search for the first occurrence of the duplicated value in a section of the array.
   int position = index + 1;
   index = Array::IndexOf(strings, searchString, position, strings->GetUpperBound(0) - position + 1);
   Console::WriteLine("The first occurrence of \"{0}\" between index {1} and index {2} is at index {3}.",
                      searchString, position, strings->GetUpperBound(0), index);
}
// The example displays the following output:
//    The array contains the following values:
//       [ 0]: the
//       [ 1]: quick
//       [ 2]: brown
//       [ 3]: fox
//       [ 4]: jumps
//       [ 5]: over
//       [ 6]: the
//       [ 7]: lazy
//       [ 8]: dog
//       [ 9]: in
//       [10]: the
//       [11]: barn
//    The first occurrence of "the" is at index 0.
//    The first occurrence of "the" between index 4 and the end is at index 6.
//    The first occurrence of "the" between index 7 and index 11 is at index 10.
using System;

public class Example
{
    public static void Main()
    {
       // Create a string array with 3 elements having the same value.
       String[] strings = { "the", "quick", "brown", "fox", "jumps",
                            "over", "the", "lazy", "dog", "in", "the",
                            "barn" };

       // Display the elements of the array.
       Console.WriteLine("The array contains the following values:");
       for (int i = strings.GetLowerBound(0); i <= strings.GetUpperBound(0); i++)
          Console.WriteLine("   [{0,2}]: {1}", i, strings[i]);

       // Search for the first occurrence of the duplicated value.
       String searchString = "the";
       int index = Array.IndexOf(strings, searchString);
       Console.WriteLine("The first occurrence of \"{0}\" is at index {1}.",
                         searchString, index);
 
       // Search for the first occurrence of the duplicated value in the last section of the array.
       index = Array.IndexOf(strings, searchString, 4);
       Console.WriteLine("The first occurrence of \"{0}\" between index 4 and the end is at index {1}.",
                         searchString, index);
 
       // Search for the first occurrence of the duplicated value in a section of the array.
       int position = index + 1;
       index = Array.IndexOf(strings, searchString, position, strings.GetUpperBound(0) - position + 1);
       Console.WriteLine("The first occurrence of \"{0}\" between index {1} and index {2} is at index {3}.",
                         searchString, position, strings.GetUpperBound(0), index);
    }
 }
// The example displays the following output:
//    The array contains the following values:
//       [ 0]: the
//       [ 1]: quick
//       [ 2]: brown
//       [ 3]: fox
//       [ 4]: jumps
//       [ 5]: over
//       [ 6]: the
//       [ 7]: lazy
//       [ 8]: dog
//       [ 9]: in
//       [10]: the
//       [11]: barn
//    The first occurrence of "the" is at index 0.
//    The first occurrence of "the" between index 4 and the end is at index 6.
//    The first occurrence of "the" between index 7 and index 11 is at index 10.
Public Module Example
   Public Sub Main()
      ' Create a string array with 3 elements having the same value.
      Dim strings() As String = { "the", "quick", "brown", "fox",
                                  "jumps", "over", "the", "lazy",
                                  "dog", "in", "the", "barn" }

      ' Display the values of the array.
      Console.WriteLine("The array contains the following values:")
      For i As Integer = strings.GetLowerBound(0) To strings.GetUpperBound(0)
         Console.WriteLine("   [{0,2}]: {1}", i, strings(i))
      Next

      ' Search for the first occurrence of the duplicated value.
      Dim searchString As String = "the"
      Dim index As Integer = Array.IndexOf(strings, searchString)
      Console.WriteLine("The first occurrence of ""{0}"" is at index {1}.",
                        searchString, index)
        
      ' Search for the first occurrence of the duplicated value in the last section of the array.
      index = Array.IndexOf(strings, searchString, 4)
      Console.WriteLine("The first occurrence of ""{0}"" between index 4 and the end is at index {1}.",
                        searchString, index)
        
      ' Search for the first occurrence of the duplicated value in a section of the array.
       Dim position As Integer = index + 1
       index = Array.IndexOf(strings, searchString, position, strings.GetUpperBound(0) - position + 1)
       Console.WriteLine("The first occurrence of ""{0}"" between index {1} and index {2} is at index {3}.",
                         searchString, position, strings.GetUpperBound(0), index)
    End Sub
End Module
' The example displays the following output:
'    The array contains the following values:
'       [ 0]: the
'       [ 1]: quick
'       [ 2]: brown
'       [ 3]: fox
'       [ 4]: jumps
'       [ 5]: over
'       [ 6]: the
'       [ 7]: lazy
'       [ 8]: dog
'       [ 9]: in
'       [10]: the
'       [11]: barn
'    The first occurrence of "the" is at index 0.
'    The first occurrence of "the" between index 4 and the end is at index 6.
'    The first occurrence of "the" between index 7 and index 11 is at index 10.

Hinweise

Diese Methode durchsucht ein eindimensionales Array vom-Element bei Index startIndex bis zum letzten Element.This method searches a one-dimensional array from the element at index startIndex to the last element. Um zu ermitteln, ob value in array vorhanden ist, führt die-Methode einen Gleichheits Vergleich durch, indem die Equals-Methode jedes Elements aufgerufen wird, bis eine Übereinstimmung gefunden wird.To determine whether value exists in array, the method performs an equality comparison by calling the Equals method of every element until it finds a match. Dies bedeutet, dass, wenn das Element die Object.Equals(Object)-Methode überschreibt, diese außer Kraft Setzung aufgerufen wird.This means that if the element overrides the Object.Equals(Object) method, that override is called.

Da die meisten Arrays eine untere Grenze von NULL aufweisen, gibt diese Methode in der Regel-1 zurück, wenn value nicht gefunden wird.Because most arrays have a lower bound of zero, this method generally returns -1 if value isn't found. In dem seltenen Fall, dass die untere Grenze des Arrays gleich Int32.MinValue (0x80000000) und value nicht gefunden wird, gibt diese Methode Int32.MaxValue (0x7FFFFFFF) zurück.In the rare case that the lower bound of the array is equal to Int32.MinValue(0x80000000) and value isn't found, this method returns Int32.MaxValue (0x7FFFFFFF).

Wenn startIndex Array.Length ist, gibt die Methode-1 zurück.If startIndex equals Array.Length,the method returns -1. Wenn startIndex größer als Array.Length ist, löst die Methode eine ArgumentOutOfRangeException aus.If startIndex is greater than Array.Length, the method throws an ArgumentOutOfRangeException.

Bei dieser Methode handelt es sich um eine O (n)-Operation, bei der n die Anzahl der Elemente von startIndex bis zum Ende array ist.This method is an O(n) operation, where n is the number of elements from startIndex to the end of array.

Siehe auch

IndexOf(Array, Object, Int32, Int32) IndexOf(Array, Object, Int32, Int32) IndexOf(Array, Object, Int32, Int32)

Sucht das angegebene Objekt in einem Bereich von Elementen eines eindimensionalen Arrays und gibt den Index des ersten Vorkommens zurück.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of ifs first occurrence. Der Bereich erstreckt sich von einem angegebenen Index für eine angegebene Anzahl von Elementen.The range extends from a specified index for a specified number of elements.

public:
 static int IndexOf(Array ^ array, System::Object ^ value, int startIndex, int count);
public static int IndexOf (Array array, object value, int startIndex, int count);
static member IndexOf : Array * obj * int * int -> int

Parameter

array
Array Array Array Array

Das zu durchsuchende eindimensionale Array.The one-dimensional array to search.

value
Object Object Object Object

Das in array zu suchende Objekt.The object to locate in array.

startIndex
Int32 Int32 Int32 Int32

Der Startindex für die Suche.The starting index of the search. 0 (null) ist in einem leeren Array gültig.0 (zero) is valid in an empty array.

count
Int32 Int32 Int32 Int32

Die Anzahl der zu suchenden Elemente.The number of elements to search.

Gibt zurück

Der Index des ersten Vorkommens von value, sofern gefunden im array vom startIndex-Index bis startIndex + count – 1; andernfalls die untere Grenze des Arrays minus 1.The index of the first occurrence of value, if it's found in the array from index startIndex to startIndex + count - 1; otherwise, the lower bound of the array minus 1.

Ausnahmen

startIndex liegt außerhalb des Bereichs der gültigen Indizes für array.startIndex is outside the range of valid indexes for array.

- oder --or- count ist kleiner als Null.count is less than zero.

- oder --or- startIndex und count geben keinen gültigen Abschnitt in array an.startIndex and count do not specify a valid section in array.

array ist mehrdimensional.array is multidimensional.

Beispiele

Im Beispiel werden die folgenden drei über Ladungen der IndexOf-Methode aufgerufen, um den Index einer Zeichenfolge in einem Zeichen folgen Array zu finden:The example calls the following three overloads of the IndexOf method to find the index of a string in a string array:

  • IndexOf(Array, Object), um das erste Vorkommen der Zeichenfolge "The" in einem Zeichen folgen Array zu bestimmen.IndexOf(Array, Object), to determine the first occurrence of the string "the" in a string array.

  • IndexOf(Array, Object, Int32), um das erste Vorkommen der Zeichenfolge "The" im vierten bis zu den letzten Elementen eines Zeichen folgen Arrays zu bestimmen.IndexOf(Array, Object, Int32), to determine the first occurrence of the string "the" in the fourth to the last elements of a string array.

  • IndexOf(Array, Object, Int32, Int32), um das erste Vorkommen der Zeichenfolge "The" in einem Zeichen folgen Array aus dem-Element zu bestimmen, das der letzten erfolgreichen Entsprechung bis zum Ende des Arrays folgt.IndexOf(Array, Object, Int32, Int32), to determine the first occurrence of the string "the" in a string array from the element that follows the last successful match to the end of the array. Um den Wert des count-Arguments zu ermitteln, subtrahiert er die obere Grenze des Arrays vom Start Index und fügt einen hinzu.To determine the value of the count argument, it subtracts the upper bound of the array from the starting index and adds one.

using namespace System;

void main()
{
   // Create a string array with 3 elements having the same value.
   array<String^>^ strings = { "the", "quick", "brown", "fox",
                               "jumps", "over", "the", "lazy", "dog",
                               "in", "the", "barn" };

   // Display the elements of the array.
   Console::WriteLine("The array contains the following values:");
   for (int i = strings->GetLowerBound(0); i <= strings->GetUpperBound(0); i++)
      Console::WriteLine("   [{0,2}]: {1}", i, strings[i]);
      
   // Search for the first occurrence of the duplicated value.
   String^ searchString =  "the";
   int index = Array::IndexOf(strings, searchString);
   Console::WriteLine("The first occurrence of \"{0}\" is at index {1}.",
                      searchString, index);

   // Search for the first occurrence of the duplicated value in the last section of the array.
   index = Array::IndexOf( strings, searchString, 4);
   Console::WriteLine("The first occurrence of \"{0}\" between index 4 and the end is at index {1}.",
                      searchString, index);

   // Search for the first occurrence of the duplicated value in a section of the array.
   int position = index + 1;
   index = Array::IndexOf(strings, searchString, position, strings->GetUpperBound(0) - position + 1);
   Console::WriteLine("The first occurrence of \"{0}\" between index {1} and index {2} is at index {3}.",
                      searchString, position, strings->GetUpperBound(0), index);
}
// The example displays the following output:
//    The array contains the following values:
//       [ 0]: the
//       [ 1]: quick
//       [ 2]: brown
//       [ 3]: fox
//       [ 4]: jumps
//       [ 5]: over
//       [ 6]: the
//       [ 7]: lazy
//       [ 8]: dog
//       [ 9]: in
//       [10]: the
//       [11]: barn
//    The first occurrence of "the" is at index 0.
//    The first occurrence of "the" between index 4 and the end is at index 6.
//    The first occurrence of "the" between index 7 and index 11 is at index 10.
using System;

public class Example
{
    public static void Main()
    {
       // Create a string array with 3 elements having the same value.
       String[] strings = { "the", "quick", "brown", "fox", "jumps",
                            "over", "the", "lazy", "dog", "in", "the",
                            "barn" };

       // Display the elements of the array.
       Console.WriteLine("The array contains the following values:");
       for (int i = strings.GetLowerBound(0); i <= strings.GetUpperBound(0); i++)
          Console.WriteLine("   [{0,2}]: {1}", i, strings[i]);

       // Search for the first occurrence of the duplicated value.
       String searchString = "the";
       int index = Array.IndexOf(strings, searchString);
       Console.WriteLine("The first occurrence of \"{0}\" is at index {1}.",
                         searchString, index);
 
       // Search for the first occurrence of the duplicated value in the last section of the array.
       index = Array.IndexOf(strings, searchString, 4);
       Console.WriteLine("The first occurrence of \"{0}\" between index 4 and the end is at index {1}.",
                         searchString, index);
 
       // Search for the first occurrence of the duplicated value in a section of the array.
       int position = index + 1;
       index = Array.IndexOf(strings, searchString, position, strings.GetUpperBound(0) - position + 1);
       Console.WriteLine("The first occurrence of \"{0}\" between index {1} and index {2} is at index {3}.",
                         searchString, position, strings.GetUpperBound(0), index);
    }
 }
// The example displays the following output:
//    The array contains the following values:
//       [ 0]: the
//       [ 1]: quick
//       [ 2]: brown
//       [ 3]: fox
//       [ 4]: jumps
//       [ 5]: over
//       [ 6]: the
//       [ 7]: lazy
//       [ 8]: dog
//       [ 9]: in
//       [10]: the
//       [11]: barn
//    The first occurrence of "the" is at index 0.
//    The first occurrence of "the" between index 4 and the end is at index 6.
//    The first occurrence of "the" between index 7 and index 11 is at index 10.
Public Module Example
   Public Sub Main()
      ' Create a string array with 3 elements having the same value.
      Dim strings() As String = { "the", "quick", "brown", "fox",
                                  "jumps", "over", "the", "lazy",
                                  "dog", "in", "the", "barn" }

      ' Display the values of the array.
      Console.WriteLine("The array contains the following values:")
      For i As Integer = strings.GetLowerBound(0) To strings.GetUpperBound(0)
         Console.WriteLine("   [{0,2}]: {1}", i, strings(i))
      Next

      ' Search for the first occurrence of the duplicated value.
      Dim searchString As String = "the"
      Dim index As Integer = Array.IndexOf(strings, searchString)
      Console.WriteLine("The first occurrence of ""{0}"" is at index {1}.",
                        searchString, index)
        
      ' Search for the first occurrence of the duplicated value in the last section of the array.
      index = Array.IndexOf(strings, searchString, 4)
      Console.WriteLine("The first occurrence of ""{0}"" between index 4 and the end is at index {1}.",
                        searchString, index)
        
      ' Search for the first occurrence of the duplicated value in a section of the array.
       Dim position As Integer = index + 1
       index = Array.IndexOf(strings, searchString, position, strings.GetUpperBound(0) - position + 1)
       Console.WriteLine("The first occurrence of ""{0}"" between index {1} and index {2} is at index {3}.",
                         searchString, position, strings.GetUpperBound(0), index)
    End Sub
End Module
' The example displays the following output:
'    The array contains the following values:
'       [ 0]: the
'       [ 1]: quick
'       [ 2]: brown
'       [ 3]: fox
'       [ 4]: jumps
'       [ 5]: over
'       [ 6]: the
'       [ 7]: lazy
'       [ 8]: dog
'       [ 9]: in
'       [10]: the
'       [11]: barn
'    The first occurrence of "the" is at index 0.
'    The first occurrence of "the" between index 4 and the end is at index 6.
'    The first occurrence of "the" between index 7 and index 11 is at index 10.

Hinweise

Diese Methode durchsucht die Elemente eines eindimensionalen Arrays von startIndex bis startIndex plus count minus 1, wenn count größer als 0 (null) ist.This method searches the elements of a one-dimensional array from startIndex to startIndex plus count minus 1, if count is greater than 0. Um zu ermitteln, ob value in array vorhanden ist, führt die-Methode einen Gleichheits Vergleich durch, indem die Equals-Methode jedes Elements aufgerufen wird, bis eine Übereinstimmung gefunden wird.To determine whether value exists in array, the method performs an equality comparison by calling the Equals method of every element until it finds a match. Dies bedeutet, dass, wenn das Element die Object.Equals-Methode überschreibt, diese außer Kraft Setzung aufgerufen wird.This means that if the element overrides the Object.Equals method, that override is called.

Da die meisten Arrays eine untere Grenze von NULL aufweisen, gibt diese Methode in der Regel-1 zurück, wenn value nicht gefunden wird.Because most arrays have a lower bound of zero, this method generally returns -1 when value isn't found. In dem seltenen Fall, dass die untere Grenze des Arrays gleich Int32.MinValue (0x80000000) und value nicht gefunden wird, gibt diese Methode Int32.MaxValue (0x7FFFFFFF) zurück.In the rare case that the lower bound of the array is equal to Int32.MinValue (0x80000000) and value isn't found, this method returns Int32.MaxValue (0x7FFFFFFF).

Wenn startindex Array.Length ist, gibt die Methode-1 zurück.If startindex equals Array.Length, the method returns -1. Wenn startIndex größer als Array.Length ist, löst die Methode eine ArgumentOutOfRangeException aus.If startIndex is greater than Array.Length, the method throws an ArgumentOutOfRangeException.

Bei dieser Methode handelt es sich um einen O (n)-Vorgang, bei dem n count ist.This method is an O(n) operation, where n is count.

Siehe auch

IndexOf<T>(T[], T, Int32, Int32) IndexOf<T>(T[], T, Int32, Int32) IndexOf<T>(T[], T, Int32, Int32) IndexOf<T>(T[], T, Int32, Int32)

Sucht das angegebene Objekt in einem Elementbereich eines eindimensionalen Arrays und gibt den Index seines ersten Auftretens zurück.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. Der Bereich erstreckt sich von einem angegebenen Index für eine angegebene Anzahl von Elementen.The range extends from a specified index for a specified number of elements.

public:
generic <typename T>
 static int IndexOf(cli::array <T> ^ array, T value, int startIndex, int count);
public static int IndexOf<T> (T[] array, T value, int startIndex, int count);
static member IndexOf : 'T[] * 'T * int * int -> int
Public Shared Function IndexOf(Of T) (array As T(), value As T, startIndex As Integer, count As Integer) As Integer

Typparameter

T

Der Typ der Elemente des Arrays.The type of the elements of the array.

Parameter

array
T[]

Das zu durchsuchende eindimensionale und nullbasierte Array.The one-dimensional, zero-based array to search.

value
T T T T

Das in array zu suchende Objekt.The object to locate in array.

startIndex
Int32 Int32 Int32 Int32

Der nullbasierte Startindex für die Suche.The zero-based starting index of the search. 0 (null) ist in einem leeren Array gültig.0 (zero) is valid in an empty array.

count
Int32 Int32 Int32 Int32

Die Anzahl der Elemente im zu durchsuchenden Abschnitt.The number of elements in the section to search.

Gibt zurück

Der nullbasierte Index des ersten Vorkommens von value innerhalb des Bereichs von Elementen im array, das beim startIndex beginnt und die in count angegebene Anzahl von Elementen enthält, sofern gefunden; andernfalls –1.The zero-based index of the first occurrence of value within the range of elements in array that starts at startIndex and contains the number of elements specified in count, if found; otherwise, -1.

Ausnahmen

startIndex liegt außerhalb des Bereichs der gültigen Indizes für array.startIndex is outside the range of valid indexes for array.

- oder --or- count ist kleiner als Null.count is less than zero.

- oder --or- startIndex und count geben keinen gültigen Abschnitt im array an.startIndex and count do not specify a valid section in array.

Beispiele

Im folgenden Beispiel werden alle drei generischen über Ladungen der IndexOf-Methode veranschaulicht.The following example demonstrates all three generic overloads of the IndexOf method. Ein Array von Zeichen folgen wird erstellt, wobei ein Eintrag zweimal an Indexposition 0 und Index Speicherort 5 angezeigt wird.An array of strings is created, with one entry that appears twice, at index location 0 and index location 5. Die IndexOf<T>(T[], T)-Methoden Überladung durchsucht das Array von Anfang an und findet das erste Vorkommen der Zeichenfolge.The IndexOf<T>(T[], T) method overload searches the array from the beginning, and finds the first occurrence of the string. Die IndexOf<T>(T[], T, Int32)-Methoden Überladung wird verwendet, um das Array zu durchsuchen, beginnend mit Indexposition 3 und bis zum Ende des Arrays, und findet das zweite Vorkommen der Zeichenfolge.The IndexOf<T>(T[], T, Int32) method overload is used to search the array beginning with index location 3 and continuing to the end of the array, and finds the second occurrence of the string. Schließlich wird die IndexOf<T>(T[], T, Int32, Int32)-Methoden Überladung verwendet, um einen Bereich von zwei Einträgen zu durchsuchen, beginnend bei Indexposition 2. Sie gibt-1 zurück, da in diesem Bereich keine Instanzen der Such Zeichenfolge vorhanden sind.Finally, the IndexOf<T>(T[], T, Int32, Int32) method overload is used to search a range of two entries, beginning at index location two; it returns -1 because there are no instances of the search string in that range.

using namespace System;

void main()
{
    array<String^>^ dinosaurs = { "Tyrannosaurus", 
        "Amargasaurus",
        "Mamenchisaurus",
        "Brachiosaurus",
        "Deinonychus",
        "Tyrannosaurus",
        "Compsognathus" };

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs )
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\"): {0}", 
        Array::IndexOf(dinosaurs, "Tyrannosaurus"));

    Console::WriteLine("\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 3): {0}", 
        Array::IndexOf(dinosaurs, "Tyrannosaurus", 3));

    Console::WriteLine("\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 2, 2): {0}", 
        Array::IndexOf(dinosaurs, "Tyrannosaurus", 2, 2));
}

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Deinonychus
Tyrannosaurus
Compsognathus

Array.IndexOf(dinosaurs, "Tyrannosaurus"): 0

Array.IndexOf(dinosaurs, "Tyrannosaurus", 3): 5

Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2): -1
 */
using System;

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = { "Tyrannosaurus",
            "Amargasaurus",
            "Mamenchisaurus",
            "Brachiosaurus",
            "Deinonychus",
            "Tyrannosaurus",
            "Compsognathus" };

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine(
            "\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\"): {0}", 
            Array.IndexOf(dinosaurs, "Tyrannosaurus"));

        Console.WriteLine(
            "\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 3): {0}", 
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 3));

        Console.WriteLine(
            "\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 2, 2): {0}", 
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2));
    }
}

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Deinonychus
Tyrannosaurus
Compsognathus

Array.IndexOf(dinosaurs, "Tyrannosaurus"): 0

Array.IndexOf(dinosaurs, "Tyrannosaurus", 3): 5

Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2): -1
 */
Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { "Tyrannosaurus", _
            "Amargasaurus", _
            "Mamenchisaurus", _
            "Brachiosaurus", _
            "Deinonychus", _
            "Tyrannosaurus", _
            "Compsognathus" }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "Array.IndexOf(dinosaurs, ""Tyrannosaurus""): {0}", _
            Array.IndexOf(dinosaurs, "Tyrannosaurus"))

        Console.WriteLine(vbLf & _
            "Array.IndexOf(dinosaurs, ""Tyrannosaurus"", 3): {0}", _
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 3))

        Console.WriteLine(vbLf & _
            "Array.IndexOf(dinosaurs, ""Tyrannosaurus"", 2, 2): {0}", _
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2))

    End Sub
End Class

' This code example produces the following output:
'
'Tyrannosaurus
'Amargasaurus
'Mamenchisaurus
'Brachiosaurus
'Deinonychus
'Tyrannosaurus
'Compsognathus
'
'Array.IndexOf(dinosaurs, "Tyrannosaurus"): 0
'
'Array.IndexOf(dinosaurs, "Tyrannosaurus", 3): 5
'
'Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2): -1

Hinweise

Diese Methode durchsucht die Elemente eines eindimensionalen Arrays von startIndex bis startIndex plus count minus 1, wenn count größer als 0 (null) ist.This method searches the elements of a one-dimensional array from startIndex to startIndex plus count minus 1, if count is greater than 0. Um zu ermitteln, ob value in array vorhanden ist, führt die-Methode einen Gleichheits Vergleich durch, indem die T.Equals-Methode für jedes Element aufgerufen wird.To determine whether value exists in array, the method performs an equality comparison by calling the T.Equals method on every element. Dies bedeutet Folgendes: Wenn T die Equals-Methode überschreibt, wird diese außer Kraft Setzung aufgerufen.This means that if T overrides the Equals method, that override is called.

Wenn startIndex Array.Length ist, gibt die Methode-1 zurück.If startIndex equals Array.Length, the method returns -1. Wenn startIndex größer als Array.Length ist, löst die Methode eine ArgumentOutOfRangeException aus.If startIndex is greater than Array.Length, the method throws an ArgumentOutOfRangeException.

Bei dieser Methode handelt es sich um einen O (n)-Vorgang, bei dem n count ist.This method is an O(n) operation, where n is count.

Siehe auch

IndexOf<T>(T[], T) IndexOf<T>(T[], T) IndexOf<T>(T[], T) IndexOf<T>(T[], T)

Sucht nach dem angegebenen Objekt und gibt den Index des ersten Vorkommens in einem eindimensionalen Array zurück.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

public:
generic <typename T>
 static int IndexOf(cli::array <T> ^ array, T value);
public static int IndexOf<T> (T[] array, T value);
static member IndexOf : 'T[] * 'T -> int
Public Shared Function IndexOf(Of T) (array As T(), value As T) As Integer

Typparameter

T

Der Typ der Elemente des Arrays.The type of the elements of the array.

Parameter

array
T[]

Das zu durchsuchende eindimensionale und nullbasierte Array.The one-dimensional, zero-based array to search.

value
T T T T

Das in array zu suchende Objekt.The object to locate in array.

Gibt zurück

Der nullbasierte Index des ersten Vorkommens von value im gesamten array, sofern gefunden, andernfalls –1.The zero-based index of the first occurrence of value in the entire array, if found; otherwise, -1.

Ausnahmen

Beispiele

Im folgenden Beispiel werden alle drei generischen über Ladungen der IndexOf-Methode veranschaulicht.The following example demonstrates all three generic overloads of the IndexOf method. Ein Array von Zeichen folgen wird erstellt, wobei ein Eintrag zweimal an Indexposition 0 und Index Speicherort 5 angezeigt wird.An array of strings is created, with one entry that appears twice, at index location 0 and index location 5. Die IndexOf<T>(T[], T)-Methoden Überladung durchsucht das Array von Anfang an und findet das erste Vorkommen der Zeichenfolge.The IndexOf<T>(T[], T) method overload searches the array from the beginning, and finds the first occurrence of the string. Die IndexOf<T>(T[], T, Int32)-Methoden Überladung wird verwendet, um das Array zu durchsuchen, beginnend mit Indexposition 3 und bis zum Ende des Arrays, und findet das zweite Vorkommen der Zeichenfolge.The IndexOf<T>(T[], T, Int32) method overload is used to search the array beginning with index location 3 and continuing to the end of the array, and finds the second occurrence of the string. Schließlich wird die IndexOf<T>(T[], T, Int32, Int32)-Methoden Überladung verwendet, um einen Bereich von zwei Einträgen zu durchsuchen, beginnend bei Indexposition 2. Sie gibt-1 zurück, da in diesem Bereich keine Instanzen der Such Zeichenfolge vorhanden sind.Finally, the IndexOf<T>(T[], T, Int32, Int32) method overload is used to search a range of two entries, beginning at index location two; it returns -1 because there are no instances of the search string in that range.

using namespace System;

void main()
{
    array<String^>^ dinosaurs = { "Tyrannosaurus", 
        "Amargasaurus",
        "Mamenchisaurus",
        "Brachiosaurus",
        "Deinonychus",
        "Tyrannosaurus",
        "Compsognathus" };

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs )
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\"): {0}", 
        Array::IndexOf(dinosaurs, "Tyrannosaurus"));

    Console::WriteLine("\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 3): {0}", 
        Array::IndexOf(dinosaurs, "Tyrannosaurus", 3));

    Console::WriteLine("\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 2, 2): {0}", 
        Array::IndexOf(dinosaurs, "Tyrannosaurus", 2, 2));
}

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Deinonychus
Tyrannosaurus
Compsognathus

Array.IndexOf(dinosaurs, "Tyrannosaurus"): 0

Array.IndexOf(dinosaurs, "Tyrannosaurus", 3): 5

Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2): -1
 */
using System;

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = { "Tyrannosaurus",
            "Amargasaurus",
            "Mamenchisaurus",
            "Brachiosaurus",
            "Deinonychus",
            "Tyrannosaurus",
            "Compsognathus" };

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine(
            "\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\"): {0}", 
            Array.IndexOf(dinosaurs, "Tyrannosaurus"));

        Console.WriteLine(
            "\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 3): {0}", 
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 3));

        Console.WriteLine(
            "\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 2, 2): {0}", 
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2));
    }
}

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Deinonychus
Tyrannosaurus
Compsognathus

Array.IndexOf(dinosaurs, "Tyrannosaurus"): 0

Array.IndexOf(dinosaurs, "Tyrannosaurus", 3): 5

Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2): -1
 */
Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { "Tyrannosaurus", _
            "Amargasaurus", _
            "Mamenchisaurus", _
            "Brachiosaurus", _
            "Deinonychus", _
            "Tyrannosaurus", _
            "Compsognathus" }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "Array.IndexOf(dinosaurs, ""Tyrannosaurus""): {0}", _
            Array.IndexOf(dinosaurs, "Tyrannosaurus"))

        Console.WriteLine(vbLf & _
            "Array.IndexOf(dinosaurs, ""Tyrannosaurus"", 3): {0}", _
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 3))

        Console.WriteLine(vbLf & _
            "Array.IndexOf(dinosaurs, ""Tyrannosaurus"", 2, 2): {0}", _
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2))

    End Sub
End Class

' This code example produces the following output:
'
'Tyrannosaurus
'Amargasaurus
'Mamenchisaurus
'Brachiosaurus
'Deinonychus
'Tyrannosaurus
'Compsognathus
'
'Array.IndexOf(dinosaurs, "Tyrannosaurus"): 0
'
'Array.IndexOf(dinosaurs, "Tyrannosaurus", 3): 5
'
'Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2): -1

Hinweise

Diese Methode durchsucht alle Elemente eines eindimensionalen Arrays nach value.This method searches all the elements of a one-dimensional array for value. Um zu ermitteln, ob value in array vorhanden ist, führt die-Methode einen Gleichheits Vergleich durch, indem die T.Equals-Methode für jedes Element aufgerufen wird.To determine whether value exists in array, the method performs an equality comparison by calling the T.Equals method on every element. Dies bedeutet Folgendes: Wenn T die Equals-Methode überschreibt, wird diese außer Kraft Setzung aufgerufen.This means that if T overrides the Equals method, that override is called.

Bei dieser Methode handelt es sich um einen O (n)-Vorgang, bei dem n der Length von array ist.This method is an O(n) operation, where n is the Length of array.

Siehe auch

IndexOf<T>(T[], T, Int32) IndexOf<T>(T[], T, Int32) IndexOf<T>(T[], T, Int32) IndexOf<T>(T[], T, Int32)

Sucht das angegebene Objekt in einem Bereich von Elementen eines eindimensionalen Arrays und gibt den Index des ersten Vorkommens zurück.Searches for the specified object in a range of elements of a one dimensional array, and returns the index of its first occurrence. Der Bereich erstreckt sich von einem angegebenen Index bis zum Ende des Arrays.The range extends from a specified index to the end of the array.

public:
generic <typename T>
 static int IndexOf(cli::array <T> ^ array, T value, int startIndex);
public static int IndexOf<T> (T[] array, T value, int startIndex);
static member IndexOf : 'T[] * 'T * int -> int
Public Shared Function IndexOf(Of T) (array As T(), value As T, startIndex As Integer) As Integer

Typparameter

T

Der Typ der Elemente des Arrays.The type of the elements of the array.

Parameter

array
T[]

Das zu durchsuchende eindimensionale und nullbasierte Array.The one-dimensional, zero-based array to search.

value
T T T T

Das in array zu suchende Objekt.The object to locate in array.

startIndex
Int32 Int32 Int32 Int32

Der nullbasierte Startindex für die Suche.The zero-based starting index of the search. 0 (null) ist in einem leeren Array gültig.0 (zero) is valid in an empty array.

Gibt zurück

Der nullbasierte Index des ersten Vorkommens von value innerhalb des Bereichs von Elementen in array, der sich von startIndex bis zum letzten Element erstreckt, sofern gefunden, andernfalls –1.The zero-based index of the first occurrence of value within the range of elements in array that extends from startIndex to the last element, if found; otherwise, -1.

Ausnahmen

startIndex liegt außerhalb des Bereichs der gültigen Indizes für array.startIndex is outside the range of valid indexes for array.

Beispiele

Im folgenden Beispiel werden alle drei generischen über Ladungen der IndexOf-Methode veranschaulicht.The following example demonstrates all three generic overloads of the IndexOf method. Ein Array von Zeichen folgen wird erstellt, wobei ein Eintrag zweimal an Indexposition 0 und Index Speicherort 5 angezeigt wird.An array of strings is created, with one entry that appears twice, at index location 0 and index location 5. Die IndexOf<T>(T[], T)-Methoden Überladung durchsucht das Array von Anfang an und findet das erste Vorkommen der Zeichenfolge.The IndexOf<T>(T[], T) method overload searches the array from the beginning, and finds the first occurrence of the string. Die IndexOf<T>(T[], T, Int32)-Methoden Überladung wird verwendet, um das Array zu durchsuchen, beginnend mit Indexposition 3 und bis zum Ende des Arrays, und findet das zweite Vorkommen der Zeichenfolge.The IndexOf<T>(T[], T, Int32) method overload is used to search the array beginning with index location 3 and continuing to the end of the array, and finds the second occurrence of the string. Schließlich wird die IndexOf<T>(T[], T, Int32, Int32)-Methoden Überladung verwendet, um einen Bereich von zwei Einträgen zu durchsuchen, beginnend bei Indexposition 2. Sie gibt-1 zurück, da in diesem Bereich keine Instanzen der Such Zeichenfolge vorhanden sind.Finally, the IndexOf<T>(T[], T, Int32, Int32) method overload is used to search a range of two entries, beginning at index location two; it returns -1 because there are no instances of the search string in that range.

using namespace System;

void main()
{
    array<String^>^ dinosaurs = { "Tyrannosaurus", 
        "Amargasaurus",
        "Mamenchisaurus",
        "Brachiosaurus",
        "Deinonychus",
        "Tyrannosaurus",
        "Compsognathus" };

    Console::WriteLine();
    for each(String^ dinosaur in dinosaurs )
    {
        Console::WriteLine(dinosaur);
    }

    Console::WriteLine("\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\"): {0}", 
        Array::IndexOf(dinosaurs, "Tyrannosaurus"));

    Console::WriteLine("\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 3): {0}", 
        Array::IndexOf(dinosaurs, "Tyrannosaurus", 3));

    Console::WriteLine("\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 2, 2): {0}", 
        Array::IndexOf(dinosaurs, "Tyrannosaurus", 2, 2));
}

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Deinonychus
Tyrannosaurus
Compsognathus

Array.IndexOf(dinosaurs, "Tyrannosaurus"): 0

Array.IndexOf(dinosaurs, "Tyrannosaurus", 3): 5

Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2): -1
 */
using System;

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = { "Tyrannosaurus",
            "Amargasaurus",
            "Mamenchisaurus",
            "Brachiosaurus",
            "Deinonychus",
            "Tyrannosaurus",
            "Compsognathus" };

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine(
            "\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\"): {0}", 
            Array.IndexOf(dinosaurs, "Tyrannosaurus"));

        Console.WriteLine(
            "\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 3): {0}", 
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 3));

        Console.WriteLine(
            "\nArray.IndexOf(dinosaurs, \"Tyrannosaurus\", 2, 2): {0}", 
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2));
    }
}

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Deinonychus
Tyrannosaurus
Compsognathus

Array.IndexOf(dinosaurs, "Tyrannosaurus"): 0

Array.IndexOf(dinosaurs, "Tyrannosaurus", 3): 5

Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2): -1
 */
Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { "Tyrannosaurus", _
            "Amargasaurus", _
            "Mamenchisaurus", _
            "Brachiosaurus", _
            "Deinonychus", _
            "Tyrannosaurus", _
            "Compsognathus" }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "Array.IndexOf(dinosaurs, ""Tyrannosaurus""): {0}", _
            Array.IndexOf(dinosaurs, "Tyrannosaurus"))

        Console.WriteLine(vbLf & _
            "Array.IndexOf(dinosaurs, ""Tyrannosaurus"", 3): {0}", _
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 3))

        Console.WriteLine(vbLf & _
            "Array.IndexOf(dinosaurs, ""Tyrannosaurus"", 2, 2): {0}", _
            Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2))

    End Sub
End Class

' This code example produces the following output:
'
'Tyrannosaurus
'Amargasaurus
'Mamenchisaurus
'Brachiosaurus
'Deinonychus
'Tyrannosaurus
'Compsognathus
'
'Array.IndexOf(dinosaurs, "Tyrannosaurus"): 0
'
'Array.IndexOf(dinosaurs, "Tyrannosaurus", 3): 5
'
'Array.IndexOf(dinosaurs, "Tyrannosaurus", 2, 2): -1

Hinweise

Diese Methode durchsucht ein eindimensionales Array vom-Element an startIndex bis zum Ende des-Arrays.This method searches a one-dimensional array from the element at startIndex to the end of the array. Um zu ermitteln, ob value in array vorhanden ist, führt die-Methode einen Gleichheits Vergleich durch, indem die T.Equals-Methode für jedes Element aufgerufen wird.To determine whether value exists in array, the method performs an equality comparison by calling the T.Equals method on every element. Dies bedeutet Folgendes: Wenn T die Equals-Methode überschreibt, wird diese außer Kraft Setzung aufgerufen.This means that if T overrides the Equals method, that override is called.

Wenn startIndex gleich Length ist, gibt die Methode -1 zurück. wenn startIndex größer als Array.Length ist, löst die Methode einen ArgumentOutOfRangeException aus.If startIndex equals Length,the method returns -1.If startIndex is greater than Array.Length, the method throws an ArgumentOutOfRangeException.

Bei dieser Methode handelt es sich um eine O (n)-Operation, bei der n die Anzahl der Elemente von startIndex bis zum Ende array ist.This method is an O(n) operation, where n is the number of elements from startIndex to the end of array.

Siehe auch

Gilt für: