SortedList<TKey,TValue> SortedList<TKey,TValue> SortedList<TKey,TValue> SortedList<TKey,TValue> Class

Definizione

Rappresenta una raccolta di coppie chiave/valore ordinate per chiave in base all'implementazione IComparer<T> associata.Represents a collection of key/value pairs that are sorted by key based on the associated IComparer<T> implementation.

generic <typename TKey, typename TValue>
public ref class SortedList : System::Collections::Generic::ICollection<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IDictionary<TKey, TValue>, System::Collections::Generic::IEnumerable<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IReadOnlyCollection<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IReadOnlyDictionary<TKey, TValue>, System::Collections::IDictionary
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class SortedList<TKey,TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IDictionary<TKey,TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IReadOnlyCollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IReadOnlyDictionary<TKey,TValue>, System.Collections.IDictionary
type SortedList<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface IDictionary
    interface IReadOnlyDictionary<'Key, 'Value>
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IEnumerable
    interface ICollection
    interface IReadOnlyCollection<KeyValuePair<'Key, 'Value>>
Public Class SortedList(Of TKey, TValue)
Implements ICollection(Of KeyValuePair(Of TKey, TValue)), IDictionary, IDictionary(Of TKey, TValue), IEnumerable(Of KeyValuePair(Of TKey, TValue)), IReadOnlyCollection(Of KeyValuePair(Of TKey, TValue)), IReadOnlyDictionary(Of TKey, TValue)

Parametri di tipo

TKey

Tipo di chiavi nella raccolta.The type of keys in the collection.

TValue

Tipo di valori nell'insieme.The type of values in the collection.

Ereditarietà
SortedList<TKey,TValue>SortedList<TKey,TValue>SortedList<TKey,TValue>SortedList<TKey,TValue>
Derivato
Attributi
Implementazioni

Esempi

Esempio di codice seguente crea un oggetto vuoto SortedList<TKey,TValue> delle stringhe con chiavi di stringa e Usa il Add metodo per aggiungere alcuni elementi.The following code example creates an empty SortedList<TKey,TValue> of strings with string keys and uses the Add method to add some elements. Nell'esempio viene illustrato che il Add metodo genera un ArgumentException durante il tentativo di aggiungere una chiave duplicata.The example demonstrates that the Add method throws an ArgumentException when attempting to add a duplicate key.

L'esempio Usa la Item[TKey] proprietà (l'indicizzatore in c#) per recuperare i valori, che illustra un KeyNotFoundException viene generata quando una chiave richiesta non è presente, e che mostra che il valore associato alla chiave può essere sostituito.The example uses the Item[TKey] property (the indexer in C#) to retrieve values, demonstrating that a KeyNotFoundException is thrown when a requested key is not present, and showing that the value associated with a key can be replaced.

Nell'esempio viene illustrato come utilizzare il TryGetValue un modo più efficiente per recuperare i valori, se un programma deve provare valori di chiave che non sono presenti nell'elenco ordinato e viene illustrato come utilizzare il metodo di ContainsKey metodo per verificare se esiste una chiave prima di chiamare il Add metodo.The example shows how to use the TryGetValue method as a more efficient way to retrieve values if a program often must try key values that are not in the sorted list, and it shows how to use the ContainsKey method to test whether a key exists before calling the Add method.

Nell'esempio viene illustrato come enumerare le chiavi e valori nell'elenco ordinato e come enumerare le chiavi e i valori da soli usando il Keys proprietà e il Values proprietà.The example shows how to enumerate the keys and values in the sorted list and how to enumerate the keys and values alone using the Keys property and the Values property.

Infine, nell'esempio viene illustrato il Remove (metodo).Finally, the example demonstrates the Remove method.

#using <System.dll>

using namespace System;
using namespace System::Collections::Generic;

