Partilhar via


ArraySegment<T> Estrutura

Definição

Delimita uma seção de uma 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>
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>
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>
[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>
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

T

O tipo dos elementos no segmento de matriz.

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

Exemplos

O exemplo de código a seguir passa uma estrutura ArraySegment<T> para um 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

Comentários

ArraySegment<T> é um wrapper em torno de uma matriz que delimita um intervalo de elementos nessa matriz. Várias instâncias de ArraySegment<T> podem se referir à mesma matriz original e podem se sobrepor. A matriz original deve ser unidimensional e deve ter indexação baseada em zero.

Nota

ArraySegment<T> implementa a interface IReadOnlyCollection<T> começando com o .NET Framework 4.6; nas versões anteriores do .NET Framework, a estrutura ArraySegment<T> não implementou essa interface.

A estrutura ArraySegment<T> é útil sempre que os elementos de uma matriz são manipulados em segmentos distintos. Por exemplo:

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

  • Em um aplicativo multithreaded, você pode usar a estrutura ArraySegment<T> para que cada thread opere apenas em uma parte da matriz.

  • Para operações assíncronas baseadas em tarefa, você pode usar um objeto ArraySegment<T> para garantir que cada tarefa opere em um segmento distinto da matriz. O exemplo a seguir divide uma matriz em segmentos individuais com até dez elementos. Cada elemento no segmento é multiplicado por seu número de segmento. O resultado mostra que o uso da classe ArraySegment<T> para manipular elementos dessa forma altera os valores de sua matriz 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
    

No entanto, observe que, embora a estrutura de ArraySegment<T> possa ser usada para dividir uma matriz em segmentos distintos, os segmentos não são completamente independentes uns dos outros. A propriedade Array retorna toda a matriz original, não uma cópia da matriz; portanto, as alterações feitas na matriz retornada pela propriedade Array são feitas na matriz original. Se isso for indesejável, você deverá executar operações em uma cópia da matriz, em vez de um objeto ArraySegment<T> que representa uma parte da matriz.

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

  • Faça referência à mesma matriz.

  • Comece no mesmo índice na matriz.

  • Tenha o mesmo número de elementos.

Se você quiser recuperar um elemento por seu índice no objeto ArraySegment<T>, deverá convertê-lo em um objeto IList<T> e recuperá-lo ou modificá-lo usando a propriedade IList<T>.Item[]. Observe que isso não é necessário em F#. O exemplo a seguir recupera o elemento em um objeto ArraySegment<T> que delimita uma seção de uma matriz de cadeia de caracteres.

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

ArraySegment<T>(T[])

Inicializa uma nova instância da estrutura ArraySegment<T> que delimita todos os elementos na matriz especificada.

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

Inicializa uma nova instância da estrutura de ArraySegment<T> que delimita o intervalo especificado dos elementos na matriz especificada.

Propriedades

Array

Obtém a matriz original que contém o intervalo de elementos que o segmento de matriz delimita.

Count

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

Empty

Representa o segmento de matriz vazio. Este campo é somente leitura.

Item[Int32]

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

Offset

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

Métodos

CopyTo(ArraySegment<T>)

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

CopyTo(T[])

Copia o conteúdo dessa instância para a matriz de destino especificada do mesmo tipo T.

CopyTo(T[], Int32)

Copia o conteúdo dessa instância para a matriz de destino especificada do mesmo tipo T, começando no índice de destino especificado.

Equals(ArraySegment<T>)

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

Equals(Object)

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

GetEnumerator()

Retorna um enumerador que pode ser usado para iterar por meio do segmento de matriz.

GetHashCode()

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

Slice(Int32)

Forma uma fatia do segmento de matriz atual começando no índice especificado.

Slice(Int32, Int32)

Forma uma fatia do comprimento especificado fora do segmento de matriz atual, começando no índice especificado.

ToArray()

Copia o conteúdo desse segmento de matriz em uma nova matriz.

Operadores

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

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

Implicit(T[] to ArraySegment<T>)

Define uma conversão implícita de uma matriz de tipo T em um segmento de matriz do tipo T.

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

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

Implantações explícitas de interface

ICollection<T>.Add(T)

Gera uma exceção NotSupportedException em todos os casos.

ICollection<T>.Clear()

Gera uma exceção NotSupportedException em todos os casos.

ICollection<T>.Contains(T)

Determina se o segmento de matriz contém um valor específico.

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

Copia os elementos do segmento de matriz para uma matriz, começando no índice de matriz especificado.

ICollection<T>.IsReadOnly

Obtém um valor que indica se o segmento de matriz é somente leitura.

ICollection<T>.Remove(T)

Gera uma exceção NotSupportedException em todos os casos.

IEnumerable.GetEnumerator()

Retorna um enumerador que itera por meio de um segmento de matriz.

IEnumerable<T>.GetEnumerator()

Retorna um enumerador que itera por meio do segmento de matriz.

IList<T>.IndexOf(T)

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

IList<T>.Insert(Int32, T)

Gera uma exceção NotSupportedException em todos os casos.

IList<T>.Item[Int32]

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

IList<T>.RemoveAt(Int32)

Gera uma exceção NotSupportedException em todos os casos.

IReadOnlyList<T>.Item[Int32]

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

Métodos de Extensão

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

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

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

Cria um FrozenDictionary<TKey,TValue> de uma IEnumerable<T> de acordo com as funções de seletor de elemento e seletor de elemento especificadas.

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

Cria um FrozenSet<T> com os valores especificados.

AsReadOnly<T>(IList<T>)

Retorna um wrapper de ReadOnlyCollection<T> somente leitura para a lista especificada.

ToImmutableArray<TSource>(IEnumerable<TSource>)

Cria uma matriz imutável da coleção especificada.

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 de origem.

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

Constrói um dicionário imutável com base em alguma transformação de uma sequência.

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 de seu conteúdo.

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 de seu conteúdo usando o comparador de chave especificado.

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 de seu conteúdo usando os comparadores de chave e valor especificados.

ToImmutableHashSet<TSource>(IEnumerable<TSource>)

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

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

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

ToImmutableList<TSource>(IEnumerable<TSource>)

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

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

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

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 classificado imutável de seu conteúdo usando o comparador de chave especificado.

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 classificado imutável de seu conteúdo usando os comparadores de chave e valor especificados.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>)

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

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

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

