ArrayList vs lista< > w C#

Za pomocą List<T> można zapobiec błędom rzucania. Bardzo przydatne jest unikanie błędu uruchamiania .

Przykład:

Tutaj (używając ArrayList) możesz skompilować ten kod, ale później zobaczysz błąd wykonania.

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
}

Jeśli używasz List, unikasz tych błędów:

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

Odniesienie: MSDN

Aby dodać do powyższych punktów. Użycie ArrayList W 64-bitowym systemie operacyjnym zajmuje 2x pamięci niż użycie w 32-bitowym systemie operacyjnym. Tymczasem lista generyczna List<T> będzie zużywała dużo mniej pamięci niż ArrayList.

Na przykład, jeśli użyjemy ArrayList 19MB w 32-bitach, to zajmie to 39mb w 64-bitach. Ale jeśli masz ogólną listę List<int> 8MB w 32-bitach, zajęłoby to tylko 8.1 MB w 64-bitach, co jest ogromną różnicą 481% w porównaniu do ArrayList.

Źródło: ArrayList vs. generic Lista typów prymitywnych i 64-bitowych

Kolejną różnicą do dodania jest synchronizacja wątków.

ArrayList zapewnia pewne bezpieczeństwo wątku poprzez właściwość Synchronized, która zwraca bezpieczną dla wątku owijkę wokół kolekcji. Owijarka działa poprzez zablokowanie całej kolekcji przy każdej operacji dodawania lub usuwania. Dlatego każdy wątek, który próbuje uzyskać dostęp do kolekcji, musi czekać na swoją kolej, aby wziąć jedną blokadę. Nie jest skalowalny i może spowodować znaczny spadek wydajności dla duże kolekcje.

List<T> nie zapewnia żadnej synchronizacji wątków; kod użytkownika musi zapewnić całą synchronizację, gdy elementy są dodawane lub usuwane w wielu wątkach jednocześnie.

Więcej informacji tutaj Synchronizacja wątków w. Net Framework

ArrayList nie są bezpieczne dla typu, podczas gdy List<T> są bezpieczne dla typu. Proste:).

Prosta odpowiedź brzmi:

ArrayList nie jest generyczny

• jest to typ obiektowy, więc można do niego zapisać dowolny typ danych.
• możesz przechowywać dowolne wartości (typ wartości lub typ referencji) takie jak string, int, employee i object w ArrayList. (Uwaga i)
• boks i Unboxing się stanie.
• nie jest bezpieczny.
Jest starsza.

Lista jest ogólna

• jest to typ typu, więc można określić T na czas trwania.
• Możesz zapisać tylko wartość typu T (string lub int lub employee lub object) na podstawie deklaracji. (Uwaga lub)
• boks i Unboxing nie nastąpi.
• Typ Bezpieczny.
• jest nowsza.

Przykład:

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

Przeczytaj oficjalny dokument Microsoft : https://blogs.msdn.microsoft.com/kcwalina/2005/09/23/system-collections-vs-system-collection-generic-and-system-collections-objectmodel/

Uwaga : powinieneś znać Generyki, zanim zrozumiesz różnicę: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/generics/

ArrayList jest zbiorem danych różnych typów, podczas gdy {[1] } jest zbiorem podobnych typów własnych depedencjacji.

Myślę, że różnice między ArrayList i List<T> są następujące:

1. List<T>, gdzie T jest wartością-typ jest szybszy niż ArrayList. To jest ponieważ List<T> unika boksu/unboxingu (gdzie T jest typem wartości).
2. wiele źródeł mówi - zwykle ArrayList używane tylko dla wstecz kompatybilność. (nie jest to prawdziwa różnica, ale myślę, że jest ważna uwaga).
3. odbicie jest łatwiejsze z nongeneric ArrayList then List<T>

4. ArrayList posiada IsSynchronized własność. Tak, to jest łatwe aby tworzyć i używać syncronized ArrayList. Nie znalazłem IsSynchronized nieruchomości dla List<T>. Należy również pamiętać, że tego typu synchronizacja jest stosunkowo nieefektywna, 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 posiada właściwość ArrayList.SyncRoot, która może być użyta do synchronizacji (msdn ). List<T> nie posiada SyncRoot własności, więc w jeśli używasz List<T>, musisz użyć następującego obiektu:

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

• ArrayList nie ma ograniczeń typu do przechowywania danych, tzn. nie jest bezpieczny dla typu. Możesz przechowywać wszystko w ArrayList. W rzeczywistości ta sama ArrayList może przechowywać wiele typów obiektów.
• w liście ogólnej (List), T oznacza typ danych, tj. string, int, DateTime, itd. W ten sposób będzie przechowywał tylko określone typy obiektów na podstawie tego, jaki typ danych został określony, podczas gdy deklaracje tzn. jest Bezpieczny. Tak więc, jeśli masz ogólną listę łańcuchów, możesz przechowywać tylko wartości łańcuchów, cokolwiek else spowoduje błąd kompilacji. Odzyskiwanie danych jest również bezproblemowe i nie wymaga konwersji typu

Używając "listy" możesz zapobiec błędom w rzucaniu. Jest to bardzo przydatne, aby uniknąć błędu odlewania runtime.

Przykład:

Tutaj (używając ArrayList) możesz skompilować ten kod, ale później zobaczysz błąd wykonania.

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

Dla mnie chodzi o poznanie Twoich danych. Jeśli nadal będę rozbudowywał swój kod w oparciu o efektywność, będę musiał wybrać opcję listy jako sposób rozszyfrowania moich danych bez zbędnego etapu ciągłego zastanawiania się nad typami, szczególnie "typami niestandardowymi". Jeśli maszyna rozumie różnicę i może określić, z jakim typem danych faktycznie mam do czynienia, to dlaczego mam wchodzić w drogę i tracić czas na wyznaczanie "IF THEN ELSE"? My filozofia to pozwolić maszynie pracować dla mnie, a nie ja pracować na maszynie? Znajomość unikalnych różnic w różnych poleceniach kodu obiektowego sprawia, że kod jest równie wydajny.

Tom Johnson (Jeden Wpis ... Jedno Wyjście)

To nie tylko różnica. Pręty ArrayList mogą być dostępne za pośrednictwem indeksu jak zwykłe tablice, a także pręty ArrayList mogą być łatwo sortowane w kolejności bezpośredniej i odwrotnej, a dwie ArrayList mogą być łatwo scalone, co nie jest w przypadku simple List. Zobacz więcej na

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