public ref class Example
{
public:
    static void Main()
    {
        // Create a new sorted list of strings, with string
        // keys.
        SortedList<String^, String^>^ openWith =
            gcnew SortedList<String^, String^>();

        // Add some elements to the list. There are no 
        // duplicate keys, but some of the values are duplicates.
        openWith->Add("txt", "notepad.exe");
        openWith->Add("bmp", "paint.exe");
        openWith->Add("dib", "paint.exe");
        openWith->Add("rtf", "wordpad.exe");

        // The Add method throws an exception if the new key is
        // already in the list.
        try
        {
            openWith->Add("txt", "winword.exe");
        }
        catch (ArgumentException^)
        {
            Console::WriteLine("An element with Key = \"txt\" already exists.");
        }

        // The Item property is another name for the indexer, so you
        // can omit its name when accessing elements.
        Console::WriteLine("For key = \"rtf\", value = {0}.",
            openWith["rtf"]);

        // The indexer can be used to change the value associated
        // with a key.
        openWith["rtf"] = "winword.exe";
        Console::WriteLine("For key = \"rtf\", value = {0}.",
            openWith["rtf"]);

        // If a key does not exist, setting the indexer for that key
        // adds a new key/value pair.
        openWith["doc"] = "winword.exe";

        // The indexer throws an exception if the requested key is
        // not in the list.
        try
        {
            Console::WriteLine("For key = \"tif\", value = {0}.",
                openWith["tif"]);
        }
        catch (KeyNotFoundException^)
        {
            Console::WriteLine("Key = \"tif\" is not found.");
        }

        // When a program often has to try keys that turn out not to
        // be in the list, TryGetValue can be a more efficient
        // way to retrieve values.
        String^ value = "";
        if (openWith->TryGetValue("tif", value))
        {
            Console::WriteLine("For key = \"tif\", value = {0}.", value);
        }
        else
        {
            Console::WriteLine("Key = \"tif\" is not found.");
        }

        // ContainsKey can be used to test keys before inserting
        // them.
        if (!openWith->ContainsKey("ht"))
        {
            openWith->Add("ht", "hypertrm.exe");
            Console::WriteLine("Value added for key = \"ht\": {0}",
                openWith["ht"]);
        }

        // When you use foreach to enumerate list elements,
        // the elements are retrieved as KeyValuePair objects.
        Console::WriteLine();
        for each( KeyValuePair<String^, String^> kvp in openWith )
        {
            Console::WriteLine("Key = {0}, Value = {1}",
                kvp.Key, kvp.Value);
        }

        // To get the values alone, use the Values property.
        IList<String^>^ ilistValues = openWith->Values;

        // The elements of the list are strongly typed with the
        // type that was specified for the SorteList values.
        Console::WriteLine();
        for each( String^ s in ilistValues )
        {
            Console::WriteLine("Value = {0}", s);
        }

        // The Values property is an efficient way to retrieve
        // values by index.
        Console::WriteLine("\nIndexed retrieval using the Values " +
            "property: Values[2] = {0}", openWith->Values[2]);

        // To get the keys alone, use the Keys property.
        IList<String^>^ ilistKeys = openWith->Keys;

        // The elements of the list are strongly typed with the
        // type that was specified for the SortedList keys.
        Console::WriteLine();
        for each( String^ s in ilistKeys )
        {
            Console::WriteLine("Key = {0}", s);
        }

        // The Keys property is an efficient way to retrieve
        // keys by index.
        Console::WriteLine("\nIndexed retrieval using the Keys " +
            "property: Keys[2] = {0}", openWith->Keys[2]);

        // Use the Remove method to remove a key/value pair.
        Console::WriteLine("\nRemove(\"doc\")");
        openWith->Remove("doc");

        if (!openWith->ContainsKey("doc"))
        {
            Console::WriteLine("Key \"doc\" is not found.");
        }
    }
};

int main()
{
    Example::Main();
}

/* This code example produces the following output:

An element with Key = "txt" already exists.
For key = "rtf", value = wordpad.exe.
For key = "rtf", value = winword.exe.
Key = "tif" is not found.
Key = "tif" is not found.
Value added for key = "ht": hypertrm.exe

Key = bmp, Value = paint.exe
Key = dib, Value = paint.exe
Key = doc, Value = winword.exe
Key = ht, Value = hypertrm.exe
Key = rtf, Value = winword.exe
Key = txt, Value = notepad.exe

Value = paint.exe
Value = paint.exe
Value = winword.exe
Value = hypertrm.exe
Value = winword.exe
Value = notepad.exe

Indexed retrieval using the Values property: Values[2] = winword.exe

Key = bmp
Key = dib
Key = doc
Key = ht
Key = rtf
Key = txt

Indexed retrieval using the Keys property: Keys[2] = doc

Remove("doc")
Key "doc" is not found.
 */
using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        // Create a new sorted list of strings, with string
        // keys.
        SortedList<string, string> openWith = 
            new SortedList<string, string>();

        // Add some elements to the list. There are no 
        // duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe");
        openWith.Add("bmp", "paint.exe");
        openWith.Add("dib", "paint.exe");
        openWith.Add("rtf", "wordpad.exe");

        // The Add method throws an exception if the new key is 
        // already in the list.
        try
        {
            openWith.Add("txt", "winword.exe");
        }
        catch (ArgumentException)
        {
            Console.WriteLine("An element with Key = \"txt\" already exists.");
        }

        // The Item property is another name for the indexer, so you 
        // can omit its name when accessing elements. 
        Console.WriteLine("For key = \"rtf\", value = {0}.", 
            openWith["rtf"]);

        // The indexer can be used to change the value associated
        // with a key.
        openWith["rtf"] = "winword.exe";
        Console.WriteLine("For key = \"rtf\", value = {0}.", 
            openWith["rtf"]);

        // If a key does not exist, setting the indexer for that key
        // adds a new key/value pair.
        openWith["doc"] = "winword.exe";

        // The indexer throws an exception if the requested key is
        // not in the list.
        try
        {
            Console.WriteLine("For key = \"tif\", value = {0}.", 
                openWith["tif"]);
        }
        catch (KeyNotFoundException)
        {
            Console.WriteLine("Key = \"tif\" is not found.");
        }

        // When a program often has to try keys that turn out not to
        // be in the list, TryGetValue can be a more efficient 
        // way to retrieve values.
        string value = "";
        if (openWith.TryGetValue("tif", out value))
        {
            Console.WriteLine("For key = \"tif\", value = {0}.", value);
        }
        else
        {
            Console.WriteLine("Key = \"tif\" is not found.");
        }

        // ContainsKey can be used to test keys before inserting 
        // them.
        if (!openWith.ContainsKey("ht"))
        {
            openWith.Add("ht", "hypertrm.exe");
            Console.WriteLine("Value added for key = \"ht\": {0}", 
                openWith["ht"]);
        }

        // When you use foreach to enumerate list elements,
        // the elements are retrieved as KeyValuePair objects.
        Console.WriteLine();
        foreach( KeyValuePair<string, string> kvp in openWith )
        {
            Console.WriteLine("Key = {0}, Value = {1}", 
                kvp.Key, kvp.Value);
        }

        // To get the values alone, use the Values property.
        IList<string> ilistValues = openWith.Values;

        // The elements of the list are strongly typed with the 
        // type that was specified for the SorteList values.
        Console.WriteLine();
        foreach( string s in ilistValues )
        {
            Console.WriteLine("Value = {0}", s);
        }

        // The Values property is an efficient way to retrieve
        // values by index.
        Console.WriteLine("\nIndexed retrieval using the Values " +
            "property: Values[2] = {0}", openWith.Values[2]);

        // To get the keys alone, use the Keys property.
        IList<string> ilistKeys = openWith.Keys;

        // The elements of the list are strongly typed with the 
        // type that was specified for the SortedList keys.
        Console.WriteLine();
        foreach( string s in ilistKeys )
        {
            Console.WriteLine("Key = {0}", s);
        }

        // The Keys property is an efficient way to retrieve
        // keys by index.
        Console.WriteLine("\nIndexed retrieval using the Keys " +
            "property: Keys[2] = {0}", openWith.Keys[2]);

        // Use the Remove method to remove a key/value pair.
        Console.WriteLine("\nRemove(\"doc\")");
        openWith.Remove("doc");

        if (!openWith.ContainsKey("doc"))
        {
            Console.WriteLine("Key \"doc\" is not found.");
        }
    }
}

