Arrays in Visual Basic

Ein Array ist ein Satz von Werten, die als Elemente bezeichnet werden, die logisch miteinander verknüpft sind. Ein Array kann beispielsweise aus der Anzahl der Schüler in jeder Klasse eines Gymnasiums bestehen; jedes Element des Arrays ist die Anzahl der Schüler in einer einzelnen Klasse. Ebenso kann ein Array aus den Noten eines Schülers für eine Klasse bestehen; jedes Element des Arrays ist eine einzelne Klasse.

Es ist möglich, einzelne Variablen zu verwenden, um jedes unserer Datenelemente zu speichern. Wenn unsere Anwendung z. B. Schülernoten analysiert, können wir eine separate Variable für die Note jedes Schülers verwenden, z. B. englishGrade1, englishGrade2 usw. Dieser Ansatz weist drei wesentliche Einschränkungen auf:

• Wir müssen zur Entwurfszeit genau wissen, wie viele Noten verarbeitet werden müssen.
• Die Verarbeitung vieler Noten wird schnell unhandlich. Dies wiederum führt dazu, dass eine Anwendung viel wahrscheinlicher schwerwiegende Fehler aufweist.
• Die Wartung ist schwierig. Jede neue Klasse, die wir hinzufügen, erfordert, dass die Anwendung geändert, neu kompiliert und erneut bereitgestellt wird.

Mithilfe eines Arrays können Sie mit demselben Namen auf diese verknüpften Werte verweisen und eine Zahl verwenden, die als Index oder Feldindex bezeichnet wird, um die ein einzelnes Element basierend auf seiner Position im Array zu identifizieren. Die Indizes eines Arrays reichen von 0 bis eins kleiner als die Gesamtanzahl der Elemente im Array. Wenn Sie die Größe eines Arrays mithilfe der Visual Basic-Syntax definieren, geben Sie den höchsten Index an, nicht die Gesamtanzahl der Elemente im Array. Sie können mit dem Array als Einheit arbeiten, und dank der Möglichkeit, seine Elemente zu iterieren, müssen Sie zur Entwurfszeit nicht genau wissen, wie viele es enthält.

Hier einige Beispiele, bevor wir mit den Erklärungen starten:

' Declare a single-dimension array of 5 numbers.
Dim numbers(4) As Integer

' Declare a single-dimension array and set its 4 values.
Dim numbers = New Integer() {1, 2, 4, 8}

' Change the size of an existing array to 16 elements and retain the current values.
ReDim Preserve numbers(15)

' Redefine the size of an existing array and reset the values.
ReDim numbers(15)

' Declare a 6 x 6 multidimensional array.
Dim matrix(5, 5) As Double

' Declare a 4 x 3 multidimensional array and set array element values.
Dim matrix = New Integer(,) {{1, 2, 3}, {2, 3, 4}, {3, 4, 5}, {4, 5, 6}}

' Declare a jagged array
Dim sales()() As Double = New Double(11)() {}

Arrayelemente in einem einfachen Array

Wir erstellen ein Array namens students zum Speichern der Anzahl der Schüler in jeder Klasse eines Gymnasiums. Die Indizes der Elemente reichen von 0 bis 6. Es ist einfacher, dieses Array zu verwenden, als sieben verschiedene Variablen zu deklarieren.

Die folgende Abbildung zeigt das students-Array. Für jedes Element des Arrays gilt:

• Der Index des Elements steht für die Jahrgangsstufe (Index 0 (null) steht für die erste Jahrgangsstufe).

• Der im Element enthaltene Wert steht für die Anzahl der Schüler in dieser Jahrgangsstufe.

Das folgende Beispiel enthält den Visual Basic-Code, der das Array erstellt und verwendet:

Module SimpleArray
   Public Sub Main()
      ' Declare an array with 7 elements.
      Dim students(6) As Integer

      ' Assign values to each element.
      students(0) = 23
      students(1) = 19
      students(2) = 21
      students(3) = 17
      students(4) = 19
      students(5) = 20
      students(6) = 22
      
      ' Display the value of each element.
      For ctr As Integer = 0 To 6
         Dim grade As String = If(ctr = 0, "kindergarten", $"grade {ctr}")
         Console.WriteLine($"Students in {grade}: {students(ctr)}")
      Next
   End Sub
End Module
' The example displays the following output:
'     Students in kindergarten: 23
'     Students in grade 1: 19
'     Students in grade 2: 21
'     Students in grade 3: 17
'     Students in grade 4: 19
'     Students in grade 5: 20
'     Students in grade 6: 22

Im Beispiel passieren drei Dinge:

• Es wird ein students-Array mit sieben Elementen deklariert. Die Zahl 6 in der Arraydeklaration gibt den letzten Index im Array an. Sie ist eins kleiner als die Anzahl der Elemente im Array.
• Jedem Element im Array werden Werte zugewiesen. Auf Arrayelemente wird mithilfe des Arraynamens zugegriffen und der Index des einzelnen Elements ist in Klammern eingeschlossen.
• Jeder Wert des Arrays wird aufgelistet. Im Beispiel wird eine For-Anweisung verwendet, um auf jedes Element des Arrays anhand seiner Indexnummer zuzugreifen.

