Compartir vía


ConcurrentDictionary<TKey,TValue> Clase

Definición

Representa una colección segura para subprocesos de pares clave-valor a los que pueden acceder varios subprocesos simultáneamente.

generic <typename TKey, typename TValue>
public ref class ConcurrentDictionary : 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
generic <typename TKey, typename TValue>
public ref class ConcurrentDictionary : 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::IDictionary
public class ConcurrentDictionary<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
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class ConcurrentDictionary<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.IDictionary
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class ConcurrentDictionary<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
public class ConcurrentDictionary<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.IDictionary
type ConcurrentDictionary<'Key, 'Value> = class
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IEnumerable
    interface IDictionary<'Key, 'Value>
    interface IReadOnlyCollection<KeyValuePair<'Key, 'Value>>
    interface IReadOnlyDictionary<'Key, 'Value>
    interface ICollection
    interface IDictionary
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type ConcurrentDictionary<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IDictionary
    interface ICollection
    interface IEnumerable
[<System.Runtime.InteropServices.ComVisible(false)>]
[<System.Serializable>]
type ConcurrentDictionary<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IEnumerable
    interface IDictionary
    interface ICollection
    interface IReadOnlyDictionary<'Key, 'Value>
    interface IReadOnlyCollection<KeyValuePair<'Key, 'Value>>
type ConcurrentDictionary<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IDictionary
    interface ICollection
    interface IEnumerable