/* This code example produces the following output:

An element with Key = "txt" already exists.
For key = "rtf", value = wordpad.exe.
For key = "rtf", value = winword.exe.
Key = "tif" is not found.
Key = "tif" is not found.
Value added for key = "ht": hypertrm.exe

Key = bmp, Value = paint.exe
Key = dib, Value = paint.exe
Key = doc, Value = winword.exe
Key = ht, Value = hypertrm.exe
Key = rtf, Value = winword.exe
Key = txt, Value = notepad.exe

Value = paint.exe
Value = paint.exe
Value = winword.exe
Value = hypertrm.exe
Value = winword.exe
Value = notepad.exe

Indexed retrieval using the Values property: Values[2] = winword.exe

Key = bmp
Key = dib
Key = doc
Key = ht
Key = rtf
Key = txt

Indexed retrieval using the Keys property: Keys[2] = doc

Remove("doc")
Key "doc" is not found.
 */
Imports System
Imports System.Collections.Generic

Public Class Example
    
    Public Shared Sub Main() 

        ' Create a new sorted list of strings, with string 
        ' keys. 
        Dim openWith As New SortedList(Of String, String)
        
        ' Add some elements to the list. There are no 
        ' duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe")
        openWith.Add("bmp", "paint.exe")
        openWith.Add("dib", "paint.exe")
        openWith.Add("rtf", "wordpad.exe")
        
        ' The Add method throws an exception if the new key is 
        ' already in the list.
        Try
            openWith.Add("txt", "winword.exe")
        Catch 
            Console.WriteLine("An element with Key = ""txt"" already exists.")
        End Try

        ' The Item property is the default property, so you 
        ' can omit its name when accessing elements. 
        Console.WriteLine("For key = ""rtf"", value = {0}.", _
            openWith("rtf"))
        
        ' The default Item property can be used to change the value
        ' associated with a key.
        openWith("rtf") = "winword.exe"
        Console.WriteLine("For key = ""rtf"", value = {0}.", _
            openWith("rtf"))
        
        ' If a key does not exist, setting the default Item property
        ' for that key adds a new key/value pair.
        openWith("doc") = "winword.exe"

        ' The default Item property throws an exception if the requested
        ' key is not in the list.
        Try
            Console.WriteLine("For key = ""tif"", value = {0}.", _
                openWith("tif"))
        Catch 
            Console.WriteLine("Key = ""tif"" is not found.")
        End Try

        ' When a program often has to try keys that turn out not to
        ' be in the list, TryGetValue can be a more efficient 
        ' way to retrieve values.
        Dim value As String = ""
        If openWith.TryGetValue("tif", value) Then
            Console.WriteLine("For key = ""tif"", value = {0}.", value)
        Else
            Console.WriteLine("Key = ""tif"" is not found.")
        End If

        ' ContainsKey can be used to test keys before inserting 
        ' them.
        If Not openWith.ContainsKey("ht") Then
            openWith.Add("ht", "hypertrm.exe")
            Console.WriteLine("Value added for key = ""ht"": {0}", _
                openWith("ht"))
        End If

        ' When you use foreach to enumerate list elements,
        ' the elements are retrieved as KeyValuePair objects.
        Console.WriteLine()
        For Each kvp As KeyValuePair(Of String, String) In openWith
            Console.WriteLine("Key = {0}, Value = {1}", _
                kvp.Key, kvp.Value)
        Next kvp

        ' To get the values alone, use the Values property.
        Dim ilistValues As IList(Of String) = openWith.Values
        
        ' The elements of the list are strongly typed with the
        ' type that was specified for the SortedList values.
        Console.WriteLine()
        For Each s As String In ilistValues
            Console.WriteLine("Value = {0}", s)
        Next s

        ' The Values property is an efficient way to retrieve
        ' values by index.
        Console.WriteLine(vbLf & "Indexed retrieval using the " & _
            "Values property: Values(2) = {0}", openWith.Values(2))

        ' To get the keys alone, use the Keys property.
        Dim ilistKeys As IList(Of String) = openWith.Keys
        
        ' The elements of the list are strongly typed with the
        ' type that was specified for the SortedList keys.
        Console.WriteLine()
        For Each s As String In ilistKeys 
            Console.WriteLine("Key = {0}", s)
        Next s

        ' The Keys property is an efficient way to retrieve
        ' keys by index.
        Console.WriteLine(vbLf & "Indexed retrieval using the " & _
            "Keys property: Keys(2) = {0}", openWith.Keys(2))

        ' Use the Remove method to remove a key/value pair.
        Console.WriteLine(vbLf + "Remove(""doc"")")
        openWith.Remove("doc")
        
        If Not openWith.ContainsKey("doc") Then
            Console.WriteLine("Key ""doc"" is not found.")
        End If

    End Sub

