Esporta (0) Stampa
Espandi tutto

Classe List<T>

Aggiornamento: novembre 2007

Rappresenta un elenco di oggetti fortemente tipizzato accessibile per indice. Fornisce metodi per la ricerca, l'ordinamento e la modifica degli elenchi.

Spazio dei nomi:  System.Collections.Generic
Assembly:  mscorlib (in mscorlib.dll)

[SerializableAttribute]
public class List<T> : IList<T>, ICollection<T>, 
	IEnumerable<T>, IList, ICollection, IEnumerable

J# supporta l'utilizzo di API generiche ma non la dichiarazione di nuove.
JScript non supporta i tipi o i metodi generici.

Parametri di tipo

T

Tipo di elementi contenuti nell'elenco.

La classe List<T> è l'equivalente generico della classe ArrayList. Consente di implementare l'interfaccia generica IList<T> utilizzando una matrice la cui dimensione aumenta dinamicamente in base alle necessità.

La classe List<T> utilizza sia un operatore di confronto di uguaglianza, sia un operatore di confronto di ordinamento.

  • Metodi quali Contains, IndexOf, LastIndexOf e Remove utilizzano un operatore di confronto di uguaglianza per gli elementi dell'elenco. L'operatore di confronto di uguaglianza predefinito per il tipo T viene determinato nel modo descritto di seguito. Se mediante il tipo T viene implementata l'interfaccia generica IEquatable<T>, l'operatore di confronto di uguaglianza è il metodo Equals(T) di quella interfaccia; in caso contrario, sarà Object.Equals(Object).

  • Metodi quali BinarySearch e Sort utilizzano un operatore di confronto di ordinamento per gli elementi dell'elenco. L'operatore di confronto predefinito per il tipo T viene determinato nel modo descritto di seguito. Se mediante il tipo T viene implementata l'interfaccia generica IComparable<T>, l'operatore di confronto predefinito è il metodo CompareTo(T) di quella interfaccia; in caso contrario, se mediante il tipo T viene implementata l'interfaccia non generica IComparable, l'operatore di confronto predefinito sarà il metodo CompareTo(Object) di quella interfaccia. Se mediante il tipo T non viene implementata alcuna interfaccia, non sarà presente nessun operatore di confronto predefinito e sarà necessario fornirne uno in modo esplicito oppure fornire un delegato di confronto.

Non è garantito che la classe List<T> sia ordinata. È necessario ordinare la classe List<T> prima di eseguire operazioni, quali BinarySearch, che richiedono che la classe List<T> sia ordinata.

È possibile accedere agli elementi di questo insieme tramite un indice di integer. Gli indici in questo insieme sono in base zero.

List<T> accetta null come valore valido per i tipi di riferimento e consente elementi duplicati.

Considerazioni sulle prestazioni

Al momento di decidere se utilizzare la classe List<T> o ArrayList, che dispongono di funzionalità simili, ricordare che List<T> è una classe indipendente dai tipi con prestazioni migliori nella maggior parte dei casi. Se per il tipo T della classe List<T> si utilizza un tipo di riferimento, il comportamento delle due classi è identico. Tuttavia, se per il tipo T si utilizza un tipo di valore, è necessario prendere in considerazione i problemi relativi all'implementazione e alla conversione boxing.

Se per il tipo T si utilizza un tipo di valore, il compilatore genera un'implementazione della classe List<T> specifica per quel tipo di valore. Ciò significa che non è necessario eseguire la conversione boxing di un elemento di elenco di un oggetto List<T> prima che sia possibile utilizzarlo. Dopo la creazione di circa 500 elementi di elenco la memoria salvata senza la conversione boxing degli elementi di elenco sarà più grande della memoria utilizzata per generare l'implementazione della classe.

Accertarsi che il tipo di valore utilizzato per il tipo T implementi l'interfaccia generica IEquatable<T>. In caso contrario, è necessario che i metodi quali Contains chiamino il metodo Object.Equals(Object) mediante il quale viene eseguita la conversione boxing dell'elemento di elenco interessato. Se mediante il tipo di valore viene implementata l'interfaccia IComparable e si è proprietari del codice sorgente, implementare anche l'interfaccia generica IComparable<T> per evitare che i metodi BinarySearch e Sort eseguano la conversione boxing degli elementi di elenco. Se non si è proprietari del codice sorgente, passare un oggetto IComparer<T> ai metodi BinarySearch e Sort.

