Raccolte e strutture di datiCollections and Data Structures

Dati simili possono spesso essere gestiti in modo più efficiente quando memorizzati e modificati come una raccolta.Similar data can often be handled more efficiently when stored and manipulated as a collection. È possibile usare la System.Array classe o le classi negli System.Collections System.Collections.Generic System.Collections.Concurrent System.Collections.Immutable spazi dei nomi,, e per aggiungere, rimuovere e modificare singoli elementi o un intervallo di elementi in una raccolta.You can use the System.Array class or the classes in the System.Collections, System.Collections.Generic, System.Collections.Concurrent, and System.Collections.Immutable namespaces to add, remove, and modify either individual elements or a range of elements in a collection.

Esistono due tipi principali di raccolte: raccolte generiche e raccolte non generiche.There are two main types of collections; generic collections and non-generic collections. Le raccolte generiche sono indipendenti dai tipi in fase di compilazione.Generic collections are type-safe at compile time. Per questo motivo, le raccolte generiche offrono in genere prestazioni migliori.Because of this, generic collections typically offer better performance. Le raccolte generiche accettano un parametro di tipo quando vengono costruite e non è necessario eseguire il cast da e verso il tipo Object quando si aggiungono o rimuovono elementi dalla raccolta.Generic collections accept a type parameter when they are constructed and do not require that you cast to and from the Object type when you add or remove items from the collection. Inoltre, la maggior parte delle raccolte generiche sono supportate nelle app di Windows Store.In addition, most generic collections are supported in Windows Store apps. Le raccolte non generiche memorizzano elementi come Object , richiedono il cast e la maggior parte non sono supportate per lo sviluppo di applicazioni Windows Store.Non-generic collections store items as Object, require casting, and most are not supported for Windows Store app development. Tuttavia, si possono vedere raccolte non generiche nel codice precedente.However, you may see non-generic collections in older code.

A partire da .NET Framework 4, le raccolte nello System.Collections.Concurrent spazio dei nomi forniscono operazioni thread-safe efficienti per accedere agli elementi della raccolta da più thread.Starting with .NET Framework 4, the collections in the System.Collections.Concurrent namespace provide efficient thread-safe operations for accessing collection items from multiple threads. Le classi di raccolte non modificabili nello System.Collections.Immutable spazio dei nomi (pacchetto NuGet) sono intrinsecamente thread-safe, perché le operazioni vengono eseguite su una copia della raccolta originale e la raccolta originale non può essere modificata.The immutable collection classes in the System.Collections.Immutable namespace (NuGet package) are inherently thread-safe because operations are performed on a copy of the original collection and the original collection cannot be modified.

Funzionalità comuni delle raccolteCommon collection features

Tutte le raccolte forniscono metodi per l'aggiunta, la rimozione o la ricerca di elementi nella raccolta.All collections provide methods for adding, removing, or finding items in the collection. In aggiunta, tutte le raccolte che implementano direttamente o indirettamente l'interfaccia ICollection o l'interfaccia ICollection<T> condividono le funzionalità seguenti:In addition, all collections that directly or indirectly implement the ICollection interface or the ICollection<T> interface share these features:

Inoltre, molte classi di raccolte contengono le seguenti funzionalità:In addition, many collection classes contain the following features:

  • Proprietà capacità e conteggioCapacity and Count properties

    La capacità di una raccolta è il numero di elementi che può contenere.The capacity of a collection is the number of elements it can contain. Il conteggio di una raccolta è il numero di elementi che contiene effettivamente.The count of a collection is the number of elements it actually contains. Alcune raccolte nascondono la capacità o il conteggio oppure entrambi.Some collections hide the capacity or the count or both.

    La capacità della maggior parte delle raccolte si espande automaticamente quando viene raggiunta la capacità corrente.Most collections automatically expand in capacity when the current capacity is reached. La memoria viene riallocata e gli elementi vengono copiati dalla raccolta precedente a quella nuova.The memory is reallocated, and the elements are copied from the old collection to the new one. Ciò riduce la quantità di codice necessario per usare la raccolta. Tuttavia, le prestazioni della raccolta possono essere influenzate negativamente.This reduces the code required to use the collection; however, the performance of the collection might be negatively affected. Ad esempio, per List<T> , se Count è minore di Capacity , l'aggiunta di un elemento è un'operazione O (1).For example, for List<T>, if Count is less than Capacity, adding an item is an O(1) operation. Se la capacità deve essere aumentata per adattarsi al nuovo elemento, l'aggiunta di un elemento diventa un'operazione O ( n ), dove n è Count .If the capacity needs to be increased to accommodate the new element, adding an item becomes an O(n) operation, where n is Count. Il modo migliore per evitare una riduzione delle prestazioni causata da più riallocazioni consiste nell'impostare la capacità iniziale sulla dimensione prevista della raccolta.The best way to avoid poor performance caused by multiple reallocations is to set the initial capacity to be the estimated size of the collection.

    Un BitArray è un caso speciale: la sua capacità corrisponde alla sua lunghezza, che corrisponde al relativo conteggio.A BitArray is a special case; its capacity is the same as its length, which is the same as its count.

  • Un limite inferiore coerenteA consistent lower bound

    Il limite inferiore di una raccolta è l'indice del primo elemento.The lower bound of a collection is the index of its first element. Tutte le raccolte indicizzate negli spazi dei nomi System.Collections hanno un limite inferiore pari a zero, ossia possono essere indicizzate da 0.All indexed collections in the System.Collections namespaces have a lower bound of zero, meaning they are 0-indexed. Array ha un limite inferiore pari a zero per impostazione predefinita, ma è possibile definire un limite inferiore diverso quando si crea un'istanza della classe Array usando Array.CreateInstance .Array has a lower bound of zero by default, but a different lower bound can be defined when creating an instance of the Array class using Array.CreateInstance.

  • Sincronizzazione per l'accesso da più thread ( System.Collections solo classi).Synchronization for access from multiple threads (System.Collections classes only).

    I tipi di raccolta non generica nello spazio dei nomi System.Collections forniscono una determinata thread safety con la sincronizzazione, in genere esposte attraverso i membri SyncRoot e IsSynchronized.Non-generic collection types in the System.Collections namespace provide some thread safety with synchronization; typically exposed through the SyncRoot and IsSynchronized members. Queste raccolte non sono thread-safe per impostazione predefinita.These collections are not thread-safe by default. Se si richiede un accesso multithreading scalabile ed efficiente a una raccolta, usare una delle classi nello spazio dei nomi System.Collections.Concurrent o considerare l'uso di una raccolta non modificabile.If you require scalable and efficient multi-threaded access to a collection, use one of the classes in the System.Collections.Concurrent namespace or consider using an immutable collection. Per altre informazioni, vedere Raccolte thread-safe.For more information, see Thread-Safe Collections.

Scegliere una raccoltaChoose a collection

In generale, è necessario usare raccolte generiche.In general, you should use generic collections. Nella tabella seguente vengono descritti alcuni scenari comuni di raccolta e le classi di raccolta che è possibile usare per gli scenari.The following table describes some common collection scenarios and the collection classes you can use for those scenarios. Se si ha già familiarità con le raccolte generiche, questa tabella consente di scegliere la raccolta generica più adatta alla propria attività.If you are new to generic collections, this table will help you choose the generic collection that works the best for your task.

Si desidera...I want to… Opzioni di raccolta genericaGeneric collection options Opzioni di raccolta non genericaNon-generic collection options Opzioni di raccolta thread-safe o non modificabileThread-safe or immutable collection options
Archiviare gli elementi come coppie chiave/valore per la ricerca rapida dalla chiaveStore items as key/value pairs for quick look-up by key Dictionary<TKey,TValue> Hashtable

(Una raccolta di coppie chiave/valore che sono organizzate in base al codice hash della chiave).(A collection of key/value pairs that are organized based on the hash code of the key.)
ConcurrentDictionary<TKey,TValue>

ReadOnlyDictionary<TKey,TValue>

ImmutableDictionary<TKey,TValue>
Accedere agli elementi in base all'indiceAccess items by index List<T> Array

ArrayList
ImmutableList<T>

ImmutableArray
Usare gli elementi first-in-first-out (FIFO)Use items first-in-first-out (FIFO) Queue<T> Queue ConcurrentQueue<T>

ImmutableQueue<T>
Usare i dati Last-In-First-Out (LIFO)Use data Last-In-First-Out (LIFO) Stack<T> Stack ConcurrentStack<T>

ImmutableStack<T>
Accedere agli elementi in sequenzaAccess items sequentially LinkedList<T> Nessuna raccomandazioneNo recommendation Nessuna raccomandazioneNo recommendation
Ricevere notifiche quando gli elementi vengono rimossi o aggiunti alla raccolta.Receive notifications when items are removed or added to the collection. (implementa INotifyPropertyChanged e INotifyCollectionChanged)(implements INotifyPropertyChanged and INotifyCollectionChanged) ObservableCollection<T> Nessuna raccomandazioneNo recommendation Nessuna raccomandazioneNo recommendation
Una raccolta ordinataA sorted collection SortedList<TKey,TValue> SortedList ImmutableSortedDictionary<TKey,TValue>

ImmutableSortedSet<T>
Un set di funzioni matematicheA set for mathematical functions HashSet<T>

SortedSet<T>
Nessuna raccomandazioneNo recommendation ImmutableHashSet<T>

ImmutableSortedSet<T>

Complessità algoritmica delle raccolteAlgorithmic complexity of collections

Quando si sceglie una classe di raccolta, vale la pena considerare potenziali compromessi nelle prestazioni.When choosing a collection class, it is worth considering potential tradeoffs in performance. Usare la tabella seguente per fare riferimento al confronto tra i diversi tipi di raccolte modificabili nella complessità algoritmica con le corrispondenti controparti non modificabili.Use the following table to reference how various mutable collection types compare in algorithmic complexity to their corresponding immutable counterparts. Spesso i tipi di raccolta non modificabili sono meno performanti, ma forniscono un'immutabilità, che è spesso un vantaggio comparativa valido.Often immutable collection types are less performant but provide immutability - which is often a valid comparative benefit.

ModificabileMutable AmmortizzatoAmortized Caso peggioreWorst Case Non modificabileImmutable ComplessitàComplexity
Stack<T>.Push O (1)O(1) O ( n )O(n) ImmutableStack<T>.Push O (1)O(1)
Queue<T>.Enqueue O (1)O(1) O ( n )O(n) ImmutableQueue<T>.Enqueue O (1)O(1)
List<T>.Add O (1)O(1) O ( n )O(n) ImmutableList<T>.Add O (log n )O(log n)
List<T>.Item[Int32] O (1)O(1) O (1)O(1) ImmutableList<T>.Item[Int32] O (log n )O(log n)
List<T>.Enumerator O ( n )O(n) O ( n )O(n) ImmutableList<T>.Enumerator O ( n )O(n)
HashSet<T>.Add, ricercaHashSet<T>.Add, lookup O (1)O(1) O ( n )O(n) ImmutableHashSet<T>.Add O (log n )O(log n)
SortedSet<T>.Add O (log n )O(log n) O ( n )O(n) ImmutableSortedSet<T>.Add O (log n )O(log n)
Dictionary<T>.Add O (1)O(1) O ( n )O(n) ImmutableDictionary<T>.Add O (log n )O(log n)
Dictionary<T> ricercaDictionary<T> lookup O (1)O(1) O (1)-o rigorosamente O ( n )O(1) – or strictly O(n) ImmutableDictionary<T> ricercaImmutableDictionary<T> lookup O (log n )O(log n)
SortedDictionary<T>.Add O (log n )O(log n) O ( n log n )O(n log n) ImmutableSortedDictionary<T>.Add O (log n )O(log n)