End Class

' This code example produces the following output:
'
'An element with Key = "txt" already exists.
'For key = "rtf", value = wordpad.exe.
'For key = "rtf", value = winword.exe.
'Key = "tif" is not found.
'Key = "tif" is not found.
'Value added for key = "ht": hypertrm.exe
'
'Key = bmp, Value = paint.exe
'Key = dib, Value = paint.exe
'Key = doc, Value = winword.exe
'Key = ht, Value = hypertrm.exe
'Key = rtf, Value = winword.exe
'Key = txt, Value = notepad.exe
'
'Value = paint.exe
'Value = paint.exe
'Value = winword.exe
'Value = hypertrm.exe
'Value = winword.exe
'Value = notepad.exe
'
'Indexed retrieval using the Values property: Values(2) = winword.exe
'
'Key = bmp
'Key = dib
'Key = doc
'Key = ht
'Key = rtf
'Key = txt
'
'Indexed retrieval using the Keys property: Keys(2) = doc
'
'Remove("doc")
'Key "doc" is not found.
' 

Commenti

Il SortedList<TKey,TValue> classe generica è una matrice di coppie chiave/valore con O (log n) il recupero, dove n è il numero di elementi nel dizionario.The SortedList<TKey,TValue> generic class is an array of key/value pairs with O(log n) retrieval, where n is the number of elements in the dictionary. Questa classe è simile al SortedDictionary<TKey,TValue> classe generica.In this, it is similar to the SortedDictionary<TKey,TValue> generic class. Le due classi hanno modelli di oggetto simile ed entrambi presentano O (log n) il recupero.The two classes have similar object models, and both have O(log n) retrieval. In cui le due classi diverse è in uso della memoria e velocità di inserimento e rimozione:Where the two classes differ is in memory use and speed of insertion and removal:

Un'altra differenza tra il SortedDictionary<TKey,TValue> e SortedList<TKey,TValue> classi è che SortedList<TKey,TValue> supporta efficiente recupero indicizzato di chiavi e valori tramite le raccolte restituite dal Keys e Values proprietà.Another difference between the SortedDictionary<TKey,TValue> and SortedList<TKey,TValue> classes is that SortedList<TKey,TValue> supports efficient indexed retrieval of keys and values through the collections returned by the Keys and Values properties. Non è necessario rigenerare gli elenchi di quando si accede a proprietà, poiché gli elenchi sono semplicemente wrapper per le matrici interne di chiavi e valori.It is not necessary to regenerate the lists when the properties are accessed, because the lists are just wrappers for the internal arrays of keys and values. Il codice seguente viene illustrato come utilizzare il Values proprietà per il recupero indicizzato di valori da un elenco ordinato di stringhe:The following code shows the use of the Values property for indexed retrieval of values from a sorted list of strings:

String^ v = mySortedList->Values[3];
string v = mySortedList.Values[3];
Dim v As String = mySortedList.Values(3)

SortedList<TKey,TValue> viene implementato come una matrice di coppie chiave/valore, ordinate per chiave.SortedList<TKey,TValue> is implemented as an array of key/value pairs, sorted by the key. Ogni elemento può essere recuperato come un KeyValuePair<TKey,TValue> oggetto.Each element can be retrieved as a KeyValuePair<TKey,TValue> object.

Gli oggetti principali devono essere non modificabili, purché vengono utilizzati come chiavi nel SortedList<TKey,TValue>.Key objects must be immutable as long as they are used as keys in the SortedList<TKey,TValue>. Ogni chiave in un SortedList<TKey,TValue> devono essere univoci.Every key in a SortedList<TKey,TValue> must be unique. Una chiave non può essere null, ma un valore può essere, se il tipo dei valori nell'elenco, TValue, è un tipo riferimento.A key cannot be null, but a value can be, if the type of values in the list, TValue, is a reference type.

SortedList<TKey,TValue> richiede un'implementazione di comparer per ordinare ed eseguire i confronti.SortedList<TKey,TValue> requires a comparer implementation to sort and to perform comparisons. L'operatore di confronto Comparer<T>.Default controlla se la chiave di tipo TKey implementa System.IComparable<T> e utilizza tale implementazione, se disponibile.The default comparer Comparer<T>.Default checks whether the key type TKey implements System.IComparable<T> and uses that implementation, if available. In caso contrario, Comparer<T>.Default controlla se la chiave di tipo TKey implementa System.IComparable.If not, Comparer<T>.Default checks whether the key type TKey implements System.IComparable. Se il tipo di chiave TKey non implementa alcuna interfaccia, è possibile specificare un System.Collections.Generic.IComparer<T> implementazione in un overload del costruttore che accetta un comparer parametro.If the key type TKey does not implement either interface, you can specify a System.Collections.Generic.IComparer<T> implementation in a constructor overload that accepts a comparer parameter.

