ArraySegment<T> Estructura

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Source:

ArraySegment.cs

Delimita una sección de una matriz unidimensional.

generic <typename T>
public value class ArraySegment : System::Collections::Generic::ICollection<T>, System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IList<T>, System::Collections::Generic::IReadOnlyCollection<T>, System::Collections::Generic::IReadOnlyList<T>

public readonly struct ArraySegment<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IList<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.IReadOnlyList<T>

type ArraySegment<'T> = struct
    interface ICollection<'T>
    interface seq<'T>
    interface IEnumerable
    interface IList<'T>
    interface IReadOnlyCollection<'T>
    interface IReadOnlyList<'T>

Public Structure ArraySegment(Of T)
Implements ICollection(Of T), IEnumerable(Of T), IList(Of T), IReadOnlyCollection(Of T), IReadOnlyList(Of T)

Parámetros de tipo

T

Tipo de los elementos del segmento de la matriz.

Herencia

Object

ValueType

ArraySegment<T>

Implementaciones

ICollection<T> IEnumerable<T> IList<T> IReadOnlyCollection<T> IReadOnlyList<T> IEnumerable

Ejemplos

En el ejemplo de código siguiente se pasa una ArraySegment<T> estructura a un método .

using namespace System;


namespace Sample
{
    public ref class SampleArray  
    {
    public:
        static void Work()  
        {

            // Create and initialize a new string array.
            array <String^>^ words = {"The", "quick", "brown",
                "fox", "jumps", "over", "the", "lazy", "dog"};

            // Display the initial contents of the array.
            Console::WriteLine("The first array segment"
                " (with all the array's elements) contains:");
            PrintIndexAndValues(words);

            // Define an array segment that contains the entire array.
            ArraySegment<String^> segment(words);
            
            // Display the contents of the ArraySegment.
            Console::WriteLine("The first array segment"
                " (with all the array's elements) contains:");
            PrintIndexAndValues(segment);

            // Define an array segment that contains the middle five 
            // values of the array.
            ArraySegment<String^> middle(words, 2, 5);
            
            // Display the contents of the ArraySegment.
            Console::WriteLine("The second array segment"
                " (with the middle five elements) contains:");
            PrintIndexAndValues(middle);

            // Modify the fourth element of the first array 
            // segment
            segment.Array[3] = "LION";

            // Display the contents of the second array segment 
            // middle. Note that the value of its second element 
            // also changed.
            Console::WriteLine("After the first array segment"
                " is modified,the second array segment"
                " now contains:");
            PrintIndexAndValues(middle);
            Console::ReadLine();
        }

        static void PrintIndexAndValues(ArraySegment<String^>^ segment)  
        {
            for (int i = segment->Offset; 
                i < (segment->Offset + segment->Count); i++)  
            {
                Console::WriteLine("   [{0}] : {1}", i,
                    segment->Array[i]);
            }
            Console::WriteLine();
        }

        static void PrintIndexAndValues(array<String^>^ words) 
        {
            for (int i = 0; i < words->Length; i++)  
            {
                Console::WriteLine("   [{0}] : {1}", i,
                    words[i]);
            }
            Console::WriteLine();
        }
    };
}

int main()
{
    Sample::SampleArray::Work();
    return 0; 
}


    /* 
    This code produces the following output.

    The original array initially contains:
    [0] : The
    [1] : quick
    [2] : brown
    [3] : fox
    [4] : jumps
    [5] : over
    [6] : the
    [7] : lazy
    [8] : dog

    The first array segment (with all the array's elements) contains:
    [0] : The
    [1] : quick
    [2] : brown
    [3] : fox
    [4] : jumps
    [5] : over
    [6] : the
    [7] : lazy
    [8] : dog

    The second array segment (with the middle five elements) contains:
    [2] : brown
    [3] : fox
    [4] : jumps
    [5] : over
    [6] : the

    After the first array segment is modified, the second array segment now contains:
    [2] : brown
    [3] : LION
    [4] : jumps
    [5] : over
    [6] : the

    */

using System;

public class SamplesArray  {