L'utilizzo dell'implementazione specifica del tipo della classe List<T> risulta più vantaggioso rispetto all'utilizzo della classe ArrayList o alla scrittura diretta di un insieme di wrapper fortemente tipizzato. Infatti, l'implementazione deve svolgere le operazioni attualmente svolte da .NET Framework. Il Common Language Runtime, al contrario dell'implementazione consente di condividere il codice MSIL (Microsoft Intermediate Language) e i metadati.

Nell'esempio di codice riportato di seguito vengono illustrati diversi metodi e proprietà della classe generica List<T>. Viene utilizzato il costruttore predefinito per creare un elenco di stringhe con la capacità predefinita. Viene visualizzata la proprietà Capacity e viene quindi utilizzato il metodo Add per aggiungere diversi elementi. Gli elementi vengono elencati e viene visualizzata nuovamente la proprietà Capacity insieme alla proprietà Count, in modo da mostrare che la capacità è stata aumentata secondo le necessità.

Viene utilizzato il metodo Contains per verificare la presenza di un elemento all'interno dell'elenco, quindi mediante il metodo Insert si inserisce un nuovo elemento al centro dell'elenco e viene visualizzato nuovamente il contenuto dell'elenco.

La proprietà predefinita Item (l'indicizzatore in C#) viene utilizzata per recuperare un elemento, mediante il metodo Remove viene rimossa la prima istanza dell'elemento duplicato aggiunto in precedenza e viene visualizzato nuovamente il contenuto. Il metodo Remove rimuove sempre la prima istanza rilevata.

Il metodo TrimExcess è utilizzato per ridurre la capacità in modo che corrisponda al conteggio e vengono visualizzate le proprietà Capacity e Count. Se la capacità inutilizzata fosse stata inferiore al 10 percento della capacità totale, l'elenco non sarebbe stato ridimensionato.

Infine, si utilizza il metodo Clear per rimuovere tutti gli elementi dall'elenco e vengono visualizzate le proprietà Capacity e Count.

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>();

        Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);

        dinosaurs.Add("Tyrannosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        dinosaurs.Add("Compsognathus");

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);
        Console.WriteLine("Count: {0}", dinosaurs.Count);

        Console.WriteLine("\nContains(\"Deinonychus\"): {0}",
            dinosaurs.Contains("Deinonychus"));

        Console.WriteLine("\nInsert(2, \"Compsognathus\")");
        dinosaurs.Insert(2, "Compsognathus");

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine("\ndinosaurs[3]: {0}", dinosaurs[3]);

        Console.WriteLine("\nRemove(\"Compsognathus\")");
        dinosaurs.Remove("Compsognathus");

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        dinosaurs.TrimExcess();
        Console.WriteLine("\nTrimExcess()");
        Console.WriteLine("Capacity: {0}", dinosaurs.Capacity);
        Console.WriteLine("Count: {0}", dinosaurs.Count);

        dinosaurs.Clear();
        Console.WriteLine("\nClear()");
        Console.WriteLine("Capacity: {0}", dinosaurs.Capacity);
        Console.WriteLine("Count: {0}", dinosaurs.Count);
    }
}

/* This code example produces the following output:

Capacity: 0

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus

Capacity: 8
Count: 5

Contains("Deinonychus"): True

Insert(2, "Compsognathus")

Tyrannosaurus
Amargasaurus
Compsognathus
Mamenchisaurus
Deinonychus
Compsognathus

dinosaurs[3]: Mamenchisaurus

Remove("Compsognathus")

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Deinonychus
Compsognathus

TrimExcess()
Capacity: 5
Count: 5

Clear()
Capacity: 5
Count: 0
 */


I membri statici pubblici (Shared in Visual Basic) di questo tipo sono thread-safe. Qualsiasi membro di istanza non ha garanzia di essere thread-safe.

Un oggetto List<T> può supportare più lettori simultaneamente, purché l'insieme non venga modificato. L'enumerazione di un insieme non è di per sé una procedura thread-safe. Nel raro caso in cui un'enumerazione condivida uno o più accessi in scrittura, l'unico modo per garantire l'accesso thread-safe consiste nel bloccare l'insieme durante l'intero processo di enumerazione. Per consentire l'accesso all'insieme in lettura e scrittura da parte di più thread, è necessario implementare una sincronizzazione personalizzata.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition , Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile per Smartphone, Windows Mobile per Pocket PC, Xbox 360

.NET Framework e .NET Compact Framework non supportano tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

.NET Framework

Supportato in: 3.5, 3.0, 2.0

.NET Compact Framework

Supportato in: 3.5, 2.0

XNA Framework

Supportato in: 2.0, 1.0

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft