C# Language
arrays

Syntaxis

• Een array declareren:

  <type> [] <naam>;

• Tweedimensionale array verklaren:

  <type> [,] <naam> = nieuw <type> [<waarde>, <waarde>];

• Een gekartelde array verklaren:

  <type> [] <naam> = nieuw <type> [<waarde>];

• Een subarray voor een Jagged Array declareren:

  <naam> [<waarde>] = nieuw <type> [<waarde>];

• Een array zonder waarden initialiseren:

  <naam> = nieuw <type> [<lengte>];

• Een array met waarden initialiseren:

  <naam> = nieuw <type> [] {<waarde>, <waarde>, <waarde>, ...};

• Een tweedimensionale array met waarden initialiseren:

  <naam> = nieuw <type> [,] {{<waarde>, <waarde>}, {<waarde>, <waarde>}, ...};

• Toegang tot een element bij index i:

  <Name> [i]

• De lengte van de array verkrijgen:

  <Name> .length

Opmerkingen

Array covariantie

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

Deze conversie is niet typeveilig. De volgende code veroorzaakt een runtime-uitzondering:

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

Arraywaarden ophalen en instellen

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

Een array declareren

Een array kan worden gedeclareerd en gevuld met de standaardwaarde met behulp van initialisatie syntaxis van vierkante haakjes ( [] ). Bijvoorbeeld, een array van 10 gehele getallen maken:

int[] arr = new int[10];

Indices in C # zijn gebaseerd op nul. De indices van de bovenstaande array zijn 0-9. Bijvoorbeeld:

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

Dit betekent dat het systeem de elementindex begint te tellen vanaf 0. Bovendien worden toegangen tot elementen van arrays in constante tijd uitgevoerd . Dat betekent dat toegang tot het eerste element van de reeks dezelfde (tijd) kosten heeft voor toegang tot het tweede element, het derde element, enzovoort.

U kunt ook een duidelijke verwijzing naar een array declareren zonder een array te instantiëren.

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

Een array kan ook worden gemaakt en geïnitialiseerd met aangepaste waarden met behulp van de initialisatie-syntaxis van de collectie:

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

Het new int[] kan worden weggelaten bij het declareren van een arrayvariabele. Dit is geen zelfstandige uitdrukking , dus het gebruiken als onderdeel van een ander gesprek werkt niet (gebruik daarvoor de versie met new ):

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

Impliciet getypte arrays

Als alternatief kan in combinatie met het var trefwoord het specifieke type worden weggelaten, zodat het type van de array wordt afgeleid:

// 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 };

Herhaal over een array

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

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

met behulp van foreach:

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

onveilige toegang gebruiken met wijzers 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
        }
    }
}

Output:

1
6
3
3
9

Multi-dimensionale arrays

Arrays kunnen meer dan één dimensie hebben. In het volgende voorbeeld wordt een tweedimensionale array van tien rijen en tien kolommen gemaakt:

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

Een reeks van drie dimensies:

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

U kunt de array ook initialiseren na declaratie:

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

Jagged arrays

Jagged arrays zijn arrays die in plaats van primitieve typen arrays (of andere collecties) bevatten. Het is als een array van arrays - elk arrayelement bevat een andere array.

Ze zijn vergelijkbaar met multidimensionale arrays, maar hebben een klein verschil - omdat multidimensionale arrays beperkt zijn tot een vast aantal rijen en kolommen, met gekartelde arrays, kan elke rij een ander aantal kolommen hebben.

Een gekartelde array verklaren

Bijvoorbeeld, een gekartelde array met 8 kolommen declareren:

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

De tweede [] wordt geïnitialiseerd zonder een nummer. Om de subarrays te initialiseren, moet u dat afzonderlijk doen:

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

Waarden verkrijgen / instellen

Het is nu eenvoudig om een van de subreeksen te krijgen. Laten we alle nummers van de 3e kolom van a afdrukken:

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

Een specifieke waarde krijgen:

a[<row_number>][<column_number>]

Een specifieke waarde instellen:

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