   public static void Main()  {

      // Create and initialize a new string array.
      String[] myArr = { "The", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog" };

      // Display the initial contents of the array.
      Console.WriteLine( "The original array initially contains:" );
      PrintIndexAndValues( myArr );

      // Define an array segment that contains the entire array.
      ArraySegment<string> myArrSegAll = new ArraySegment<string>( myArr );

      // Display the contents of the ArraySegment.
      Console.WriteLine( "The first array segment (with all the array's elements) contains:" );
      PrintIndexAndValues( myArrSegAll );

      // Define an array segment that contains the middle five values of the array.
      ArraySegment<string> myArrSegMid = new ArraySegment<string>( myArr, 2, 5 );

      // Display the contents of the ArraySegment.
      Console.WriteLine( "The second array segment (with the middle five elements) contains:" );
      PrintIndexAndValues( myArrSegMid );

      // Modify the fourth element of the first array segment myArrSegAll.
      myArrSegAll.Array[3] = "LION";

      // Display the contents of the second array segment myArrSegMid.
      // Note that the value of its second element also changed.
      Console.WriteLine( "After the first array segment is modified, the second array segment now contains:" );
      PrintIndexAndValues( myArrSegMid );
   }

   public static void PrintIndexAndValues( ArraySegment<string> arrSeg )  {
      for ( int i = arrSeg.Offset; i < (arrSeg.Offset + arrSeg.Count); i++ )  {
         Console.WriteLine( "   [{0}] : {1}", i, arrSeg.Array[i] );
      }
      Console.WriteLine();
   }

   public static void PrintIndexAndValues( String[] myArr )  {
      for ( int i = 0; i < myArr.Length; i++ )  {
         Console.WriteLine( "   [{0}] : {1}", i, myArr[i] );
      }
      Console.WriteLine();
   }
}


/*
This code produces the following output.

The original array initially contains:
   [0] : The
   [1] : quick
   [2] : brown
   [3] : fox
   [4] : jumps
   [5] : over
   [6] : the
   [7] : lazy
   [8] : dog

The first array segment (with all the array's elements) contains:
   [0] : The
   [1] : quick
   [2] : brown
   [3] : fox
   [4] : jumps
   [5] : over
   [6] : the
   [7] : lazy
   [8] : dog

The second array segment (with the middle five elements) contains:
   [2] : brown
   [3] : fox
   [4] : jumps
   [5] : over
   [6] : the

After the first array segment is modified, the second array segment now contains:
   [2] : brown
   [3] : LION
   [4] : jumps
   [5] : over
   [6] : the

*/

open System

// Print functions.
let printIndexAndValues (myArr: string []) =
    for i = 0 to myArr.Length - 1 do
        printfn $"   [{i}] : {myArr[i]}"
    printfn ""

let printIndexAndValuesSeg (arrSeg: ArraySegment<string>) =
    for i = arrSeg.Offset to arrSeg.Offset + arrSeg.Count - 1 do
        printfn $"   [{i}] : {arrSeg.Array[i]}"
    printfn ""

// Create and initialize a new string array.
let myArr = [| "The"; "quick"; "brown"; "fox"; "jumps"; "over"; "the"; "lazy"; "dog" |]

// Display the initial contents of the array.
printfn "The original array initially contains:"
printIndexAndValues myArr

// Define an array segment that contains the entire array.
let myArrSegAll = ArraySegment<string>(myArr)

// Display the contents of the ArraySegment.
printfn "The first array segment (with all the array's elements) contains:"
printIndexAndValuesSeg myArrSegAll

// Define an array segment that contains the middle five values of the array.
let myArrSegMid = ArraySegment<string>(myArr, 2, 5)

// Display the contents of the ArraySegment.
printfn "The second array segment (with the middle five elements) contains:"
printIndexAndValuesSeg myArrSegMid

// Modify the fourth element of the first array segment myArrSegAll.
myArrSegAll.Array[3] <- "LION"

// Display the contents of the second array segment myArrSegMid.
// Note that the value of its second element also changed.
printfn "After the first array segment is modified, the second array segment now contains:"
printIndexAndValuesSeg myArrSegMid


(*
This code produces the following output.

The original array initially contains:
   [0] : The
   [1] : quick
   [2] : brown
   [3] : fox
   [4] : jumps
   [5] : over
   [6] : the
   [7] : lazy
   [8] : dog

The first array segment (with all the array's elements) contains:
   [0] : The
   [1] : quick
   [2] : brown
   [3] : fox
   [4] : jumps
   [5] : over
   [6] : the
   [7] : lazy
   [8] : dog

The second array segment (with the middle five elements) contains:
   [2] : brown
   [3] : fox
   [4] : jumps
   [5] : over
   [6] : the

After the first array segment is modified, the second array segment now contains:
   [2] : brown
   [3] : LION
   [4] : jumps
   [5] : over
   [6] : the

*)

Public Class SamplesArray

    Public Shared Sub Main()

        ' Create and initialize a new string array.
        Dim myArr As String() =  {"The", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"}

        ' Display the initial contents of the array.
        Console.WriteLine("The original array initially contains:")
        PrintIndexAndValues(myArr)

        ' Define an array segment that contains the entire array.
        Dim myArrSegAll As New ArraySegment(Of String)(myArr)

        ' Display the contents of the ArraySegment.
        Console.WriteLine("The first array segment (with all the array's elements) contains:")
        PrintIndexAndValues(myArrSegAll)

        ' Define an array segment that contains the middle five values of the array.
        Dim myArrSegMid As New ArraySegment(Of String)(myArr, 2, 5)

        ' Display the contents of the ArraySegment.
        Console.WriteLine("The second array segment (with the middle five elements) contains:")
        PrintIndexAndValues(myArrSegMid)

        ' Modify the fourth element of the first array segment myArrSegAll.
        myArrSegAll.Array(3) = "LION"

        ' Display the contents of the second array segment myArrSegMid.
        ' Note that the value of its second element also changed.
        Console.WriteLine("After the first array segment is modified, the second array segment now contains:")
        PrintIndexAndValues(myArrSegMid)

    End Sub

    Public Shared Sub PrintIndexAndValues(arrSeg As ArraySegment(Of String))
        Dim i As Integer
        For i = arrSeg.Offset To (arrSeg.Offset + arrSeg.Count - 1)
            Console.WriteLine("   [{0}] : {1}", i, arrSeg.Array(i))
        Next i
        Console.WriteLine()
    End Sub

    Public Shared Sub PrintIndexAndValues(myArr as String())
        Dim i As Integer
        For i = 0 To (myArr.Length - 1)
            Console.WriteLine("   [{0}] : {1}", i, myArr(i))
        Next i
        Console.WriteLine()
    End Sub

End Class


'This code produces the following output.
'
'The original array initially contains:
'   [0] : The
'   [1] : quick
'   [2] : brown
'   [3] : fox
'   [4] : jumps
'   [5] : over
'   [6] : the
'   [7] : lazy
'   [8] : dog
'
'The first array segment (with all the array's elements) contains:
'   [0] : The
'   [1] : quick
'   [2] : brown
'   [3] : fox
'   [4] : jumps
'   [5] : over
'   [6] : the
'   [7] : lazy
'   [8] : dog
'
'The second array segment (with the middle five elements) contains:
'   [2] : brown
'   [3] : fox
'   [4] : jumps
'   [5] : over
'   [6] : the
'
'After the first array segment is modified, the second array segment now contains:
'   [2] : brown
'   [3] : LION
'   [4] : jumps
'   [5] : over
'   [6] : the

Comentarios

ArraySegment<T> es un contenedor alrededor de una matriz que delimita un intervalo de elementos de esa matriz. Varias ArraySegment<T> instancias pueden hacer referencia a la misma matriz original y pueden superponerse. La matriz original debe ser unidimensional y debe tener una indexación de base cero.

Nota:

ArraySegment<T> implementa la IReadOnlyCollection<T> interfaz a partir de .NET Framework 4.6; en versiones anteriores de .NET Framework, la ArraySegment<T> estructura no implementaba esta interfaz.

La ArraySegment<T> estructura es útil siempre que los elementos de una matriz se manipulen en segmentos distintos. Por ejemplo:

• Puede pasar un ArraySegment<T> objeto que representa solo una parte de una matriz como argumento a un método, en lugar de llamar a un método relativamente caro como Copy pasar una copia de una parte de una matriz.

• En una aplicación multiproceso, puede usar la ArraySegment<T> estructura para que cada subproceso funcione solo en una parte de la matriz.

• En el caso de las operaciones asincrónicas basadas en tareas, puede usar un ArraySegment<T> objeto para asegurarse de que cada tarea funciona en un segmento distinto de la matriz. En el ejemplo siguiente se divide una matriz en segmentos individuales con hasta diez elementos. Cada elemento del segmento se multiplica por su número de segmento. El resultado muestra que el uso de la ArraySegment<T> clase para manipular elementos de esta manera cambia los valores de su matriz subyacente.

  using System;
  using System.Collections.Generic;
  using System.Threading.Tasks;
  
  public class Example
  {
     private const int segmentSize = 10;
  
     public static async Task Main()
     {
        List<Task> tasks = new List<Task>();
  
        // Create array.
        int[] arr = new int[50];
        for (int ctr = 0; ctr <= arr.GetUpperBound(0); ctr++)
           arr[ctr] = ctr + 1;
  
        // Handle array in segments of 10.
        for (int ctr = 1; ctr <= Math.Ceiling(((double)arr.Length)/segmentSize); ctr++) {
           int multiplier = ctr;
           int elements = (multiplier - 1) * 10 + segmentSize > arr.Length ?
                           arr.Length - (multiplier - 1) * 10 : segmentSize;
           ArraySegment<int> segment = new ArraySegment<int>(arr, (ctr - 1) * 10, elements);
           tasks.Add(Task.Run( () => { IList<int> list = (IList<int>) segment;
                                       for (int index = 0; index < list.Count; index++)
                                          list[index] = list[index] * multiplier;
                                     } ));
        }
        try {
           await Task.WhenAll(tasks.ToArray());
           int elementsShown = 0;
           foreach (var value in arr) {
              Console.Write("{0,3} ", value);
              elementsShown++;
              if (elementsShown % 18 == 0)
                 Console.WriteLine();
           }
        }
        catch (AggregateException e) {
           Console.WriteLine("Errors occurred when working with the array:");
           foreach (var inner in e.InnerExceptions)
              Console.WriteLine("{0}: {1}", inner.GetType().Name, inner.Message);
        }
     }
  }
  // The example displays the following output:
  //      1   2   3   4   5   6   7   8   9  10  22  24  26  28  30  32  34  36
  //     38  40  63  66  69  72  75  78  81  84  87  90 124 128 132 136 140 144
  //    148 152 156 160 205 210 215 220 225 230 235 240 245 250
  

  open System
  open System.Threading.Tasks
  
  // Create array.
  let arr = Array.init 50 (fun i -> i + 1)
  
  // Handle array in segments of 10.
  let tasks =
      Array.chunkBySize 10 arr
      |> Array.mapi (fun m elements ->
          let mutable segment = ArraySegment<int>(arr, m * 10, elements.Length)
          task {
              for i = 0 to segment.Count - 1 do
                  segment[i] <- segment[i] * (m + 1)
          } :> Task)
  
  try
      Task.WhenAll(tasks).Wait()
      let mutable i = 0
  
      for value in arr do
          printf $"{value, 3} "
          i <- i + 1
          if i % 18 = 0 then printfn ""
  
  with :? AggregateException as e ->
      printfn "Errors occurred when working with the array:"
  
      for inner in e.InnerExceptions do
          printfn $"{inner.GetType().Name}: {inner.Message}"
  
  
  // The example displays the following output:
  //      1   2   3   4   5   6   7   8   9  10  22  24  26  28  30  32  34  36
  //     38  40  63  66  69  72  75  78  81  84  87  90 124 128 132 136 140 144
  //    148 152 156 160 205 210 215 220 225 230 235 240 245 250
  

  Imports System.Collections.Generic
  Imports System.Threading.Tasks
  
  Module Example
    Private Const SegmentSize As Integer = 10
    
     Public Sub Main()
        Dim tasks As New List(Of Task)
        
         ' Create array.
        Dim arr(49) As Integer
        For ctr As Integer = 0 To arr.GetUpperBound(0)
           arr(ctr) = ctr + 1
        Next
  
        ' Handle array in segments of 10.
        For ctr As Integer = 1 To CInt(Math.Ceiling(arr.Length / segmentSize))
           Dim multiplier As Integer = ctr
           Dim elements As Integer = If((multiplier - 1) * 10 + segmentSize > arr.Length,
                                        arr.Length - (multiplier - 1) * 10,
                                        segmentSize)
           Dim segment As New ArraySegment(Of Integer)(arr, (ctr - 1) * 10, elements)
           tasks.Add(Task.Run( Sub()
                                  Dim list As IList(Of Integer) = CType(segment, IList(Of Integer))
                                  For index As Integer = 0 To list.Count - 1
                                     list(index) = list(index) * multiplier
                                  Next
                               End Sub ))
        Next
        Try
           Task.WaitAll(tasks.ToArray())
           Dim elementsShown As Integer = 0
           For Each value In arr
              Console.Write("{0,3} ", value)
              elementsShown += 1
              If elementsShown Mod 18 = 0 Then Console.WriteLine()
           Next
        Catch e As AggregateException
           Console.WriteLine("Errors occurred when working with the array:")
           For Each inner As Exception In e.InnerExceptions
              Console.WriteLine("{0}: {1}", inner.GetType().Name, inner.Message)
           Next
        End Try
     End Sub
  End Module
  ' The example displays the following output:
  '         1   2   3   4   5   6   7   8   9  10  22  24  26  28  30  32  34  36
  '        38  40  63  66  69  72  75  78  81  84  87  90 124 128 132 136 140 144
  '       148 152 156 160 205 210 215 220 225 230 235 240 245 250
  

Sin embargo, tenga en cuenta que, aunque la ArraySegment<T> estructura se puede usar para dividir una matriz en segmentos distintos, los segmentos no son completamente independientes entre sí. La Array propiedad devuelve toda la matriz original, no una copia de la matriz; por lo tanto, los cambios realizados en la matriz devuelta por la Array propiedad se realizan en la matriz original. Si esto no es deseable, debe realizar operaciones en una copia de la matriz, en lugar de un ArraySegment<T> objeto que represente una parte de la matriz.

El Equals método y los operadores de igualdad y desigualdad comprueban la igualdad de referencia cuando comparan dos ArraySegment<T> objetos. Para que dos ArraySegment<T> objetos se consideren iguales, deben cumplir todas las condiciones siguientes:

• Haga referencia a la misma matriz.

• Comience en el mismo índice de la matriz.

• Tienen el mismo número de elementos.

Si desea recuperar un elemento por su índice en el ArraySegment<T> objeto , debe convertirlo en un IList<T> objeto y recuperarlo o modificarlo mediante la IList<T>.Item[] propiedad . Tenga en cuenta que esto no es necesario en F#. En el ejemplo siguiente se recupera el elemento de un ArraySegment<T> objeto que delimita una sección de una matriz de cadenas.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      String[] names = { "Adam", "Bruce", "Charles", "Daniel",
                         "Ebenezer", "Francis", "Gilbert",
                         "Henry", "Irving", "John", "Karl",
                         "Lucian", "Michael" };
      var partNames = new ArraySegment<string>(names, 2, 5);

