C# Language
Arrays

Syntax

• Ein Array deklarieren:

  <Typ> [] <Name>;

• Zweidimensionales Array deklarieren:

  <Typ> [,] <Name> = neuer <Typ> [<Wert>, <Wert>];

• Deklarieren eines gezackten Arrays:

  <Typ> [] <Name> = neuer <Typ> [<Wert>];

• Unterfeld für ein gezacktes Array deklarieren:

  <Name> [<Wert>] = neuer <Typ> [<Wert>];

• Ein Array ohne Werte initialisieren:

  <Name> = neuer <Typ> [<Länge>];

• Ein Array mit Werten initialisieren:

  <Name> = neuer <Typ> [] {<Wert>, <Wert>, <Wert>, ...};

• Initialisieren eines zweidimensionalen Arrays mit Werten:

  <Name> = neuer <Typ> [,] {{<Wert>, <Wert>}, {<Wert>, <Wert>}, ...};

• Zugriff auf ein Element am Index i:

  <name> [i]

• Länge des Arrays erhalten:

  <name> .Länge

Bemerkungen

Array-Kovarianz

string[] strings = new[] {"foo", "bar"};
object[] objects = strings; // implicit conversion from string[] to object[]

Diese Konvertierung ist nicht typsicher. Der folgende Code löst eine Laufzeitausnahme aus:

string[] strings = new[] {"Foo"};
object[] objects = strings;

objects[0] = new object(); // runtime exception, object is not string
string str = strings[0];   // would have been bad if above assignment had succeeded

Array-Werte abrufen und einstellen

int[] arr = new int[] { 0, 10, 20, 30}; 

// Get 
Console.WriteLine(arr[2]); // 20

// Set 
arr[2] = 100;

// Get the updated value
Console.WriteLine(arr[2]); // 100

Array deklarieren

Ein Array kann mithilfe der Initialisierungssyntax für eckige Klammern ( [] ) deklariert und mit dem Standardwert gefüllt werden. Beispiel: Erstellen eines Arrays von 10 Ganzzahlen:

int[] arr = new int[10];

Indizes in C # sind nullbasiert. Die Indizes des obigen Arrays sind 0-9. Zum Beispiel:

int[] arr = new int[3] {7,9,4};
Console.WriteLine(arr[0]); //outputs 7
Console.WriteLine(arr[1]); //outputs 9

Das heißt, das System beginnt den Elementindex ab 0 zu zählen. Zugriffe auf Elemente von Arrays erfolgen in konstanter Zeit . Das bedeutet, dass der Zugriff auf das erste Element des Arrays (zeitlich) die gleichen Kosten für den Zugriff auf das zweite Element, das dritte Element usw. verursacht.

Sie können auch einen bloßen Verweis auf ein Array angeben, ohne ein Array zu instantiieren.

int[] arr = null;   // OK, declares a null reference to an array.
int first = arr[0]; // Throws System.NullReferenceException because there is no actual array.

Ein Array kann auch mit benutzerdefinierten Werten unter Verwendung der Erfassungsinitialisierungssyntax erstellt und initialisiert werden:

int[] arr = new int[] { 24, 2, 13, 47, 45 };

Der new int[] -Abschnitt kann bei der Deklaration einer Array-Variablen weggelassen werden. Dies ist kein in sich geschlossener Ausdruck , daher kann es nicht als Teil eines anderen Aufrufs verwendet werden (verwenden Sie dazu die Version mit new ):

int[] arr = { 24, 2, 13, 47, 45 };  // OK
int[] arr1;
arr1 = { 24, 2, 13, 47, 45 };       // Won't compile

Implizit typisierte Arrays

Alternativ kann in Kombination mit dem Schlüsselwort var der bestimmte Typ weggelassen werden, so dass auf den Typ des Arrays geschlossen wird:

// same as int[]
var arr = new [] { 1, 2, 3 };
// same as string[]
var arr = new [] { "one", "two", "three" };
// same as double[]
var arr = new [] { 1.0, 2.0, 3.0 };

Über ein Array iterieren

int[] arr = new int[] {1, 6, 3, 3, 9};

for (int i = 0; i < arr.Length; i++) 
{
    Console.WriteLine(arr[i]);
}

foreach verwenden:

foreach (int element in arr) 
{
    Console.WriteLine(element);
}

mit unsicherem Zugang mit Zeigern https://msdn.microsoft.com/en-ca/library/y31yhkeb.aspx

unsafe
{
    int length = arr.Length;
    fixed (int* p = arr)
    {
        int* pInt = p;
        while (length-- > 0)
        {
            Console.WriteLine(*pInt);
            pInt++;// move pointer to next element
        }
    }
}

Ausgabe:

1
6
3
3
9

Mehrdimensionale Arrays