Un oggetto List<T> può essere enumerato in modo efficiente utilizzando un for ciclo o un foreach ciclo.A List<T> can be efficiently enumerated using either a for loop or a foreach loop. Un ImmutableList<T> , tuttavia, esegue un processo scadente all'interno di un for ciclo, a causa del tempo di O (log n ) per il relativo indicizzatore.An ImmutableList<T>, however, does a poor job inside a for loop, due to the O(log n) time for its indexer. L'enumerazione di un oggetto ImmutableList<T> utilizzando un foreach ciclo è efficiente perché ImmutableList<T> utilizza un albero binario per archiviare i dati anziché una semplice matrice come List<T> utilizza.Enumerating an ImmutableList<T> using a foreach loop is efficient because ImmutableList<T> uses a binary tree to store its data instead of a simple array like List<T> uses. Una matrice può essere indicizzata molto rapidamente in, mentre un albero binario deve essere riavviato fino a quando non viene trovato il nodo con l'indice desiderato.An array can be very quickly indexed into, whereas a binary tree must be walked down until the node with the desired index is found.

Inoltre, SortedSet<T> ha la stessa complessità di ImmutableSortedSet<T> .Additionally, SortedSet<T> has the same complexity as ImmutableSortedSet<T>. Questo perché entrambi utilizzano alberi binari.That's because they both use binary trees. La differenza significativa, ovviamente, è che ImmutableSortedSet<T> Usa un albero binario non modificabile.The significant difference, of course, is that ImmutableSortedSet<T> uses an immutable binary tree. Poiché ImmutableSortedSet<T> offre anche una System.Collections.Immutable.ImmutableSortedSet<T>.Builder classe che consente la mutazione, è possibile avere sia l'immutabilità che le prestazioni.Since ImmutableSortedSet<T> also offers a System.Collections.Immutable.ImmutableSortedSet<T>.Builder class that allows mutation, you can have both immutability and performance.

TitoloTitle DescrizioneDescription
Selezione di una classe CollectionSelecting a Collection Class Vengono descritte le diverse raccolte e come selezionarne una per lo scenario.Describes the different collections and helps you select one for your scenario.
Tipi di raccolte comunemente usateCommonly Used Collection Types Vengono descritti i tipi di raccolta generici e non generici comunemente usati, quali System.Array, System.Collections.Generic.List<T> e System.Collections.Generic.Dictionary<TKey,TValue>.Describes commonly used generic and nongeneric collection types such as System.Array, System.Collections.Generic.List<T>, and System.Collections.Generic.Dictionary<TKey,TValue>.
Quando usare le raccolte genericheWhen to Use Generic Collections Viene illustrato l'utilizzo di tipi di raccolta generici.Discusses the use of generic collection types.
Confronti e ordinamenti all'interno delle raccolteComparisons and Sorts Within Collections Viene illustrato l'utilizzo di confronti di uguaglianza e ordinamento nelle raccolte.Discusses the use of equality comparisons and sorting comparisons in collections.
Tipi di raccolta ordinatiSorted Collection Types Vengono descritte le caratteristiche e le prestazioni di raccolte ordinateDescribes sorted collections performance and characteristics
Tipi di Collection Hashtable e DictionaryHashtable and Dictionary Collection Types Vengono descritte le funzionalità dei tipi di dizionario basati su hash generici e non generici.Describes the features of generic and non-generic hash-based dictionary types.
Raccolte thread-safeThread-Safe Collections Vengono descritti i tipi di raccolta quali System.Collections.Concurrent.BlockingCollection<T> e System.Collections.Concurrent.ConcurrentBag<T> che supportano l'accesso simultaneo sicuro ed efficiente da più thread.Describes collection types such as System.Collections.Concurrent.BlockingCollection<T> and System.Collections.Concurrent.ConcurrentBag<T> that support safe and efficient concurrent access from multiple threads.
System.Collections.ImmutableSystem.Collections.Immutable Introduce le raccolte non modificabili e fornisce collegamenti ai tipi di raccolta.Introduces the immutable collections and provides links to the collection types.

RiferimentoReference

System.Array System.Collections System.Collections.Concurrent System.Collections.Generic System.Collections.Specialized System.Linq System.Collections.Immutable