SortedList Class

Definition

Namespace:: System.Collections.Generic

Assemblies:: System.dll, System.Collections.dll

Assemblies:: netstandard.dll, System.Collections.dll

Assembly:: System.Collections.dll

Assembly:: System.dll

Assembly:: netstandard.dll

Source:: SortedList.cs

Source:: SortedList.cs

Source:: SortedList.cs

Source:: SortedList.cs

Source:: SortedList.cs

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Represents a collection of key/value pairs that are sorted by key based on the associated IComparer implementation.

generic 
public ref class SortedList : System::Collections::Generic::ICollection>, System::Collections::Generic::IDictionary, System::Collections::Generic::IEnumerable>, System::Collections::Generic::IReadOnlyCollection>, System::Collections::Generic::IReadOnlyDictionary, System::Collections::IDictionary

generic 
public ref class SortedList : System::Collections::Generic::ICollection>, System::Collections::Generic::IDictionary, System::Collections::Generic::IEnumerable>, System::Collections::IDictionary

public class SortedList : System.Collections.Generic.ICollection>, System.Collections.Generic.IDictionary, System.Collections.Generic.IEnumerable>, System.Collections.Generic.IReadOnlyCollection>, System.Collections.Generic.IReadOnlyDictionary, System.Collections.IDictionary