Public Class ConcurrentDictionary(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 ConcurrentDictionary(Of TKey, TValue)
Implements ICollection(Of KeyValuePair(Of TKey, TValue)), IDictionary, IDictionary(Of TKey, TValue), IEnumerable(Of KeyValuePair(Of TKey, TValue))

Parámetros de tipo

TKey

Tipo de las claves del diccionario.

TValue

Tipo de los valores del diccionario.

Herencia
ConcurrentDictionary<TKey,TValue>
Atributos
Implementaciones

Ejemplos

En el ejemplo siguiente se muestra cómo construir un objeto ConcurrentDictionary<TKey,TValue>.


class CD_Ctor
{
        // Demonstrates:
        //      ConcurrentDictionary<TKey, TValue> ctor(concurrencyLevel, initialCapacity)
        //      ConcurrentDictionary<TKey, TValue>[TKey]
        static void Main()
        {
            // We know how many items we want to insert into the ConcurrentDictionary.
            // So set the initial capacity to some prime number above that, to ensure that
            // the ConcurrentDictionary does not need to be resized while initializing it.
            int NUMITEMS = 64;
            int initialCapacity = 101;

            // The higher the concurrencyLevel, the higher the theoretical number of operations
            // that could be performed concurrently on the ConcurrentDictionary.  However, global
            // operations like resizing the dictionary take longer as the concurrencyLevel rises.
            // For the purposes of this example, we'll compromise at numCores * 2.
            int numProcs = Environment.ProcessorCount;
            int concurrencyLevel = numProcs * 2;

            // Construct the dictionary with the desired concurrencyLevel and initialCapacity
            ConcurrentDictionary<int, int> cd = new ConcurrentDictionary<int, int>(concurrencyLevel, initialCapacity);

            // Initialize the dictionary
            for (int i = 0; i < NUMITEMS; i++) cd[i] = i * i;

            Console.WriteLine("The square of 23 is {0} (should be {1})", cd[23], 23 * 23);
        }
}
// Demonstrates:
//      ConcurrentDictionary<TKey, TValue> ctor(concurrencyLevel, initialCapacity)
//      ConcurrentDictionary<TKey, TValue>[TKey]

// We know how many items we want to insert into the ConcurrentDictionary.
// So set the initial capacity to some prime number above that, to ensure that
// the ConcurrentDictionary does not need to be resized while initializing it.
let NUMITEMS = 64
let initialCapacity = 101

// The higher the concurrencyLevel, the higher the theoretical number of operations
// that could be performed concurrently on the ConcurrentDictionary.  However, global
// operations like resizing the dictionary take longer as the concurrencyLevel rises.
// For the purposes of this example, we'll compromise at numCores * 2.
let numProcs = Environment.ProcessorCount
let concurrencyLevel = numProcs * 2

// Construct the dictionary with the desired concurrencyLevel and initialCapacity
let cd = ConcurrentDictionary<int, int>(concurrencyLevel, initialCapacity)

// Initialize the dictionary
for i = 0 to NUMITEMS - 1 do
    cd[i] <- i * i

printfn $"The square of 23 is {cd[23]} (should be {23 * 23})"
Imports System.Collections.Concurrent
Imports System.Threading.Tasks

Class CD_Ctor
    ' Demonstrates:
    ' ConcurrentDictionary<TKey, TValue> ctor(concurrencyLevel, initialCapacity)
    ' ConcurrentDictionary<TKey, TValue>[TKey]
    Shared Sub Main()
        ' We know how many items we want to insert into the ConcurrentDictionary.
        ' So set the initial capacity to some prime number above that, to ensure that
        ' the ConcurrentDictionary does not need to be resized while initializing it.
        Dim NUMITEMS As Integer = 64
        Dim initialCapacity As Integer = 101

        ' The higher the concurrencyLevel, the higher the theoretical number of operations
        ' that could be performed concurrently on the ConcurrentDictionary. However, global
        ' operations like resizing the dictionary take longer as the concurrencyLevel rises. 
        ' For the purposes of this example, we'll compromise at numCores * 2.
        Dim numProcs As Integer = Environment.ProcessorCount
        Dim concurrencyLevel As Integer = numProcs * 2

        ' Construct the dictionary with the desired concurrencyLevel and initialCapacity
        Dim cd As New ConcurrentDictionary(Of Integer, Integer)(concurrencyLevel, initialCapacity)

        ' Initialize the dictionary
        For i As Integer = 0 To NUMITEMS - 1
            cd(i) = i * i
        Next

        Console.WriteLine("The square of 23 is {0} (should be {1})", cd(23), 23 * 23)
    End Sub
End Class

Comentarios

Para objetos de ConcurrentDictionary<TKey,TValue> muy grandes, puede aumentar el tamaño máximo de la matriz a 2 gigabytes (GB) en un sistema de 64 bits estableciendo el elemento de configuración de <gcAllowVeryLargeObjects> en true en el entorno en tiempo de ejecución.

Nota

ConcurrentDictionary<TKey,TValue> implementa las interfaces IReadOnlyCollection<T> y IReadOnlyDictionary<TKey,TValue> a partir de .NET Framework 4.6; en versiones anteriores de .NET Framework, la clase ConcurrentDictionary<TKey,TValue> no implementó estas interfaces.

Al igual que la clase System.Collections.Generic.Dictionary<TKey,TValue>, ConcurrentDictionary<TKey,TValue> implementa la interfaz IDictionary<TKey,TValue>. Además, ConcurrentDictionary<TKey,TValue> proporciona varios métodos para agregar o actualizar pares clave-valor en el diccionario, como se describe en la tabla siguiente.

Para ello Usar este método Notas de uso
Agregue una nueva clave al diccionario, si aún no existe en el diccionario. TryAdd Este método agrega el par clave-valor especificado, si la clave no existe actualmente en el diccionario. El método devuelve true o false en función de si se agregó el nuevo par.
Actualice el valor de una clave existente en el diccionario, si esa clave tiene un valor específico. TryUpdate Este método comprueba si la clave tiene un valor especificado y, si es así, actualiza la clave con un nuevo valor. Es similar al método CompareExchange, excepto que se usa para los elementos de diccionario.
Almacenar un par clave-valor en el diccionario incondicionalmente y sobrescribir el valor de una clave que ya existe Establecedor del indexador: dictionary[key] = newValue
Agregue un par clave-valor al diccionario o, si la clave ya existe, actualice el valor de la clave en función del valor existente de la clave. AddOrUpdate(TKey, Func<TKey,TValue>, Func<TKey,TValue,TValue>)

-o-

AddOrUpdate(TKey, TValue, Func<TKey,TValue,TValue>)
AddOrUpdate(TKey, Func<TKey,TValue>, Func<TKey,TValue,TValue>) acepta la clave y dos delegados. Usa el primer delegado si la clave no existe en el diccionario; acepta la clave y devuelve el valor que se debe agregar para la clave. Usa el segundo delegado si la clave existe; acepta la clave y su valor actual, y devuelve el nuevo valor que se debe establecer para la clave.

AddOrUpdate(TKey, TValue, Func<TKey,TValue,TValue>) acepta la clave, un valor que se va a agregar y el delegado de actualización. Esto es lo mismo que la sobrecarga anterior, salvo que no usa un delegado para agregar una clave.
Obtenga el valor de una clave en el diccionario, agregando el valor al diccionario y devolviéndole si la clave no existe. GetOrAdd(TKey, TValue)

-o-

GetOrAdd(TKey, Func<TKey,TValue>)
Estas sobrecargas proporcionan inicialización diferida para un par clave-valor en el diccionario, agregando el valor solo si no está allí.

GetOrAdd(TKey, TValue) toma el valor que se va a agregar si la clave no existe.

GetOrAdd(TKey, Func<TKey,TValue>) toma un delegado que generará el valor si la clave no existe.

Todas estas operaciones son atómicas y son seguras para subprocesos con respecto a todas las demás operaciones de la clase ConcurrentDictionary<TKey,TValue>. Las únicas excepciones son los métodos que aceptan un delegado, es decir, AddOrUpdate y GetOrAdd. En el caso de las modificaciones y las operaciones de escritura en el diccionario, ConcurrentDictionary<TKey,TValue> usa bloqueos específicos para garantizar la seguridad de los subprocesos. (Las operaciones de lectura en el diccionario se realizan de forma sin bloqueos). Sin embargo, se llama a delegados para estos métodos fuera de los bloqueos para evitar los problemas que pueden surgir al ejecutar código desconocido bajo un bloqueo. Por lo tanto, el código ejecutado por estos delegados no está sujeto a la atomicidad de la operación.

Constructores

ConcurrentDictionary<TKey,TValue>()

Inicializa una nueva instancia de la clase ConcurrentDictionary<TKey,TValue> que está vacía, tiene el nivel de simultaneidad predeterminado, tiene la capacidad inicial predeterminada y usa el comparador predeterminado para el tipo de clave.

ConcurrentDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>)

Inicializa una nueva instancia de la clase ConcurrentDictionary<TKey,TValue> que contiene elementos copiados del IEnumerable<T>especificado, tiene el nivel de simultaneidad predeterminado, tiene la capacidad inicial predeterminada y usa el comparador predeterminado para el tipo de clave.

ConcurrentDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>)

Inicializa una nueva instancia de la clase ConcurrentDictionary<TKey,TValue> que contiene elementos copiados del IEnumerable especificados tiene el nivel de simultaneidad predeterminado, tiene la capacidad inicial predeterminada y usa el IEqualityComparer<T>especificado.

ConcurrentDictionary<TKey,TValue>(IEqualityComparer<TKey>)

Inicializa una nueva instancia de la clase ConcurrentDictionary<TKey,TValue> que está vacía, tiene el nivel de simultaneidad y la capacidad predeterminados y usa el IEqualityComparer<T>especificado.

ConcurrentDictionary<TKey,TValue>(Int32, IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>)

Inicializa una nueva instancia de la clase ConcurrentDictionary<TKey,TValue> que contiene elementos copiados del IEnumerableespecificado y usa el IEqualityComparer<T>especificado.

ConcurrentDictionary<TKey,TValue>(Int32, Int32)

Inicializa una nueva instancia de la clase ConcurrentDictionary<TKey,TValue> que está vacía, tiene el nivel de simultaneidad y la capacidad especificados y usa el comparador predeterminado para el tipo de clave.

ConcurrentDictionary<TKey,TValue>(Int32, Int32, IEqualityComparer<TKey>)

Inicializa una nueva instancia de la clase ConcurrentDictionary<TKey,TValue> que está vacía, tiene el nivel de simultaneidad especificado, tiene la capacidad inicial especificada y usa el IEqualityComparer<T>especificado.

Propiedades

Comparer

Obtiene el IEqualityComparer<T> que se usa para determinar la igualdad de claves para el diccionario.

Count

Obtiene el número de pares clave-valor contenidos en el ConcurrentDictionary<TKey,TValue>.

IsEmpty

Obtiene un valor que indica si el ConcurrentDictionary<TKey,TValue> está vacío.

Item[TKey]

Obtiene o establece el valor asociado a la clave especificada.

Keys

Obtiene una colección que contiene las claves del Dictionary<TKey,TValue>.

Values

Obtiene una colección que contiene los valores de la Dictionary<TKey,TValue>.

Métodos

AddOrUpdate(TKey, Func<TKey,TValue>, Func<TKey,TValue,TValue>)

Usa las funciones especificadas para agregar un par clave-valor a la ConcurrentDictionary<TKey,TValue> si la clave aún no existe, o para actualizar un par clave-valor en el ConcurrentDictionary<TKey,TValue> si la clave ya existe.

AddOrUpdate(TKey, TValue, Func<TKey,TValue,TValue>)

Agrega un par clave-valor al ConcurrentDictionary<TKey,TValue> si la clave aún no existe, o actualiza un par clave-valor en el ConcurrentDictionary<TKey,TValue> mediante la función especificada si la clave ya existe.

AddOrUpdate<TArg>(TKey, Func<TKey,TArg,TValue>, Func<TKey,TValue,TArg,TValue>, TArg)

Usa las funciones y el argumento especificados para agregar un par clave-valor al ConcurrentDictionary<TKey,TValue> si la clave aún no existe, o para actualizar un par clave-valor en el ConcurrentDictionary<TKey,TValue> si la clave ya existe.

Clear()

Quita todas las claves y valores de la ConcurrentDictionary<TKey,TValue>.

ContainsKey(TKey)

Determina si el ConcurrentDictionary<TKey,TValue> contiene la clave especificada.

Equals(Object)

Determina si el objeto especificado es igual al objeto actual.

(Heredado de Object)
GetAlternateLookup<TAlternateKey>()

Obtiene una instancia de un tipo que se puede usar para realizar operaciones en un ConcurrentDictionary<TKey,TValue>

usar un TAlternateKey como clave en lugar de un TKey.

GetEnumerator()

Devuelve un enumerador que recorre en iteración el ConcurrentDictionary<TKey,TValue>.

GetHashCode()

Actúa como función hash predeterminada.

(Heredado de Object)
GetOrAdd(TKey, Func<TKey,TValue>)

Agrega un par clave-valor al ConcurrentDictionary<TKey,TValue> mediante la función especificada si la clave aún no existe. Devuelve el nuevo valor o el valor existente si la clave existe.

GetOrAdd(TKey, TValue)

Agrega un par clave-valor al ConcurrentDictionary<TKey,TValue> si la clave aún no existe. Devuelve el nuevo valor o el valor existente si la clave existe.

GetOrAdd<TArg>(TKey, Func<TKey,TArg,TValue>, TArg)

Agrega un par clave-valor al ConcurrentDictionary<TKey,TValue> mediante la función especificada y un argumento si la clave aún no existe, o devuelve el valor existente si la clave existe.

GetType()

Obtiene el Type de la instancia actual.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Objectactual.

(Heredado de Object)
ToArray()

Copia los pares clave y valor almacenados en el ConcurrentDictionary<TKey,TValue> en una nueva matriz.

ToString()

Devuelve una cadena que representa el objeto actual.

(Heredado de Object)
TryAdd(TKey, TValue)

Intenta agregar la clave y el valor especificados al ConcurrentDictionary<TKey,TValue>.

TryGetAlternateLookup<TAlternateKey>(ConcurrentDictionary<TKey,TValue>.AlternateLookup<TAlternateKey>)