Onthoud : het wordt altijd aanbevolen om gekartelde arrays (arrays of arrays) te gebruiken in plaats van multidimensionale arrays (matrixen). Het is sneller en veiliger in gebruik.

Let op de volgorde van de haakjes

Beschouw een driedimensionale reeks van vijf-dimensionale arrays van eendimensionale arrays van int . Dit staat in C # als:

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

In het CLR-type systeem is de conventie voor het bestellen van de beugels omgekeerd, dus met het bovenstaande arr exemplaar hebben we:

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

en evenzo:

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

Controleren of de ene array een andere array bevat

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;
    }
}

/// Voorbeeld

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

Een array initialiseren die is gevuld met een herhaalde niet-standaardwaarde

Zoals we weten, kunnen we een array met standaardwaarden declareren:

int[] arr = new int[10];

Hiermee maakt u een array van 10 gehele getallen waarbij elk element van de array waarde 0 (de standaardwaarde van het type int ).

Om een array te maken die is geïnitialiseerd met een niet-standaardwaarde, kunnen we Enumerable.Repeat van de System.Linq naamruimte gebruiken:

1. Om een bool array van maat 10 te maken gevuld met "true"

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

2. Een int array van maat 5 maken gevuld met "100"

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

3. Het creëren van een string reeks van maat 5 gevuld met "C #"

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

Arrays kopiëren

Een gedeeltelijke array kopiëren met de statische methode Array.Copy() , beginnend bij index 0 in zowel bron als bestemming:

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

De hele array kopiëren met de CopyTo() , beginnend bij index 0 van de bron en de opgegeven index in de bestemming:

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 wordt gebruikt om een kopie van een arrayobject te maken.

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

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

Zowel CopyTo als Clone voeren een ondiepe kopie uit, wat betekent dat de inhoud verwijzingen naar hetzelfde object bevat als de elementen in de oorspronkelijke array.

Een reeks opeenvolgende nummers maken

LINQ biedt een methode waarmee u eenvoudig een verzameling met opeenvolgende nummers kunt maken. U kunt bijvoorbeeld een array declareren die de gehele getallen tussen 1 en 100 bevat.

Met de methode Enumerable.Range kunnen we een reeks gehele getallen maken op basis van een opgegeven startpositie en een aantal elementen.

De methode heeft twee argumenten: de startwaarde en het aantal te genereren elementen.

Enumerable.Range(int start, int count)

Merk op dat het count niet negatief kan zijn.

Gebruik:

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

Dit genereert een array met de nummers 1 tot en met 100 ( [1, 2, 3, ..., 98, 99, 100] ).

Omdat de Range methode een IEnumerable<int> retourneert, kunnen we er andere LINQ-methoden op gebruiken:

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

Dit genereert een array met 10 gehele vierkanten beginnend bij 4 : [4, 9, 16, ..., 100, 121] .

Arrays vergelijken voor gelijkheid

LINQ biedt een ingebouwde functie voor het controleren van de gelijkheid van twee IEnumerable s, en die functie kan worden gebruikt op arrays.

De functie SequenceEqual retourneert true als de arrays dezelfde lengte hebben en de waarden in bijbehorende indices gelijk zijn en anders false .

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

Dit zal afdrukken:

Arrays equal? True

Arrays als IEnumerable <> instanties

Alle arrays implementeren de niet-generieke IList interface (en dus niet-generieke ICollection en IEnumerable base-interfaces).

Wat nog belangrijker is, is dat eendimensionale arrays de IList<> en IReadOnlyList<> generieke interfaces (en hun IReadOnlyList<> ) implementeren voor het type gegevens dat ze bevatten. Dit betekent dat ze kunnen worden behandeld als generieke soorten en kunnen worden doorgegeven aan een verscheidenheid aan methoden zonder ze eerst naar een niet-array-vorm te moeten converteren.

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.

Na het uitvoeren van deze code bevat de list listOfIntegers een List<int> met de waarden 3, 5 en 7.

De IEnumerable<> ondersteuning betekent dat arrays kunnen worden opgevraagd met LINQ, bijvoorbeeld arr1.Select(i => 10 * i) .