ArraySegment<T> Estrutura

Definição

Delimita uma secção de um arranjo 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>
generic <typename T>
public value class ArraySegment
public 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>
[System.Serializable]
public struct ArraySegment<T>
[System.Serializable]
public 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>
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>
[<System.Serializable>]
type ArraySegment<'T> = struct
[<System.Serializable>]
type ArraySegment<'T> = struct
    interface IList<'T>
    interface ICollection<'T>
    interface IReadOnlyList<'T>
    interface IReadOnlyCollection<'T>
    interface seq<'T>
    interface IEnumerable
[<System.Serializable>]
type ArraySegment<'T> = struct
    interface IList<'T>
    interface ICollection<'T>
    interface seq<'T>
    interface IEnumerable
    interface IReadOnlyList<'T>
    interface IReadOnlyCollection<'T>
type ArraySegment<'T> = struct
    interface IList<'T>
    interface ICollection<'T>
    interface IReadOnlyList<'T>
    interface IReadOnlyCollection<'T>
    interface seq<'T>
    interface IEnumerable
Public Structure ArraySegment(Of T)
Implements ICollection(Of T), IEnumerable(Of T), IList(Of T), IReadOnlyCollection(Of T), IReadOnlyList(Of T)
Public Structure ArraySegment(Of T)

Parâmetros de Tipo Genérico

T

O tipo dos elementos no segmento do array.

Herança
ArraySegment<T>
Atributos
Implementações

Exemplos

O seguinte exemplo de código passa uma ArraySegment<T> estrutura para um método.

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

Observações

ArraySegment<T> é um wrapper em torno de um array que delimita um conjunto de elementos nesse array. Múltiplas ArraySegment<T> instâncias podem referir-se ao mesmo array original e podem sobrepor-se. O array original deve ser unidimensional e ter indexação baseada em zero.

Note

ArraySegment<T> implementa a interface IReadOnlyCollection<T> a partir do .NET Framework 4.6; em versões anteriores do .NET Framework, a estrutura ArraySegment<T> não implementava esta interface.

A ArraySegment<T> estrutura é útil sempre que os elementos de um array forem manipulados em segmentos distintos. Por exemplo:

  • Podes passar um ArraySegment<T> objeto que representa apenas uma parte de um array como argumento para um método, em vez de chamar um método relativamente caro, como Copy passar uma cópia de uma parte de um array.

  • Numa aplicação multithread, pode usar a ArraySegment<T> estrutura para que cada thread opere apenas numa parte do array.

  • Para operações assíncronas baseadas em tarefas, pode usar um ArraySegment<T> objeto para garantir que cada tarefa opera num segmento distinto do array. O exemplo seguinte divide um array em segmentos individuais com até dez elementos. Cada elemento do segmento é multiplicado pelo seu número de segmento. O resultado mostra que usar a ArraySegment<T> classe para manipular elementos desta forma altera os valores do seu array subjacente.

    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
    

Note-se, no entanto, que embora a ArraySegment<T> estrutura possa ser usada para dividir um array em segmentos distintos, os segmentos não são completamente independentes uns dos outros. A Array propriedade devolve o array original completo, não uma cópia do array; portanto, alterações feitas ao array devolvido pela Array propriedade são feitas no array original. Se isto não for desejável, deve realizar operações numa cópia do array, em vez de num ArraySegment<T> objeto que represente uma parte do array.

O Equals método e os operadores de igualdade e desigualdade testam a igualdade de referência quando comparam dois ArraySegment<T> objetos. Para que dois ArraySegment<T> objetos sejam considerados iguais, devem cumprir todas as seguintes condições:

  • Faz referência ao mesmo array.

  • Comece no mesmo índice do array.

  • Tem o mesmo número de elementos.

Se quiser recuperar um elemento pelo seu índice no ArraySegment<T> objeto, deve confundir para um IList<T> objeto e recuperá-lo ou modificá-lo usando a IList<T>.Item[] propriedade. Note que isto não é necessário em F#. O exemplo seguinte recupera o elemento num ArraySegment<T> objeto que delimita uma secção de um array de cordas.

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

Construtores

Name Description
ArraySegment<T>(T[], Int32, Int32)

Inicializa uma nova instância da ArraySegment<T> estrutura que delimita o intervalo especificado dos elementos no array especificado.

ArraySegment<T>(T[])

Inicializa uma nova instância da ArraySegment<T> estrutura que delimita todos os elementos no array especificado.