Representa una colección segura para subprocesos de pares clave-valor a los que pueden acceder varios subprocesos simultáneamente.

TryGetValue(TKey, TValue)

Intenta obtener el valor asociado a la clave especificada del ConcurrentDictionary<TKey,TValue>.

TryRemove(KeyValuePair<TKey,TValue>)

Quita una clave y un valor del diccionario.

TryRemove(TKey, TValue)

Intenta quitar y devolver el valor que tiene la clave especificada de la ConcurrentDictionary<TKey,TValue>.

TryUpdate(TKey, TValue, TValue)

Actualiza el valor asociado a key a newValue si el valor existente con key es igual a comparisonValue.

Implementaciones de interfaz explícitas

ICollection.CopyTo(Array, Int32)

Copia los elementos de la ICollection en una matriz, empezando por el índice de matriz especificado.

ICollection.IsSynchronized

Obtiene un valor que indica si el acceso a la ICollection está sincronizado con SyncRoot.

ICollection.SyncRoot

Obtiene un objeto que se puede usar para sincronizar el acceso a la ICollection. Esta propiedad no se admite.

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

Agrega un elemento a la colección.

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

Obtiene si el ICollection<T> contiene un elemento con la clave especificada.

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

Copia los elementos de la ICollection en una matriz, empezando por el índice de matriz especificado.

ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly

Obtiene un valor que indica si el ICollection es de solo lectura.

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

Quita el par clave-valor especificado de la colección.

IDictionary.Add(Object, Object)

Agrega la clave y el valor especificados al diccionario.

IDictionary.Contains(Object)

Obtiene un valor que indica el IDictionary<TKey,TValue> contiene un elemento con la clave especificada.

IDictionary.GetEnumerator()

Proporciona un IDictionaryEnumerator para el IDictionary<TKey,TValue>.

IDictionary.IsFixedSize

Obtiene un valor que indica si el IDictionary<TKey,TValue> tiene un tamaño fijo.

IDictionary.IsReadOnly

Obtiene un valor que indica si el IDictionary<TKey,TValue> es de solo lectura.

IDictionary.Item[Object]

Obtiene o establece el valor asociado a la clave especificada.

IDictionary.Keys

Obtiene un ICollection que contiene las claves del IDictionary<TKey,TValue>.

IDictionary.Remove(Object)

Quita el elemento con la clave especificada de la IDictionary.

IDictionary.Values

Obtiene un ICollection que contiene los valores de la IDictionary.

IDictionary<TKey,TValue>.Add(TKey, TValue)

Agrega la clave y el valor especificados al IDictionary<TKey,TValue>.

IDictionary<TKey,TValue>.Remove(TKey)

Quita el elemento con la clave especificada de la IDictionary<TKey,TValue>.

IEnumerable.GetEnumerator()

Devuelve un enumerador que recorre en iteración el ConcurrentDictionary<TKey,TValue>.

IReadOnlyDictionary<TKey,TValue>.Keys

Obtiene una colección que contiene las claves del Dictionary<TKey,TValue>.

IReadOnlyDictionary<TKey,TValue>.Values

Obtiene una colección que contiene los valores de la Dictionary<TKey,TValue>.

Métodos de extensión

ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Crea un FrozenDictionary<TKey,TValue> a partir de un IEnumerable<T> según la función del selector de claves especificada.

ToFrozenDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Crea un FrozenDictionary<TKey,TValue> a partir de un IEnumerable<T> según las funciones especificadas del selector de claves y del selector de elementos.

ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>)

Crea un FrozenSet<T> con los valores especificados.

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

Devuelve un contenedor de ReadOnlyDictionary<TKey,TValue> de solo lectura para el diccionario actual.

GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey)

Intenta obtener el valor asociado al key especificado en el dictionary.

GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey, TValue)

Intenta obtener el valor asociado al key especificado en el dictionary.

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

Intenta quitar el valor con el key especificado de la dictionary.

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

Intenta agregar el key y value especificados al dictionary.

ToImmutableArray<TSource>(IEnumerable<TSource>)

Crea una matriz inmutable a partir de la colección especificada.

ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Construye un diccionario inmutable a partir de una colección de elementos existente, aplicando una función de transformación a las claves de origen.

ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Construye un diccionario inmutable basado en alguna transformación de una secuencia.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

Enumera y transforma una secuencia y genera un diccionario inmutable de su contenido.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)

Enumera y transforma una secuencia y genera un diccionario inmutable de su contenido mediante el comparador de claves especificado.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)

Enumera y transforma una secuencia y genera un diccionario inmutable de su contenido mediante los comparadores de clave y valor especificados.

ToImmutableHashSet<TSource>(IEnumerable<TSource>)

Enumera una secuencia y genera un conjunto hash inmutable de su contenido.

ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Enumera una secuencia, genera un conjunto hash inmutable de su contenido y usa el comparador de igualdad especificado para el tipo de conjunto.

ToImmutableList<TSource>(IEnumerable<TSource>)

Enumera una secuencia y genera una lista inmutable de su contenido.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

Enumera y transforma una secuencia y genera un diccionario ordenado inmutable de su contenido.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)

Enumera y transforma una secuencia y genera un diccionario ordenado inmutable de su contenido mediante el comparador de claves especificado.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)

