FAQ C#Consultez toutes les FAQ

Nombre d'auteurs : 39, nombre de questions : 272, dernière mise à jour : 24 mai 2015  Ajouter une question

 

Cette FAQ a été réalisée pour répondre aux questions les plus fréquemment posées concernant C# sur le forum Développement DotNET

Je tiens à souligner qu'elle ne garantit en aucun cas que les informations qu'elle contient sont correctes ; les auteurs font le maximum, mais l'erreur est humaine. Si vous trouvez une erreur, ou que vous souhaitez devenir rédacteur, lisez ceci .

Sur ce, je vous souhaite une bonne lecture.

Commentez cette FAQ : Commentez


Sommaire.NET FrameworkCollections (5)
précédent sommaire suivant
 

La classe BitArray permet de stocker une liste de valeurs booléennes (« vrai » - « faux ») :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
// Création du tableau de 3 bits 
// Les 3 valeurs sont initialisées à false 
BitArray monTableauBits = new BitArray(3); 
  
// Accès à l'index 1 
monTableauBits[1] = true; 
  
// Affiche false, true puis false 
foreach (bool curBool in monTableauBits) 
    Console.WriteLine("Valeur : {0}", curBool);

Mis à jour le 2 janvier 2007 Jérôme Lambert 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.

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
      // Création de la file 
      Queue maFile = new Queue(); 
  
      // Ajout de 2 chaines de caractères 
      maFile.Enqueue("Bonjour"); 
      maFile.Enqueue("Au revoir"); 
  
      // Affiche succesivement "Bonjour" puis "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.

Mis à jour le 2 janvier 2007 Jérôme Lambert 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.

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
// Création de la pile 
Stack maPile = new Stack(); 
  
// Ajout de 2 entiers 
maPile.Push(5); 
maPile.Push(10); 
  
// Affiche succesivement 10 puis 5 
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.

Mis à jour le 2 janvier 2007 Jérôme Lambert 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 :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Dictionnaire utilisant une clé de type string, et dont les valeurs sont de type int 
Dictionary<string, int> dict = new Dictionary<string, int>(); 
  
// Ajout d'éléments au dictionnaire : 
dict.Add("foo", 42); 
dict.Add("bar", 123); 
  
// Erreur, la clé existe déjà ! 
dict.Add("foo", 456); 
  
// Récupération d'un élément du dictionnaire 
int foo = dict["foo"]; 
int bar = dict["bar"]; 
  
// Erreur, la clé n'existe pas ! 
int toto = dict["toto"];
On peut également remplacer un élément du dictionnaire de la façon suivante :

Code c# : Sélectionner tout
1
2
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 :

Code c# : Sélectionner tout
1
2
3
4
5
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 :

Code c# : Sélectionner tout
1
2
3
4
5
int toto; 
if (dict.TryGetValue("toto", out toto)) 
{ 
    // ... 
}

Mis à jour le 8 mars 2010 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 :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
// ArrayList 
ArrayList list1 = new ArrayList(); 
list1.Add(new Person("John", "Doe")); 
... 
// list1[0] renvoie un Object, il faut donc faire un cast pour récupérer une Person 
Person p1 = (Person)list1[0]; 
  
// List<T> 
List<Person> list2 = new List<Person>(); 
list2.Add(new Person("Luke", "Skywalker")) 
... 
// list2[0] renvoie directement un objet de type Person, pas de cast nécessaire 
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 :

Code c# : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
ArrayList list = new ArrayList(); 
list.Add(new Person("Lara", "Croft")); 
  
... 
  
// Pas d'erreur pour l'instant... 
list.Add(new Animal("Flipper le dauphin")); 
  
... 
  
Person p1 = (Person)list[0]; 
// Erreur : cet élément est un Animal, et ne peut pas être converti en Person ! 
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.

Mis à jour le 8 mars 2010 tomlev

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2017 Developpez 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'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsable bénévole de la rubrique Microsoft DotNET : Hinault Romaric -