ArrayList vs List en C#

En utilisant List<T>, Vous pouvez éviter les erreurs de coulée. Il est très utile d'éviter une erreurruntime casting.

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 éviter ces erreurs:

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

Pour ajouter aux points ci-dessus. L'utilisation de ArrayList dans le système d'exploitation 64 bits prend 2 fois la mémoire que l'utilisation dans le système d'exploitation 32 bits. Pendant ce temps, la liste générique List<T> utilisera beaucoup de mémoire faible que le 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 prendrait que 8,1 Mo en 64 bits, ce qui représente une différence de 481% par rapport à ArrayList.

Source: ArrayList du vs générique Liste des types primitifs et 64 bits

Une autre différence à ajouter est en ce qui concerne la synchronisation des threads.

ArrayList fournit une sécurité thread via la propriété Synchronized, qui renvoie un wrapper thread-safe autour de la collection. Le wrapper fonctionne en verrouillant la collection entière à 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 une serrure. Ceci n'est pas évolutif et peut entraîner une dégradation significative des performances pour de 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'informations ici synchronisation des threads dans le Framework. net

ArrayList ne sont pas de type sécuritaire alors que List<T> sont de type sécuritaire. Simple :).

La réponse Simple est,

ArrayList est Non 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 string, int, employee et object dans ArrayList. (Note et)
• la boxe et le déballage se produiront.
• Pas de type sûr.
• Il est plus ancien.

La Liste est Générique

• c'est un Type de Type, donc vous pouvez spécifier le T sur 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. (Remarque ou)
• la boxe et le déballage n'auront pas lieu.
• Type coffre-fort.
• 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 de Microsoft : https://blogs.msdn.microsoft.com/kcwalina/2005/09/23/system-collections-vs-system-collection-generic-and-system-collections-objectmodel/

Note: Vous devez savoir Génériques avant de comprendre la différence: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/generics/

ArrayList est la collection de différents types de données alors que List<> est la collection de type similaire de ses propres depedencties.

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

1. List<T>, Où T est valeur-type est plus rapide que ArrayList. C'est parce que List<T> évite la boxe/unboxing (où T est value-type).
2. de nombreuses sources disent - généralement ArrayList utilisé juste pour l'arrière compatibilité. (n'est pas une réelle différence, mais je pense que c'est remarque importante).
3. la réflexion est plus facile avec nongeneric ArrayList puis List<T>

4. ArrayList a IsSynchronized la propriété. Donc, Il est facile créer et utiliser syncronisé ArrayList. Je n'ai pas trouvé la propriété IsSynchronized pour List<T>. Gardez également à l'esprit 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 syncronisation ( msdn ). List<T> n'a pas de 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)
       {
           // ...
       }
   }
   

• ArrayList n'a pas de restriction de type pour stocker des données, c'est-à-dire qu'il N'est pas sûr de Type. Vous pouvez stocker n'importe quoi dans ArrayList. En fait même ArrayList peut stocker plusieurs types d'objets.
• dans la liste générique (liste), T signifie type de données, c'est-à-dire chaîne, int, DateTime, etc. Ainsi, il ne stockera que des types spécifiques d'objets en fonction du type de données spécifié alors que les déclarations, c'est-à-dire Qu'il est sécurisé. Ainsi, si vous avez une liste générique de chaîne, vous ne pouvez stocker que des valeurs de chaîne, n'importe quoi else donnera une erreur de compilation. Récupérer les données est également sans tracas et aucune conversion de type requise

En utilisant "List", vous pouvez éviter les erreurs de coulée. Il est très utile d'éviter une erreur de casting d'exécution.

Exemple:

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

    // Create a new ArrayList


    System.Collections.ArrayList mixedList = new System.Collections.ArrayList();


    // Add some numbers to the list
    mixedList.Add(7);
    mixedList.Add(21);


    // Add some strings to the list
    mixedList.Add("Hello");
    mixedList.Add("This is going to be a problem");




    System.Collections.ArrayList intList = new System.Collections.ArrayList();
    System.Collections.ArrayList strList = new System.Collections.ArrayList();


    foreach (object obj in mixedList)
    {
        if (obj.GetType().Equals(typeof(int)))
        {
            intList.Add(obj);
        }
        else if (obj.GetType().Equals(typeof(string)))
        {
            strList.Add(obj);
        }
        else
        {
            // error.
        }
    }

Pour moi, il s'agit de connaître vos données. Si je continue à développer mon code sur la base de l'efficacité, je devrais choisir L'option de liste comme un moyen de déchiffrer mes données sans l'étape inutile de toujours s'interroger sur les types, en particulier les "types personnalisés". Si la machine comprend la différence et peut déterminer sur quel type de données je traite réellement, alors pourquoi devrais-je me mettre en travers et perdre du temps à passer par les girations des déterminations "IF THEN ELSE"? Mon la philosophie est de laisser la machine travailler pour moi au lieu de travailler sur la machine? Connaître les différences uniques de différentes commandes de code objet va un long chemin pour rendre votre code aussi efficace.

Tom Johnson (Une Seule Entrée ... Une Sortie)

Ce n'est pas seulement la différence. Les membres ArrayList sont accessibles via index comme les tableaux ordinaires et les membres ArrayList peuvent également être facilement triés dans l'ordre direct et inverse et deux ArrayList peuvent être facilement fusionnés, ce qui n'est pas le cas avec simple List. Voir plus sur

Http://www.cirvirlab.com/index.php/c-sharp-code-examples/112-c-sharp-arraylist-example.html