Arrays können mehr als eine Dimension haben. Im folgenden Beispiel wird ein zweidimensionales Array mit zehn Zeilen und zehn Spalten erstellt:

int[,] arr = new int[10, 10];

Ein Array von drei Dimensionen:

int[,,] arr = new int[10, 10, 10];

Sie können das Array auch bei der Deklaration initialisieren:

int[,] arr = new int[4, 2] { {1, 1}, {2, 2}, {3, 3}, {4, 4} };

// Access a member of the multi-dimensional array:
Console.Out.WriteLine(arr[3, 1]);  // 4

Gezackte Arrays

Gezackte Arrays sind Arrays, die anstelle von primitiven Typen Arrays (oder andere Sammlungen) enthalten. Es ist wie ein Array von Arrays - jedes Array-Element enthält ein anderes Array.

Sie ähneln mehrdimensionalen Arrays, unterscheiden sich jedoch geringfügig - da multidimensionale Arrays auf eine feste Anzahl von Zeilen und Spalten beschränkt sind und bei gezackten Arrays kann jede Zeile eine andere Anzahl von Spalten haben.

Deklarieren eines gezackten Arrays

Beispiel: Deklarieren eines gezackten Arrays mit 8 Spalten:

int[][] a = new int[8][];

Das zweite [] wird ohne Nummer initialisiert. Um die Sub-Arrays zu initialisieren, müssen Sie dies separat tun:

for (int i = 0; i < a.length; i++) 
{
    a[i] = new int[10];
}

Werte einstellen / einstellen

Nun ist es ganz einfach, eines der Subarrays zu bekommen. Lassen Sie uns alle Zahlen der 3. Spalte von a ausdrucken:

for (int i = 0; i < a[2].length; i++)
{
    Console.WriteLine(a[2][i]);
}

Einen bestimmten Wert erhalten:

a[<row_number>][<column_number>]

Einen bestimmten Wert einstellen:

a[<row_number>][<column_number>] = <value>

Denken Sie daran : Es wird immer empfohlen, gezackte Arrays (Arrays von Arrays) anstelle von mehrdimensionalen Arrays (Matrizen) zu verwenden. Die Verwendung ist schneller und sicherer.

Beachten Sie die Reihenfolge der Klammern

Betrachten Sie ein dreidimensionales Array von fünfdimensionalen Arrays von eindimensionalen Arrays von int . Dies ist in C # geschrieben als:

int[,,][,,,,][] arr = new int[8, 10, 12][,,,,][];

Im CLR-Typensystem ist die Konvention für die Anordnung der Klammern umgekehrt, so dass wir mit der obigen arr Instanz Folgendes haben:

    arr.GetType().ToString() == "System.Int32[][,,,,][,,]"

und ebenfalls:

    typeof(int[,,][,,,,][]).ToString() == "System.Int32[][,,,,][,,]"

Prüfen, ob ein Array ein anderes Array enthält

public static class ArrayHelpers
{
    public static bool Contains<T>(this T[] array, T[] candidate)
    {
        if (IsEmptyLocate(array, candidate))
            return false;

        if (candidate.Length > array.Length)
            return false;

        for (int a = 0; a <= array.Length - candidate.Length; a++)
        {
            if (array[a].Equals(candidate[0]))
            {
                int i = 0;
                for (; i < candidate.Length; i++)
                {
                    if (false == array[a + i].Equals(candidate[i]))
                        break;
                }
                if (i == candidate.Length)
                    return true;
            }
        }
        return false;
    }

    static bool IsEmptyLocate<T>(T[] array, T[] candidate)
    {
        return array == null
            || candidate == null
            || array.Length == 0
            || candidate.Length == 0
            || candidate.Length > array.Length;
    }
}

/// Probe

byte[] EndOfStream = Encoding.ASCII.GetBytes("---3141592---");
byte[] FakeReceivedFromStream = Encoding.ASCII.GetBytes("Hello, world!!!---3141592---");
if (FakeReceivedFromStream.Contains(EndOfStream))
{
    Console.WriteLine("Message received");
}

Initialisieren eines Arrays, das mit einem wiederholten, nicht standardmäßigen Wert gefüllt ist

Wie wir wissen, können wir ein Array mit Standardwerten deklarieren:

int[] arr = new int[10];

Dadurch wird ein Array mit 10 Ganzzahlen erstellt, wobei jedes Element des Arrays den Wert 0 (Standardwert des Typs int ) hat.

Um ein Array zu erstellen, das mit einem nicht standardmäßigen Wert initialisiert wurde, können Sie Enumerable.Repeat aus dem System.Linq Namespace verwenden:

1. So erstellen Sie ein bool Array der Größe 10, das mit "true" gefüllt ist

   bool[] booleanArray = Enumerable.Repeat(true, 10).ToArray(); 
   