Propriedades

Name Description
Array

Obtém o array original contendo o intervalo de elementos que o segmento do array delimita.

Count

Obtém o número de elementos no intervalo delimitado pelo segmento do array.

Empty

Representa o segmento vazio do array. Este campo é só de leitura.

Item[Int32]

Obtém ou define o elemento no índice especificado.

Offset

Obtém a posição do primeiro elemento no intervalo delimitada pelo segmento do array, em relação ao início do array original.

Métodos

Name Description
CopyTo(ArraySegment<T>)

Copia o conteúdo desta instância para o segmento de array de destino especificado do mesmo tipo T.

CopyTo(T[], Int32)

Copia o conteúdo desta instância para o array de destino especificado do mesmo tipo T, começando no índice de destino especificado.

CopyTo(T[])

Copia o conteúdo desta instância para o array de destino especificado do mesmo tipo T.

Equals(ArraySegment<T>)

Determina se a estrutura especificada ArraySegment<T> é igual à instância atual.

Equals(Object)

Determina se o objeto especificado é igual à instância atual.

GetEnumerator()

Devolve um enumerador que pode ser usado para iterar pelo segmento do array.

GetHashCode()

Devolve o código hash da instância atual.

Slice(Int32, Int32)

Forma uma fatia do comprimento especificado a partir do segmento atual do array, começando no índice especificado.

Slice(Int32)

Forma uma fatia a partir do segmento atual do array começando no índice especificado.

ToArray()

Copia o conteúdo deste segmento de array para um novo array.

Operadores

Name Description
Equality(ArraySegment<T>, ArraySegment<T>)

Indica se duas ArraySegment<T> estruturas são iguais.

Implicit(T[] to ArraySegment<T>)

Define uma conversão implícita de um array de tipo T para um segmento de array de tipo T.

Inequality(ArraySegment<T>, ArraySegment<T>)

Indica se duas ArraySegment<T> estruturas são desiguais.

Implementações de Interface Explícita

Name Description
ICollection<T>.Add(T)

Faz NotSupportedException exceção em todos os casos.

ICollection<T>.Clear()

Faz NotSupportedException exceção em todos os casos.

ICollection<T>.Contains(T)

Determina se o segmento do array contém um valor específico.

ICollection<T>.CopyTo(T[], Int32)

Copia os elementos do segmento do array para um array, começando no índice especificado do array.

ICollection<T>.IsReadOnly

Obtém um valor que indica se o segmento do array é apenas de leitura.

ICollection<T>.Remove(T)

Faz NotSupportedException exceção em todos os casos.

IEnumerable.GetEnumerator()

Devolve um enumerador que itera através de um segmento de array.

IEnumerable<T>.GetEnumerator()

Devolve um enumerador que itera pelo segmento do array.

IList<T>.IndexOf(T)

Determina o índice de um item específico no segmento do array.

IList<T>.Insert(Int32, T)

Faz NotSupportedException exceção em todos os casos.

IList<T>.Item[Int32]

Obtém ou define o elemento no índice especificado.

IList<T>.RemoveAt(Int32)

Faz NotSupportedException exceção em todos os casos.

IReadOnlyList<T>.Item[Int32]

Obtém o elemento no índice especificado do segmento do array.

Métodos da Extensão

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

Aplica uma função acumuladora sobre uma sequência. O valor semente especificado é usado como valor inicial do acumulador, e a função especificada é usada para selecionar o valor do resultado.

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

Aplica uma função acumuladora sobre uma sequência. O valor semente especificado é usado como valor inicial do acumulador.

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

Aplica uma função acumuladora sobre uma sequência.

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

Determina se todos os elementos de uma sequência satisfazem uma condição.

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

Devolve uma coleção filtrada de elementos que contém os antepassados de cada nó na coleção fonte. Apenas os elementos que têm correspondência XName são incluídos na coleção.

Ancestors<T>(IEnumerable<T>)

Devolve uma coleção de elementos que contém os antepassados de cada nó na coleção de código-fonte.

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

Determina se algum elemento de uma sequência satisfaz uma condição.

Any<TSource>(IEnumerable<TSource>)

Determina se uma sequência contém algum elemento.

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

Acrescenta um valor ao final da sequência.

AsEnumerable<TSource>(IEnumerable<TSource>)

Retorna a entrada digitada como IEnumerable<T>.

AsMemory<T>(ArraySegment<T>, Int32, Int32)