CopyToDataTable<T>(IEnumerable<T>)

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

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

Copia DataRow objetos para o DataTableespecificado, considerando um objeto de IEnumerable<T> de entrada em que o parâmetro genérico T é DataRow.

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

Copia DataRow objetos para o DataTableespecificado, considerando um objeto de IEnumerable<T> de entrada em que o parâmetro genérico T é DataRow.

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

Aplica uma função de acumulador em uma sequência.

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

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

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

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

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

Delimita uma seção de uma matriz unidimensional.

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

Delimita uma seção de uma matriz unidimensional.

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

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

Any<TSource>(IEnumerable<TSource>)

Determina se uma sequência contém elementos.

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

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

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

Acrescenta um valor ao final da sequência.

AsEnumerable<TSource>(IEnumerable<TSource>)

Retorna a entrada digitada como IEnumerable<T>.

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

Calcula a média de uma sequência de valores Decimal 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 valores Double 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 valores Int32 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 valores Int64 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 Decimal anuláveis 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 Double anuláveis 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 Int32 anuláveis 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 Int64 anuláveis 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 Single anuláveis 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 valores Single obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

Cast<TResult>(IEnumerable)

Converte os elementos de um IEnumerable para o tipo especificado.

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

Divide os elementos de uma sequência em partes de tamanho no máximo size.

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

Concatena duas sequências.

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

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

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

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

Count<TSource>(IEnumerable<TSource>)

Retorna o número de elementos em uma sequência.

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

Retorna um número que representa quantos elementos na sequência especificada atendem a uma condição.

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

Delimita uma seção de uma matriz unidimensional.

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

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

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

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

Distinct<TSource>(IEnumerable<TSource>)

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

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

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

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

Retorna elementos distintos de uma sequência de acordo com uma função de seletor de chave especificada.

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

Retorna elementos distintos de uma sequência de acordo com uma função de seletor de chave especificada e usando um comparador especificado para comparar chaves.

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