Das students-Array im vorherigen Beispiel ist ein eindimensionales Array, da es einen Index verwendet. Ein Array, das mehr als einen Index oder Feldindex verwendet, wird mehrdimensional genannt. Weitere Informationen finden Sie im weiteren Verlauf dieses Artikels und unter Array Dimensions in Visual Basic.

Erstellen eines Arrays

Es gibt mehrere Möglichkeiten zum Definieren der Größe eines Arrays:

• Sie können die Größe angeben, wenn das Array deklariert wird:

  ' Declare an array with 10 elements.
  Dim cargoWeights(9) As Double               
  ' Declare a 24 x 2 array.
  Dim hourlyTemperatures(23, 1) As Integer
  ' Declare a jagged array with 31 elements.
  Dim januaryInquiries(30)() As String
  

• Sie können die Größe eines Arrays bei seiner Erstellung auch mit einer New-Klausel angeben:

  ' Declare an array with 10 elements.
  Dim cargoWeights() As Double = New Double(9) {}
  ' Declare a 24 x 2 array.
  Dim hourlyTemperatures(,) As Integer = New Integer(23, 1) {}
  ' Declare a jagged array with 31 elements. 
  Dim januaryInquiries()() As String = New String(30)() {}
  

Die Größe eines vorhandenen Arrays kann mit der ReDim -Anweisung neu definiert werden. Sie können angeben, dass die ReDim-Anweisung die derzeit im Array gespeicherten Werte beibehalten soll, oder Sie können angeben, dass ein leeres Array erstellt wird. Im folgenden Beispiel werden andere Möglichkeiten veranschaulicht, um mit der ReDim -Anweisung die Größe eines vorhandenen Arrays zu ändern.

' Assign a new array size and retain the current values.
ReDim Preserve cargoWeights(20)
' Assign a new array size and retain only the first five values.
ReDim Preserve cargoWeights(4)
' Assign a new array size and discard all current element values.
ReDim cargoWeights(15)

Weitere Informationen finden Sie unter ReDim-Anweisung.

Speichern von Werten in einem Array

Sie können mit einem Index vom Typ Integerauf die einzelnen Positionen in einem Array zugreifen. Die Werte in einem Array können gespeichert und abgerufen werden, indem mit dem entsprechenden in Klammern eingeschlossenen Index auf die einzelnen Arraypositionen verwiesen wird. Indizes für mehrdimensionale Arrays sind durch Kommas (,) getrennt. Sie benötigen einen Index für jede Arraydimension.

Im folgenden Beispiel werden einige Anweisungen gezeigt, die Werte in Arrays speichern und abrufen.

Module Example
   Public Sub Main()
      ' Create a 10-element integer array.
      Dim numbers(9) As Integer
      Dim value As Integer = 2
        
      ' Write values to it.
      For ctr As Integer = 0 To 9
         numbers(ctr) = value
         value *= 2
      Next
        
      ' Read and sum the array values.  
      Dim sum As Integer
      For ctr As Integer = 0 To 9
         sum += numbers(ctr)
      Next
      Console.WriteLine($"The sum of the values is {sum:N0}")
    End Sub
End Module
' The example displays the following output:
'     The sum of the values is 2,046

Auffüllen eines Arrays mit Arrayliteralen

Mithilfe eines Arrayliterals können Sie ein Array während der Erstellung mit einem anfänglichen Satz von Werten auffüllen. Ein Arrayliteral besteht aus einer Liste von durch Trennzeichen getrennten Werten, die in geschweifte Klammern ({}) eingeschlossen sind.

Beim Erstellen eines Arrays mit einem Arrayliteral können Sie den Arraytyp entweder angeben oder mittels Typrückschluss bestimmen. Das folgende Beispiel zeigt beide Optionen.

' Array literals with explicit type definition.
Dim numbers = New Integer() {1, 2, 4, 8}
' Array literals with type inference.
Dim doubles = {1.5, 2, 9.9, 18}
' Array literals with explicit type definition.
Dim articles() As String = { "the", "a", "an" }

' Array literals with explicit widening type definition.
Dim values() As Double = { 1, 2, 3, 4, 5 }

Beim Typrückschluss wird der Typ des Arrays anhand des bestimmenden Typs in der Liste der Literalwerte bestimmt. Der bestimmende Typ ist der Typ, auf den alle anderen Typen im Array erweitert werden können. Wenn dieser eindeutige Typ nicht bestimmt werden kann, ist der bestimmende Typ der eindeutige Typ, auf den alle anderen Typen im Array eingegrenzt werden können. Wenn keiner dieser eindeutigen Typen bestimmt werden kann, ist der bestimmende Typ Object. Wenn die für das Arrayliteral angegebene Liste der Werte z. B. Werte vom Typ Integer, Longund Doubleenthält, weist das erhaltene Array den Typ Doubleauf. Da Integer und Long nur auf Double erweitert werden, ist Double der bestimmende Typ. Weitere Informationen finden Sie unter Widening and Narrowing Conversions.