La capacità di un SortedList<TKey,TValue> è il numero di elementi di SortedList<TKey,TValue> può contenere.The capacity of a SortedList<TKey,TValue> is the number of elements the SortedList<TKey,TValue> can hold. Man mano che gli elementi vengono aggiunti a un SortedList<TKey,TValue>, la capacità viene aumentata automaticamente come richiesto da la riallocazione della matrice interna.As elements are added to a SortedList<TKey,TValue>, the capacity is automatically increased as required by reallocating the internal array. È possibile diminuire la capacità chiamando TrimExcess oppure impostando il Capacity proprietà in modo esplicito.The capacity can be decreased by calling TrimExcess or by setting the Capacity property explicitly. La riduzione della capacità la memoria viene riallocata e copia tutti gli elementi di SortedList<TKey,TValue>.Decreasing the capacity reallocates memory and copies all the elements in the SortedList<TKey,TValue>.

Solo in .NET framework: Per grandi SortedList<TKey,TValue> oggetti, è possibile aumentare la capacità massima a 2 miliardi di elementi in un sistema a 64 bit impostando il enabled attributo del <gcAllowVeryLargeObjects> elemento di configurazione true nel ambiente di runtime..NET Framework only: For very large SortedList<TKey,TValue> objects, you can increase the maximum capacity to 2 billion elements on a 64-bit system by setting the enabled attribute of the <gcAllowVeryLargeObjects> configuration element to true in the run-time environment.

Il foreach istruzione del linguaggio c# (for each in C++, For Each in Visual Basic) restituisce un oggetto del tipo degli elementi nella raccolta.The foreach statement of the C# language (for each in C++, For Each in Visual Basic) returns an object of the type of the elements in the collection. Poiché gli elementi del SortedList<TKey,TValue> sono coppie chiave/valore, il tipo di elemento non è il tipo della chiave o il tipo del valore.Since the elements of the SortedList<TKey,TValue> are key/value pairs, the element type is not the type of the key or the type of the value. Al contrario, il tipo di elemento è KeyValuePair<TKey,TValue>.Instead, the element type is KeyValuePair<TKey,TValue>. Ad esempio:For example:

for each( KeyValuePair<int, String^> kvp in mySortedList )
{
    Console::WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
}
foreach( KeyValuePair<int, string> kvp in mySortedList )
{
    Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
}
For Each kvp As KeyValuePair(Of Integer, String) In mySortedList
    Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value)
Next kvp

Il foreach istruzione è un wrapper per l'enumeratore, che consente solo di leggere da, non la scrittura, la raccolta.The foreach statement is a wrapper around the enumerator, which only allows reading from, not writing to, the collection.

Costruttori

SortedList<TKey,TValue>() SortedList<TKey,TValue>() SortedList<TKey,TValue>() SortedList<TKey,TValue>()

Inizializza una nuova istanza vuota della classe SortedList<TKey,TValue> con la capacità iniziale predefinita e che utilizza l'interfaccia IComparer<T> predefinita.Initializes a new instance of the SortedList<TKey,TValue> class that is empty, has the default initial capacity, and uses the default IComparer<T>.

SortedList<TKey,TValue>(IComparer<TKey>) SortedList<TKey,TValue>(IComparer<TKey>) SortedList<TKey,TValue>(IComparer<TKey>) SortedList<TKey,TValue>(IComparer<TKey>)

Inizializza una nuova istanza vuota della classe SortedList<TKey,TValue>, con capacità iniziale predefinita e che utilizza l'interfaccia IComparer<T> specificata.Initializes a new instance of the SortedList<TKey,TValue> class that is empty, has the default initial capacity, and uses the specified IComparer<T>.

SortedList<TKey,TValue>(IDictionary<TKey,TValue>) SortedList<TKey,TValue>(IDictionary<TKey,TValue>) SortedList<TKey,TValue>(IDictionary<TKey,TValue>) SortedList<TKey,TValue>(IDictionary<TKey,TValue>)

Inizializza una nuova istanza della classe SortedList<TKey,TValue> che contiene gli elementi copiati dall'interfaccia IDictionary<TKey,TValue> specificata, che presenta una capacità sufficiente a contenere il numero di elementi copiati e che utilizza l'interfaccia IComparer<T> predefinita.Initializes a new instance of the SortedList<TKey,TValue> class that contains elements copied from the specified IDictionary<TKey,TValue>, has sufficient capacity to accommodate the number of elements copied, and uses the default IComparer<T>.

SortedList<TKey,TValue>(IDictionary<TKey,TValue>, IComparer<TKey>) SortedList<TKey,TValue>(IDictionary<TKey,TValue>, IComparer<TKey>) SortedList<TKey,TValue>(IDictionary<TKey,TValue>, IComparer<TKey>) SortedList<TKey,TValue>(IDictionary<TKey,TValue>, IComparer<TKey>)

Inizializza una nuova istanza della classe SortedList<TKey,TValue> che contiene gli elementi copiati dall'interfaccia IDictionary<TKey,TValue> specificata, che presenta una capacità sufficiente a contenere il numero di elementi copiati e che utilizza l'interfaccia IComparer<T> specificata.Initializes a new instance of the SortedList<TKey,TValue> class that contains elements copied from the specified IDictionary<TKey,TValue>, has sufficient capacity to accommodate the number of elements copied, and uses the specified IComparer<T>.