Cria uma nova região de memória sobre a porção do segmento do array alvo que começa numa posição especificada com um comprimento especificado.

AsMemory<T>(ArraySegment<T>, Int32)

Cria uma nova região de memória sobre a porção do segmento do array alvo que começa numa posição especificada até ao final do segmento.

AsMemory<T>(ArraySegment<T>)

Cria uma nova região de memória sobre a parte do segmento do array alvo.

AsParallel(IEnumerable)

Permite a paralelização de uma consulta.

AsParallel<TSource>(IEnumerable<TSource>)

Permite a paralelização de uma consulta.

AsQueryable(IEnumerable)

Converte um IEnumerable para um IQueryable.

AsQueryable<TElement>(IEnumerable<TElement>)

Converte um genérico IEnumerable<T> num genérico IQueryable<T>.

AsSpan<T>(ArraySegment<T>, Index)

Cria um novo espaço sobre uma porção do segmento alvo do array, começando num índice especificado e terminando no final do segmento.

AsSpan<T>(ArraySegment<T>, Int32, Int32)

Cria um novo vão sobre uma porção de um segmento de matriz alvo a partir de uma posição especificada para um comprimento especificado.

AsSpan<T>(ArraySegment<T>, Int32)

Cria um novo vão sobre uma porção de um segmento de matriz alvo desde uma posição especificada até ao fim do segmento.

AsSpan<T>(ArraySegment<T>, Range)

Cria um novo vão sobre uma porção de um segmento de array alvo usando os índices de início e fim da faixa.

AsSpan<T>(ArraySegment<T>)

Cria um novo espaço sobre um segmento de array alvo.

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

Calcula a média de uma sequência de Decimal valores obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a média de uma sequência de Double valores obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a média de uma sequência de Int32 valores obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a média de uma sequência de Int64 valores obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a média de uma sequência de valores anuláveis Decimal que são obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a média de uma sequência de valores anuláveis Double que são obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a média de uma sequência de valores anuláveis Int32 que são obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a média de uma sequência de valores anuláveis Int64 que são obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a média de uma sequência de valores anuláveis Single que são obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a média de uma sequência de Single valores obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

Cast<TResult>(IEnumerable)

Conjura os elementos de an IEnumerable para o tipo especificado.

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

Concatena duas sequências.

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

Determina se uma sequência contém um elemento especificado usando um .IEqualityComparer<T>

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

Determina se uma sequência contém um elemento especificado usando o comparador de igualdade padrão.

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

Copia DataRow objetos para o especificado DataTable, dado um objeto de entrada IEnumerable<T> onde o parâmetro T genérico é DataRow.

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

Copia DataRow objetos para o especificado DataTable, dado um objeto de entrada IEnumerable<T> onde o parâmetro T genérico é DataRow.

CopyToDataTable<T>(IEnumerable<T>)

Devolve a DataTable que contém cópias dos DataRow objetos, dado um objeto de entrada IEnumerable<T> onde o parâmetro T genérico é DataRow.

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

Devolve um número que representa quantos elementos na sequência especificada satisfazem uma condição.

Count<TSource>(IEnumerable<TSource>)

Devolve o número de elementos numa sequência.

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

Devolve os elementos da sequência especificada ou o valor especificado numa coleção singleton se a sequência estiver vazia.

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

Devolve os elementos da sequência especificada ou o valor padrão do parâmetro de tipo numa coleção singleton se a sequência estiver vazia.

DescendantNodes<T>(IEnumerable<T>)

Devolve uma coleção dos nós descendentes de cada documento e elemento da coleção de origem.

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

Devolve uma coleção filtrada de elementos que contém os elementos descendentes de cada elemento e documento da coleção de origem. Apenas os elementos que têm correspondência XName são incluídos na coleção.

Descendants<T>(IEnumerable<T>)

Devolve uma coleção de elementos que contém os elementos descendentes de cada elemento e documento da coleção fonte.

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

Devolve elementos distintos de uma sequência usando um especificado IEqualityComparer<T> para comparar valores.

Distinct<TSource>(IEnumerable<TSource>)

Devolve elementos distintos de uma sequência usando o comparador de igualdade padrão para comparar valores.

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

Devolve o elemento num índice especificado numa sequência.

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

Devolve o elemento num índice especificado numa sequência ou um valor padrão se o índice estiver fora do intervalo.

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