Beachten Sie, dass im vorherigen Beispiel values als ein Array vom Typ Double definiert ist, obwohl alle Arrayliterale vom Typ Integer sind. Sie können dieses Array erstellen, da die Werte im Arrayliteral auf Double-Werte ausgeweitet werden können.

Sie können auch ein mehrdimensionales Array mithilfe von geschachtelten Arrayliteralen erstellen und auffüllen. Geschachtelte Arrayliterale müssen über eine Anzahl von Dimensionen verfügen, der mit dem erhaltenen Array konsistent ist. Im folgenden Beispiel wird mit geschachtelten Arrayliteralen ein zweidimensionales Array von ganzen Zahlen erstellt.

' Create and populate a 2 x 2 array.
Dim grid1 = {{1, 2}, {3, 4}}
' Create and populate a 2 x 2 array with 3 elements.
Dim grid2(,) = {{1, 2}, {3, 4}, {5, 6}}

Wenn Sie geschachtelte Arrayliterale zum Erstellen und Auffüllen eines Arrays verwenden, tritt ein Fehler auf, wenn die Anzahl der Elemente in den geschachtelten Arrayliteralen nicht übereinstimmt. Ein Fehler tritt auch auf, wenn Sie explizit deklarieren, dass die Arrayvariable eine andere Anzahl von Dimensionen als die Arrayliterale aufweist.

Genau wie bei eindimensionalen Arrays können Sie sich beim Erstellen eines mehrdimensionalen Arrays mit geschachtelten Arrayliteralen auf den Typrückschluss verlassen. Der abgeleitete Typ ist der bestimmende Typ für sämtliche Werte in allen Arrayliteralen für alle Schachtelungsebenen. Im folgenden Beispiel wird ein zweidimensionales Array vom Typ Double[,] aus Werten erstellt, die vom Typ Integer und Doublesind.

Dim arr = {{1, 2.0}, {3, 4}, {5, 6}, {7, 8}}

Weitere Beispiele finden Sie unter How to: Initialize an Array Variable in Visual Basic (Gewusst wie: Initialisieren einer Arrayvariablen in Visual Basic).

Durchlaufen eines Arrays

Wenn Sie ein Array durchlaufen, greifen Sie vom niedrigsten bis zum höchsten Index oder vom höchsten bis zum niedrigsten Index auf jedes Element im Array zu. Verwenden Sie in der Regel entweder die For...Next-Anweisung oder die For Each...Next-Anweisung, um die Elemente eines Arrays zu durchlaufen. Wenn Sie die Obergrenzen des Arrays nicht kennen, können Sie die Array.GetUpperBound-Methode aufrufen, um den höchsten Wert des Indexes abzurufen. Obwohl der niedrigste Indexwert fast immer 0 ist, können Sie die Array.GetLowerBound-Methode aufrufen, um den niedrigsten Wert des Indexes abzurufen.

Im folgenden Beispiel wird ein eindimensionales Array mit der For...Next-Anweisung durchlaufen.

Module IterateArray
   Public Sub Main()
      Dim numbers = {10, 20, 30}

      For index = 0 To numbers.GetUpperBound(0)
         Console.WriteLine(numbers(index))
      Next
   End Sub
End Module
' The example displays the following output:
'  10
'  20
'  30

Im folgenden Beispiel wird ein mehrdimensionales Array mit einer For...Next -Anweisung durchlaufen. Die GetUpperBound -Methode enthält einen Parameter, der die Dimension angibt. GetUpperBound(0) gibt den höchsten Index der ersten Dimension und GetUpperBound(1) gibt den höchsten Index der zweiten Dimension zurück.

Module IterateArray
   Public Sub Main()
      Dim numbers = {{1, 2}, {3, 4}, {5, 6}}

      For index0 = 0 To numbers.GetUpperBound(0)
         For index1 = 0 To numbers.GetUpperBound(1)
            Console.Write($"{numbers(index0, index1)} ")
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
' Output 
'  1 2 
'  3 4 
'  5 6

Im folgenden Beispiel wird eine For Each...Next-Anweisung verwendet, um ein eindimensionales Array und ein zweidimensionales Array zu durchlaufen.

Module IterateWithForEach
   Public Sub Main()
      ' Declare and iterate through a one-dimensional array.
      Dim numbers1 = {10, 20, 30}
      
      For Each number In numbers1
         Console.WriteLine(number)
      Next
      Console.WriteLine()
      
      Dim numbers = {{1, 2}, {3, 4}, {5, 6}}

      For Each number In numbers
         Console.WriteLine(number)
      Next
   End Sub
End Module
' The example displays the following output:
'  10
'  20
'  30
'
'  1
'  2
'  3
'  4
'  5
'  6

Arraygröße