2. So erstellen Sie ein int Array der Größe 5 mit "100"

   int[] intArray = Enumerable.Repeat(100, 5).ToArray();
   

3. So erstellen Sie ein string Array der Größe 5, das mit "C #" gefüllt ist

   string[] strArray = Enumerable.Repeat("C#", 5).ToArray();
   

Arrays kopieren

Kopieren eines Array.Copy() mit der statischen Array.Copy() Methode, beginnend bei Index 0 in Quelle und Ziel:

var sourceArray = new int[] { 11, 12, 3, 5, 2, 9, 28, 17 };
var destinationArray= new int[3];
Array.Copy(sourceArray, destinationArray, 3);

// destinationArray will have 11,12 and 3

Kopieren des gesamten Arrays mit der CopyTo() Instanzmethode, beginnend mit Index 0 der Quelle und dem angegebenen Index im Ziel:

var sourceArray = new int[] { 11, 12, 7 };
var destinationArray = new int[6];
sourceArray.CopyTo(destinationArray, 2);

// destinationArray will have 0, 0, 11, 12, 7 and 0

Clone wird verwendet, um eine Kopie eines Array-Objekts zu erstellen.

var sourceArray = new int[] { 11, 12, 7 };
var destinationArray = (int)sourceArray.Clone();

//destinationArray will be created and will have 11,12,17.

Sowohl CopyTo als auch Clone führen eine flache Kopie aus. CopyTo bedeutet, dass der Inhalt Verweise auf dasselbe Objekt wie die Elemente im ursprünglichen Array enthält.

Erstellen eines Arrays von fortlaufenden Nummern

LINQ stellt eine Methode bereit, mit der sich eine Sammlung mit fortlaufenden Nummern auf einfache Weise erstellen lässt. Sie können beispielsweise ein Array deklarieren, das die ganzen Zahlen zwischen 1 und 100 enthält.

Mit der Enumerable.Range Methode können Sie eine Sequenz von Ganzzahlen aus einer angegebenen Startposition und einer Anzahl von Elementen erstellen.

Die Methode akzeptiert zwei Argumente: den Startwert und die Anzahl der zu generierenden Elemente.

Enumerable.Range(int start, int count)

Beachten Sie, dass die count nicht negativ sein kann.

Verwendungszweck:

int[] sequence = Enumerable.Range(1, 100).ToArray();

Dadurch wird ein Array mit den Zahlen 1 bis 100 ( [1, 2, 3, ..., 98, 99, 100] ) erstellt.

Da die Range Methode ein IEnumerable<int> , können wir andere LINQ-Methoden verwenden:

int[] squares = Enumerable.Range(2, 10).Select(x => x * x).ToArray();

Dadurch wird ein Array mit 10 ganzzahligen Quadraten beginnend mit 4 generiert: [4, 9, 16, ..., 100, 121] .

Vergleich von Arrays auf Gleichheit

LINQ bietet eine integrierte Funktion zum Überprüfen der Gleichheit von zwei IEnumerable Funktion kann in Arrays verwendet werden.

Die SequenceEqual Funktion gibt true wenn die Arrays dieselbe Länge haben und die Werte in den entsprechenden Indizes gleich sind, andernfalls false .

int[] arr1 = { 3, 5, 7 };
int[] arr2 = { 3, 5, 7 };
bool result = arr1.SequenceEqual(arr2);
Console.WriteLine("Arrays equal? {0}", result);

Dies wird drucken:

Arrays equal? True

Arrays als IEnumerable <> -Instanzen

Alle Arrays implementieren die nicht generische IList Schnittstelle (und damit auch nicht generische ICollection und IEnumerable Basisschnittstellen).

Wichtiger ist, dass eindimensionale Arrays die generischen Schnittstellen IList<> und IReadOnlyList<> (und ihre Basisschnittstellen) für den darin enthaltenen Datentyp implementieren. Dies bedeutet, dass sie als generische aufzählbare Typen behandelt und an eine Vielzahl von Methoden übergeben werden können, ohne dass sie zuerst in eine Nicht-Array-Form konvertiert werden müssen.

int[] arr1 = { 3, 5, 7 };
IEnumerable<int> enumerableIntegers = arr1; //Allowed because arrays implement IEnumerable<T>
List<int> listOfIntegers = new List<int>();
listOfIntegers.AddRange(arr1); //You can pass in a reference to an array to populate a List.

Nach dem Ausführen dieses Codes enthält die Liste listOfIntegers eine List<int> mit den Werten 3, 5 und 7.

Die Unterstützung für IEnumerable<> bedeutet, dass Arrays mit LINQ abgefragt werden können, zum Beispiel arr1.Select(i => 10 * i) .