Devolve uma coleção filtrada dos elementos filhos de cada elemento e documento da coleção de origem. Apenas os elementos que têm correspondência XName são incluídos na coleção.

Elements<T>(IEnumerable<T>)

Devolve uma coleção dos elementos filhos de cada elemento e documento da coleção de origem.

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

Produz a diferença de conjuntos de duas sequências usando o especificado IEqualityComparer<T> para comparar valores.

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

Produz a diferença de conjuntos de duas sequências usando o comparador de igualdade por defeito para comparar valores.

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

Devolve o primeiro elemento numa sequência que satisfaz uma condição especificada.

First<TSource>(IEnumerable<TSource>)

Devolve o primeiro elemento de uma sequência.

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

Devolve o primeiro elemento da sequência que satisfaz uma condição ou um valor padrão se tal elemento não for encontrado.

FirstOrDefault<TSource>(IEnumerable<TSource>)

Devolve o primeiro elemento de uma sequência, ou um valor padrão se a sequência não contiver elementos.

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

Agrupa os elementos de uma sequência de acordo com uma função seletora de teclas especificada e cria um valor de resultado a partir de cada grupo e da sua chave. Os valores-chave são comparados usando um comparador especificado, e os elementos de cada grupo são projetados usando uma função especificada.

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

Agrupa os elementos de uma sequência de acordo com uma função seletora de teclas especificada e cria um valor de resultado a partir de cada grupo e da sua chave. Os elementos de cada grupo são projetados usando uma função especificada.

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

Agrupa os elementos de uma sequência de acordo com uma função seletora de tecla. As chaves são comparadas usando um comparador e os elementos de cada grupo são projetados usando uma função especificada.

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

Agrupa os elementos de uma sequência de acordo com uma função seletora de teclas especificada e projeta os elementos para cada grupo usando uma função especificada.

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

Agrupa os elementos de uma sequência de acordo com uma função seletora de teclas especificada e cria um valor de resultado a partir de cada grupo e da sua chave. As chaves são comparadas usando um comparador especificado.

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

Agrupa os elementos de uma sequência de acordo com uma função seletora de teclas especificada e cria um valor de resultado a partir de cada grupo e da sua chave.

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

Agrupa os elementos de uma sequência de acordo com uma função seletora de teclas especificada e compara as chaves usando um comparador especificado.

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

Agrupa os elementos de uma sequência de acordo com uma função seletora de teclas especificada.

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

Correlaciona os elementos de duas sequências com base na igualdade de chave e agrupa os resultados. Um especificado IEqualityComparer<T> é usado para comparar tonalidades.

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

Correlaciona os elementos de duas sequências com base na igualdade das chaves e agrupa os resultados. O comparador de igualdade por defeito é usado para comparar chaves.

InDocumentOrder<T>(IEnumerable<T>)

Devolve uma coleção de nós que contém todos os nós da coleção de código-fonte, ordenados pela ordem dos documentos.

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

Produz a interseção conjunta de duas sequências usando o especificado IEqualityComparer<T> para comparar valores.

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

Produz a interseção conjunta de duas sequências usando o comparador de igualdade padrão para comparar valores.

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

Correlaciona os elementos de duas sequências com base nas chaves correspondentes. Um especificado IEqualityComparer<T> é usado para comparar tonalidades.

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

Correlaciona os elementos de duas sequências com base nas chaves correspondentes. O comparador de igualdade por defeito é usado para comparar chaves.

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

Devolve o último elemento de uma sequência que satisfaz uma condição especificada.

Last<TSource>(IEnumerable<TSource>)

Devolve o último elemento de uma sequência.

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

Devolve o último elemento de uma sequência que satisfaz uma condição ou um valor padrão se tal elemento não for encontrado.

LastOrDefault<TSource>(IEnumerable<TSource>)

Devolve o último elemento de uma sequência, ou um valor padrão se a sequência não contiver elementos.

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

Devolve e Int64 que representa quantos elementos numa sequência satisfazem uma condição.

LongCount<TSource>(IEnumerable<TSource>)

Retorna e Int64 que representa o número total de elementos numa sequência.

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

Invoca uma função de transformação em cada elemento de uma sequência genérica e devolve o valor máximo resultante.

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor máximo Decimal .

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor máximo Double .

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor máximo Int32 .

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor máximo Int64 .

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor máximo anulável Decimal .

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor máximo anulável Double .

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor máximo anulável Int32 .

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor máximo anulável Int64 .

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor máximo anulável Single .

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor máximo Single .

