TOC

This article is currently in the process of being translated into French (~42% done).

Collections:

Arrays

Les tableaux fonctionnent comme des collections d'éléments (par exemple, comme une chaine de caractères) . Vous pouvez utiliser les tableaux pour regrouper un ensemble d'élements, et effectuer différentes opérations dessus (par exemple: les trier). De plus, un certain nombre de méthodes du Framework peuvent s'appliquer aux tableaux, rendant possible d'accepter un groupe d'éléments au lieu d'un seul. Ce seul fait rend important de comprendre les tableaux.

On déclare un tableau un peu comme une variable, avec des crochets [] après le datatype, comme ceci:

string[] names;

You need to instantiate the array to use it, which is done like this:

string[] names = new string[2];

Le nombre [2] est la taille du tableau. C'est-à-dire, le nombre d'éléments que l'on peut y mettre. Mettre des éléments dans le tableau se fait aussi très simplement:

names[0] = "John Doe";

Pourquoi 0? Comme très souvent dans le domaine de l'informatique, on commence à compter à partir de 0 et non de 1. C'est pourquoi le premier élément a un index de 0, le suivant de 1 et ainsi de suite. Vous devrez vous en souvenir lorsque vous remplirez le tableau, car ajouter des élements au delà de sa taille causera une "exception". Lorsque vous regardez la déclaration du tableau, où on a définit la taille à 2, il pourrait vous sembler naturel de mettre des éléments dans le tableau aux emplacements 0, 1 et 2. Mais c'est un de trop, et si vous faites ceci, une exception sera levée. Nous expliquerons les exceptions dans un prochain chapitre.

Précédemment, nous avons parlé des boucles, et clairement, elles sont très bien adaptées aux tableaux. La méthode la plus courante pour lire les données d'un tableau et de les parcourir grâce à une boucle, et d'effectuer un traitement sur chaque valeur lue. Reprenons notre tableau précédent, pour réaliser un exemple réaliste:

using System;
using System.Collections;

namespace ConsoleApplication1
{
    class Program
    {
static void Main(string[] args)
{
    string[] names = new string[2];

    names[0] = "John Doe";
    names[1] = "Jane Doe";

    foreach(string s in names)
Console.WriteLine(s);

    Console.ReadLine();
}
    }
}

Nous avons utilisé une boucle de type "foreach" car c'est la plus facile, mais nous aurions pu utiliser n'importe quel autre type de boucle à la place. La boucle "for" fonctionne aussi très bien avec les tableaux, par exemple lorsque vous avez besoin de compter les éléments lus:

for(int i = 0; i < names.Length; i++)
    Console.WriteLine("Item number " + i + ": " + names[i]);

It's actually very simple. We use the Length property of the array to decide how many times the loop should iterate, and then we use the counter (i) to output where we are in the process, as well as get the item from the array. Just like we used a number, a so called indexer, to put items into the array, we can use it to get a specific item out again.

I told you earlier that we could use an array to sort a range of values, and it's actually very easy. The Array class contains a bunch of smart methods for working with arrays. This example will use numbers instead of strings, just to try something else, but it could just as easily have been strings. I wish to show you another way of populating an array, which is much easier if you have a small, predefined set of items that you wish to put into your array. Take a look:

int[] numbers = new int[5] { 4, 3, 8, 0, 5 };

With one line, we have created an array with a size of 5, and filled it with 5 integers. By filling the array like this, you get an extra advantage, since the compiler will check and make sure that you don't put too many items into the array. Try adding a number more - you will see the compiler complain about it.

Actually, it can be done even shorter, like this:

int[] numbers = { 4, 3, 8, 0, 5 };

This is short, and you don't have to specify a size. The first approach may be easier to read later on though.

Let's try sorting the array - here's a complete example:

using System;
using System.Collections;

namespace ConsoleApplication1
{
    class Program
    {
static void Main(string[] args)
{
    int[] numbers = { 4, 3, 8, 0, 5 };

    Array.Sort(numbers);

    foreach(int i in numbers)
Console.WriteLine(i);

    Console.ReadLine();
}
    }
}

The only real new thing here is the Array.Sort command. It can take various parameters, for various kinds of sorting, but in this case, it simply takes our array. As you can see from the result, our array has been sorted. The Array class has other methods as well, for instance the Reverse() method. You can look it up in the documentation to see all the features of the Array class.

The arrays we have used so far have only had one dimension. However, C# arrays can be multidimensional, sometimes referred to as arrays in arrays. Multidimensional arrays come in two flavors with C#: Rectangular arrays and jagged arrays. The difference is that with rectangular arrays, all the dimensions have to be the same size, hence the name rectangular. A jagged array can have dimensions of various sizes. Multidimensional arrays are a heavy subject, and a bit out of the scope of this tutorial.

This article has been fully translated into the following languages: Is your preferred language not on the list? Click here to help us translate this article into your language!