Die Größe eines Arrays ist das Produkt der Längen aller seiner Dimensionen. Sie stellt die Gesamtzahl der Elemente dar, die derzeit im Array enthalten sind. Im folgenden Beispiel wird beispielsweise ein zweidimensionales Array mit vier Elementen in jeder Dimension deklariert. Wie die Ausgabe aus dem Beispiel zeigt, ist die Größe des Arrays 16 (oder (3 + 1) * (3 + 1).

Module Example
   Public Sub Main()
      Dim arr(3, 3) As Integer
      Console.WriteLine(arr.Length)     
   End Sub
End Module
' The example displays the following output:
'     16

Sie können die Größe eines Arrays mithilfe der Array.Length-Eigenschaft bestimmen. Sie können die Länge der einzelnen Dimensionen eines mehrdimensionalen Arrays mithilfe der Array.GetLength-Methode bestimmen.

Sie können die Größe einer Arrayvariablen ändern, indem Sie ihr ein neues Arrayobjekt zuweisen oder indem Sie die ReDim-Anweisung verwenden. Im folgenden Beispiel wird die ReDim-Anweisung verwendet, um ein Array mit 100 Elementen in ein Array mit 51 Elementen zu ändern.

Module Example
   Public Sub Main()
      Dim arr(99) As Integer
      Console.WriteLine(arr.Length)
      
      Redim arr(50)
      Console.WriteLine(arr.Length)
   End Sub
End Module
' The example displays the following output:
'     100
'     51

 

Mehrere Faktoren wirken sich auf die Arraygröße aus.

Der Arraytyp

Jedes Array besitzt einen Datentyp, der nicht mit dem Datentyp seiner Elemente identisch ist. Es gibt keinen universellen Datentyp, der sich für alle Arrays eignet. Stattdessen wird der Datentyp eines Arrays durch die Anzahl der Dimensionen (den Rang) des Arrays bestimmt, sowie durch den Datentyp der Elemente im Array. Die Datentypen zweier Arrayvariablen sind nur dann gleich, wenn die Arrayvariablen den gleichen Rang aufweisen und ihre Elemente den gleichen Datentyp aufweisen. Die Länge der Dimensionen eines Arrays haben keinerlei Auswirkungen auf den Arraydatentyp.

Jedes Array erbt aus der System.Array-Klasse. Sie können eine Variable des Typs Array deklarieren, ein Array des Typs Array können Sie jedoch nicht erstellen. Wenn beispielsweise der folgende Code die arr-Variable als Typ Array deklariert und die Array.CreateInstance-Methode zum Instanziieren des Arrays aufruft, erweist sich der Typ des Arrays als Object[].

Module Example
   Public Sub Main()
      Dim arr As Array = Array.CreateInstance(GetType(Object), 19)
      Console.WriteLine(arr.Length)
      Console.WriteLine(arr.GetType().Name)
   End Sub
End Module
' The example displays the following output:
'     19
'     Object[]

Die ReDim-Anweisung kann nicht für eine Variable verwendet werden, die mit dem Typ Array deklariert ist. Aus diesen Gründen und zur Gewährleistung der Typsicherheit empfiehlt es sich, jedes Array als bestimmten Typ zu deklarieren.

Sie können den Datentyp eines Arrays oder seiner Elemente auf verschiedene Arten ermitteln.

• Sie können die GetType-Methode für die Variable aufrufen, um ein Type-Objekt zu erhalten, das für den Laufzeittyp der Variable steht. Das Type -Objekt stellt in seinen Eigenschaften und Methoden umfassende Informationen bereit.
• Sie können die Variable an die TypeName -Funktion übergeben, um eine String mit dem Namen des Laufzeittyps zu erhalten.

Im folgenden Beispiel wird sowohl die GetType-Methode als auch die TypeName-Funktion aufgerufen, um den Typ eines Arrays zu bestimmen. Der Arraytyp ist Byte(,). Beachten Sie, dass die Type.BaseType-Eigenschaft auch angibt, dass der Basistyp des Bytearrays die Array-Klasse ist.

Module Example
   Public Sub Main()
      Dim bytes(9,9) As Byte
      Console.WriteLine($"Type of {nameof(bytes)} array: {bytes.GetType().Name}")
      Console.WriteLine($"Base class of {nameof(bytes)}: {bytes.GetType().BaseType.Name}")
      Console.WriteLine()
      Console.WriteLine($"Type of {nameof(bytes)} array: {TypeName(bytes)}")
   End Sub
End Module
' The example displays the following output:
' Type of bytes array: Byte[,]
' Base class of bytes: Array
' 
' Type of bytes array: Byte(,)

Arrays als Parameter und Rückgabewerte

Damit eine Function-Prozedur ein Array zurückgibt, geben Sie den Arraydatentyp und die Anzahl der Dimensionen als Rückgabetyp für die Function-Anweisung an. Deklarieren Sie in der Funktion eine lokale Arrayvariable mit dem gleichen Datentyp und der gleichen Anzahl an Dimensionen. Schließen Sie die lokale Arrayvariable ohne Klammern in die Return-Anweisung ein.

Um ein Array als Parameter für eine Sub - oder Function -Prozedur anzugeben, definieren Sie den Parameter als Array mit einem bestimmten Datentyp und einer bestimmten Anzahl von Dimensionen. Übergeben Sie im Aufruf zur Prozedur eine Arrayvariable mit dem gleichen Datentyp und der gleichen Anzahl von Dimensionen.

Im folgenden Beispiel gibt die GetNumbers-Funktion eine Integer(), ein eindimensionales Array vom Typ Integer zurück. Die Prozedur ShowNumbers akzeptiert ein Argument Integer() .

Module ReturnValuesAndParams
   Public Sub Main()
      Dim numbers As Integer() = GetNumbers()
      ShowNumbers(numbers)
   End Sub

   Private Function GetNumbers() As Integer()
      Dim numbers As Integer() = {10, 20, 30}
      Return numbers
   End Function

   Private Sub ShowNumbers(numbers As Integer())
      For index = 0 To numbers.GetUpperBound(0)
         Console.WriteLine($"{numbers(index)} ")
      Next
   End Sub
End Module
' The example displays the following output:
'   10
'   20
'   30
    

Im folgenden Beispiel gibt die GetNumbersMultiDim-Funktion eine Integer(,), ein zweidimensionales Array vom Typ Integer zurück. Die Prozedur ShowNumbersMultiDim akzeptiert ein Argument Integer(,) .

Module Example
   Public Sub Main()
      Dim numbers As Integer(,) = GetNumbersMultidim()
      ShowNumbersMultidim(numbers)
   End Sub

   Private Function GetNumbersMultidim() As Integer(,)
      Dim numbers As Integer(,) = {{1, 2}, {3, 4}, {5, 6}}
      Return numbers
   End Function

   Private Sub ShowNumbersMultidim(numbers As Integer(,))
      For index0 = 0 To numbers.GetUpperBound(0)
         For index1 = 0 To numbers.GetUpperBound(1)
            Console.Write($"{numbers(index0, index1)} ")
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'     1 2
'     3 4
'     5 6

Verzweigte Arrays

In einigen Fällen ist die Datenstruktur in einer Anwendung zweidimensional, jedoch nicht rechteckig. Sie können beispielsweise ein Array verwenden, um Daten über die hohe Temperatur jedes Tages im Monat zu speichern. Die erste Dimension des Arrays stellt den Monat dar, aber die zweite Dimension stellt die Anzahl der Tage dar, und die Anzahl der Tage in einem Monat ist nicht einheitlich. Ein Jagged Array, das auch als Array von Arrays bezeichnet wird, ist für solche Szenarien konzipiert. Ein Jagged Array ist ein Array, dessen Elemente wiederum Arrays sind. Ein verzweigtes Array und jedes Element in einem verzweigten Array können über eine oder mehrere Dimensionen verfügen.

Im folgenden Beispiel wird ein Array von Monaten verwendet, bei dem jedes Element ein Array von Tagen ist. Im Beispiel wird ein Jagged Array verwendet, da verschiedene Monate unterschiedliche Anzahl von Tagen aufweisen. Das Beispiel zeigt, wie Sie ein Jagged Array erstellen, ihm Werte zuweisen und dessen Werte abrufen und anzeigen.

Imports System.Globalization

Module JaggedArray
   Public Sub Main()
      ' Declare the jagged array of 12 elements. Each element is an array of Double.
      Dim sales(11)() As Double
      ' Set each element of the sales array to a Double array of the appropriate size.
      For month As Integer = 0 To 11
         ' The number of days in the month determines the appropriate size.
         Dim daysInMonth As Integer =
            DateTime.DaysInMonth(Year(Now), month + 1)
         sales(month) = New Double(daysInMonth - 1) {}
      Next 

      ' Store values in each element.
      For month As Integer = 0 To 11
         For dayOfMonth = 0 To sales(month).GetUpperBound(0)
            sales(month)(dayOfMonth) = (month * 100) + dayOfMonth
         Next
      Next

      ' Retrieve and display the array values.
      Dim monthNames = DateTimeFormatInfo.CurrentInfo.AbbreviatedMonthNames
      ' Display the month names.
      Console.Write("    ")
      For ctr = 0 To sales.GetUpperBound(0)
         Console.Write($" {monthNames(ctr)}   ")
      Next   
      Console.WriteLine()
      ' Display data for each day in each month.
      For dayInMonth = 0 To 30
         Console.Write($"{dayInMonth + 1,2}.  ")
         For monthNumber = 0 To sales.GetUpperBound(0)
            If dayInMonth > sales(monthNumber).GetUpperBound(0) Then 
               Console.Write("       ")
            Else
               Console.Write($"{sales(monthNumber)(dayInMonth),-5}  ")
            End If
         Next   
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'      Jan    Feb    Mar    Apr    May    Jun    Jul    Aug    Sep    Oct    Nov    Dec
'  1.  0      100    200    300    400    500    600    700    800    900    1000   1100
'  2.  1      101    201    301    401    501    601    701    801    901    1001   1101
'  3.  2      102    202    302    402    502    602    702    802    902    1002   1102
'  4.  3      103    203    303    403    503    603    703    803    903    1003   1103
'  5.  4      104    204    304    404    504    604    704    804    904    1004   1104
'  6.  5      105    205    305    405    505    605    705    805    905    1005   1105
'  7.  6      106    206    306    406    506    606    706    806    906    1006   1106
'  8.  7      107    207    307    407    507    607    707    807    907    1007   1107
'  9.  8      108    208    308    408    508    608    708    808    908    1008   1108
' 10.  9      109    209    309    409    509    609    709    809    909    1009   1109
' 11.  10     110    210    310    410    510    610    710    810    910    1010   1110
' 12.  11     111    211    311    411    511    611    711    811    911    1011   1111
' 13.  12     112    212    312    412    512    612    712    812    912    1012   1112
' 14.  13     113    213    313    413    513    613    713    813    913    1013   1113
' 15.  14     114    214    314    414    514    614    714    814    914    1014   1114
' 16.  15     115    215    315    415    515    615    715    815    915    1015   1115
' 17.  16     116    216    316    416    516    616    716    816    916    1016   1116
' 18.  17     117    217    317    417    517    617    717    817    917    1017   1117
' 19.  18     118    218    318    418    518    618    718    818    918    1018   1118
' 20.  19     119    219    319    419    519    619    719    819    919    1019   1119
' 21.  20     120    220    320    420    520    620    720    820    920    1020   1120
' 22.  21     121    221    321    421    521    621    721    821    921    1021   1121
' 23.  22     122    222    322    422    522    622    722    822    922    1022   1122
' 24.  23     123    223    323    423    523    623    723    823    923    1023   1123
' 25.  24     124    224    324    424    524    624    724    824    924    1024   1124
' 26.  25     125    225    325    425    525    625    725    825    925    1025   1125
' 27.  26     126    226    326    426    526    626    726    826    926    1026   1126
' 28.  27     127    227    327    427    527    627    727    827    927    1027   1127
' 29.  28            228    328    428    528    628    728    828    928    1028   1128
' 30.  29            229    329    429    529    629    729    829    929    1029   1129
' 31.  30            230           430           630    730           930           1130

Im vorherigen Beispiel werden dem Jagged Array mithilfe einer For...Next-Schleife Werte auf Element-für-Element-Basis zugewiesen. Sie können den Elementen eines Jagged Arrays auch Werte zuweisen, indem Sie geschachtelte Arrayliterale verwenden. Der Versuch, geschachtelte Arrayliterale zu verwenden (z. B. Dim valuesjagged = {{1, 2}, {2, 3, 4}}), generiert jedoch den Compilerfehler BC30568. Um den Fehler zu beheben, schließen Sie die inneren Arrayliterale in Klammern ein. Die Klammern erzwingen die Auswertung des Literalausdrucks des Arrays, und die erhaltenen Werte werden mit dem äußeren Arrayliteral verwendet. Dies ist im folgenden Beispiel veranschaulicht.

Module Example
   Public Sub Main()
      Dim values1d = { 1, 2, 3 }
      Dim values2d = {{1, 2}, {2, 3}, {3, 4}}
      Dim valuesjagged = {({1, 2}), ({2, 3, 4})}
   End Sub
End Module

Ein Jagged Array ist ein eindimensionales Array, dessen Elemente Arrays enthalten. Daher geben die Array.Length-Eigenschaft und die Array.GetLength(0)-Methode die Anzahl der Elemente im eindimensionalen Array zurück und Array.GetLength(1) löst eine IndexOutOfRangeException aus, da ein Jagged Array nicht mehrdimensional ist. Sie bestimmen die Anzahl der Elemente in jedem Subarray, indem Sie den Wert der Array.Length-Eigenschaft jedes Subarrays abrufen. Im folgenden Beispiel wird veranschaulicht, wie die Anzahl von Elementen in einem Jagged Array bestimmt wird.

Module Example
   Public Sub Main()
      Dim jagged = { ({1, 2}), ({2, 3, 4}), ({5, 6}), ({7, 8, 9, 10}) }
      Console.WriteLine($"The value of jagged.Length: {jagged.Length}.")
      Dim total = jagged.Length
      For ctr As Integer = 0 To jagged.GetUpperBound(0)
         Console.WriteLine($"Element {ctr + 1} has {jagged(ctr).Length} elements.") 
         total += jagged(ctr).Length 
      Next
      Console.WriteLine($"The total number of elements in the jagged array: {total}")
   End Sub
End Module
' The example displays the following output:
'     The value of jagged.Length: 4.
'     Element 1 has 2 elements.
'     Element 2 has 3 elements.
'     Element 3 has 2 elements.
'     Element 4 has 4 elements.
'     The total number of elements in the jagged array: 15

Arrays mit der Länge 0 (null)

Visual Basic unterscheidet zwischen einem nicht initialisierten Array (einem Array, dessen Wert Nothing ist) und einem Array mit der Länge null oder einem leeren Array (ein Array ohne Elemente). Ein nicht initialisiertes Array ist ein Array, das nicht dimensioniert wurde oder dem keine Werte zugewiesen wurden. Zum Beispiel:

Dim arr() As String

Ein Array mit der Länge null wird mit einer Dimension von -1 deklariert. Zum Beispiel:

Dim arrZ(-1) As String

Unter den folgenden Bedingungen müssen Sie eventuell ein Array der Länge 0 (null) erstellen:

• Der Code muss, ohne eine NullReferenceException -Ausnahme auszulösen, auf Member der Array -Klasse zugreifen, beispielsweise auf Length oder Rank, oder eine Visual Basic-Funktion wie UBound aufrufen.

• Sie sollten Ihren Code dadurch einfach halten, dass eine Überprüfung auf das Vorhandensein von Nothing als Sonderfall entfällt.

• Der Code interagiert mit einer API (Application Programming Interface), die entweder verlangt, dass mindestens einer Prozedur ein Array der Länge Null übergeben wird. Oder er interagiert mit einer API, die ein solches Array von mindestens einer Prozedur zurückgibt.

Aufteilen eines Arrays

In einigen Fällen müssen Sie ein einzelnes Array möglicherweise in mehrere Arrays aufteilen. Dazu ist es nötig, den Punkt oder die Punkte zu identifizieren, an denen das Array aufgeteilt werden soll, und dann muss das Array in zwei oder mehr separate Arrays aufgeteilt werden.

Die häufigsten Kriterien für die Aufteilung eines Arrays sind:

• Die Anzahl der Elemente im Array. Beispielsweise können Sie ein Array mit mehr als einer angegebenen Anzahl von Elementen in eine Anzahl von ungefähr gleichen Teilen aufteilen. Zu diesem Zweck können Sie den Wert verwenden, der von der Methode Array.Length oder Array.GetLength zurückgegeben wird.

• Der Wert eines Elements, das als Trennzeichen dient, das angibt, wo das Array aufgeteilt werden soll. Sie können nach einem bestimmten Wert suchen, indem Sie die Methoden Array.FindIndex und Array.FindLastIndex aufrufen.

Nachdem Sie den Index oder die Indizes ermittelt haben, an denen das Array aufgeteilt werden soll, können Sie die einzelnen Arrays erstellen, indem Sie die Array.Copy-Methode aufrufen.

Im folgenden Beispiel wird ein Array in zwei Arrays mit ungefähr gleicher Größe unterteilt. (Wenn die Gesamtzahl der Arrayelemente ungerade ist, verfügt das erste Array über ein Element mehr als das zweite.)

Module Example
   Public Sub Main()
      ' Create an array of 100 elements.
      Dim arr(99) As Integer
      ' Populate the array.
      Dim rnd As new Random()
      For ctr = 0 To arr.GetUpperBound(0)
         arr(ctr) = rnd.Next()
      Next
      
      ' Determine how many elements should be in each array.
      Dim divisor = 2
      Dim remainder As Integer
      Dim boundary = Math.DivRem(arr.GetLength(0), divisor, remainder)
            
      ' Copy the array.
      Dim arr1(boundary - 1 + remainder), arr2(boundary - 1) as Integer
      Array.Copy(arr, 0, arr1, 0, boundary + remainder)
      Array.Copy(arr, boundary + remainder, arr2, 0, arr.Length - boundary) 
   End Sub
End Module

Im folgenden Beispiel wird ein Zeichenfolgenarray basierend auf dem Vorhandensein eines Elements, dessen Wert „zzz“ (das Arraytrennzeichen) ist, in zwei Arrays unterteilt. Die neuen Arrays enthalten das Element mit dem Trennzeichen nicht.

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      
      ' Create an array of 100 elements.
      Dim arr(99) As String
      ' Populate each element with an arbitrary ASCII character.
      For ctr = 0 To arr.GetUpperBound(0)
         arr(ctr) = ChrW(Rnd.Next(&h21, &h7F))
      Next
      ' Get a random number that will represent the point to insert the delimiter.
      arr(rnd.Next(0, arr.GetUpperBound(0))) = "zzz"

      ' Find the delimiter.
      Dim location = Array.FindIndex(arr, Function(x) x = "zzz")

      ' Create the arrays.
      Dim arr1(location - 1) As String
      Dim arr2(arr.GetUpperBound(0) - location - 1) As String
      
      ' Populate the two arrays.
      Array.Copy(arr, 0, arr1, 0, location)
      Array.Copy(arr, location + 1, arr2, 0, arr.GetUpperBound(0) - location)
   End Sub
End Module

Verknüpfen von Arrays

Es ist auch möglich, eine Reihe von Arrays zu einem einzelnen größeren Array zu kombinieren. Dafür können Sie auch die Array.Copy-Methode verwenden.

Bevor Sie die Elemente jedes Arrays in das neue Array kopieren, müssen Sie sicherstellen, dass Sie das Array so initialisiert haben, dass es groß genug ist, um das neue Array aufzunehmen. Dazu haben Sie zwei Möglichkeiten:

• Verwenden Sie die ReDim Preserve-Anweisung, um das Array vor dem Hinzufügen neuer Elemente dynamisch zu erweitern. Dies ist die einfachste Technik, kann jedoch zu Leistungseinbußen und übermäßigem Arbeitsspeicherverbrauch führen, wenn Sie große Arrays kopieren.
• Berechnen Sie die Gesamtanzahl der Elemente, die für das neue große Array erforderlich sind, und fügen Sie dann die Elemente jedes Quellarrays hinzu.

Im folgenden Beispiel wird der zweite Ansatz verwendet, um einem einzelnen Array vier Arrays mit jeweils zehn Elementen hinzuzufügen.

Imports System.Collections.Generic
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks As New List(Of Task(Of Integer()))
      ' Generate four arrays.
      For ctr = 0 To 3
         Dim value = ctr
         tasks.Add(Task.Run(Function()
                               Dim arr(9) As Integer
                               For ndx = 0 To arr.GetUpperBound(0)
                                  arr(ndx) = value
                               Next
                               Return arr
                            End Function))   
       Next
       Task.WaitAll(tasks.ToArray())
       ' Compute the number of elements in all arrays.
       Dim elements = 0
       For Each task In tasks
          elements += task.Result.Length
       Next
       Dim newArray(elements - 1) As Integer
       Dim index = 0
       For Each task In tasks
          Dim n = task.Result.Length
          Array.Copy(task.Result, 0, newArray, index, n)
          index += n
       Next 
      Console.WriteLine($"The new array has {newArray.Length} elements.")
   End Sub
End Module
' The example displays the following output:
'     The new array has 40 elements.

Da in diesem Fall alle Quellarrays klein sind, können wir das Array auch dynamisch erweitern, wenn wir die Elemente jedes neuen Arrays hinzufügen. In folgendem Beispiel wird dies getan.

Imports System.Collections.Generic
Imports System.Threading.Tasks

Module Example
   Public Sub Main()
      Dim tasks As New List(Of Task(Of Integer()))
      ' Generate four arrays.
      For ctr = 0 To 3
         Dim value = ctr
         tasks.Add(Task.Run(Function()
                               Dim arr(9) As Integer
                               For ndx = 0 To arr.GetUpperBound(0)
                                  arr(ndx) = value
                               Next
                               Return arr
                            End Function))   
       Next
       Task.WaitAll(tasks.ToArray())

       ' Dimension the target array and copy each element of each source array to it.
       Dim newArray() As Integer = {}
       ' Define the next position to copy to in newArray.
       Dim index = 0
       For Each task In tasks
          Dim n = Task.Result.Length
          ReDim Preserve newArray(newArray.GetUpperBound(0) + n)
          Array.Copy(task.Result, 0, newArray, index, n)
          index += n
       Next 
      Console.WriteLine($"The new array has {newArray.Length} elements.")
   End Sub
End Module
' The example displays the following output:
'     The new array has 40 elements.

Auflistungen als Alternative zu Arrays

Arrays eignen sich bestens zum Erstellen und Arbeiten mit einer festen Anzahl von Objekten mit starkem Typ. Auflistungen ermöglichen ein flexibleres Arbeiten mit Objektgruppen. Im Gegensatz zu Arrays, bei denen Sie die Größe eines Arrays explizit mit der ReDim-Anweisung ändern müssen, werden Sammlungen dynamisch vergrößert und verkleinern, wenn sich die Anforderungen einer Anwendung ändern.

Wenn Sie ReDim verwenden, um ein Array neu zu dimensionieren, erstellt Visual Basic ein neues Array und gibt das vorherige Array frei. Dies nimmt Ausführungszeit in Anspruch. Wenn sich die Anzahl der verwendeten Elemente häufig ändert oder Sie die maximale Anzahl der benötigten Elemente nicht vorhersehen können, erzielen Sie mit einer Auflistung normalerweise eine höhere Leistung.

Bei einigen Auflistungen können Sie jedem Objekt, das Sie in die Auflistung einfügen, einen Schlüssel zuweisen, sodass das Objekt anhand des Schlüssels schnell abgerufen werden kann.

Wenn die Auflistung Elemente eines Datentyps enthält, können Sie eine der Klassen im System.Collections.Generic-Namespace verwenden. Eine generische Auflistung erzwingt Typsicherheit, sodass der Auflistung kein anderer Datentyp hinzugefügt werden kann.

Weitere Informationen über Auflistungen finden Sie unter Auflistungen.

Zugehörige Themen

Siehe auch

• System.Array
• Dim-Anweisung
• ReDim-Anweisung