Max<TSource>(IEnumerable<TSource>)

Devolve o valor máximo numa sequência genérica.

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

Invoca uma função de transformação em cada elemento de uma sequência genérica e devolve o valor mínimo resultante.

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo Decimal .

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo Double .

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo Int32 .

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo Int64 .

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo anulável Decimal .

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo anulável Double .

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo anulável Int32 .

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo anulável Int64 .

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo anulável Single .

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

Invoca uma função de transformação em cada elemento de uma sequência e devolve o valor mínimo Single .

Min<TSource>(IEnumerable<TSource>)

Devolve o valor mínimo numa sequência genérica.

Nodes<T>(IEnumerable<T>)

Devolve uma coleção dos nós filhos de cada documento e elemento da coleção de código-fonte.

OfType<TResult>(IEnumerable)

Filtra os elementos de um IEnumerable com base num tipo especificado.

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

Ordena os elementos de uma sequência por ordem crescente usando um comparador especificado.

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

Ordena os elementos de uma sequência por ordem crescente de acordo com uma chave.

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

Ordena os elementos de uma sequência por ordem decrescente usando um comparador especificado.

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

Ordena os elementos de uma sequência por ordem decrescente de acordo com uma chave.

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

Acrescenta um valor ao início da sequência.

Remove<T>(IEnumerable<T>)

Remove todos os nós da coleção de origem do seu nó pai.

Reverse<TSource>(IEnumerable<TSource>)

Inverte a ordem dos elementos numa sequência.

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

Projeta cada elemento de uma sequência numa nova forma incorporando o índice do elemento.

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

Projeta cada elemento de uma sequência numa nova forma.

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

Projeta cada elemento de uma sequência para um IEnumerable<T>, achata as sequências resultantes numa sequência e invoca uma função seletora de resultados em cada elemento nelas.

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

Projeta cada elemento de uma sequência para um IEnumerable<T>, achata as sequências resultantes numa sequência e invoca uma função seletora de resultados em cada elemento nelas. O índice de cada elemento fonte é usado na forma intermédia projetada desse elemento.

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

Projeta cada elemento de uma sequência para um IEnumerable<T> e achata as sequências resultantes numa sequência.

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

Projeta cada elemento de uma sequência para um IEnumerable<T>, e achata as sequências resultantes numa só sequência. O índice de cada elemento fonte é usado na forma projetada desse elemento.

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

Determina se duas sequências são iguais comparando os seus elementos usando um especificado IEqualityComparer<T>.

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

Determina se duas sequências são iguais comparando os elementos usando o comparador de igualdade padrão para o seu tipo.

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

Devolve o único elemento de uma sequência que satisfaz uma condição especificada, e lança uma exceção se existirem mais do que um desses elementos.

Single<TSource>(IEnumerable<TSource>)

Devolve o único elemento de uma sequência e lança uma exceção se não houver exatamente um elemento na sequência.

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

Devolve o único elemento de uma sequência que satisfaz uma condição especificada ou um valor padrão se tal elemento não existir; este método lança uma exceção se mais do que um elemento satisfizerem a condição.

SingleOrDefault<TSource>(IEnumerable<TSource>)

Devolve o único elemento de uma sequência, ou um valor padrão se a sequência estiver vazia; este método lança uma exceção se houver mais do que um elemento na sequência.

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

Ignora um número especificado de elementos numa sequência e depois devolve os elementos restantes.

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

Devolve uma nova coleção enumerável que contém os elementos de source com os últimos count elementos da coleção fonte omitidos.

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

Ignora elementos numa sequência desde que uma condição especificada seja verdadeira e depois devolve os elementos restantes.

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

Ignora elementos numa sequência desde que uma condição especificada seja verdadeira e depois devolve os elementos restantes. O índice do elemento é usado na lógica da função de predicado.

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

Calcula a soma da sequência de Decimal valores obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a soma da sequência de Double valores obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a soma da sequência de Int32 valores obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a soma da sequência de Int64 valores obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a soma da sequência de valores nulos Decimal que são obtidos ao invocar uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a soma da sequência de valores nulos Double que são obtidos ao invocar uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a soma da sequência de valores nulos Int32 que são obtidos ao invocar uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a soma da sequência de valores nulos Int64 que são obtidos ao invocar uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a soma da sequência de valores nulos Single que são obtidos ao invocar uma função de transformação em cada elemento da sequência de entrada.

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