      // Cast the ArraySegment object to an IList<string> and enumerate it.
      var list = (IList<string>) partNames;
      for (int ctr = 0; ctr <= list.Count - 1; ctr++)
         Console.WriteLine(list[ctr]);
   }
}
// The example displays the following output:
//    Charles
//    Daniel
//    Ebenezer
//    Francis
//    Gilbert

open System

let names = 
    [| "Adam"; "Bruce"; "Charles"; "Daniel"
       "Ebenezer"; "Francis"; "Gilbert"
       "Henry"; "Irving"; "John"; "Karl"
       "Lucian"; "Michael" |]

let partNames = ArraySegment<string>(names, 2, 5)

// Enumerate over the ArraySegment object.
for part in partNames do 
    printfn $"{part}"

// The example displays the following output:
//    Charles
//    Daniel
//    Ebenezer
//    Francis
//    Gilbert

Imports System.Collections.Generic

Module Example
   Public Sub Main()
      Dim names() As String = { "Adam", "Bruce", "Charles", "Daniel", 
                                "Ebenezer", "Francis", "Gilbert", 
                                "Henry", "Irving", "John", "Karl",
                                "Lucian", "Michael" }
      Dim partNames As New ArraySegment(Of String)(names, 2, 5)
      
      ' Cast the ArraySegment object to an IList<String> and enumerate it.
      Dim list = CType(partNames, IList(Of String))
      For ctr As Integer = 0 To list.Count - 1
         Console.WriteLine(list(ctr))
      Next     
   End Sub