Enumera y transforma una secuencia y genera un diccionario ordenado inmutable de su contenido mediante los comparadores de clave y valor especificados.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>)

Enumera una secuencia y genera un conjunto ordenado inmutable de su contenido.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Enumera una secuencia, genera un conjunto ordenado inmutable de su contenido y usa el comparador especificado.

CopyToDataTable<T>(IEnumerable<T>)

Devuelve un DataTable que contiene copias de los objetos DataRow, dado un objeto de entrada IEnumerable<T> donde el parámetro genérico T es DataRow.

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

Copia DataRow objetos en el DataTableespecificado, dado un objeto IEnumerable<T> de entrada donde se DataRowel parámetro genérico T .

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

Copia DataRow objetos en el DataTableespecificado, dado un objeto IEnumerable<T> de entrada donde se DataRowel parámetro genérico T .

Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)

Aplica una función de acumulador a través de una secuencia.

Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)

Aplica una función de acumulador a través de una secuencia. El valor de inicialización especificado se usa como valor de acumulador inicial.

Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)

Aplica una función de acumulador a través de una secuencia. El valor de inicialización especificado se usa como valor de acumulador inicial y la función especificada se usa para seleccionar el valor de resultado.

AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>)

Representa una colección segura para subprocesos de pares clave-valor a los que pueden acceder varios subprocesos simultáneamente.

AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey,TAccumulate>, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>)

Representa una colección segura para subprocesos de pares clave-valor a los que pueden acceder varios subprocesos simultáneamente.

All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Determina si todos los elementos de una secuencia cumplen una condición.

Any<TSource>(IEnumerable<TSource>)

Determina si una secuencia contiene elementos.

Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Determina si algún elemento de una secuencia cumple una condición.

Append<TSource>(IEnumerable<TSource>, TSource)

Anexa un valor al final de la secuencia.

AsEnumerable<TSource>(IEnumerable<TSource>)

Devuelve la entrada con tipo IEnumerable<T>.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Calcula el promedio de una secuencia de Decimal valores que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Calcula el promedio de una secuencia de Double valores que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Calcula el promedio de una secuencia de Int32 valores que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Calcula el promedio de una secuencia de Int64 valores que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Calcula el promedio de una secuencia de valores que aceptan valores NULL Decimal que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Calcula el promedio de una secuencia de valores que aceptan valores NULL Double que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Calcula el promedio de una secuencia de valores que aceptan valores NULL Int32 que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Calcula el promedio de una secuencia de valores que aceptan valores NULL Int64 que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Calcula el promedio de una secuencia de valores que aceptan valores NULL Single que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Calcula el promedio de una secuencia de Single valores que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Cast<TResult>(IEnumerable)

Convierte los elementos de un IEnumerable al tipo especificado.

Chunk<TSource>(IEnumerable<TSource>, Int32)

Divide los elementos de una secuencia en fragmentos de tamaño como máximo size.

Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Concatena dos secuencias.

Contains<TSource>(IEnumerable<TSource>, TSource)

Determina si una secuencia contiene un elemento especificado mediante el comparador de igualdad predeterminado.

Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)

Determina si una secuencia contiene un elemento especificado mediante un IEqualityComparer<T>especificado.

Count<TSource>(IEnumerable<TSource>)

Devuelve el número de elementos de una secuencia.

Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Devuelve un número que representa el número de elementos de la secuencia especificada que cumplen una condición.

CountBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Representa una colección segura para subprocesos de pares clave-valor a los que pueden acceder varios subprocesos simultáneamente.

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

Devuelve los elementos de la secuencia especificada o el valor predeterminado del parámetro de tipo en una colección singleton si la secuencia está vacía.

DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)

Devuelve los elementos de la secuencia especificada o el valor especificado en una colección singleton si la secuencia está vacía.

Distinct<TSource>(IEnumerable<TSource>)

Devuelve distintos elementos de una secuencia mediante el comparador de igualdad predeterminado para comparar valores.

Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Devuelve distintos elementos de una secuencia mediante un IEqualityComparer<T> especificado para comparar valores.

DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Devuelve distintos elementos de una secuencia según una función de selector de claves especificada.

DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Devuelve distintos elementos de una secuencia según una función de selector de claves especificada y utilizando un comparador especificado para comparar claves.

ElementAt<TSource>(IEnumerable<TSource>, Index)

Devuelve el elemento en un índice especificado de una secuencia.

ElementAt<TSource>(IEnumerable<TSource>, Int32)

Devuelve el elemento en un índice especificado de una secuencia.

ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index)

Devuelve el elemento de un índice especificado en una secuencia o un valor predeterminado si el índice está fuera del intervalo.

ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)

Devuelve el elemento de un índice especificado en una secuencia o un valor predeterminado si el índice está fuera del intervalo.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Genera la diferencia de conjunto de dos secuencias mediante el comparador de igualdad predeterminado para comparar valores.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Genera la diferencia de conjunto de dos secuencias usando el IEqualityComparer<T> especificado para comparar valores.

ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)

Genera la diferencia de conjunto de dos secuencias según una función de selector de claves especificada.

ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Genera la diferencia de conjunto de dos secuencias según una función de selector de claves especificada.

First<TSource>(IEnumerable<TSource>)

Devuelve el primer elemento de una secuencia.

First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Devuelve el primer elemento de una secuencia que satisface una condición especificada.

FirstOrDefault<TSource>(IEnumerable<TSource>)

