Glengamoi (Forum) · AspHeute · .NET Heute (RSS-Suche) · AspxFiles (Wiki) · .NET Blogs

Verwendung von Arrays in C#

Geschrieben von: Christian Holm
Kategorie: C#

This printed page brought to you by AlphaSierraPapa

Heute möchte ich Ihnen die Verwendung von Arrays (engl. für Feld) in C# präsentieren. Dabei präsentiere ich Arrays deren Größe zur Compilezeit bestimmt ist, als auch solche, die zur Laufzeit mit variabler Größe erzeugt werden können.

Die Verwendung von Arrays bietet sich speziell dann an, wenn man mit großen Datenmengen vom gleichen Datentyp arbeitet, oder/und die Reihenfolge der Daten eine wichtige Rolle spielt - wenn man über den Index ein Element ansprechen können soll.

In diesem Artikel werden wir folgende Arraytypen behandeln:

eindimensionale Arrays
mehrdimensionale Arrays
Arrays von Arrays (Jagged Arrays)

Definition: Ein Array ist eine Datenstruktur, welche eine Anzahl von Daten gleichen Typs beinhaltet. Dieser Typ wird dann Elementtyp eines Arrays genannt. Arrays können jeden möglichen Datentyp beinhalten also z.B. Integer, Strings (Zeichenfolgen), Pointer (Zeiger), Arraytypen oder jeden anderen gültigen Datentyp, mit Ausnahme von Referenzen (reference types). Die Variablen, die ein Array beinhaltet, werden Array-Elemente genannt. Die einzelnen Elemente werden durch errechnete Indizes adressiert.

Arrays können ein- oder mehrdimensional sein. Die Anzahl der Dimensionen wird auch Rang genannt. Eindimensionale Arrays haben somit den Rang Eins (1). Die Größe der Dimension eines Arrays ist nicht Teil des Typs des Arrays, sondern diese wird erst bei der Instanzierung des Arrays bei der Laufzeit erstellt. Die Dimensionsgröße bestimmt die gültige Anzahl von Indizes innerhalb eines Arrays.

Bei der Verwendung von Arrays gibt es einiges zu beachten:

Arrays sind Objekte und müssen instanziert werden
Die Arraygröße wird in eckige Klammern [] geschrieben
Gültige Werte für die Größe eines Arrays sind positive, ganzzahlige Zahlen
Der Arrayindex beginnt wie in C++ mit 0
Für ein Array der Größe n ist somit der Endindex (n-1)
Gültige Größen für Arrays sind (0, 1, 2, ...). Arrays mit Größe Null (0) sind leere Arrays.

Arrays sind Objekte

Wie schon erwähnt sind nun in C# die Arrays Objekte (System.Array Klasse) - das heißt, daß sich der Garbage Collector um das Freigeben des Speichers kümmert. Ein zusätzlicher Vorteil daß ein Array nun ein Objekt ist, daß Sie nun die Eigenschaften bzw. Methoden verwenden können, die die System.Array Klasse hat. Sie können dadurch einfachst den Inhalt eines Arrays sortieren (Sort Methode), kopieren (Clone, Copy) und darin suchen (BinarySearch).

Eindimensionale Arrays

Man kann das Array deklarieren, und erst später erzeugen:

int[] arTestSDim;
// some code...
arTestSDim = new int[10];

Natürlich kann man das auch auf eine einzige Zeile zusammenziehen:

int[] arTestSDim = new int[10];

Wir haben hier also ein Array namens arTestSDim (der Präfix "ar" entstammt der ungarischen Notation und hilft Variablen leichter zu indentifizieren) erstellt; dieses hat 10 Elemente, vom Datentyp Integer.

Initialisierung von Arrays

Nun wollen wir ein integer Array mit der Größe 4 initialisieren - und die Elemente, welche einfache Zahlen sind, zusätzlich im Deklarationsstatement angeben:

int[] arTestSDim = {0, 1, 2, 3};

Alternativ dazu könnte man das Array auch einfach deklarieren, und die Werte dann einzeln zuweisen:

int[] arTestSDim = new int[4];
for (int n=0; n < 4; n++)
{
	arTestSDim[n] = n;
}

Zugriff auf ein Element innerhalb eines Arrays

Natürlich möchte man auch Elemente des Arrays auslesen oder verändern können. Dazu verwendet man die eckigen Klammern:

int[] arTestSDim = {0, 1, 2, 3};
int n = arTestSDim[3];

Um die Verwendung eines eindimensionalen Arrays zu verdeutlichen, habe ich eine (von vielen) Varianten zur Errechnung der Primzahlen implementiert. Die Primzahlen werden im Array arPrimZ gespeichert, und der Einfachheit halber werden nur die ersten fünfzig gesucht. Wer möchte, kann ein Eingabeformular für die Anzahl der zu suchenden Primzahlen hinzufügen.

<% @Page Language="C#" %>
<%
const int nLimit = 50;
long[] arPrimZ = new long[nLimit];
arPrimZ[0] = 2;

long nTest = 1;		// Zahl die auf Primzahl getestet werden soll
int nAnzahl = 1;	// Anzahl der bis jetzt gefundenen Primzahlen
bool bTeilbar = false;	// Boolsche Variable für die Schleife

do
{
	nTest += 2;

	for(int i=0; i < nAnzahl; i++)
	{
		bTeilbar = (0 == (nTest % arPrimZ[i]));
		if (true == bTeilbar)
			break;
	}

	// falls es nicht teilbar war, dann
	// ist eine Primzahl
	if (false == bTeilbar)
	{
		arPrimZ[nAnzahl] = nTest;
		nAnzahl++;
	}
} 
while(nAnzahl < nLimit);

// Ausgabe der Primzahlen
Response.Write("<table border=1><tr>\r\n");
for(int i=0; i < nLimit; i++)
{
	if (0 == (i % 6))
		Response.Write("</tr>\r\n<tr>");
	Response.Write("<td>" + arPrimZ[i].ToString() + "</td>");
}
Response.Write("</tr></table>\r\n");
%>

Wie gesagt eine von vielen Varianten, Primzahlen zu berechnen.

Mehrdimensionale Arrays

Mehrdimensionale Arrays sind nicht wirklich schwieriger zu handhaben als eindimensionale - einzig und allein die Syntax ändert sich. Die Deklaration zum Beispiel sieht wie folgt aus:

int[,] arTestMDim;

Instanziert wird das mehrdimensionale Array-Objekt wie folgt:

arTestMDim = new int[4,5];
// oder in einer Zeile geht es auch
int[,] arTestMDim2 = new int[4,5];

Der Zugriff auf einzelne Elemente des Arrays funktioniert so:

arTestMDim[0, 0] = 5;
Console.WriteLine(arTestMDim[0, 0].ToString());

Arrays von Arrays (Jagged-Arrays)

Nun kommen wir zum letzten Arraytyp - dem Jagged Array. Dies ist ein Array, das andere Arrays aufnehmen kann. Deklariert wird ein solches wie folgt:

byte[] [] arTestJagAr;

Die Instanzierung erfolgt wie gewohnt (erste Zeile), allerdings müssen dann die Unter-Arrays ebenfalls nach Wunsch angelegt werden:

byte[] [] arTestJagAr = new byte[4] [];
for(int n = 0; x < arTestJagAr.Length; n++)
{
	arTestJagAr[n] = new byte[3];
}

Schlußbemerkung

Der vorliegende Artikel umreißt natürlich nur die Grundlagen von Arrays. Diese Grundlagen sollen einerseits das Konzept und die Verwendung von Arrays veranschaulichen und andererseits den Umstieg von einer anderen Programmiersprache zu C# erleichtern. Durch die neuen Möglichkeiten der System.Array Klasse in C#, hat der Programmierer ein mächtiges Werkzeug bekommen.

Weitere Artikel werden sich mit dynamisch vergrößer- oder verkleinerbaren Arrays beschäftigen, sowie die Methoden und Eigenschaften der System.Array Klasse genauer unter die Lupe nehmen.