SortedList<TKey,TValue>(Int32) SortedList<TKey,TValue>(Int32) SortedList<TKey,TValue>(Int32) SortedList<TKey,TValue>(Int32)

Inizializza una nuova istanza vuota della classe SortedList<TKey,TValue>, con la capacità iniziale specificata e che utilizza l'interfaccia IComparer<T> predefinita.Initializes a new instance of the SortedList<TKey,TValue> class that is empty, has the specified initial capacity, and uses the default IComparer<T>.

SortedList<TKey,TValue>(Int32, IComparer<TKey>) SortedList<TKey,TValue>(Int32, IComparer<TKey>) SortedList<TKey,TValue>(Int32, IComparer<TKey>) SortedList<TKey,TValue>(Int32, IComparer<TKey>)

Inizializza una nuova istanza vuota della classe SortedList<TKey,TValue>, con capacità iniziale specificata e che utilizza l'interfaccia IComparer<T> specificata.Initializes a new instance of the SortedList<TKey,TValue> class that is empty, has the specified initial capacity, and uses the specified IComparer<T>.

Proprietà

Capacity Capacity Capacity Capacity

Ottiene o imposta il numero di elementi che SortedList<TKey,TValue> può contenere.Gets or sets the number of elements that the SortedList<TKey,TValue> can contain.

Comparer Comparer Comparer Comparer

Ottiene l'interfaccia IComparer<T> per l'elenco ordinato.Gets the IComparer<T> for the sorted list.

Count Count Count Count

Ottiene il numero di coppie chiave/valore contenute in SortedList<TKey,TValue>.Gets the number of key/value pairs contained in the SortedList<TKey,TValue>.

Item[TKey] Item[TKey] Item[TKey] Item[TKey]

Ottiene o imposta il valore associato alla chiave specificata.Gets or sets the value associated with the specified key.

Keys Keys Keys Keys

Ottiene una raccolta contenente le chiavi in SortedList<TKey,TValue> nell'ordine specificato.Gets a collection containing the keys in the SortedList<TKey,TValue>, in sorted order.

Values Values Values Values

Ottiene una raccolta contenente i valori di SortedList<TKey,TValue>.Gets a collection containing the values in the SortedList<TKey,TValue>.

Metodi

Add(TKey, TValue) Add(TKey, TValue) Add(TKey, TValue) Add(TKey, TValue)

Aggiunge un elemento con la chiave e il valore specificati al metodo SortedList<TKey,TValue>.Adds an element with the specified key and value into the SortedList<TKey,TValue>.

Clear() Clear() Clear() Clear()

Rimuove tutti gli elementi da SortedList<TKey,TValue>.Removes all elements from the SortedList<TKey,TValue>.

ContainsKey(TKey) ContainsKey(TKey) ContainsKey(TKey) ContainsKey(TKey)

Determina se l'oggetto SortedList<TKey,TValue> contiene una chiave specifica.Determines whether the SortedList<TKey,TValue> contains a specific key.

ContainsValue(TValue) ContainsValue(TValue) ContainsValue(TValue) ContainsValue(TValue)

Stabilisce se SortedList<TKey,TValue> contiene un valore specifico.Determines whether the SortedList<TKey,TValue> contains a specific value.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Restituisce un enumeratore che esegue l'iterazione di SortedList<TKey,TValue>.Returns an enumerator that iterates through the SortedList<TKey,TValue>.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Inherited from Object)
IndexOfKey(TKey) IndexOfKey(TKey) IndexOfKey(TKey) IndexOfKey(TKey)

Cerca la chiave specificata e restituisce l'indice in base zero all'interno dell'intero insieme SortedList<TKey,TValue>.Searches for the specified key and returns the zero-based index within the entire SortedList<TKey,TValue>.

IndexOfValue(TValue) IndexOfValue(TValue) IndexOfValue(TValue) IndexOfValue(TValue)

Cerca il valore specificato e restituisce l'indice in base zero della prima occorrenza all'interno dell'intero insieme SortedList<TKey,TValue>.Searches for the specified value and returns the zero-based index of the first occurrence within the entire SortedList<TKey,TValue>.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
Remove(TKey) Remove(TKey) Remove(TKey) Remove(TKey)

Rimuove l'elemento con la chiave specificata da SortedList<TKey,TValue>.Removes the element with the specified key from the SortedList<TKey,TValue>.

RemoveAt(Int32) RemoveAt(Int32) RemoveAt(Int32) RemoveAt(Int32)

Rimuove l'elemento in corrispondenza dell'indice specificato di SortedList<TKey,TValue>.Removes the element at the specified index of the SortedList<TKey,TValue>.

ToString() ToString() ToString() ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Inherited from Object)
TrimExcess() TrimExcess() TrimExcess() TrimExcess()

Imposta la capacità dell'insieme sul numero reale di elementi contenuti nell'oggetto SortedList<TKey,TValue>, se questo numero è inferiore al 90 per cento della capacità corrente.Sets the capacity to the actual number of elements in the SortedList<TKey,TValue>, if that number is less than 90 percent of current capacity.

TryGetValue(TKey, TValue) TryGetValue(TKey, TValue) TryGetValue(TKey, TValue) TryGetValue(TKey, TValue)