Retorna o elemento em um índice especificado em uma sequência.

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

Retorna o elemento em um índice especificado em uma sequência.

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

Retorna o elemento em um índice especificado em uma sequência ou um valor padrão se o índice estiver fora do intervalo.

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

Retorna o elemento em um índice especificado em uma sequência ou um valor padrão se o índice estiver fora do intervalo.

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

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

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

Produz a diferença de conjunto de duas sequências usando a IEqualityComparer<T> especificada para comparar valores.

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

Produz a diferença de conjunto de duas sequências de acordo com uma função de seletor de chave especificada.

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

Produz a diferença de conjunto de duas sequências de acordo com uma função de seletor de chave especificada.

First<TSource>(IEnumerable<TSource>)

Retorna o primeiro elemento de uma sequência.

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

Retorna o primeiro elemento em uma sequência que satisfaz uma condição especificada.

FirstOrDefault<TSource>(IEnumerable<TSource>)

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

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

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

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

Retorna o primeiro elemento da sequência que satisfaz uma condição ou um valor padrão se nenhum elemento desse tipo for encontrado.

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

Retorna o primeiro elemento da sequência que satisfaz uma condição ou um valor padrão especificado se nenhum elemento desse tipo for encontrado.

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

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

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

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

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 de seletor de chave especificada e projeta os elementos para cada grupo 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 de seletor de chave. 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,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)

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

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 de seletor de chave especificada e cria um valor de resultado de cada grupo e sua chave. As chaves são comparadas usando um comparador especificado.

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 de seletor de chave especificada e cria um valor de resultado de cada grupo e sua chave. 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>, IEqualityComparer<TKey>)

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

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 de chaves e agrupa os resultados. O comparador de igualdade padrão é usado para comparar chaves.

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 IEqualityComparer<T> especificado é usado para comparar chaves.

Index<TSource>(IEnumerable<TSource>)

Retorna um enumerável que incorpora o índice do elemento em uma tupla.

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

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

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

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

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

Produz a interseção definida de duas sequências de acordo com uma função de seletor de chave especificada.

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

Produz a interseção definida de duas sequências de acordo com uma função de seletor de chave especificada.

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 em chaves correspondentes. O comparador de igualdade padrão é usado para comparar chaves.

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 em chaves correspondentes. Um IEqualityComparer<T> especificado é usado para comparar chaves.

Last<TSource>(IEnumerable<TSource>)

Retorna o último elemento de uma sequência.

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

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

LastOrDefault<TSource>(IEnumerable<TSource>)

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

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

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

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

Retorna o último elemento de uma sequência que satisfaz uma condição ou um valor padrão se nenhum elemento desse tipo for encontrado.

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

Retorna o último elemento de uma sequência que satisfaz uma condição ou um valor padrão especificado se nenhum elemento desse tipo for encontrado.

LongCount<TSource>(IEnumerable<TSource>)

Retorna um Int64 que representa o número total de elementos em uma sequência.

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

Retorna um Int64 que representa quantos elementos em uma sequência atendem a uma condição.

Max<TSource>(IEnumerable<TSource>)

Retorna o valor máximo em uma sequência genérica.

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

Retorna o valor máximo em uma sequência genérica.

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

Invoca uma função de transformação em cada elemento de uma sequência e retorna 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 retorna 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 retorna 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 retorna 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 retorna o valor máximo de Decimal anulável.

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

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

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

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

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

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

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

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

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

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

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 retorna o valor máximo resultante.

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

Retorna o valor máximo em uma sequência genérica de acordo com uma função de seletor de chave especificada.

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

Retorna o valor máximo em uma sequência genérica de acordo com uma função de seletor de chave especificada e um comparador de chave.

Min<TSource>(IEnumerable<TSource>)

Retorna o valor mínimo em uma sequência genérica.

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

Retorna o valor mínimo em uma sequência genérica.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 retorna o valor mínimo resultante.

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

Retorna o valor mínimo em uma sequência genérica de acordo com uma função de seletor de chave especificada.

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

Retorna o valor mínimo em uma sequência genérica de acordo com uma função de seletor de chave especificada e um comparador de chave.