[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class SortedList : System.Collections.Generic.ICollection>, System.Collections.Generic.IDictionary, System.Collections.Generic.IEnumerable>, System.Collections.IDictionary

[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class SortedList : System.Collections.Generic.ICollection>, System.Collections.Generic.IDictionary, System.Collections.Generic.IEnumerable>, System.Collections.Generic.IReadOnlyCollection>, System.Collections.Generic.IReadOnlyDictionary, System.Collections.IDictionary

type SortedList<'Key, 'Value> = class
    interface ICollection>
    interface seq>
    interface IEnumerable
    interface IDictionary<'Key, 'Value>
    interface IReadOnlyCollection>
    interface IReadOnlyDictionary<'Key, 'Value>
    interface ICollection
    interface IDictionary

[]
[]
type SortedList<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface ICollection>
    interface seq>
    interface IDictionary
    interface ICollection
    interface IEnumerable

[]
[]
type SortedList<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface ICollection>
    interface seq>
    interface IEnumerable
    interface IDictionary
    interface ICollection
    interface IReadOnlyDictionary<'Key, 'Value>
    interface IReadOnlyCollection>

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)

Public Class SortedList(Of TKey, TValue)
Implements ICollection(Of KeyValuePair(Of TKey, TValue)), IDictionary, IDictionary(Of TKey, TValue), IEnumerable(Of KeyValuePair(Of TKey, TValue))

Type Parameters

TKey

The type of keys in the collection.

TValue

The type of values in the collection.

Inheritance: Object
SortedList

Derived: System.IdentityModel.Metadata.IndexedProtocolEndpointDictionary

Attributes: ComVisibleAttribute SerializableAttribute

Implements: ICollection<KeyValuePair> IDictionary IEnumerable<KeyValuePair> IEnumerable IReadOnlyCollection<KeyValuePair> IReadOnlyDictionary ICollection IDictionary IEnumerable

Examples

The following code example creates an empty SortedList of strings with string keys and uses the Add method to add some elements. The example demonstrates that the Add method throws an ArgumentException when attempting to add a duplicate key.

The example uses the Item[] 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.

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.

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.

Finally, the example demonstrates the Remove method.

using System;
using System.Collections.Generic;

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

        // 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 kvp in openWith )
        {
            Console.WriteLine("Key = {0}, Value = {1}",
                kvp.Key, kvp.Value);
        }

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

        // The elements of the list are strongly typed with the
        // type that was specified for the SortedList 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 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.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.
'

open System
open System.Collections.Generic

// Create a new sorted list of strings, with string
// keys.
let openWith = SortedList()

// 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");
with
    | :? ArgumentException ->
        printfn "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.
printfn $"""For key = "rtf", value = {openWith["rtf"]}."""

// The indexer can be used to change the value associated
// with a key.
openWith["rtf"] <- "winword.exe"
printfn $"""For key = "rtf", value = {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
    printfn $"""For key = "tif", value = {openWith["tif"]}."""
with 
    | :? KeyNotFoundException ->
        printfn "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.
match openWith.TryGetValue("tif") with
| true, value ->
    printfn "For key = \"tif\", value = {value}."
| false, _ ->
    printfn "Key = \"tif\" is not found."

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

// When you use foreach to enumerate list elements,
// the elements are retrieved as KeyValuePair objects.
Console.WriteLine()
for kvp in openWith do
    printfn $"Key = {kvp.Key}, Value = {kvp.Value}"

// To get the values alone, use the Values property.
let ilistValues = openWith.Values;

// The elements of the list are strongly typed with the
// type that was specified for the SortedList values.
Console.WriteLine()
for s in ilistValues do
    printfn $"Value = {s}"

// The Values property is an efficient way to retrieve
// values by index.
printf "\nIndexed retrieval using the Values "
printfn $"property: Values[2] = {openWith.Values[2]}"

// To get the keys alone, use the Keys property.
let ilistKeys = openWith.Keys;

// The elements of the list are strongly typed with the
// type that was specified for the SortedList keys.
Console.WriteLine()
for s in ilistKeys do
    printfn $"Key = {s}"

// The Keys property is an efficient way to retrieve
// keys by index.
printf "\nIndexed retrieval using the Keys "
printfn $"property: Keys[2] = {openWith.Keys[2]}"

// Use the Remove method to remove a key/value pair.
printfn "\nRemove(\"doc\")"
openWith.Remove("doc") |> ignore

if not (openWith.ContainsKey("doc")) then
    printfn "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.
 *)

Remarks

The SortedList generic class is an array of key/value pairs with O(log n) retrieval, where n is the number of elements in the dictionary. In this, it is similar to the SortedDictionary generic class. The two classes have similar object models, and both have O(log n) retrieval. Where the two classes differ is in memory use and speed of insertion and removal:

SortedList uses less memory than SortedDictionary.
SortedDictionary has faster insertion and removal operations for unsorted data, O(log n) as opposed to O(n) for SortedList.
If the list is populated all at once from sorted data, SortedList is faster than SortedDictionary.

Another difference between the SortedDictionary and SortedList classes is that SortedList supports efficient indexed retrieval of keys and values through the collections returned by the Keys and Values properties. 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. 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];

Dim v As String = mySortedList.Values(3)

let v = mySortedList.Values[3]

SortedList is implemented as an array of key/value pairs, sorted by the key. Each element can be retrieved as a KeyValuePair object.

Key objects must be immutable as long as they are used as keys in the SortedList. Every key in a SortedList must be unique. A key cannot be null, but a value can be, if the type of values in the list, TValue, is a reference type.

SortedList requires a comparer implementation to sort and to perform comparisons. The default comparer Comparer.Default checks whether the key type TKey implements System.IComparable and uses that implementation, if available. If not, Comparer.Default checks whether the key type TKey implements System.IComparable. If the key type TKey does not implement either interface, you can specify a System.Collections.Generic.IComparer implementation in a constructor overload that accepts a comparer parameter.

The capacity of a SortedList is the number of elements the SortedList can hold. As elements are added to a SortedList, the capacity is automatically increased as required by reallocating the internal array. The capacity can be decreased by calling TrimExcess or by setting the Capacity property explicitly. Decreasing the capacity reallocates memory and copies all the elements in the SortedList.

.NET Framework only: For very large SortedList objects, you can increase the maximum capacity to 2 billion elements on a 64-bit system by setting the enabled attribute of the configuration element to true in the run-time environment.

The foreach statement of the C# language (For Each in Visual Basic) returns an object of the type of the elements in the collection. Since the elements of the SortedList are key/value pairs, the element type is not the type of the key or the type of the value. Instead, the element type is KeyValuePair. For example:

foreach( KeyValuePair 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

for kvp in mySortedList do
    printfn $"Key = {kvp.Key}, Value = {kvp.Value}"

The foreach statement is a wrapper around the enumerator, which only allows reading from, not writing to, the collection.

Constructors

Name	Description
SortedList()	Initializes a new instance of the SortedList class that is empty, has the default initial capacity, and uses the default IComparer.
SortedList(IComparer)	Initializes a new instance of the SortedList class that is empty, has the default initial capacity, and uses the specified IComparer.
SortedList(IDictionary, IComparer)	Initializes a new instance of the SortedList class that contains elements copied from the specified IDictionary, has sufficient capacity to accommodate the number of elements copied, and uses the specified IComparer.
SortedList(IDictionary)	Initializes a new instance of the SortedList class that contains elements copied from the specified IDictionary, has sufficient capacity to accommodate the number of elements copied, and uses the default IComparer.
SortedList(Int32, IComparer)	Initializes a new instance of the SortedList class that is empty, has the specified initial capacity, and uses the specified IComparer.
SortedList(Int32)	Initializes a new instance of the SortedList class that is empty, has the specified initial capacity, and uses the default IComparer.

Properties

Name	Description
Capacity	Gets or sets the number of elements that the SortedList can contain.
Comparer	Gets the IComparer for the sorted list.
Count	Gets the number of key/value pairs contained in the SortedList.
Item[TKey]	Gets or sets the value associated with the specified key.
Keys	Gets a collection containing the keys in the SortedList, in sorted order.
Values	Gets a collection containing the values in the SortedList.

Methods

Name	Description
Add(TKey, TValue)	Adds an element with the specified key and value into the SortedList.
Clear()	Removes all elements from the SortedList.
ContainsKey(TKey)	Determines whether the SortedList contains a specific key.
ContainsValue(TValue)	Determines whether the SortedList contains a specific value.
Equals(Object)	Determines whether the specified object is equal to the current object. (Inherited from Object)
GetEnumerator()	Returns an enumerator that iterates through the SortedList.
GetHashCode()	Serves as the default hash function. (Inherited from Object)
GetKeyAtIndex(Int32)	Gets the key corresponding to the specified index.
GetType()	Gets the Type of the current instance. (Inherited from Object)
GetValueAtIndex(Int32)	Gets the value corresponding to the specified index.
IndexOfKey(TKey)	Searches for the specified key and returns the zero-based index within the entire SortedList.
IndexOfValue(TValue)	Searches for the specified value and returns the zero-based index of the first occurrence within the entire SortedList.
MemberwiseClone()	Creates a shallow copy of the current Object. (Inherited from Object)
Remove(TKey)	Removes the element with the specified key from the SortedList.
RemoveAt(Int32)	Removes the element at the specified index of the SortedList.
SetValueAtIndex(Int32, TValue)	Updates the value corresponding to the specified index.
ToString()	Returns a string that represents the current object. (Inherited from Object)
TrimExcess()	Sets the capacity to the actual number of elements in the SortedList, if that number is less than 90 percent of current capacity.
TryGetValue(TKey, TValue)	Gets the value associated with the specified key.

Explicit Interface Implementations

Name	Description
ICollection.CopyTo(Array, Int32)	Copies the elements of the ICollection to an Array, starting at a particular Array index.
ICollection.IsSynchronized	Gets a value indicating whether access to the ICollection is synchronized (thread safe).
ICollection.SyncRoot	Gets an object that can be used to synchronize access to the ICollection.
ICollection>.Add(KeyValuePair)	Adds a key/value pair to the ICollection.
ICollection>.Contains(KeyValuePair)	Determines whether the ICollection contains a specific element.
ICollection>.CopyTo(KeyValuePair[], Int32)	Copies the elements of the ICollection to an Array, starting at a particular Array index.
ICollection>.IsReadOnly	Gets a value indicating whether the ICollection is read-only.
ICollection>.Remove(KeyValuePair)	Removes the first occurrence of a specific key/value pair from the ICollection.
IDictionary.Add(Object, Object)	Adds an element with the provided key and value to the IDictionary.
IDictionary.Contains(Object)	Determines whether the IDictionary contains an element with the specified key.
IDictionary.GetEnumerator()	Returns an IDictionaryEnumerator for the IDictionary.
IDictionary.IsFixedSize	Gets a value indicating whether the IDictionary has a fixed size.
IDictionary.IsReadOnly	Gets a value indicating whether the IDictionary is read-only.
IDictionary.Item[Object]	Gets or sets the element with the specified key.
IDictionary.Keys	Gets an ICollection containing the keys of the IDictionary.
IDictionary.Remove(Object)	Removes the element with the specified key from the IDictionary.
IDictionary.Values	Gets an ICollection containing the values in the IDictionary.
IDictionary.Keys	Gets an ICollection containing the keys of the IDictionary.
IDictionary.Values	Gets an ICollection containing the values in the IDictionary.
IEnumerable.GetEnumerator()	Returns an enumerator that iterates through a collection.
IEnumerable>.GetEnumerator()	Returns an enumerator that iterates through a collection.
IReadOnlyDictionary.Keys	Gets an enumerable collection that contains the keys in the read-only dictionary.
IReadOnlyDictionary.Values	Gets an enumerable collection that contains the values in the read-only dictionary.

Extension Methods

Name	Description
Aggregate(IEnumerable, TAccumulate, Func, Func)	Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.
Aggregate(IEnumerable, TAccumulate, Func)	Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value.
Aggregate(IEnumerable, Func)	Applies an accumulator function over a sequence.
AggregateBy(IEnumerable, Func, Func, Func, IEqualityComparer)	Applies an accumulator function over a sequence, grouping results by key.
AggregateBy(IEnumerable, Func, TAccumulate, Func, IEqualityComparer)	Applies an accumulator function over a sequence, grouping results by key.
All(IEnumerable, Func)	Determines whether all elements of a sequence satisfy a condition.
Ancestors(IEnumerable, XName)	Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Only elements that have a matching XName are included in the collection.
Ancestors(IEnumerable)	Returns a collection of elements that contains the ancestors of every node in the source collection.
Any(IEnumerable, Func)	Determines whether any element of a sequence satisfies a condition.
Any(IEnumerable)	Determines whether a sequence contains any elements.
Append(IEnumerable, TSource)	Appends a value to the end of the sequence.
AsEnumerable(IEnumerable)	Returns the input typed as IEnumerable.
AsParallel(IEnumerable)	Enables parallelization of a query.
AsParallel(IEnumerable)	Enables parallelization of a query.
AsQueryable(IEnumerable)	Converts an IEnumerable to an IQueryable.
AsQueryable(IEnumerable)	Converts a generic IEnumerable to a generic IQueryable.
AsReadOnly(IDictionary)	Returns a read-only ReadOnlyDictionary wrapper for the current dictionary.
Average(IEnumerable, Func)	Computes the average of a sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.
Average(IEnumerable, Func)	Computes the average of a sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.
Average(IEnumerable, Func)	Computes the average of a sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.
Average(IEnumerable, Func)	Computes the average of a sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.
Average(IEnumerable, Func>)	Computes the average of a sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.
Average(IEnumerable, Func>)	Computes the average of a sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.
Average(IEnumerable, Func>)	Computes the average of a sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.
Average(IEnumerable, Func>)	Computes the average of a sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence.
Average(IEnumerable, Func>)	Computes the average of a sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence.
Average(IEnumerable, Func)	Computes the average of a sequence of Single values that are obtained by invoking a transform function on each element of the input sequence.
Cast(IEnumerable)	Casts the elements of an IEnumerable to the specified type.
Chunk(IEnumerable, Int32)	Splits the elements of a sequence into chunks of size at most `size`.
Concat(IEnumerable, IEnumerable)	Concatenates two sequences.
Contains(IEnumerable, TSource, IEqualityComparer)	Determines whether a sequence contains a specified element by using a specified IEqualityComparer.
Contains(IEnumerable, TSource)	Determines whether a sequence contains a specified element by using the default equality comparer.
CopyToDataTable(IEnumerable, DataTable, LoadOption, FillErrorEventHandler)	Copies DataRow objects to the specified DataTable, given an input IEnumerable object where the generic parameter `T` is DataRow.
CopyToDataTable(IEnumerable, DataTable, LoadOption)	Copies DataRow objects to the specified DataTable, given an input IEnumerable object where the generic parameter `T` is DataRow.
CopyToDataTable(IEnumerable)	Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable object where the generic parameter `T` is DataRow.
Count(IEnumerable, Func)	Returns a number that represents how many elements in the specified sequence satisfy a condition.
Count(IEnumerable)	Returns the number of elements in a sequence.
CountBy(IEnumerable, Func, IEqualityComparer)	Returns the count of elements in the source sequence grouped by key.
DefaultIfEmpty(IEnumerable, TSource)	Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.
DefaultIfEmpty(IEnumerable)	Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.
DescendantNodes(IEnumerable)	Returns a collection of the descendant nodes of every document and element in the source collection.
Descendants(IEnumerable, XName)	Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Only elements that have a matching XName are included in the collection.
Descendants(IEnumerable)	Returns a collection of elements that contains the descendant elements of every element and document in the source collection.
Distinct(IEnumerable, IEqualityComparer)	Returns distinct elements from a sequence by using a specified IEqualityComparer to compare values.
Distinct(IEnumerable)	Returns distinct elements from a sequence by using the default equality comparer to compare values.
DistinctBy(IEnumerable, Func, IEqualityComparer)	Returns distinct elements from a sequence according to a specified key selector function and using a specified comparer to compare keys.
DistinctBy(IEnumerable, Func)	Returns distinct elements from a sequence according to a specified key selector function.
ElementAt(IEnumerable, Index)	Returns the element at a specified index in a sequence.
ElementAt(IEnumerable, Int32)	Returns the element at a specified index in a sequence.
ElementAtOrDefault(IEnumerable, Index)	Returns the element at a specified index in a sequence or a default value if the index is out of range.
ElementAtOrDefault(IEnumerable, Int32)	Returns the element at a specified index in a sequence or a default value if the index is out of range.
Elements(IEnumerable, XName)	Returns a filtered collection of the child elements of every element and document in the source collection. Only elements that have a matching XName are included in the collection.
Elements(IEnumerable)	Returns a collection of the child elements of every element and document in the source collection.
Except(IEnumerable, IEnumerable, IEqualityComparer)	Produces the set difference of two sequences by using the specified IEqualityComparer to compare values.
Except(IEnumerable, IEnumerable)	Produces the set difference of two sequences by using the default equality comparer to compare values.
ExceptBy(IEnumerable, IEnumerable, Func, IEqualityComparer)	Produces the set difference of two sequences according to a specified key selector function.
ExceptBy(IEnumerable, IEnumerable, Func)	Produces the set difference of two sequences according to a specified key selector function.
First(IEnumerable, Func)	Returns the first element in a sequence that satisfies a specified condition.
First(IEnumerable)	Returns the first element of a sequence.
FirstOrDefault(IEnumerable, Func, TSource)	Returns the first element of the sequence that satisfies a condition, or a specified default value if no such element is found.
FirstOrDefault(IEnumerable, Func)	Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.
FirstOrDefault(IEnumerable, TSource)	Returns the first element of a sequence, or a specified default value if the sequence contains no elements.
FirstOrDefault(IEnumerable)	Returns the first element of a sequence, or a default value if the sequence contains no elements.
FullJoin(IEnumerable, IEnumerable, Func, Func, Func, IEqualityComparer)
FullJoin(IEnumerable, IEnumerable, Func, Func, IEqualityComparer)
GetValueOrDefault(IReadOnlyDictionary, TKey, TValue)	Tries to get the value associated with the specified `key` in the `dictionary`.
GetValueOrDefault(IReadOnlyDictionary, TKey)	Tries to get the value associated with the specified `key` in the `dictionary`.
GroupBy(IEnumerable, Func, Func, Func, TResult>, IEqualityComparer)	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Key values are compared by using a specified comparer, and the elements of each group are projected by using a specified function.
GroupBy(IEnumerable, Func, Func, Func,TResult>)	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. The elements of each group are projected by using a specified function.
GroupBy(IEnumerable, Func, Func, IEqualityComparer)	Groups the elements of a sequence according to a key selector function. The keys are compared by using a comparer and each group's elements are projected by using a specified function.
GroupBy(IEnumerable, Func, Func)	Groups the elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function.
GroupBy(IEnumerable, Func, Func,TResult>, IEqualityComparer)	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. The keys are compared by using a specified comparer.
GroupBy(IEnumerable, Func, Func,TResult>)	Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.
GroupBy(IEnumerable, Func, IEqualityComparer)	Groups the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.
GroupBy(IEnumerable, Func)	Groups the elements of a sequence according to a specified key selector function.
GroupJoin(IEnumerable, IEnumerable, Func, Func, Func, TResult>, IEqualityComparer)	Correlates the elements of two sequences based on key equality and groups the results. A specified IEqualityComparer is used to compare keys.
GroupJoin(IEnumerable, IEnumerable, Func, Func, Func, TResult>)	Correlates the elements of two sequences based on equality of keys and groups the results. The default equality comparer is used to compare keys.
GroupJoin(IEnumerable, IEnumerable, Func, Func, IEqualityComparer)
Index(IEnumerable)	Returns an enumerable that incorporates the element's index into a tuple.
InDocumentOrder(IEnumerable)	Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.
Intersect(IEnumerable, IEnumerable, IEqualityComparer)	Produces the set intersection of two sequences by using the specified IEqualityComparer to compare values.
Intersect(IEnumerable, IEnumerable)	Produces the set intersection of two sequences by using the default equality comparer to compare values.
IntersectBy(IEnumerable, IEnumerable, Func, IEqualityComparer)	Produces the set intersection of two sequences according to a specified key selector function.
IntersectBy(IEnumerable, IEnumerable, Func)	Produces the set intersection of two sequences according to a specified key selector function.
Join(IEnumerable, IEnumerable, Func, Func, Func, IEqualityComparer)	Correlates the elements of two sequences based on matching keys. A specified IEqualityComparer is used to compare keys.
Join(IEnumerable, IEnumerable, Func, Func, Func)	Correlates the elements of two sequences based on matching keys. The default equality comparer is used to compare keys.
Join(IEnumerable, IEnumerable, Func, Func, IEqualityComparer)
Last(IEnumerable, Func)	Returns the last element of a sequence that satisfies a specified condition.
Last(IEnumerable)	Returns the last element of a sequence.
LastOrDefault(IEnumerable, Func, TSource)	Returns the last element of a sequence that satisfies a condition, or a specified default value if no such element is found.
LastOrDefault(IEnumerable, Func)	Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.
LastOrDefault(IEnumerable, TSource)	Returns the last element of a sequence, or a specified default value if the sequence contains no elements.
LastOrDefault(IEnumerable)	Returns the last element of a sequence, or a default value if the sequence contains no elements.
LeftJoin(IEnumerable, IEnumerable, Func, Func, Func, IEqualityComparer)	Correlates the elements of two sequences based on matching keys. A specified IEqualityComparer is used to compare keys.
LeftJoin(IEnumerable, IEnumerable, Func, Func, Func)	Correlates the elements of two sequences based on matching keys. The default equality comparer is used to compare keys.
LeftJoin(IEnumerable, IEnumerable, Func, Func, IEqualityComparer)
LongCount(IEnumerable, Func)	Returns an Int64 that represents how many elements in a sequence satisfy a condition.
LongCount(IEnumerable)	Returns an Int64 that represents the total number of elements in a sequence.
Max(IEnumerable, Func)	Invokes a transform function on each element of a generic sequence and returns the maximum resulting value.
Max(IEnumerable, Func)	Invokes a transform function on each element of a sequence and returns the maximum Decimal value.
Max(IEnumerable, Func)	Invokes a transform function on each element of a sequence and returns the maximum Double value.
Max(IEnumerable, Func)	Invokes a transform function on each element of a sequence and returns the maximum Int32 value.
Max(IEnumerable, Func)	Invokes a transform function on each element of a sequence and returns the maximum Int64 value.
Max(IEnumerable, Func>)	Invokes a transform function on each element of a sequence and returns the maximum nullable Decimal value.
Max(IEnumerable, Func>)	Invokes a transform function on each element of a sequence and returns the maximum nullable Double value.
Max(IEnumerable, Func>)	Invokes a transform function on each element of a sequence and returns the maximum nullable Int32 value.
Max(IEnumerable, Func>)	Invokes a transform function on each element of a sequence and returns the maximum nullable Int64 value.
Max(IEnumerable, Func>)	Invokes a transform function on each element of a sequence and returns the maximum nullable Single value.
Max(IEnumerable, Func)	Invokes a transform function on each element of a sequence and returns the maximum Single value.
Max(IEnumerable, IComparer)	Returns the maximum value in a generic sequence.
Max(IEnumerable)	Returns the maximum value in a generic sequence.
MaxBy(IEnumerable, Func, IComparer)	Returns the maximum value in a generic sequence according to a specified key selector function and key comparer.
MaxBy(IEnumerable, Func)	Returns the maximum value in a generic sequence according to a specified key selector function.
Min(IEnumerable, Func)	Invokes a transform function on each element of a generic sequence and returns the minimum resulting value.
Min(IEnumerable, Func)	Invokes a transform function on each element of a sequence and returns the minimum Decimal value.
Min(IEnumerable, Func)	Invokes a transform function on each element of a sequence and returns the minimum Double value.
Min(IEnumerable, Func)	Invokes a transform function on each element of a sequence and returns the minimum Int32 value.
Min(IEnumerable, Func)	Invokes a transform function on each element of a sequence and returns the minimum Int64 value.
Min(IEnumerable, Func>)	Invokes a transform function on each element of a sequence and returns the minimum nullable Decimal value.
Min(IEnumerable, Func>)	Invokes a transform function on each element of a sequence and returns the minimum nullable Double value.
Min(IEnumerable, Func>)	Invokes a transform function on each element of a sequence and returns the minimum nullable Int32 value.
Min(IEnumerable, Func>)	Invokes a transform function on each element of a sequence and returns the minimum nullable Int64 value.
Min(IEnumerable, Func>)	Invokes a transform function on each element of a sequence and returns the minimum nullable Single value.
Min(IEnumerable, Func)	Invokes a transform function on each element of a sequence and returns the minimum Single value.
Min(IEnumerable, IComparer)	Returns the minimum value in a generic sequence.
Min(IEnumerable)	Returns the minimum value in a generic sequence.
MinBy(IEnumerable, Func, IComparer)	Returns the minimum value in a generic sequence according to a specified key selector function and key comparer.
MinBy(IEnumerable, Func)	Returns the minimum value in a generic sequence according to a specified key selector function.
Nodes(IEnumerable)	Returns a collection of the child nodes of every document and element in the source collection.
OfType(IEnumerable)	Filters the elements of an IEnumerable based on a specified type.
Order(IEnumerable, IComparer)	Sorts the elements of a sequence in ascending order.
Order(IEnumerable)	Sorts the elements of a sequence in ascending order.
OrderBy(IEnumerable, Func, IComparer)	Sorts the elements of a sequence in ascending order by using a specified comparer.
OrderBy(IEnumerable, Func)	Sorts the elements of a sequence in ascending order according to a key.
OrderByDescending(IEnumerable, Func, IComparer)	Sorts the elements of a sequence in descending order by using a specified comparer.
OrderByDescending(IEnumerable, Func)	Sorts the elements of a sequence in descending order according to a key.
OrderDescending(IEnumerable, IComparer)	Sorts the elements of a sequence in descending order.
OrderDescending(IEnumerable)	Sorts the elements of a sequence in descending order.
Prepend(IEnumerable, TSource)	Adds a value to the beginning of the sequence.
Remove(IEnumerable)	Removes every node in the source collection from its parent node.
Remove(IDictionary, TKey, TValue)	Tries to remove the value with the specified `key` from the `dictionary`.
Reverse(IEnumerable)	Inverts the order of the elements in a sequence.
RightJoin(IEnumerable, IEnumerable, Func, Func, Func, IEqualityComparer)	Correlates the elements of two sequences based on matching keys. A specified IEqualityComparer is used to compare keys.
RightJoin(IEnumerable, IEnumerable, Func, Func, Func)	Correlates the elements of two sequences based on matching keys. The default equality comparer is used to compare keys.
RightJoin(IEnumerable, IEnumerable, Func, Func, IEqualityComparer)
Select(IEnumerable, Func)	Projects each element of a sequence into a new form by incorporating the element's index.
Select(IEnumerable, Func)	Projects each element of a sequence into a new form.
SelectMany(IEnumerable, Func>, Func)	Projects each element of a sequence to an IEnumerable, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.
SelectMany(IEnumerable, Func>, Func)	Projects each element of a sequence to an IEnumerable, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. The index of each source element is used in the intermediate projected form of that element.
SelectMany(IEnumerable, Func>)	Projects each element of a sequence to an IEnumerable and flattens the resulting sequences into one sequence.
SelectMany(IEnumerable, Func>)	Projects each element of a sequence to an IEnumerable, and flattens the resulting sequences into one sequence. The index of each source element is used in the projected form of that element.
SequenceEqual(IEnumerable, IEnumerable, IEqualityComparer)	Determines whether two sequences are equal by comparing their elements by using a specified IEqualityComparer.
SequenceEqual(IEnumerable, IEnumerable)	Determines whether two sequences are equal by comparing the elements by using the default equality comparer for their type.
Shuffle(IEnumerable)	Shuffles the order of the elements of a sequence.
Single(IEnumerable, Func)	Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.
Single(IEnumerable)	Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.
SingleOrDefault(IEnumerable, Func, TSource)	Returns the only element of a sequence that satisfies a specified condition, or a specified default value if no such element exists; this method throws an exception if more than one element satisfies the condition.
SingleOrDefault(IEnumerable, Func)	Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition.
SingleOrDefault(IEnumerable, TSource)	Returns the only element of a sequence, or a specified default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.
SingleOrDefault(IEnumerable)	Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.
Skip(IEnumerable, Int32)	Bypasses a specified number of elements in a sequence and then returns the remaining elements.
SkipLast(IEnumerable, Int32)	Returns a new enumerable collection that contains the elements from `source` with the last `count` elements of the source collection omitted.
SkipWhile(IEnumerable, Func)	Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.
SkipWhile(IEnumerable, Func)	Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. The element's index is used in the logic of the predicate function.
Sum(IEnumerable, Func)	Computes the sum of the sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.
Sum(IEnumerable, Func)	Computes the sum of the sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.
Sum(IEnumerable, Func)	Computes the sum of the sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.
Sum(IEnumerable, Func)	Computes the sum of the sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.
Sum(IEnumerable, Func>)	Computes the sum of the sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.
Sum(IEnumerable, Func>)	Computes the sum of the sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.
Sum(IEnumerable, Func>)	Computes the sum of the sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.
Sum(IEnumerable, Func>)	Computes the sum of the sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence.
Sum(IEnumerable, Func>)	Computes the sum of the sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence.
Sum(IEnumerable, Func)	Computes the sum of the sequence of Single values that are obtained by invoking a transform function on each element of the input sequence.
Take(IEnumerable, Int32)	Returns a specified number of contiguous elements from the start of a sequence.
Take(IEnumerable, Range)	Returns a specified range of contiguous elements from a sequence.
TakeLast(IEnumerable, Int32)	Returns a new enumerable collection that contains the last `count` elements from `source`.
TakeWhile(IEnumerable, Func)	Returns elements from a sequence as long as a specified condition is true.
TakeWhile(IEnumerable, Func)	Returns elements from a sequence as long as a specified condition is true. The element's index is used in the logic of the predicate function.
ToArray(IEnumerable)	Creates an array from a IEnumerable.
ToAsyncEnumerable(IEnumerable)	Converts an IEnumerable to an IAsyncEnumerable.
ToDictionary(IEnumerable, Func, Func, IEqualityComparer)	Creates a Dictionary from an IEnumerable according to a specified key selector function, a comparer, and an element selector function.
ToDictionary(IEnumerable, Func, Func)	Creates a Dictionary from an IEnumerable according to specified key selector and element selector functions.
ToDictionary(IEnumerable, Func, IEqualityComparer)	Creates a Dictionary from an IEnumerable according to a specified key selector function and key comparer.
ToDictionary(IEnumerable, Func)	Creates a Dictionary from an IEnumerable according to a specified key selector function.
ToFrozenDictionary(IEnumerable, Func, Func, IEqualityComparer)	Creates a FrozenDictionary from an IEnumerable according to specified key selector and element selector functions.
ToFrozenDictionary(IEnumerable, Func, IEqualityComparer)	Creates a FrozenDictionary from an IEnumerable according to specified key selector function.
ToFrozenSet(IEnumerable, IEqualityComparer)	Creates a FrozenSet with the specified values.
ToHashSet(IEnumerable, IEqualityComparer)	Creates a HashSet from an IEnumerable using the `comparer` to compare keys.
ToHashSet(IEnumerable)	Creates a HashSet from an IEnumerable.
ToImmutableArray(IEnumerable)	Creates an immutable array from the specified collection.
ToImmutableDictionary(IEnumerable, Func, Func, IEqualityComparer, IEqualityComparer)	Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key and value comparers.
ToImmutableDictionary(IEnumerable, Func, Func, IEqualityComparer)	Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key comparer.
ToImmutableDictionary(IEnumerable, Func, Func)	Enumerates and transforms a sequence, and produces an immutable dictionary of its contents.
ToImmutableDictionary(IEnumerable, Func, IEqualityComparer)	Constructs an immutable dictionary based on some transformation of a sequence.
ToImmutableDictionary(IEnumerable, Func)	Constructs an immutable dictionary from an existing collection of elements, applying a transformation function to the source keys.
ToImmutableHashSet(IEnumerable, IEqualityComparer)	Enumerates a sequence, produces an immutable hash set of its contents, and uses the specified equality comparer for the set type.
ToImmutableHashSet(IEnumerable)	Enumerates a sequence and produces an immutable hash set of its contents.
ToImmutableList(IEnumerable)	Enumerates a sequence and produces an immutable list of its contents.
ToImmutableSortedDictionary(IEnumerable, Func, Func, IComparer, IEqualityComparer)	Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key and value comparers.
ToImmutableSortedDictionary(IEnumerable, Func, Func, IComparer)	Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key comparer.
ToImmutableSortedDictionary(IEnumerable, Func, Func)	Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents.
ToImmutableSortedSet(IEnumerable, IComparer)	Enumerates a sequence, produces an immutable sorted set of its contents, and uses the specified comparer.
ToImmutableSortedSet(IEnumerable)	Enumerates a sequence and produces an immutable sorted set of its contents.
ToList(IEnumerable)	Creates a List from an IEnumerable.
ToLookup(IEnumerable, Func, Func, IEqualityComparer)	Creates a Lookup from an IEnumerable according to a specified key selector function, a comparer and an element selector function.
ToLookup(IEnumerable, Func, Func)	Creates a Lookup from an IEnumerable according to specified key selector and element selector functions.
ToLookup(IEnumerable, Func, IEqualityComparer)	Creates a Lookup from an IEnumerable according to a specified key selector function and key comparer.
ToLookup(IEnumerable, Func)	Creates a Lookup from an IEnumerable according to a specified key selector function.
TryAdd(IDictionary, TKey, TValue)	Tries to add the specified `key` and `value` to the `dictionary`.
TryGetNonEnumeratedCount(IEnumerable, Int32)	Attempts to determine the number of elements in a sequence without forcing an enumeration.
Union(IEnumerable, IEnumerable, IEqualityComparer)	Produces the set union of two sequences by using a specified IEqualityComparer.
Union(IEnumerable, IEnumerable)	Produces the set union of two sequences by using the default equality comparer.
UnionBy(IEnumerable, IEnumerable, Func, IEqualityComparer)	Produces the set union of two sequences according to a specified key selector function.
UnionBy(IEnumerable, IEnumerable, Func)	Produces the set union of two sequences according to a specified key selector function.
Where(IEnumerable, Func)	Filters a sequence of values based on a predicate.
Where(IEnumerable, Func)	Filters a sequence of values based on a predicate. Each element's index is used in the logic of the predicate function.
Zip(IEnumerable, IEnumerable, Func)	Applies a specified function to the corresponding elements of two sequences, producing a sequence of the results.
Zip(IEnumerable, IEnumerable, IEnumerable)	Produces a sequence of tuples with elements from the three specified sequences.
Zip(IEnumerable, IEnumerable)	Produces a sequence of tuples with elements from the two specified sequences.

Applies to

Thread Safety

Public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

A SortedList can support multiple readers concurrently, as long as the collection is not modified. Even so, enumerating through a collection is intrinsically not a thread-safe procedure. To guarantee thread safety during enumeration, you can lock the collection during the entire enumeration. To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

Feedback

Was this page helpful?