End Module
' The example displays the following output:
'    Charles
'    Daniel
'    Ebenezer
'    Francis
'    Gilbert

Constructores

ArraySegment<T>(T[])	Inicializa una nueva instancia de la estructura ArraySegment<T> que delimita todos los elementos de la matriz especificada.
ArraySegment<T>(T[], Int32, Int32)	Inicializa una nueva instancia de la estructura ArraySegment<T> que delimita el intervalo de elementos establecido en la matriz especificada.

Propiedades

Array	Obtiene la matriz original que contiene el intervalo de elementos delimitados por el segmento de la matriz.
Count	Obtiene el número de elementos del intervalo delimitado por el segmento de la matriz.
Empty	Representa el segmento de matriz vacío. Este campo es de solo lectura.
Item[Int32]	Obtiene o establece el elemento en el índice especificado.
Offset	Obtiene la posición del primer elemento del intervalo delimitado por el segmento de la matriz, respecto al inicio de la matriz original.

Métodos

CopyTo(ArraySegment<T>)	Copia el contenido de esta instancia en el segmento de la matriz de destino especificada del mismo tipo T.
CopyTo(T[])	Copia el contenido de esta instancia en la matriz de destino especificada del mismo tipo T.
CopyTo(T[], Int32)	Copia el contenido de esta instancia en la matriz de destino especificada del mismo tipo T, a partir del índice de destino especificado.
Equals(ArraySegment<T>)	Determina si la estructura ArraySegment<T> especificada es igual a la instancia actual.
Equals(Object)	Determina si el objeto especificado es igual a la instancia actual.
GetEnumerator()	Devuelve un enumerador que se puede usar para iterar por el segmento de la matriz.
GetHashCode()	Devuelve el código hash de la instancia actual.
Slice(Int32)	Crea un sector del segmento de la matriz actual a partir del índice especificado.
Slice(Int32, Int32)	Crea un sector con la longitud especificada del segmento de matriz actual a partir del índice especificado.
ToArray()	Copia el contenido de este segmento de matriz en una matriz nueva.

