ArrayList vs List <> en C #

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

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

Si, mas o menos. List<T>Es una clase genérica. Es compatible con el almacenamiento de valores de un tipo específico sin conversión hacia o desde object(que habría incurrido en gastos generales de boxeo / unboxing cuando Tes un tipo de valor en el ArrayListcaso). ArrayListsimplemente almacena objectreferencias. Como una colección genérica, List<T>implementa la IEnumerable<T>interfaz genérica y se puede usar fácilmente en LINQ (sin requerir ninguna CastoOfType llamar).

ArrayListpertenece a los días en que C # no tenía genéricos. Está en desuso a favor de List<T>. No debe usar un ArrayListcódigo nuevo que apunte a .NET> = 2.0 a menos que tenga que interactuar con una API antigua que lo usa.

Usarlo List<T>puede evitar errores de transmisión. Es muy útil para evitar un error de transmisión en tiempo de ejecución .

Ejemplo:

Aquí (usando 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 lo usa List, evita 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

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

por ejemplo, si utilizamos una ArrayListde 19 MB en 32 bits, se necesitarían 39 MB en 64 bits. Pero si tienes una lista genéricaList<int> de 8 MB en 32 bits, solo necesitaría 8.1 MB en 64 bits, lo que es una gran diferencia del 481% en comparación con ArrayList.

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

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

ArrayListproporciona cierta seguridad de subprocesos a través de la propiedad Sincronizada, que devuelve un contenedor seguro para subprocesos alrededor de la colección. El contenedor funciona bloqueando 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 único bloqueo. Esto no es escalable y puede causar una degradación significativa del rendimiento para grandes colecciones.

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 simultáneamente.

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

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 string, int, employee y object en ArrayList. (Nota y)
• Boxing y Unboxing sucederán.
• No es 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 u objeto) según la declaración. (Nota o)
• Boxeo y Unboxing no sucederán.
• Escriba seguro.
• 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/

ArrayListes la recopilación de datos de diferentes tipos, mientras que List<>es la recopilación de un tipo similar de sus propias dependencias.

ArrayListno son de tipo seguro, mientras que List<T>son de tipo seguro. Simple :).

El rendimiento ya se ha mencionado en varias respuestas como un factor diferenciador, pero para abordar el tema " ¿Cuánto más lento es el ArrayList? "Y" ¿Por qué es más lento en general?", Eche un vistazo a continuación.

Siempre que los tipos de valor se utilizan como elementos, el rendimiento disminuye drásticamente con ArrayList. Considere el caso de simplemente agregar elementos. Debido a que el boxeo continúa, ya que ArrayListAdd solo toma objectparámetros, el recolector de basura se activa para realizar mucho más trabajo que con List<T>.

¿Cuánto es la diferencia horaria? Al menos varias veces más lento que con List<T>. Solo eche un vistazo a lo que sucede con el código que agrega valores de 10 mil int a un ArrayListvs List<T>:

Esa es una diferencia de tiempo de ejecución de 5x en la columna 'Media', resaltada en amarillo. Tenga en cuenta también la diferencia en el número de recolecciones de basura realizadas para cada uno, resaltado en rojo (no de GC / 1000 ejecuciones).

El uso de un generador de perfiles para ver lo que sucede rápidamente muestra que la mayor parte del tiempo se gasta haciendo GC , en lugar de agregar elementos. Las barras marrones a continuación representan el bloqueo de la actividad del recolector de basura:

He escrito un análisis detallado de lo que sucede con el ArrayListescenario anterior aquí https://mihai-albert.com/2019/12/15/boxing-performance-in-c-analysis-and-benchmark/ .

Hallazgos similares se encuentran en "CLR vía C #" de Jeffrey Richter. Del capítulo 12 (Genéricos):

[…] Cuando compilo y ejecuto una versión de lanzamiento (con las optimizaciones activadas) de este programa en mi computadora, obtengo el siguiente resultado.

00: 00: 01.6246959 (GCs = 6) Lista <Int32>
00: 00: 10.8555008 (GCs = 390) ArrayList de Int32
00: 00: 02.5427847 (GCs = 4) Lista <String>
00: 00: 02.7944831 (GCs = 7 ) ArrayList of String

El resultado aquí muestra que usar el algoritmo genérico List con el tipo Int32 es mucho más rápido que usar el algoritmo ArrayList no genérico con Int32. De hecho, la diferencia es fenomenal: 1.6 segundos versus casi 11 segundos. ¡Eso es ~ 7 veces más rápido ! Además, el uso de un tipo de valor (Int32) con ArrayList hace que se produzcan muchas operaciones de boxeo, lo que resulta en 390 recolecciones de basura. Mientras tanto, el algoritmo List requirió 6 recolecciones de basura.

Creo que las diferencias entre ArrayListy List<T>son:

1. List<T>, donde T es de tipo valor es más rápido que ArrayList. Esto se debe a que List<T>evita el boxing / unboxing (donde T es de tipo valor).
2. Muchas fuentes dicen que generalmente se ArrayListusa 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 no genérico ArrayListcontinuación,List<T>

4. ArrayListTiene IsSynchronizedpropiedad. Por lo tanto, es fácil de crear y usar sincronizado ArrayList. No encontré IsSynchronizedpropiedad para 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. ArrayListtiene una ArrayList.SyncRootpropiedad que se puede usar para la sincronización ( msdn ). List<T>no tiene SyncRootpropiedad, por lo que en la siguiente construcción debe 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)
       {
           // ...
       }
   }

Como se menciona en la documentación de .NET Framework

No recomendamos que use la ArrayListclase para un nuevo desarrollo. En su lugar, le recomendamos que use la List<T> clase genérica . La ArrayListclase está diseñada para contener colecciones heterogéneas de objetos. Sin embargo, no siempre ofrece el mejor rendimiento. En cambio, recomendamos lo siguiente:

• Para una colección heterogénea de objetos, use el tipo List<Object>(en C #) o List(Of Object)(en Visual Basic).
• Para una colección homogénea de objetos, use la List<T>clase

Consulte también No se deben usar colecciones no genéricas

Usando "Lista" puede evitar errores de transmisión. Es muy útil para evitar un error de transmisión en tiempo de ejecución.

Ejemplo:

Aquí (usando 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.
        }
    }

Para mí, todo se trata de conocer sus 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 preguntarme acerca de los tipos, especialmente 'Tipos personalizados'. Si la máquina entiende la diferencia y puede determinar en qué tipo de datos estoy tratando realmente, ¿por qué debería interponerme y perder el tiempo pasando por los giros de las determinaciones 'SI ENTONCES?' ¿Mi filosofía es dejar que la máquina funcione 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)