ArrayList vs List en C #

¿Cuál es la diferencia entre ArrayList y List en C #?

¿Es solo que List tiene un tipo mientras ArrayList no?

Sí, más o menos. List es una clase genérica. Admite el almacenamiento de valores de un tipo específico sin conversión desde o hacia el object (lo que habría generado una sobrecarga de boxeo / unboxing cuando T es un tipo de valor en el caso de ArrayList ). ArrayList simplemente almacena referencias de object . Como una colección genérica, List implementa la IEnumerable genérica IEnumerable y se puede usar fácilmente en LINQ (sin requerir ninguna llamada de Cast o OfType ).

ArrayList pertenece a los días en que C # no tenía generics. Está en desuso en favor de List . No debe usar ArrayList en un código nuevo que se dirija a .NET> = 2.0 a menos que tenga que interactuar con una API anterior que lo use.

Usando List puedes evitar errores de conversión. Es muy útil para evitar un error de lanzamiento de tiempo de ejecución .

Ejemplo:

Aquí (usando ArrayList ) puede comstackr este código pero verá un error de ejecución más adelante.

 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 usa List , evita estos errores:

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

Referencia: MSDN

Para agregar a los puntos anteriores. El uso de ArrayList en el sistema operativo de 64 bits requiere una memoria 2 veces mayor que el uso en el sistema operativo de 32 bits. Mientras tanto, la lista genérica List usará mucha memoria baja que la ArrayList .

por ejemplo, si usamos una ArrayList de 19MB en 32 bits, tomaría 39MB en la de 64 bits. Pero si tiene una lista genérica List de 8 MB en 32 bits, solo tomaría 8.1 MB en 64 bits, que es una diferencia de 481% al compararla con ArrayList.

Fuente: ArrayList vs. Lista genérica para tipos primitivos y 64 bits

Otra diferencia para agregar es con respecto a la sincronización de subprocesos.

ArrayList proporciona seguridad de subprocesos a través de la propiedad Sincronizada, que devuelve un envoltorio seguro para subprocesos alrededor de la colección. El contenedor funciona bloqueando la colección completa en cada operación de agregar o quitar. Por lo tanto, cada subproceso que intenta acceder a la colección debe esperar su turno para tomar el único locking. Esto no es escalable y puede causar una degradación significativa del rendimiento para colecciones grandes.

List no proporciona ninguna sincronización de hilos; el código de usuario debe proporcionar toda la sincronización cuando los elementos se agregan o eliminan en múltiples hilos al mismo tiempo.

Más información aquí Sincronización de subprocesos en .Net Framework

ArrayList no es seguro, mientras que List son de tipo seguro. Sencillo :).

La respuesta simple es,

ArrayList no es genérico

  • Es un tipo de objeto, por lo que puede almacenar cualquier tipo de datos en él.
  • Puede almacenar cualquier valor (tipo de valor o tipo de referencia) tal string, int, employee y object en ArrayList. (Nota y)
  • Boxeo y Unboxing sucederán.
  • No escriba seguro.
  • Es más viejo.

La lista es genérica

  • Es un tipo de tipo, por lo que puede especificar la T en tiempo de ejecución.
  • Puede almacenar un único valor de Tipo T (cadena o int o empleado u objeto) basado en la statement. (Nota o)
  • Boxeo y Unboxing no sucederán.
  • Escriba seguro.
  • Es mas nuevo

Ejemplo:

 ArrayList arrayList = new ArrayList(); List list = new List(); 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 

Lea el documento oficial de Microsoft : https://blogs.msdn.microsoft.com/kcwalina/2005/09/23/system-collections-vs-system-collection-generic-and-system-collections-objectmodel/

enter image description here

Nota : Debe conocer los generics antes de comprender la diferencia: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/generics/

ArrayList es la colección de datos de diferentes tipos, mientras que List<> es la colección de tipos similares de sus propias dependencias.

Creo que las diferencias entre ArrayList y List son:

  1. List , donde T es value-type es más rápido que ArrayList . Esto se debe a que List evita el boxeo / unboxing (donde T es el tipo de valor).
  2. Muchas fonts dicen que, por lo general, ArrayList solo se usa para compatibilidad con versiones anteriores. (No es una diferencia real, pero creo que es una nota importante).
  3. La reflexión es más fácil con ArrayList genérica y luego con List
  4. ArrayList tiene la propiedad IsSynchronized . Por lo tanto, es fácil crear y utilizar ArrayList sincronizado. No encontré la propiedad IsSynchronized para List . También tenga en cuenta que este tipo de sincronización es relativamente ineficiente, msdn ):

     var arraylist = new ArrayList(); var arrayListSyncronized = ArrayList.Synchronized(arraylist Console.WriteLine($"syncronized {arraylist.IsSynchronized}"); Console.WriteLine($"syncronized {arrayListSyncronized.IsSynchronized}"); var list = new List(); 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 tiene la propiedad ArrayList.SyncRoot que se puede usar para la sincronización ( msdn ). List no SyncRoot propiedad SyncRoot , por lo que en la siguiente construcción necesita usar algún objeto si usa List :

     ArrayList myCollection = new ArrayList(); lock(myCollection.SyncRoot) // ofcourse you can use another object for this goal { foreach (object item in myCollection) { // ... } } 
  • ArrayList no tiene restricción de tipo para almacenar datos, es decir, no es Type Safe. Puede almacenar cualquier cosa en ArrayList. De hecho, el mismo ArrayList puede almacenar múltiples tipos de objetos.
  • En la Lista genérica (Lista), T significa tipo de datos, es decir, cadena, int, DateTime, etc. Por lo tanto, solo almacenará tipos específicos de objetos según el tipo de datos que se haya especificado en las declaraciones, es decir, Tipo Safe. Por lo tanto, si tiene una lista genérica de cadenas, solo puede almacenar valores de cadena, cualquier otra cosa dará error de comstackción. Recuperar los datos también es sencillo y no se requieren conversiones de tipo

Usando “Lista” puede evitar errores de lanzamiento. Es muy útil para evitar un error de lanzamiento de tiempo de ejecución.

Ejemplo:

Aquí (usando ArrayList) puede comstackr este código pero verá un error de ejecución más adelante.

  // 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. } } 

Para mí, todo se trata de conocer tus datos. Si continúo expandiendo mi código sobre la base de la eficiencia, tendría que elegir la opción Lista como una forma de descifrar mis datos sin el paso innecesario de siempre preguntar acerca de los tipos, especialmente ‘Tipos personalizados’. Si la máquina entiende la diferencia y puede determinar de qué tipo de datos estoy tratando, ¿por qué debería interferir y perder el tiempo yendo a través de los giros de las determinaciones ‘IF THEN ELSE’? Mi filosofía es dejar que la máquina trabaje para mí en lugar de que yo trabaje en la máquina. Conocer las diferencias únicas de los diferentes comandos de código objeto hace que su código sea eficiente.

Tom Johnson (una entrada … una salida)

No es solo una diferencia. Se puede acceder a los miembros de ArrayList a través del índice como arreglos ordinarios y también los miembros ArrayList pueden ordenarse fácilmente en orden directo e inverso y dos ArrayList se pueden fusionar fácilmente, que no es el caso con Simple List. Ver más en

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