OfType<TResult>(IEnumerable)

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

Order<T>(IEnumerable<T>)

Classifica os elementos de uma sequência em ordem crescente.

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

Classifica os elementos de uma sequência em ordem crescente.

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

Classifica os elementos de uma sequência em ordem crescente de acordo com uma chave.

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

Classifica os elementos de uma sequência em ordem crescente usando um comparador especificado.

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

Classifica os elementos de uma sequência em ordem decrescente de acordo com uma chave.

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

Classifica os elementos de uma sequência em ordem decrescente usando um comparador especificado.

OrderDescending<T>(IEnumerable<T>)

Classifica os elementos de uma sequência em ordem decrescente.

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

Classifica os elementos de uma sequência em ordem decrescente.

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

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

Reverse<TSource>(IEnumerable<TSource>)

Inverte a ordem dos elementos em uma sequência.

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

Projeta cada elemento de uma sequência em um novo formulário.

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

Projeta cada elemento de uma sequência em um novo formulário incorporando o índice do elemento.

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

Projeta cada elemento de uma sequência em um IEnumerable<T> e nivela as sequências resultantes em uma sequência.

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

Projeta cada elemento de uma sequência em um IEnumerable<T>e nivela as sequências resultantes em uma sequência. O índice de cada elemento de origem é usado na forma projetada desse elemento.

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

Projeta cada elemento de uma sequência em um IEnumerable<T>, nivela as sequências resultantes em uma sequência e invoca uma função de seletor de resultados em cada elemento nela.

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

Projeta cada elemento de uma sequência em um IEnumerable<T>, nivela as sequências resultantes em uma sequência e invoca uma função de seletor de resultados em cada elemento nela. O índice de cada elemento de origem é usado na forma projetada intermediária desse elemento.

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 seu tipo.

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

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

Single<TSource>(IEnumerable<TSource>)

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

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

Retorna o único elemento de uma sequência que satisfaz uma condição especificada e gera uma exceção se houver mais de um desses elementos.

SingleOrDefault<TSource>(IEnumerable<TSource>)

Retorna o único elemento de uma sequência ou um valor padrão se a sequência estiver vazia; esse método gerará uma exceção se houver mais de um elemento na sequência.

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

Retorna o único elemento de uma sequência ou um valor padrão especificado se a sequência estiver vazia; esse método gerará uma exceção se houver mais de um elemento na sequência.

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

Retorna o único elemento de uma sequência que satisfaz uma condição especificada ou um valor padrão se nenhum elemento desse tipo existir; esse método gerará uma exceção se mais de um elemento atender à condição.

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

Retorna o único elemento de uma sequência que satisfaz uma condição especificada ou um valor padrão especificado se nenhum elemento desse tipo existir; esse método gerará uma exceção se mais de um elemento atender à condição.

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

Ignora um número especificado de elementos em uma sequência e retorna os elementos restantes.

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

Retorna uma nova coleção enumerável que contém os elementos de source com os últimos elementos count da coleção de origem omitida.

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

Ignora elementos em uma sequência, desde que uma condição especificada seja verdadeira e, em seguida, retorna os elementos restantes.

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

Ignora elementos em uma sequência, desde que uma condição especificada seja verdadeira e, em seguida, retorna 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 valores Decimal 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 valores Double 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 valores Int32 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 valores Int64 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 Decimal anuláveis obtidos invocando 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 Double anuláveis obtidos invocando 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 Int32 anuláveis obtidos invocando 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 Int64 anuláveis obtidos invocando 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 Single anuláveis obtidos invocando 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 valores Single obtidos invocando uma função de transformação em cada elemento da sequência de entrada.

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

Retorna um número especificado de elementos contíguos desde o início de uma sequência.

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

Retorna um intervalo especificado de elementos contíguos de uma sequência.

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

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

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

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

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

Retorna 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 uma matriz de um IEnumerable<T>.

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

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

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

Cria um Dictionary<TKey,TValue> de um IEnumerable<T> de acordo com uma função de seletor de chave especificada e um comparador de chave.

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