Devuelve el primer elemento de una secuencia o un valor predeterminado si la secuencia no contiene elementos.

FirstOrDefault<TSource>(IEnumerable<TSource>, TSource)

Devuelve el primer elemento de una secuencia o un valor predeterminado especificado si la secuencia no contiene elementos.

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Devuelve el primer elemento de la secuencia que satisface una condición o un valor predeterminado si no se encuentra ningún elemento de este tipo.

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

Devuelve el primer elemento de la secuencia que satisface una condición o un valor predeterminado especificado si no se encuentra ningún elemento de este tipo.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Agrupa los elementos de una secuencia según una función de selector de claves especificada.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Agrupa los elementos de una secuencia según una función de selector de claves especificada y compara las claves mediante un comparador especificado.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Agrupa los elementos de una secuencia según una función de selector de claves especificada y proyecta los elementos de cada grupo mediante una función especificada.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Agrupa los elementos de una secuencia según una función del selector de claves. Las claves se comparan mediante un comparador y los elementos de cada grupo se proyectan mediante una función especificada.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)

Agrupa los elementos de una secuencia según una función de selector de claves especificada y crea un valor de resultado a partir de cada grupo y su clave.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)

Agrupa los elementos de una secuencia según una función de selector de claves especificada y crea un valor de resultado a partir de cada grupo y su clave. Las claves se comparan mediante un comparador especificado.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)

Agrupa los elementos de una secuencia según una función de selector de claves especificada y crea un valor de resultado a partir de cada grupo y su clave. Los elementos de cada grupo se proyectan mediante una función especificada.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)

Agrupa los elementos de una secuencia según una función de selector de claves especificada y crea un valor de resultado a partir de cada grupo y su clave. Los valores de clave se comparan mediante un comparador especificado y los elementos de cada grupo se proyectan mediante una función especificada.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>)

Correlaciona los elementos de dos secuencias en función de la igualdad de claves y agrupa los resultados. El comparador de igualdad predeterminado se usa para comparar claves.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)

Correlaciona los elementos de dos secuencias en función de la igualdad de claves y agrupa los resultados. Se usa un IEqualityComparer<T> especificado para comparar claves.

Index<TSource>(IEnumerable<TSource>)

Devuelve un enumerable que incorpora el índice del elemento en una tupla.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Genera la intersección de conjunto de dos secuencias mediante el comparador de igualdad predeterminado para comparar valores.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Genera la intersección de conjunto de dos secuencias mediante el IEqualityComparer<T> especificado para comparar valores.

IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)

Genera la intersección de conjunto de dos secuencias según una función de selector de claves especificada.

IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Genera la intersección de conjunto de dos secuencias según una función de selector de claves especificada.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)

Correlaciona los elementos de dos secuencias en función de las claves coincidentes. El comparador de igualdad predeterminado se usa para comparar claves.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)

Correlaciona los elementos de dos secuencias en función de las claves coincidentes. Se usa un IEqualityComparer<T> especificado para comparar claves.

Last<TSource>(IEnumerable<TSource>)

Devuelve el último elemento de una secuencia.

Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Devuelve el último elemento de una secuencia que satisface una condición especificada.

LastOrDefault<TSource>(IEnumerable<TSource>)

Devuelve el último elemento de una secuencia o un valor predeterminado si la secuencia no contiene elementos.

LastOrDefault<TSource>(IEnumerable<TSource>, TSource)

Devuelve el último elemento de una secuencia o un valor predeterminado especificado si la secuencia no contiene elementos.

LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Devuelve el último elemento de una secuencia que satisface una condición o un valor predeterminado si no se encuentra ningún elemento de este tipo.

LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

Devuelve el último elemento de una secuencia que satisface una condición o un valor predeterminado especificado si no se encuentra ningún elemento de este tipo.

LongCount<TSource>(IEnumerable<TSource>)

Devuelve un Int64 que representa el número total de elementos de una secuencia.

LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Devuelve un Int64 que representa el número de elementos de una secuencia que cumplen una condición.

Max<TSource>(IEnumerable<TSource>)

Devuelve el valor máximo de una secuencia genérica.

Max<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Devuelve el valor máximo de una secuencia genérica.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor máximo Decimal.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor máximo Double.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor máximo Int32.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor máximo Int64.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor máximo que acepta valores NULL Decimal.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor máximo que acepta valores NULL Double.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor máximo que acepta valores NULL Int32.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor máximo que acepta valores NULL Int64.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor máximo que acepta valores NULL Single.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor máximo Single.

Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Invoca una función de transformación en cada elemento de una secuencia genérica y devuelve el valor resultante máximo.

MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Devuelve el valor máximo de una secuencia genérica según una función de selector de claves especificada.

MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Devuelve el valor máximo de una secuencia genérica según una función de selector de claves y un comparador de claves especificados.

Min<TSource>(IEnumerable<TSource>)

Devuelve el valor mínimo de una secuencia genérica.

Min<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Devuelve el valor mínimo de una secuencia genérica.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor mínimo Decimal.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor mínimo Double.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor mínimo Int32.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor mínimo Int64.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor mínimo que acepta valores NULL Decimal.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor mínimo que acepta valores NULL Double.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor mínimo que acepta valores NULL Int32.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor mínimo que acepta valores NULL Int64.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor mínimo que acepta valores NULL Single.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor mínimo Single.

Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Invoca una función de transformación en cada elemento de una secuencia genérica y devuelve el valor resultante mínimo.

MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Devuelve el valor mínimo de una secuencia genérica según una función de selector de claves especificada.

MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Devuelve el valor mínimo de una secuencia genérica según una función de selector de claves y un comparador de claves especificados.

OfType<TResult>(IEnumerable)

Filtra los elementos de un IEnumerable en función de un tipo especificado.

Order<T>(IEnumerable<T>)

Ordena los elementos de una secuencia en orden ascendente.

Order<T>(IEnumerable<T>, IComparer<T>)

Ordena los elementos de una secuencia en orden ascendente.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Ordena los elementos de una secuencia en orden ascendente según una clave.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Ordena los elementos de una secuencia en orden ascendente mediante un comparador especificado.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Ordena los elementos de una secuencia en orden descendente según una clave.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Ordena los elementos de una secuencia en orden descendente mediante un comparador especificado.

OrderDescending<T>(IEnumerable<T>)

Ordena los elementos de una secuencia en orden descendente.

OrderDescending<T>(IEnumerable<T>, IComparer<T>)

Ordena los elementos de una secuencia en orden descendente.

Prepend<TSource>(IEnumerable<TSource>, TSource)

Agrega un valor al principio de la secuencia.

Reverse<TSource>(IEnumerable<TSource>)

Invierte el orden de los elementos de una secuencia.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Proyecta cada elemento de una secuencia en un nuevo formulario.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)

Proyecta cada elemento de una secuencia en un nuevo formulario mediante la incorporación del índice del elemento.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)

Proyecta cada elemento de una secuencia en una IEnumerable<T> y aplana las secuencias resultantes en una secuencia.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)

Proyecta cada elemento de una secuencia en una IEnumerable<T>y aplana las secuencias resultantes en una secuencia. El índice de cada elemento de origen se usa en la forma proyectada de ese elemento.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Proyecta cada elemento de una secuencia en un IEnumerable<T>, aplana las secuencias resultantes en una secuencia e invoca una función del selector de resultados en cada elemento de la misma.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Proyecta cada elemento de una secuencia en un IEnumerable<T>, aplana las secuencias resultantes en una secuencia e invoca una función del selector de resultados en cada elemento de la misma. El índice de cada elemento de origen se usa en la forma proyectada intermedia de ese elemento.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Determina si dos secuencias son iguales comparando los elementos mediante el comparador de igualdad predeterminado para su tipo.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Determina si dos secuencias son iguales comparando sus elementos mediante un IEqualityComparer<T>especificado.

Single<TSource>(IEnumerable<TSource>)

Devuelve el único elemento de una secuencia y produce una excepción si no hay exactamente un elemento en la secuencia.

Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Devuelve el único elemento de una secuencia que satisface una condición especificada y produce una excepción si existe más de un elemento de este tipo.

SingleOrDefault<TSource>(IEnumerable<TSource>)

Devuelve el único elemento de una secuencia o un valor predeterminado si la secuencia está vacía; Este método produce una excepción si hay más de un elemento en la secuencia.

SingleOrDefault<TSource>(IEnumerable<TSource>, TSource)

Devuelve el único elemento de una secuencia o un valor predeterminado especificado si la secuencia está vacía; Este método produce una excepción si hay más de un elemento en la secuencia.

SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Devuelve el único elemento de una secuencia que satisface una condición especificada o un valor predeterminado si no existe dicho elemento; Este método produce una excepción si más de un elemento cumple la condición.

SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

Devuelve el único elemento de una secuencia que satisface una condición especificada o un valor predeterminado especificado si no existe dicho elemento; Este método produce una excepción si más de un elemento cumple la condición.

Skip<TSource>(IEnumerable<TSource>, Int32)

Omite un número especificado de elementos en una secuencia y, a continuación, devuelve los elementos restantes.

SkipLast<TSource>(IEnumerable<TSource>, Int32)

Devuelve una nueva colección enumerable que contiene los elementos de source con los últimos elementos count de la colección de origen omitidos.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Omite los elementos de una secuencia siempre que una condición especificada sea true y, a continuación, devuelve los elementos restantes.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Omite los elementos de una secuencia siempre que una condición especificada sea true y, a continuación, devuelve los elementos restantes. El índice del elemento se usa en la lógica de la función de predicado.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Calcula la suma de la secuencia de Decimal valores que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Calcula la suma de la secuencia de Double valores que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Calcula la suma de la secuencia de Int32 valores que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Calcula la suma de la secuencia de Int64 valores que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Calcula la suma de la secuencia de valores Decimal que aceptan valores NULL que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Calcula la suma de la secuencia de valores Double que aceptan valores NULL que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Calcula la suma de la secuencia de valores Int32 que aceptan valores NULL que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Calcula la suma de la secuencia de valores Int64 que aceptan valores NULL que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Calcula la suma de la secuencia de valores Single que aceptan valores NULL que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Calcula la suma de la secuencia de Single valores que se obtienen invocando una función de transformación en cada elemento de la secuencia de entrada.

Take<TSource>(IEnumerable<TSource>, Int32)

Devuelve un número especificado de elementos contiguos desde el inicio de una secuencia.

Take<TSource>(IEnumerable<TSource>, Range)

