web-dev-qa-db-fra.com

ArrayList vs List <> en C #

Quelle est la différence entre ArrayList et List<> en C #?

Est-ce seulement que List<> a un type alors que ArrayList n'en a pas?

c#.netlistgenericsarraylist
371
scatman

Oui, à peu près. List<T> est une classe générique. Il prend en charge le stockage de valeurs d'un type spécifique sans transtyper vers ou depuis object (ce qui aurait entraîné un surcoût de boxing/unboxing lorsque T est un type de valeur dans le cas ArrayList.). ArrayList enregistre simplement object références. En tant que collection générique, List<T> implémente l'interface générique IEnumerable<T> et peut être utilisé facilement dans LINQ (sans nécessiter d'appel Cast ni OfType.).

ArrayList appartient aux jours où C # n'avait pas de génériques. Il est déconseillé en faveur de List<T>. Vous ne devez pas utiliser ArrayList dans le nouveau code ciblant .NET> = 2.0, à moins que vous n'ayez à vous connecter à une ancienne API qui l'utilise.

492
Mehrdad Afshari

En utilisant List<T>, vous pouvez éviter les erreurs de transtypage. Il est très utile d'éviter une erreur de transtypage à l'exécution .

Exemple:

Ici (en utilisant ArrayList) vous pouvez compiler ce code mais vous verrez une erreur d’exécution plus tard.

ArrayList array1 = new ArrayList();
array1.Add(1);
array1.Add("Pony"); //No error at compile process
int total = 0;
foreach (int num in array1)
{
 total += num; //-->Runtime Error
}

Si vous utilisez List, vous évitez les erreurs suivantes:

List<int> list1 = new List<int>();
list1.Add(1);
//list1.Add("Pony"); //<-- Error at compile process
int total = 0;
foreach (int num in list1 )
{
 total += num;
}

Référence: MSDN

96
termas

Pour ajouter aux points ci-dessus. L'utilisation de ArrayList dans un système d'exploitation 64 bits nécessite 2 fois plus de mémoire que pour une utilisation dans le système d'exploitation 32 bits. Pendant ce temps, la liste générique List<T> utilisera beaucoup plus de mémoire que la ArrayList.

par exemple, si nous utilisons un ArrayList de 19 Mo en 32 bits, il faudrait 39 Mo en 64 bits. Mais si vous avez une liste générique List<int> de 8 Mo en 32 bits, cela ne prend que 8,1 Mo en 64 bits, ce qui représente une différence flagrante de 481% par rapport à ArrayList.

Source: Liste ArrayList vs générique pour les types primitifs et 64 bits

23
Anoop

Une autre différence à ajouter concerne la synchronisation des threads.

ArrayList fournit une sécurité de thread par le biais de la propriété Synchronized, qui renvoie un wrapper de thread-safe autour de la collection. Le wrapper fonctionne en verrouillant toute la collection à chaque opération d'ajout ou de suppression. Par conséquent, chaque thread qui tente d'accéder à la collection doit attendre son tour pour prendre le même verrou. Ce n'est pas évolutif et peut entraîner une dégradation significative des performances pour les grandes collections.

List<T> ne fournit aucune synchronisation de thread; Le code utilisateur doit fournir toute la synchronisation lorsque des éléments sont ajoutés ou supprimés simultanément sur plusieurs threads.

Plus d'infos ici Synchronisation des threads dans le .Net Framework

18
NullReference

La réponse simple est,

ArrayList n'est pas générique

  • C'est un type d'objet, vous pouvez donc y stocker n'importe quel type de données.
  • Vous pouvez stocker toutes les valeurs (type de valeur ou type de référence) telles que chaîne, int, employé et objet dans ArrayList. (Note et)
  • La boxe et le déballage vont arriver.
  • Pas le coffre-fort.
  • Il est plus vieux.

La liste est générique

  • C'est un type de type, vous pouvez donc spécifier le T au moment de l'exécution.
  • Vous pouvez stocker une seule valeur de type T (chaîne ou int ou employé ou objet) en fonction de la déclaration. (Note ou)
  • La boxe et le déballage ne se produiront pas.
  • Tapez safe.
  • C'est plus récent.

Exemple:

ArrayList arrayList = new ArrayList();
List<int> list = new List<int>();

arrayList.Add(1);
arrayList.Add("String");
arrayList.Add(new object());


list.Add(1);
list.Add("String");                 // Compile-time Error
list.Add(new object());             // Compile-time Error

Veuillez lire le document officiel Microsoft : https://blogs.msdn.Microsoft.com/kcwalina/2005/09/23/system -collections-vs-system-collection-generic-and-system-collections-objectmodel /

enter image description here

Remarque : Vous devez connaître les génériques avant de comprendre la différence: https://docs.Microsoft.com/en-us/dotnet/csharp/guide de programmation/génériques /

7
Aravin

ArrayList ne sont pas de type sûr alors que List<T> sont de type sûr. Facile :).

3
Hassan Rahman

ArrayList est la collection de données de types différents alors que List<> est la collection de types similaires de ses propres dépendances.

3
Law Kant Dayal

Je pense que les différences entre ArrayList et List<T> sont les suivantes:

  1. List<T>, où T est le type de valeur plus rapide que ArrayList. Ceci est dû au fait que List<T> évite la boxing/unboxing (où T est value-type).
  2. De nombreuses sources disent - généralement ArrayList utilisé uniquement pour des raisons de compatibilité ascendante. (Ce n'est pas une vraie différence, mais je pense que c'est une note importante).
  3. La réflexion est plus facile avec les non-génériques ArrayList puis List<T>

  4. ArrayList a la propriété IsSynchronized. Donc, il est facile de créer et d’utiliser Syncronised ArrayList. Je n'ai pas trouvé la propriété IsSynchronized pour List<T>. N'oubliez pas non plus que ce type de synchronisation est relativement inefficace, msdn ):

    var arraylist = new ArrayList();
var arrayListSyncronized = ArrayList.Synchronized(arraylist
Console.WriteLine($"syncronized {arraylist.IsSynchronized}");
Console.WriteLine($"syncronized {arrayListSyncronized.IsSynchronized}");

var list = new List<object>();
var listSyncronized = ArrayList.Synchronized(list);
Console.WriteLine($"syncronized {list.IsSynchronized}");//error, no such prop
Console.WriteLine($"syncronized {list.IsSynchronized}");//error, no such prop

  5. ArrayList possède la propriété ArrayList.SyncRoot qui peut être utilisée pour la synchronisation ( msdn ). List<T> n'a pas la propriété SyncRoot, donc dans la construction suivante, vous devez utiliser un objet si vous utilisez List<T>:

    ArrayList myCollection = new ArrayList();
lock(myCollection.SyncRoot) //  ofcourse you can use another object for this goal
{
    foreach (object item in myCollection)
    {
        // ...
    }
}
1
burzhuy