Cria um Dictionary<TKey,TValue> de uma IEnumerable<T> de acordo com as funções de seletor de elemento e seletor de elemento especificadas.

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

Cria um Dictionary<TKey,TValue> de uma IEnumerable<T> de acordo com uma função de seletor de chave especificada, um comparador e uma função seletora de elemento.

ToHashSet<TSource>(IEnumerable<TSource>)

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

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

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

ToList<TSource>(IEnumerable<TSource>)

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

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

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

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

Cria um Lookup<TKey,TElement> de um IEnumerable<T> de acordo com uma função de seletor de chave especificada e um comparador de chave.

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

Cria um Lookup<TKey,TElement> de uma IEnumerable<T> de acordo com as funções de seletor de elemento e seletor de elemento especificadas.

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

Cria um Lookup<TKey,TElement> de uma IEnumerable<T> de acordo com uma função de seletor de chave especificada, um comparador e uma função de seletor de elemento.

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

Tenta determinar o número de elementos em uma sequência sem forçar uma enumeração.

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

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

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

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

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

Produz a união definida de duas sequências de acordo com uma função de seletor de chave especificada.

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

Produz a união definida de duas sequências de acordo com uma função de seletor de chave especificada.

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

Filtra uma sequência de valores com base em um predicado.

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

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

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

Produz uma sequência de tuplas com elementos das duas sequências especificadas.

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

Produz uma sequência de tuplas com elementos das três sequências especificadas.

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.

AsParallel(IEnumerable)

Habilita a paralelização de uma consulta.

AsParallel<TSource>(IEnumerable<TSource>)

Habilita a paralelização de uma consulta.

AsQueryable(IEnumerable)

Converte um IEnumerable em um IQueryable.

AsQueryable<TElement>(IEnumerable<TElement>)

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

AsMemory<T>(ArraySegment<T>)

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

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

Cria uma nova região de memória sobre a parte do segmento de matriz de destino começando em uma posição especificada até o final do segmento.

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

Cria uma nova região de memória sobre a parte do segmento de matriz de destino começando em uma posição especificada com um comprimento especificado.

AsSpan<T>(ArraySegment<T>)

Cria um novo intervalo em um segmento de matriz de destino.

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

Cria um novo intervalo em uma parte do segmento de matriz de destino começando em um índice especificado e terminando no final do segmento.

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

Cria um novo intervalo em uma parte de um segmento de matriz de destino de uma posição especificada até o final do segmento.

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

Cria um novo intervalo sobre uma parte de um segmento de matriz de destino de uma posição especificada para um comprimento especificado.

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

Cria um novo intervalo em uma parte de um segmento de matriz de destino usando os índices de início e de término do intervalo.

Ancestors<T>(IEnumerable<T>)

Retorna uma coleção de elementos que contém os ancestrais de cada nó na coleção de origem.

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

Retorna uma coleção filtrada de elementos que contém os ancestrais de cada nó na coleção de origem. Somente os elementos que têm uma XName correspondente são incluídos na coleção.

DescendantNodes<T>(IEnumerable<T>)

Retorna uma coleção de nós descendentes de cada documento e elemento na coleção de origem.

Descendants<T>(IEnumerable<T>)

Retorna uma coleção de elementos que contém os elementos descendentes de cada elemento e documento na coleção de origem.

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

Retorna uma coleção filtrada de elementos que contém os elementos descendentes de cada elemento e documento na coleção de origem. Somente os elementos que têm uma XName correspondente são incluídos na coleção.

Elements<T>(IEnumerable<T>)

Retorna uma coleção dos elementos filho de cada elemento e documento na coleção de origem.

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

Retorna uma coleção filtrada dos elementos filho de cada elemento e documento na coleção de origem. Somente os elementos que têm uma XName correspondente são incluídos na coleção.

InDocumentOrder<T>(IEnumerable<T>)

Retorna uma coleção de nós que contém todos os nós na coleção de origem, classificada na ordem do documento.

Nodes<T>(IEnumerable<T>)

Retorna uma coleção dos nós filho de cada documento e elemento na coleção de origem.

Remove<T>(IEnumerable<T>)

Remove cada nó da coleção de origem de seu nó pai.

Aplica-se a

Confira também