Devuelve un intervalo especificado de elementos contiguos de una secuencia.

TakeLast<TSource>(IEnumerable<TSource>, Int32)

Devuelve una nueva colección enumerable que contiene los últimos elementos count de source.

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Devuelve elementos de una secuencia siempre que se cumpla una condición especificada.

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Devuelve elementos de una secuencia siempre que se cumpla una condición especificada. El índice del elemento se usa en la lógica de la función de predicado.

ToArray<TSource>(IEnumerable<TSource>)

Crea una matriz a partir de un IEnumerable<T>.

ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Crea un Dictionary<TKey,TValue> a partir de un IEnumerable<T> según una función de selector de claves especificada.

ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Crea un Dictionary<TKey,TValue> a partir de un IEnumerable<T> según una función de selector de claves y un comparador de claves especificados.

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Crea un Dictionary<TKey,TValue> a partir de un IEnumerable<T> según las funciones especificadas del selector de claves y del selector de elementos.

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Crea un Dictionary<TKey,TValue> a partir de un IEnumerable<T> según una función de selector de claves especificada, un comparador y una función de selector de elementos.

ToHashSet<TSource>(IEnumerable<TSource>)

Crea un HashSet<T> a partir de un IEnumerable<T>.

ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Crea un HashSet<T> a partir de un IEnumerable<T> mediante el comparer para comparar claves.

ToList<TSource>(IEnumerable<TSource>)

Crea un List<T> a partir de un IEnumerable<T>.

ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Crea un Lookup<TKey,TElement> a partir de un IEnumerable<T> según una función de selector de claves especificada.

ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Crea un Lookup<TKey,TElement> a partir de un IEnumerable<T> según una función de selector de claves y un comparador de claves especificados.

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Crea un Lookup<TKey,TElement> a partir de un IEnumerable<T> según las funciones especificadas del selector de claves y del selector de elementos.

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Crea un Lookup<TKey,TElement> a partir de un IEnumerable<T> según una función de selector de claves especificada, un comparador y una función de selector de elementos.

TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32)

Intenta determinar el número de elementos de una secuencia sin forzar una enumeración.

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Genera la unión de conjunto de dos secuencias mediante el comparador de igualdad predeterminado.

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Genera la unión de conjunto de dos secuencias mediante un IEqualityComparer<T>especificado.

UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>)

Genera la unión de conjunto de dos secuencias según una función de selector de claves especificada.

UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Genera la unión de conjunto de dos secuencias según una función de selector de claves especificada.

Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Filtra una secuencia de valores en función de un predicado.

Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Filtra una secuencia de valores en función de un predicado. El índice de cada elemento se usa en la lógica de la función de predicado.

Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)

Genera una secuencia de tuplas con elementos de las dos secuencias especificadas.

Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)

Genera una secuencia de tuplas con elementos de las tres secuencias especificadas.

Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)

Aplica una función especificada a los elementos correspondientes de dos secuencias, lo que genera una secuencia de los resultados.

AsParallel(IEnumerable)

Habilita la paralelización de una consulta.

AsParallel<TSource>(IEnumerable<TSource>)

Habilita la paralelización de una consulta.

AsQueryable(IEnumerable)

Convierte un IEnumerable en un IQueryable.

AsQueryable<TElement>(IEnumerable<TElement>)

Convierte un IEnumerable<T> genérico en un IQueryable<T>genérico.

Ancestors<T>(IEnumerable<T>)

Devuelve una colección de elementos que contiene los antecesores de todos los nodos de la colección de origen.

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

Devuelve una colección filtrada de elementos que contiene los antecesores de todos los nodos de la colección de origen. En la colección solo se incluyen los elementos que tienen una XName coincidente.

DescendantNodes<T>(IEnumerable<T>)

Devuelve una colección de los nodos descendientes de todos los documentos y elementos de la colección de origen.

Descendants<T>(IEnumerable<T>)

Devuelve una colección de elementos que contiene los elementos descendientes de cada elemento y documento de la colección de origen.

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

Devuelve una colección filtrada de elementos que contiene los elementos descendientes de todos los elementos y documentos de la colección de origen. En la colección solo se incluyen los elementos que tienen una XName coincidente.

Elements<T>(IEnumerable<T>)

Devuelve una colección de los elementos secundarios de cada elemento y documento de la colección de origen.

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

Devuelve una colección filtrada de los elementos secundarios de cada elemento y documento de la colección de origen. En la colección solo se incluyen los elementos que tienen una XName coincidente.

InDocumentOrder<T>(IEnumerable<T>)

Devuelve una colección de nodos que contiene todos los nodos de la colección de origen, ordenados en orden de documento.

Nodes<T>(IEnumerable<T>)

Devuelve una colección de los nodos secundarios de todos los documentos y elementos de la colección de origen.

Remove<T>(IEnumerable<T>)

Quita todos los nodos de la colección de origen de su nodo primario.

Se aplica a

Seguridad para subprocesos

Todos los miembros públicos y protegidos de ConcurrentDictionary<TKey,TValue> son seguros para subprocesos y se pueden usar simultáneamente desde varios subprocesos. Sin embargo, los miembros a los que se accede a través de una de las interfaces que implementa el ConcurrentDictionary<TKey,TValue>, incluidos los métodos de extensión, no se garantiza que sean seguros para subprocesos y es posible que el autor de la llamada deba sincronizarse.

Consulte también