c# - que - list or arraylist

ArrayList vs List<> en C#

Question

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

¿Es solo que la List<> tiene un tipo mientras que ArrayList no lo tiene?

Answer 1

Creo que las diferencias entre ArrayList y List<T> son:

1. List<T> , donde T es valor-tipo es más rápido que ArrayList . Esto se debe a que List<T> evita el boxeo / unboxing (donde T es el tipo de valor).
2. Muchas fuentes dicen que, por lo general, ArrayList usa solo 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érico que con la List<T>

4. ArrayList tiene propiedad IsSynchronized . Por lo tanto, es fácil crear y utilizar ArrayList sincronizado. No encontré la propiedad IsSynchronized para la List<T> . 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<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 tiene la propiedad ArrayList.SyncRoot que se puede usar para la sincronización ( msdn ). List<T> no SyncRoot propiedad SyncRoot , por lo que en la siguiente construcción necesita usar algún objeto si usa List<T> :

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

Answer 2

La respuesta simple es,

ArrayList es no 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) como cadena, int, empleado y objeto en el ArrayList. (Nota y)
• Boxeo y Unboxing sucederán.
• No escriba seguro.
• Es mayor

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 o objeto) en función de la declaración. (Nota o)
• Boxeo y Unboxing no sucederán.
• Tipo de caja fuerte.
• Es mas nuevo

Ejemplo:

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

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/

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

Answer 3

No es solo la diferencia. Se puede acceder a los miembros de ArrayList a través de un índice como los arreglos ordinarios y también los miembros de ArrayList se pueden clasificar fácilmente en orden directo e inverso, y dos ArrayList se pueden combinar fácilmente, lo que no es el caso con la Lista simple. Ver más en

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

Answer 4

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

ArrayList proporciona cierta seguridad de subprocesos a través de la propiedad Sincronizada, que devuelve un contenedor seguro para subprocesos alrededor de la colección. La envoltura funciona al bloquear toda la colección 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 bloqueo. Esto no es escalable y puede causar una degradación significativa del rendimiento para colecciones grandes.

List<T> no proporciona ninguna sincronización de subprocesos; el código de usuario debe proporcionar toda la sincronización cuando los elementos se agregan o eliminan en varios subprocesos al mismo tiempo.

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

Answer 5

Para añadir a los puntos anteriores. El uso de ArrayList en el sistema operativo de 64 bits requiere 2 veces más memoria que en el sistema operativo de 32 bits. Mientras tanto, la lista genérica List<T> usará mucha menos memoria que la ArrayList .

por ejemplo, si usamos un ArrayList de 19 MB en 32 bits, tomaría 39 MB en los 64 bits. Pero si tiene una lista genérica List<int> de 8 MB en 32 bits, solo tomaría 8,1 MB en 64 bits, lo que representa una diferencia de 481% en comparación con ArrayList.

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

Answer 6

Para mí todo se trata de conocer sus datos. Si continúo expandiendo mi código en base a la eficiencia, tendría que elegir la opción de Lista como una forma de descifrar mis datos sin el paso innecesario de preguntarme siempre sobre los tipos, especialmente los "Tipos personalizados". Si la máquina entiende la diferencia y puede determinar en qué tipo de datos estoy tratando, ¿por qué debería interferir y perder el tiempo en los giros de las determinaciones de "SI ENTONCES LLEGAN"? 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 de objeto ayuda mucho a que su código sea tan eficiente.

Tom Johnson (Una entrada ... Una salida)

Answer 7

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

ArrayList pertenece a los días en que C # no tenía genéricos. Está en desuso a favor de la List<T> . No debe usar ArrayList en el nuevo código que apunta a .NET> = 2.0 a menos que tenga que interactuar con una API antigua que la usa.

Answer 8

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

Ejemplo:

Aquí (utilizando ArrayList) puede compilar 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.
        }
    }

Answer 9

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

Ejemplo:

Aquí (utilizando ArrayList ) puede compilar 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 usas List , evitas estos errores:

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;
}

Referencia: MSDN

Answer 10

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

Answer 11

ArrayList no es de tipo seguro, mientras que la List<T> es de tipo seguro. Sencillo :).

Answer 12

• ArrayList no tiene restricción de tipo para almacenar datos, es decir, no es Type Safe. Puedes guardar cualquier cosa en ArrayList. De hecho, la misma 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 en función de qué tipo de datos se ha especificado mientras que las declaraciones, es decir, es de Tipo Seguro. Por lo tanto, si tiene una Lista genérica de cadenas, solo puede almacenar valores de cadenas, cualquier otra cosa dará un error de compilación. Recuperar los datos también es sin complicaciones y no se requieren conversiones de tipos