Ottiene il valore associato alla chiave specificata.Gets the value associated with the specified key.

Implementazioni dell'interfaccia esplicita

ICollection.CopyTo(Array, Int32) ICollection.CopyTo(Array, Int32) ICollection.CopyTo(Array, Int32) ICollection.CopyTo(Array, Int32)

Copia gli elementi di ICollection in Array a partire da un particolare indice Array.Copies the elements of the ICollection to an Array, starting at a particular Array index.

ICollection.IsSynchronized ICollection.IsSynchronized ICollection.IsSynchronized ICollection.IsSynchronized

Ottiene un valore che indica se l'accesso a ICollection è sincronizzato (thread-safe).Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot ICollection.SyncRoot ICollection.SyncRoot ICollection.SyncRoot

Ottiene un oggetto che può essere usato per sincronizzare l'accesso a ICollection.Gets an object that can be used to synchronize access to the ICollection.

ICollection<KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey,TValue>) ICollection<KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey,TValue>) ICollection<KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey,TValue>) ICollection<KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey,TValue>)

Aggiunge una coppia chiave/valore all'interfaccia ICollection<T>.Adds a key/value pair to the ICollection<T>.

ICollection<KeyValuePair<TKey,TValue>>.Contains(KeyValuePair<TKey,TValue>) ICollection<KeyValuePair<TKey,TValue>>.Contains(KeyValuePair<TKey,TValue>) ICollection<KeyValuePair<TKey,TValue>>.Contains(KeyValuePair<TKey,TValue>) ICollection<KeyValuePair<TKey,TValue>>.Contains(KeyValuePair<TKey,TValue>)

Consente di stabilire se ICollection<T> contiene un elemento specifico.Determines whether the ICollection<T> contains a specific element.

ICollection<KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey,TValue>[], Int32) ICollection<KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey,TValue>[], Int32) ICollection<KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey,TValue>[], Int32) ICollection<KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey,TValue>[], Int32)

Copia gli elementi di ICollection<T> in Array a partire da un particolare indice Array.Copies the elements of the ICollection<T> to an Array, starting at a particular Array index.

ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly

Ottiene un valore che indica se ICollection<T> è di sola lettura.Gets a value indicating whether the ICollection<T> is read-only.

ICollection<KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey,TValue>) ICollection<KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey,TValue>) ICollection<KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey,TValue>) ICollection<KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey,TValue>)

Rimuove la prima occorrenza di una coppia chiave/valore specifica dall'interfaccia ICollection<T>.Removes the first occurrence of a specific key/value pair from the ICollection<T>.

IDictionary.Add(Object, Object) IDictionary.Add(Object, Object) IDictionary.Add(Object, Object) IDictionary.Add(Object, Object)

Aggiunge un elemento con la chiave e il valore forniti all'interfaccia IDictionary.Adds an element with the provided key and value to the IDictionary.

IDictionary.Contains(Object) IDictionary.Contains(Object) IDictionary.Contains(Object) IDictionary.Contains(Object)

Determina se IDictionary contiene un elemento con la chiave specificata.Determines whether the IDictionary contains an element with the specified key.

IDictionary.GetEnumerator() IDictionary.GetEnumerator() IDictionary.GetEnumerator() IDictionary.GetEnumerator()

Viene restituito un IDictionaryEnumerator per l'oggetto IDictionary.Returns an IDictionaryEnumerator for the IDictionary.

IDictionary.IsFixedSize IDictionary.IsFixedSize IDictionary.IsFixedSize IDictionary.IsFixedSize

Ottiene un valore che indica se IDictionary ha dimensioni fisse.Gets a value indicating whether the IDictionary has a fixed size.

IDictionary.IsReadOnly IDictionary.IsReadOnly IDictionary.IsReadOnly IDictionary.IsReadOnly

Ottiene un valore che indica se IDictionary è di sola lettura.Gets a value indicating whether the IDictionary is read-only.

IDictionary.Item[Object] IDictionary.Item[Object] IDictionary.Item[Object] IDictionary.Item[Object]

Ottiene o imposta l'elemento con la chiave specificata.Gets or sets the element with the specified key.

IDictionary.Keys IDictionary.Keys IDictionary.Keys IDictionary.Keys

Ottiene ICollection contenente le chiavi di IDictionary.Gets an ICollection containing the keys of the IDictionary.

IDictionary.Remove(Object) IDictionary.Remove(Object) IDictionary.Remove(Object) IDictionary.Remove(Object)

Rimuove l'elemento con la chiave specificata da IDictionary.Removes the element with the specified key from the IDictionary.

IDictionary.Values IDictionary.Values IDictionary.Values IDictionary.Values

Ottiene ICollection contenente i valori in IDictionary.Gets an ICollection containing the values in the IDictionary.

IDictionary<TKey,TValue>.Keys IDictionary<TKey,TValue>.Keys IDictionary<TKey,TValue>.Keys IDictionary<TKey,TValue>.Keys

Ottiene ICollection<T> contenente le chiavi di IDictionary<TKey,TValue>.Gets an ICollection<T> containing the keys of the IDictionary<TKey,TValue>.

IDictionary<TKey,TValue>.Values IDictionary<TKey,TValue>.Values IDictionary<TKey,TValue>.Values IDictionary<TKey,TValue>.Values

Ottiene ICollection<T> contenente i valori in IDictionary<TKey,TValue>.Gets an ICollection<T> containing the values in the IDictionary<TKey,TValue>.

IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

Restituisce un enumeratore che consente di eseguire l'iterazione di una raccolta.Returns an enumerator that iterates through a collection.

IEnumerable<KeyValuePair<TKey,TValue>>.GetEnumerator() IEnumerable<KeyValuePair<TKey,TValue>>.GetEnumerator() IEnumerable<KeyValuePair<TKey,TValue>>.GetEnumerator() IEnumerable<KeyValuePair<TKey,TValue>>.GetEnumerator()

Restituisce un enumeratore che consente di eseguire l'iterazione di una raccolta.Returns an enumerator that iterates through a collection.

IReadOnlyDictionary<TKey,TValue>.Keys IReadOnlyDictionary<TKey,TValue>.Keys IReadOnlyDictionary<TKey,TValue>.Keys IReadOnlyDictionary<TKey,TValue>.Keys

Ottiene una raccolta enumerabile contenente le chiavi nel dizionario di sola lettura.Gets an enumerable collection that contains the keys in the read-only dictionary.

IReadOnlyDictionary<TKey,TValue>.Values IReadOnlyDictionary<TKey,TValue>.Values IReadOnlyDictionary<TKey,TValue>.Values IReadOnlyDictionary<TKey,TValue>.Values

Ottiene una raccolta enumerabile contenente i valori nel dizionario di sola lettura.Gets an enumerable collection that contains the values in the read-only dictionary.

Extension Methods

GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey) GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey) GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey) GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey)
GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey, TValue) GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey, TValue) GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey, TValue) GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey, TValue)
Remove<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue) Remove<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue) Remove<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue) Remove<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue)
TryAdd<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue) TryAdd<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue) TryAdd<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue) TryAdd<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue)
CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>)

Restituisce un DataTable che contiene copie del DataRow oggetti, dato un input IEnumerable<T> oggetto in cui il parametro generico T è DataRow.Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Le copie DataRow oggetti specificata DataTable, un giudizio IEnumerable<T> oggetto in cui il parametro generico T è DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Le copie DataRow oggetti specificata DataTable, un giudizio IEnumerable<T> oggetto in cui il parametro generico T è DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Esegue il cast di elementi di un IEnumerable nel tipo specificato.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtra gli elementi di un IEnumerable basato su un tipo specificato.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Consente la parallelizzazione di una query.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Converte un' IEnumerable a un IQueryable.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>)

Restituisce una raccolta di elementi che contiene i predecessori di ciascun nodo nella raccolta di origine.Returns a collection of elements that contains the ancestors of every node in the source collection.

Ancestors<T>(IEnumerable<T>, XName) Ancestors<T>(IEnumerable<T>, XName) Ancestors<T>(IEnumerable<T>, XName) Ancestors<T>(IEnumerable<T>, XName)

Restituisce una raccolta di elementi filtrati che contiene i predecessori di ciascun nodo nella raccolta di origine.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>)

Restituisce una raccolta di nodi discendenti di ciascun documento ed elemento nella raccolta di origine.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>)

Restituisce una raccolta di elementi che contiene gli elementi discendenti di ciascun elemento e documento nella raccolta di origine.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName) Descendants<T>(IEnumerable<T>, XName) Descendants<T>(IEnumerable<T>, XName) Descendants<T>(IEnumerable<T>, XName)

Restituisce una raccolta filtrata di elementi che contiene gli elementi discendenti di ciascun elemento e documento nella raccolta di origine.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>)

Restituisce una raccolta di elementi figlio di ciascun elemento e documento nella raccolta di origine.Returns a collection of the child elements of every element and document in the source collection.

Elements<T>(IEnumerable<T>, XName) Elements<T>(IEnumerable<T>, XName) Elements<T>(IEnumerable<T>, XName) Elements<T>(IEnumerable<T>, XName)

Restituisce una raccolta filtrata degli elementi figlio di ciascun elemento e documento nella raccolta di origine.Returns a filtered collection of the child elements of every element and document in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>)

Restituisce una raccolta di nodi che contiene tutti i nodi nella raccolta di origine ordinati in base all'ordine con cui sono riportati nel documento.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>)

Restituisce una raccolta di nodi figlio di ciascun documento ed elemento nella raccolta di origine.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>)

Rimuove ciascun nodo nella raccolta di origine dal nodo padre.Removes every node in the source collection from its parent node.

Si applica a

Thread safety

Statici pubblici (Shared in Visual Basic) membri di questo tipo sono thread-safe.Public static (Shared in Visual Basic) members of this type are thread safe. I membri di istanza non sono garantiti come thread-safe.Any instance members are not guaranteed to be thread safe.

Oggetto SortedList<TKey,TValue> può supportare più lettori contemporaneamente, fino a quando non viene modificata la raccolta.A SortedList<TKey,TValue> can support multiple readers concurrently, as long as the collection is not modified. Anche in questo caso, l'enumerazione di una raccolta di per sé non è una procedura thread-safe.Even so, enumerating through a collection is intrinsically not a thread-safe procedure. Per assicurare la protezione del thread durante l'enumerazione, è possibile bloccare la raccolta durante l'intera enumerazione.To guarantee thread safety during enumeration, you can lock the collection during the entire enumeration. Per consentire l'accesso alla raccolta in lettura e scrittura da parte di più thread, è necessario implementare la propria sincronizzazione.To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

Vedi anche