Operadores

Equality(ArraySegment<T>, ArraySegment<T>)	Indica si dos estructuras de ArraySegment<T> son iguales.
Implicit(T[] to ArraySegment<T>)	Define una conversión implícita de una matriz de tipo T en un segmento de matriz de tipo T.
Inequality(ArraySegment<T>, ArraySegment<T>)	Indica si dos estructuras ArraySegment<T> no son iguales.

Implementaciones de interfaz explícitas

ICollection<T>.Add(T)	Se produce una excepción NotSupportedException en todos los casos.
ICollection<T>.Clear()	Se produce una excepción NotSupportedException en todos los casos.
ICollection<T>.Contains(T)	Determina si el segmento de la matriz contiene un valor específico.
ICollection<T>.IsReadOnly	Obtiene un valor que indica si el segmento de matriz es de solo lectura.
ICollection<T>.Remove(T)	Se produce una excepción NotSupportedException en todos los casos.
IEnumerable.GetEnumerator()	Devuelve un enumerador que recorre en iteración un segmento de la matriz.
IEnumerable<T>.GetEnumerator()	Devuelve un enumerador que recorre en iteración el segmento de la matriz.
IList<T>.IndexOf(T)	Determina el índice de un elemento específico del segmento de la matriz.
IList<T>.Insert(Int32, T)	Se produce una excepción NotSupportedException en todos los casos.
IList<T>.Item[Int32]	Obtiene o establece el elemento en el índice especificado.
IList<T>.RemoveAt(Int32)	Se produce una excepción NotSupportedException en todos los casos.
IReadOnlyList<T>.Item[Int32]	Obtiene el elemento en el índice especificado del segmento de la matriz.