Calcula a soma da sequência de Single valores obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Devolve um número especificado de elementos contíguos do início de uma sequência.

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

Devolve uma nova coleção enumerável que contém os últimos count elementos de source.

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

Devolve elementos de uma sequência desde que uma condição especificada seja verdadeira.

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

Devolve elementos de uma sequência desde que uma condição especificada seja verdadeira. O índice do elemento é usado na lógica da função de predicado.

ToArray<TSource>(IEnumerable<TSource>)

Cria um array a partir de um IEnumerable<T>.

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

Cria a Dictionary<TKey,TValue> partir de uma IEnumerable<T> função seletora de teclas especificada, um comparador e uma função seletora de elementos.

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

Cria um Dictionary<TKey,TValue> a partir de um IEnumerable<T> de acordo com as funções seletoras de teclas e seletores de elementos especificadas.

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

Cria um Dictionary<TKey,TValue> a partir de um IEnumerable<T> de acordo com uma função seletora de teclas especificada e um comparador de chaves.

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

Cria um Dictionary<TKey,TValue> a partir de um IEnumerable<T> de acordo com uma função seletor de teclas especificada.

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

Cria um HashSet<T> a partir de um IEnumerable<T> usando o comparer para comparar as chaves.

ToHashSet<TSource>(IEnumerable<TSource>)

Cria um HashSet<T> a partir de um IEnumerable<T>.

ToImmutableArray<TSource>(IEnumerable<TSource>)

Cria um array imutável a partir da coleção especificada.

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

Enumera e transforma uma sequência, e produz um dicionário imutável do seu conteúdo usando os comparadores de chave e valor especificados.

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

Enumera e transforma uma sequência, e produz um dicionário imutável do seu conteúdo usando o comparador de chaves especificado.

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

Enumera e transforma uma sequência, e produz um dicionário imutável do seu conteúdo.

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

Constrói um dicionário imutável baseado numa transformação de uma sequência.

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

Constrói um dicionário imutável a partir de uma coleção existente de elementos, aplicando uma função de transformação às chaves fonte.

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

Enumera uma sequência, produz um conjunto de hash imutável do seu conteúdo e utiliza o comparador de igualdade especificado para o tipo de conjunto.

ToImmutableHashSet<TSource>(IEnumerable<TSource>)

Enumera uma sequência e produz um conjunto de hash imutável do seu conteúdo.

ToImmutableList<TSource>(IEnumerable<TSource>)

Enumera uma sequência e produz uma lista imutável do seu conteúdo.

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

Enumera e transforma uma sequência, e produz um dicionário ordenado imutável do seu conteúdo usando os comparadores de chave e valor especificados.

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

Enumera e transforma uma sequência, e produz um dicionário ordenado imutável do seu conteúdo usando o comparador de chaves especificado.

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

Enumera e transforma uma sequência, produzindo um dicionário ordenado imutável do seu conteúdo.

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

Enumera uma sequência, produz um conjunto ordenado imutável do seu conteúdo e utiliza o comparador especificado.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>)

Enumera uma sequência e produz um conjunto ordenado imutável do seu conteúdo.

ToList<TSource>(IEnumerable<TSource>)

Cria um List<T> a partir de um IEnumerable<T>.

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

Cria a Lookup<TKey,TElement> partir de uma IEnumerable<T> função seletora de teclas especificada, um comparador e uma função seletor de elementos.

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

Cria um Lookup<TKey,TElement> a partir de um IEnumerable<T> de acordo com as funções seletoras de teclas e seletores de elementos especificadas.

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

Cria um Lookup<TKey,TElement> a partir de um IEnumerable<T> de acordo com uma função seletora de teclas especificada e um comparador de chaves.

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

Cria um Lookup<TKey,TElement> a partir de um IEnumerable<T> de acordo com uma função seletor de teclas especificada.

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

Produz a união de conjuntos de duas sequências usando um especificado IEqualityComparer<T>.

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

Produz a união conjunta de duas sequências usando o comparador de igualdade padrão.

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

Filtra uma sequência de valores com base num predicado.

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

Filtra uma sequência de valores com base num predicado. O índice de cada elemento é usado na lógica da função de predicado.

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

Aplica uma função especificada aos elementos correspondentes de duas sequências, produzindo uma sequência dos resultados.

Aplica-se a

Ver também