| auteurs : cardi, tomlev |
La classe BitArray permet de stocker une liste de valeurs booléennes (« vrai » - « faux ») :
BitArray monTableauBits = new BitArray (3 );
monTableauBits[ 1 ] = true ;
foreach (bool curBool in monTableauBits)
Console. WriteLine (" Valeur : {0} " , curBool);
|
|
lien : System.Collections.BitArray (MSDN)
|
| auteurs : cardi, tomlev |
La classe Queue vous permet de stocker une liste d'objets et de les retirer avec la technique FIFO (First In First Out) - Premier arrivé, premier retiré - tout simplement comme une file.
Queue maFile = new Queue ();
maFile. Enqueue (" Bonjour " );
maFile. Enqueue (" Au revoir " );
Console. WriteLine (" Valeur {0} " , maFile. Dequeue ());
Console. WriteLine (" Valeur {0} " , maFile. Dequeue ());
|
Depuis .NET 2.0, il existe également une version générique de la classe Queue : System.Collections.Generic.Queue<T>, ce qui permet d'avoir une file fortement typée.
|
lien : System.Collections.Queue (MSDN)
lien : System.Collections.Generic.Queue<T> (MSDN)
|
| auteurs : cardi, tomlev |
La classe Stack vous permet de stocker une liste d'objets et de les récupérer avec la technique LIFO (Last In First Out) - Dernier arrivé, premier retiré - tout simplement comme une pile.
Stack maPile = new Stack ();
maPile. Push (5 );
maPile. Push (10 );
Console. WriteLine (" Valeur {0} " , maPile. Pop ());
Console. WriteLine (" Valeur {0} " , maPile. Pop ());
|
Depuis .NET 2.0, il existe également une version générique de la classe Stack : System.Collections.Generic.Stack<T>, ce qui permet d'avoir une pile fortement typée.
|
lien : System.Collections.Stack (MSDN)
lien : System.Collections.Generic.Stack<T> (MSDN)
|
| auteur : tomlev |
Un dictionnaire (aussi appelé table de hachage) est une collection qui associe une clé unique à chaque élément. On peut ensuite accéder à cet élément via sa clé.
Le .NET Framework fournit plusieurs implémentations de ce type de collection, la plus couramment utilisée est la classe générique Dictionary<TKey, TValue>,
qui s'utilise de la manière suivante :
Dictionary< string , int > dict = new Dictionary< string , int > ();
dict. Add (" foo " , 42 );
dict. Add (" bar " , 123 );
dict. Add (" foo " , 456 );
int foo = dict[ " foo " ] ;
int bar = dict[ " bar " ] ;
int toto = dict[ " toto " ] ;
|
On peut également remplacer un élément du dictionnaire de la façon suivante :
dict[ " foo " ] = 789 ;
dict[ " bar " ] = 987 ;
|
Notez qu'avec cette dernière écriture, si la clé n'existe pas dans le dictionnaire, elle est ajoutée et aucune erreur ne se produit.
Pour vérifier l'existence d'une clé dans le dictionnaire, on utilise la méthode ContainsKey :
if (dict. ContainsKey (" toto " ))
{
int toto = dict[ " toto " ] ;
}
|
Enfin, pour tester l'existence de la clé et récupérer la valeur en une seule opération, on peut utiliser la méthode TryGetValue :
int toto;
if (dict. TryGetValue (" toto " , out toto))
{
}
|
|
lien : Classe Dictionary<TKey, TValue> (MSDN)
|
| auteur : tomlev |
La première version de C# ne supportait pas les génériques, on utilisait donc des collections non génériques, telles
que ArrayList ou Hashtable. Depuis la version 2, pour gérer des collections d'objets d'un certain type, il vaut mieux
utiliser des collections génériques telles que List<T> ou Dictionary<TKey, TValue>. Mais quels avantages
cela apporte-t-il ?
Une caractéristique intrinsèque des collections génériques est qu'elles sont fortement typées. Là où ArrayList
contenait des éléments de type Object, List<T> contient des éléments d'un type spécifique, ce qui évite d'avoir à
effectuer des conversions vers le type voulu. Comparez :
ArrayList list1 = new ArrayList ();
list1. Add (new Person (" John " , " Doe " ));
. . .
Person p1 = (Person)list1[ 0 ] ;
List< Person> list2 = new List< Person> ();
list2. Add (new Person (" Luke " , " Skywalker " ))
. . .
Person p2 = list2[ 0 ] ;
|
En plus de cet avantage d'ordre pratique, il y en a un autre beaucoup plus important : il est impossible d'ajouter à une List<T>
un objet dont le type ne correspond pas à celui défini dans la déclaration de la liste. Avec une ArrayList supposée contenir des éléments
de type X, il est facile d'ajouter par erreur un objet de type Y, puisque la méthode Add prend en paramètre n'importe quel objet :
ArrayList list = new ArrayList ();
list. Add (new Person (" Lara " , " Croft " ));
. . .
list. Add (new Animal (" Flipper le dauphin " ));
. . .
Person p1 = (Person)list[ 0 ] ;
Person p2 = (Person)list[ 1 ] ;
|
Avec une collection générique, ce type d'erreur est détecté dès la compilation : en effet la méthode Add de List<T> prend
en paramètre un objet de type Person, et le compilateur refusera donc de lui passer un objet de type Animal.
|
Consultez les autres F.A.Q's
Les sources présentés sur cette page sont libres de droits,
et vous pouvez les utiliser à votre convenance. Par contre cette page de présentation de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs.
Copyright ©2010
Developpez LLC. Tous droits réservés Developpez LLC.
Aucune reproduction, même partielle, ne peut être faite de ce site et de
l'ensemble de son contenu : textes, documents et images sans l'autorisation
expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à 3 ans
de prison et jusqu'à 300 000 E de dommages et intérêts.
Cette page est déposée à la SACD.
|