Métodos de extensión

ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Crea a FrozenDictionary<TKey,TValue> partir de un objeto IEnumerable<T> según la función de selector de claves especificada.
ToFrozenDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Crea un objeto FrozenDictionary<TKey,TValue> a partir de un objeto IEnumerable<T> según el selector de claves especificado y las funciones del selector de elementos.
ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>)	Crea un FrozenSet<T> objeto con los valores especificados.
AsReadOnly<T>(IList<T>)	Devuelve un contenedor de solo ReadOnlyCollection<T> lectura para la lista especificada.
ToImmutableArray<TSource>(IEnumerable<TSource>)	Crea una matriz inmutable a partir de la colección especificada.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Crea un diccionario inmutable de una colección de elementos existente, aplicando una función de transformación en las claves de origen.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Crea 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 el comparador de claves y valores especificado.
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 este 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 ordenador inmutable de su contenido mediante el comparador de claves y valores especificado.
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 objeto DataTable que contiene copias de los objetos DataRow, dado un objeto IEnumerable<T> de entrada donde el parámetro T genérico es DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)	Copia objetos DataRow en el objeto DataTable especificado, dado un objeto IEnumerable<T> de entrada donde el parámetro T genérico es DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)	Copia objetos DataRow en el objeto DataTable especificado, dado un objeto IEnumerable<T> de entrada donde el parámetro T genérico es DataRow.
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)	Aplica una función de acumulador a una secuencia.
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)	Aplica una función de acumulador a una secuencia. El valor de inicialización especificado se utiliza como valor de inicio del acumulador.
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)	Aplica una función de acumulador a una secuencia. El valor de inicialización especificado se utiliza como valor inicial del acumulador y la función especificada se utiliza para seleccionar el valor resultante.
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Determina si todos los elementos de una secuencia satisfacen 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 satisface 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 como IEnumerable<T>.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Calcula el promedio de una secuencia de valores Decimal que se obtiene al invocar 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 valores Double que se obtiene al invocar 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 valores Int32 que se obtiene al invocar 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 valores Int64 que se obtiene al invocar 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 Decimal que aceptan valores NULL que se obtiene al invocar 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 Double que aceptan valores NULL que se obtiene al invocar 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 Int32 que aceptan valores NULL que se obtiene al invocar 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 Int64 que aceptan valores NULL que se obtiene al invocar 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 Single que aceptan valores NULL que se obtiene al invocar 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 valores Single que se obtiene al invocar una función de transformación en cada elemento de la secuencia de entrada.
Cast<TResult>(IEnumerable)	Convierte los elementos de IEnumerable en el 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 utilizando el comparador de igualdad predeterminado.
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)	Determina si una secuencia contiene un elemento especificado utilizando un objeto IEqualityComparer<T> determinado.
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 cuántos elementos de la secuencia especificada satisfacen una condición.
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 diversos elementos de una secuencia utilizando el comparador de igualdad predeterminado para comparar los valores.
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Devuelve diversos elementos de una secuencia utilizando un objeto IEqualityComparer<T> especificado para comparar los valores.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Devuelve elementos distintos 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 usando un comparador especificado para comparar claves.
ElementAt<TSource>(IEnumerable<TSource>, Index)	Devuelve el elemento situado en un índice especificado de una secuencia.
ElementAt<TSource>(IEnumerable<TSource>, Int32)	Devuelve el elemento situado en un índice especificado de una secuencia.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index)	Devuelve el elemento situado en un índice especificado de una secuencia o un valor predeterminado si el índice está fuera del intervalo.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)	Devuelve el elemento situado en un índice especificado de una secuencia o un valor predeterminado si el índice está fuera del intervalo.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Proporciona la diferencia de conjuntos de dos secuencias utilizando el comparador de igualdad predeterminado para comparar los valores.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Proporciona la diferencia de conjuntos de dos secuencias utilizando el objeto IEqualityComparer<T> especificado para comparar los 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 ningún elemento.
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 dicho elemento.
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 del 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 del selector de claves especificada y compara las claves utilizando 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 del selector de claves especificada y proyecta los elementos de cada grupo utilizando una función determinada.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Agrupa los elementos de una secuencia conforme a una función del selector de claves. Las claves se comparan utilizando un comparador y los elementos de cada grupo se proyectan utilizando 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 del 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 del selector de claves especificada y crea un valor de resultado a partir de cada grupo y su clave. Las claves se comparan utilizando 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 del 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 utilizando una función determinada.
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 del selector de claves especificada y crea un valor de resultado a partir de cada grupo y su clave. Los valores de las claves se comparan utilizando un comparador especificado y los elementos de cada grupo se proyectan utilizando una función especificada.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>)	Establece una correlación entre los elementos de dos secuencias en función de la igualdad de sus 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>)	Establece una correlación entre los elementos de dos secuencias basándose en la igualdad de clave y agrupa los resultados. Se usa un IEqualityComparer<T> especificado para comparar claves.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Proporciona la intersección de conjuntos de dos secuencias utilizando el comparador de igualdad predeterminado para comparar los valores.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Proporciona la intersección de conjuntos de dos secuencias utilizando el objeto IEqualityComparer<T> especificado para comparar los 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>)	Establece la correlación de dos secuencias basándose en 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>)	Establece la correlación de dos secuencias basándose en 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 ningún elemento.
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 dicho elemento.
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 valor Int64 que representa el número total de elementos de una secuencia.
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Devuelve un valor Int64 que representa el número de elementos de una secuencia que satisfacen 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 Decimal máximo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Double máximo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Int32 máximo.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Int64 máximo.
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 Decimal máximo que acepta valores NULL.
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 Double máximo que acepta valores NULL.
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 Int32 máximo que acepta valores NULL.
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 Int64 máximo que acepta valores NULL.
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 Single máximo que acepta valores NULL.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Single máximo.
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 máximo resultante.
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 Decimal mínimo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Double mínimo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Int32 mínimo.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Int64 mínimo.
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 Decimal mínimo que acepta valores NULL.
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 Double mínimo que acepta valores NULL.
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 Int32 mínimo que acepta valores NULL.
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 Int64 mínimo que acepta valores NULL.
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 Single mínimo que acepta valores NULL.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Invoca una función de transformación en cada elemento de una secuencia y devuelve el valor Single mínimo.
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 mínimo resultante.
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 IEnumerable en función de un tipo especificado.
Order<T>(IEnumerable<T>)	Ordena de manera ascendente los elementos de una secuencia.
Order<T>(IEnumerable<T>, IComparer<T>)	Ordena de manera ascendente los elementos de una secuencia.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Ordena de manera ascendente los elementos de una secuencia en función de una clave.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Ordena de manera ascendente los elementos de una secuencia utilizando un comparador especificado.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Ordena de manera descendente los elementos de una secuencia en función de una clave.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Ordena de manera descendente los elementos de una secuencia utilizando un comparador especificado.
OrderDescending<T>(IEnumerable<T>)	Ordena de manera descendente los elementos de una secuencia.
OrderDescending<T>(IEnumerable<T>, IComparer<T>)	Ordena de manera descendente los elementos de una secuencia.
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 a un nuevo formulario.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)	Proyecta cada elemento de una secuencia en un nuevo formulario incorporando el índice del elemento.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)	Proyecta cada elemento de una secuencia en una interfaz IEnumerable<T> y reduce las secuencias resultantes en una secuencia.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)	Proyecta cada elemento de una secuencia en una interfaz IEnumerable<T> y reduce las secuencias resultantes en una secuencia. El índice de cada elemento de origen se utiliza en el formulario proyectado de ese elemento.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Proyecta cada elemento de una secuencia en IEnumerable<T>, reduce las secuencias resultantes en una única secuencia e invoca una función del selector de resultados en cada elemento.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Proyecta cada elemento de una secuencia en IEnumerable<T>, reduce las secuencias resultantes en una única secuencia e invoca una función del selector de resultados en cada elemento. El índice de cada elemento de origen se utiliza en el formulario proyectado intermedio de ese elemento.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Determina si dos secuencias son iguales; para ello, se comparan sus elementos mediante el comparador de igualdad predeterminado para su tipo.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Determina si dos secuencias son iguales; para ello, compara sus elementos utilizando una interfaz IEqualityComparer<T> especificada.
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 cumpla 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 cumpla la condición especificada, o bien, un valor predeterminado si ese elemento no existe; este método produce una excepción si varios elementos cumplen 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 luego devuelve los elementos restantes.
SkipLast<TSource>(IEnumerable<TSource>, Int32)	Devuelve una nueva colección que contiene los elementos de source con los últimos elementos de count de la colección de origen omitida.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Omite los elementos de una secuencia en tanto que el valor de una condición especificada sea true y luego devuelve los elementos restantes.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Omite los elementos de una secuencia en tanto que el valor de una condición especificada sea true y luego 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 una secuencia de valores Decimal que se obtiene al invocar 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 una secuencia de valores Double que se obtiene al invocar 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 una secuencia de valores Int32 que se obtiene al invocar 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 una secuencia de valores Int64 que se obtiene al invocar 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 una secuencia de valores Decimal que aceptan valores NULL que se obtiene al invocar 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 una secuencia de valores Double que aceptan valores NULL que se obtiene al invocar 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 una secuencia de valores Int32 que aceptan valores NULL que se obtiene al invocar 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 una secuencia de valores Int64 que aceptan valores NULL que se obtiene al invocar 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 una secuencia de valores Single que aceptan valores NULL que se obtiene al invocar 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 una secuencia de valores Single que se obtiene al invocar 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 principio 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 los elementos de una secuencia en tanto que el valor de una condición especificada sea true.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Devuelve los elementos de una secuencia en tanto que el valor de una condición especificada sea true. 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 una clase Dictionary<TKey,TValue> a partir de una interfaz IEnumerable<T> según una función del selector de claves especificada.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Crea un objeto Dictionary<TKey,TValue> a partir de un objeto IEnumerable<T> según una función del selector de claves especificada y el comparador de claves.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Crea un objeto Dictionary<TKey,TValue> a partir de un objeto IEnumerable<T> según el selector de claves especificado y las funciones del selector de elementos.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Crea un objeto Dictionary<TKey,TValue> a partir de un objeto IEnumerable<T> según una función del selector de claves especificada, un comparador y una función del 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 objeto HashSet<T> a partir de una instancia de IEnumerable<T> mediante 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 una clase Lookup<TKey,TElement> a partir de una interfaz IEnumerable<T> según una función del selector de claves especificada.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Crea un objeto Lookup<TKey,TElement> a partir de un objeto IEnumerable<T> según una función del selector de claves especificada y el comparador de claves.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Crea un objeto Lookup<TKey,TElement> a partir de un objeto IEnumerable<T> según el selector de claves especificado y las funciones del selector de elementos.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Crea un objeto Lookup<TKey,TElement> a partir de un objeto IEnumerable<T> según una función del selector de claves, un comparador y una función del selector de elementos especificados.
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>)	Proporciona la unión de conjuntos de dos secuencias utilizando el comparador de igualdad predeterminado.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Proporciona la unión de conjuntos de dos secuencias a través de un objeto 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 a partir 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 la función especificada a los elementos correspondientes de dos secuencias, lo que genera una secuencia de resultados.
AsParallel(IEnumerable)	Habilita la paralelización de una consulta.
AsParallel<TSource>(IEnumerable<TSource>)	Habilita la paralelización de una consulta.
AsQueryable(IEnumerable)	Convierte una interfaz IEnumerable en IQueryable.
AsQueryable<TElement>(IEnumerable<TElement>)	Convierte un parámetro IEnumerable<T> genérico en un parámetro IQueryable<T> genérico.
AsMemory<T>(ArraySegment<T>)	Crea una región de memoria en la parte del segmento de matriz de destino.
AsMemory<T>(ArraySegment<T>, Int32)	Crea una región de memoria en la parte del segmento de la matriz de destino a partir de una posición especificada hasta el final del segmento.
AsMemory<T>(ArraySegment<T>, Int32, Int32)	Crea una región de memoria en la parte del segmento de la matriz de destino a partir de una posición especificada y con una longitud especificada.
AsSpan<T>(ArraySegment<T>)	Crea un intervalo en un segmento de la matriz de destino.
AsSpan<T>(ArraySegment<T>, Index)	Crea un intervalo en una parte del segmento de la matriz de destino a partir de un índice especificado y hasta el final del segmento.
AsSpan<T>(ArraySegment<T>, Int32)	Crea un intervalo en una parte de un segmento de la matriz de destino a partir de una posición especificada hasta el final del segmento.
AsSpan<T>(ArraySegment<T>, Int32, Int32)	Crea un intervalo en una parte de un segmento de una matriz de destino a partir de una posición especificada y con una longitud especificada.
AsSpan<T>(ArraySegment<T>, Range)	Crea un intervalo en una parte de un segmento de la matriz de destino mediante los índices inicial y final del intervalo.
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 de elementos filtrada que contiene los antecesores de todos los nodos de la colección de origen. En la colección sólo se incluyen los elementos que tienen un objeto 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 todos los elementos y documentos 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 sólo se incluyen los elementos que tienen un objeto XName coincidente.
Elements<T>(IEnumerable<T>)	Devuelve una colección de los elementos secundarios de todos los elementos y documentos de la colección de origen.
Elements<T>(IEnumerable<T>, XName)	Devuelve una colección filtrada de los elementos secundarios de todos los elementos y documentos de la colección de origen. En la colección sólo se incluyen los elementos que tienen un objeto XName coincidente.
InDocumentOrder<T>(IEnumerable<T>)	Devuelve una colección de nodos que contiene todos los nodos de la colección de origen, clasificados por 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.

Consulte también

• Array