ArraySegment<T> Struktura

Definice

Obor názvů:

System

Sestavení:

System.Runtime.dll

Source:

ArraySegment.cs

Odděluje oddíl jednorozměrného pole.

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

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

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

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

Parametry typu

T

Typ prvků v segmentu pole.

Dědičnost

Object

ValueType

ArraySegment<T>

Implementuje

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

Příklady

Následující příklad kódu předá ArraySegment<T> do metody strukturu.

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

Poznámky

ArraySegment<T> je obálka kolem pole, která odděluje oblast prvků v dané matici. Více ArraySegment<T> instancí může odkazovat na stejné původní pole a může se překrývat. Původní pole musí být jednorozměrné a musí mít indexování založené na nule.

Poznámka

ArraySegment<T> implementuje IReadOnlyCollection<T> rozhraní počínaje rozhraním .NET Framework 4.6; v předchozích verzích rozhraní .NET Framework ArraySegment<T> struktura toto rozhraní neimplementovala.

Struktura ArraySegment<T> je užitečná, kdykoli bude s prvky pole manipulováno v různých segmentech. Příklad:

• Do metody můžete předat ArraySegment<T> objekt, který představuje pouze část pole jako argument, místo volání relativně nákladné metody, jako Copy je předání kopie části pole.

• V aplikaci s více vlákny můžete použít ArraySegment<T> strukturu, aby každé vlákno fungovalo pouze na části pole.

• U asynchronních operací založených na úlohách můžete pomocí objektu ArraySegment<T> zajistit, aby každý úkol fungoval na odlišném segmentu pole. Následující příklad rozdělí pole na jednotlivé segmenty s až deseti prvky. Každý prvek v segmentu se vynásobí číslem segmentu. Výsledek ukazuje, že použití ArraySegment<T> třídy k manipulaci s prvky tímto způsobem změní hodnoty jejího podkladového pole.

  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
  

Všimněte si však, že i když ArraySegment<T> lze strukturu použít k rozdělení pole na odlišné segmenty, segmenty nejsou na sobě zcela nezávislé. Vlastnost Array vrátí celou původní matici, nikoli kopii pole. Proto se změny provedené v poli vrácené Array vlastností provedou v původním poli. Pokud je to nežádoucí, měli byste provádět operace s kopií pole, nikoli s objektem ArraySegment<T> , který představuje část pole.

Metoda Equals a operátory rovnosti a nerovnosti testují rovnost odkazu při porovnání dvou ArraySegment<T> objektů. Aby se dva ArraySegment<T> objekty považovaly za rovnocenné, musí splňovat všechny následující podmínky:

• Odkaz na stejné pole.

• Začněte stejným indexem v poli.

• Mají stejný počet prvků.

Pokud chcete načíst prvek podle jeho indexu v objektu ArraySegment<T> , musíte ho přetypovat na objekt a načíst ho IList<T> nebo upravit pomocí IList<T>.Item[] vlastnosti . Všimněte si, že v jazyce F# to není nutné. Následující příklad načte element v objektu ArraySegment<T> , který odděluje oddíl pole řetězců.

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

Konstruktory

ArraySegment<T>(T[])	Inicializuje novou instanci ArraySegment<T> struktury, která odděluje všechny prvky v zadaném poli.
ArraySegment<T>(T[], Int32, Int32)	Inicializuje novou instanci ArraySegment<T> struktury, která odděluje zadaný rozsah prvků v zadané matici.

Vlastnosti

Array	Získá původní pole obsahující oblast prvků, které segment pole odděluje.
Count	Získá počet prvků v oblasti oddělené segmentem pole.
Empty	Představuje prázdný segment pole. Toto pole je jen ke čtení.
Item[Int32]	Získá nebo nastaví prvek u zadaného indexu.
Offset	Získá pozici prvního prvku v oblasti oddělené segmentem pole vzhledem k začátku původní matice.

Metody

CopyTo(ArraySegment<T>)	Zkopíruje obsah této instance do zadaného cílového segmentu pole stejného typu T.
CopyTo(T[])	Zkopíruje obsah této instance do zadaného cílového pole stejného typu T.
CopyTo(T[], Int32)	Zkopíruje obsah této instance do zadaného cílového pole stejného typu T, počínaje zadaným cílovým indexem.
Equals(ArraySegment<T>)	Určuje, zda se zadaná ArraySegment<T> struktura rovná aktuální instanci.
Equals(Object)	Určuje, zda je zadaný objekt roven aktuální instanci.
GetEnumerator()	Vrátí enumerátor, který lze použít k iteraci segmentu pole.
GetHashCode()	Vrátí kód hash pro aktuální instanci.
Slice(Int32)	Vytvoří řez z aktuálního segmentu pole počínaje zadaným indexem.
Slice(Int32, Int32)	Vytvoří řez zadané délky z aktuálního segmentu pole počínaje zadaným indexem.
ToArray()	Zkopíruje obsah tohoto segmentu pole do nového pole.

Operátory

Equality(ArraySegment<T>, ArraySegment<T>)	Označuje, zda jsou dvě ArraySegment<T> struktury rovny.
Implicit(T[] to ArraySegment<T>)	Definuje implicitní převod pole typu T na segment pole typu T.
Inequality(ArraySegment<T>, ArraySegment<T>)	Označuje, zda jsou dvě ArraySegment<T> struktury nerovné.

Explicitní implementace rozhraní

ICollection<T>.Add(T)	Ve všech případech vyvolá NotSupportedException výjimku.
ICollection<T>.Clear()	Ve všech případech vyvolá NotSupportedException výjimku.
ICollection<T>.Contains(T)	Určuje, zda segment pole obsahuje konkrétní hodnotu.
ICollection<T>.IsReadOnly	Získá hodnotu, která označuje, zda je segment pole jen pro čtení.
ICollection<T>.Remove(T)	Ve všech případech vyvolá NotSupportedException výjimku.
IEnumerable.GetEnumerator()	Vrátí enumerátor, který iteruje segmentem pole.
IEnumerable<T>.GetEnumerator()	Vrátí výčet, který iteruje segmentem pole.
IList<T>.IndexOf(T)	Určuje index konkrétní položky v segmentu pole.
IList<T>.Insert(Int32, T)	Ve všech případech vyvolá NotSupportedException výjimku.
IList<T>.Item[Int32]	Získá nebo nastaví prvek u zadaného indexu.
IList<T>.RemoveAt(Int32)	Ve všech případech vyvolá NotSupportedException výjimku.
IReadOnlyList<T>.Item[Int32]	Získá element v zadaném indexu segmentu pole.

Metody rozšíření

ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	FrozenDictionary<TKey,TValue> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů.
ToFrozenDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	FrozenDictionary<TKey,TValue> Vytvoří z objektu IEnumerable<T> podle zadaného selektoru klíčů a funkcí selektoru prvků.
ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>)	Vytvoří se FrozenSet<T> zadanými hodnotami.
AsReadOnly<T>(IList<T>)	Vrátí obálku jen ReadOnlyCollection<T> pro čtení pro zadaný seznam.
ToImmutableArray<TSource>(IEnumerable<TSource>)	Vytvoří neměnné pole ze zadané kolekce.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Vytvoří neměnný slovník z existující kolekce prvků a použije transformační funkci na zdrojové klíče.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Vytvoří neměnný slovník založený na určité transformaci sekvence.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Vytvoří výčet a transformuje sekvenci a vytvoří neměnný slovník jejího obsahu.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)	Vytvoří výčet a transformuje sekvenci a vytvoří neměnný slovník jejího obsahu pomocí zadaného porovnávače klíčů.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)	Vytvoří výčet a transformuje sekvenci a vytvoří neměnný slovník jejího obsahu pomocí zadaných porovnávačů klíčů a hodnot.
ToImmutableHashSet<TSource>(IEnumerable<TSource>)	Vytvoří výčet sekvence a vytvoří neměnnou sadu hodnot hash jejího obsahu.
ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Vytvoří výčet sekvence, vytvoří neměnnou sadu hodnot hash jejího obsahu a použije zadaný porovnávač rovnosti pro typ sady.
ToImmutableList<TSource>(IEnumerable<TSource>)	Vytvoří výčet sekvence a vytvoří neměnný seznam jejího obsahu.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Vytvoří výčet a transformuje sekvenci a vytvoří neměnný seřazený slovník jejího obsahu.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)	Vytvoří výčet a transformuje sekvenci a vytvoří neměnný seřazený slovník jejího obsahu pomocí zadaného porovnávače klíčů.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)	Vytvoří výčet a transformuje sekvenci a vytvoří neměnný slovník seřazeného obsahu pomocí zadaných porovnávačů klíčů a hodnot.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>)	Vytvoří výčet sekvence a vytvoří neměnnou seřazenou sadu jejího obsahu.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Vytvoří výčet sekvence, vytvoří neměnnou seřazenou sadu jejího obsahu a použije zadaný porovnávač.
CopyToDataTable<T>(IEnumerable<T>)	Vrátí hodnotuDataTable, která obsahuje kopie DataRow objektů vzhledem ke vstupnímu IEnumerable<T> objektu, kde je DataRowobecný parametr T .
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)	Zkopíruje DataRow objekty do zadaného DataTableobjektu s ohledem na vstupní IEnumerable<T> objekt, kde obecný parametr T je DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)	Zkopíruje DataRow objekty do zadaného DataTableobjektu s ohledem na vstupní IEnumerable<T> objekt, kde obecný parametr T je DataRow.
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)	Použije funkci akumulátoru na sekvenci.
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)	Použije funkci akumulátoru na sekvenci. Zadaná počáteční hodnota se použije jako počáteční hodnota akumulátoru.
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)	Použije funkci akumulátoru na sekvenci. Zadaná počáteční hodnota se použije jako počáteční hodnota akumulátoru a zadaná funkce se použije k výběru výsledné hodnoty.
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Určuje, zda všechny prvky sekvence splňují podmínku.
Any<TSource>(IEnumerable<TSource>)	Určuje, zda sekvence obsahuje nějaké prvky.
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Určuje, zda některý prvek sekvence splňuje podmínku.
Append<TSource>(IEnumerable<TSource>, TSource)	Připojí hodnotu na konec sekvence.
AsEnumerable<TSource>(IEnumerable<TSource>)	Vrátí vstup zadaný jako IEnumerable<T>.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Vypočítá průměr posloupnosti Decimal hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Vypočítá průměr posloupnosti Double hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Vypočítá průměr posloupnosti Int32 hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Vypočítá průměr posloupnosti Int64 hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Vypočítá průměr posloupnosti hodnot s možnou Decimal hodnotou null, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Vypočítá průměr posloupnosti hodnot s možnou Double hodnotou null, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Vypočítá průměr posloupnosti hodnot s možnou Int32 hodnotou null, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Vypočítá průměr posloupnosti hodnot s možnou Int64 hodnotou null, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Vypočítá průměr posloupnosti hodnot s možnou Single hodnotou null, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Vypočítá průměr posloupnosti Single hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence.
Cast<TResult>(IEnumerable)	Přetypuje prvky objektu na IEnumerable zadaný typ.
Chunk<TSource>(IEnumerable<TSource>, Int32)	Rozdělí prvky sekvence na bloky o velikosti maximálně size.
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Zřetězí dvě sekvence.
Contains<TSource>(IEnumerable<TSource>, TSource)	Určuje, zda sekvence obsahuje zadaný prvek pomocí výchozího porovnávače rovnosti.
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)	Určuje, zda sekvence obsahuje zadaný prvek pomocí zadané IEqualityComparer<T>.
Count<TSource>(IEnumerable<TSource>)	Vrátí počet prvků v sekvenci.
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Vrátí číslo, které představuje, kolik prvků v zadané sekvenci splňuje podmínku.
DefaultIfEmpty<TSource>(IEnumerable<TSource>)	Vrátí prvky zadané sekvence nebo výchozí hodnotu parametru typu v jednoúčelové kolekci, pokud je sekvence prázdná.
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)	Vrátí prvky zadané sekvence nebo zadanou hodnotu v jednoúčelové kolekci, pokud je sekvence prázdná.
Distinct<TSource>(IEnumerable<TSource>)	Vrátí odlišné prvky ze sekvence pomocí výchozího porovnávače rovnosti k porovnání hodnot.
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Vrátí odlišné prvky ze sekvence pomocí zadané IEqualityComparer<T> pro porovnání hodnot.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Vrátí odlišné prvky ze sekvence podle zadané funkce selektoru klíčů.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Vrátí odlišné prvky ze sekvence podle zadané funkce voliče klíčů a pomocí zadaného porovnávače k porovnání klíčů.
ElementAt<TSource>(IEnumerable<TSource>, Index)	Vrátí element v zadaném indexu v sekvenci.
ElementAt<TSource>(IEnumerable<TSource>, Int32)	Vrátí element v zadaném indexu v sekvenci.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index)	Vrátí prvek v zadaném indexu v sekvenci nebo výchozí hodnotu, pokud je index mimo rozsah.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)	Vrátí prvek v zadaném indexu v sekvenci nebo výchozí hodnotu, pokud je index mimo rozsah.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Vytvoří rozdíl sady dvou sekvencí pomocí výchozího porovnávače rovnosti k porovnání hodnot.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Vytvoří rozdíl sady dvou sekvencí pomocí zadané IEqualityComparer<T> k porovnání hodnot.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Vytvoří rozdíl sady dvou sekvencí podle zadané funkce selektoru klíčů.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Vytvoří rozdíl sady dvou sekvencí podle zadané funkce selektoru klíčů.
First<TSource>(IEnumerable<TSource>)	Vrátí první prvek sekvence.
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Vrátí první prvek v sekvenci, který splňuje zadanou podmínku.
FirstOrDefault<TSource>(IEnumerable<TSource>)	Vrátí první prvek sekvence nebo výchozí hodnotu, pokud sekvence neobsahuje žádné prvky.
FirstOrDefault<TSource>(IEnumerable<TSource>, TSource)	Vrátí první prvek sekvence nebo zadanou výchozí hodnotu, pokud sekvence neobsahuje žádné prvky.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Vrátí první prvek sekvence, který splňuje podmínku nebo výchozí hodnotu, pokud není nalezen žádný takový prvek.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Vrátí první prvek sekvence, která splňuje podmínku, nebo zadanou výchozí hodnotu, pokud není nalezen žádný takový prvek.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Seskupí prvky sekvence podle zadané funkce selektoru klíčů.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Seskupí prvky sekvence podle zadané funkce selektoru klíčů a porovná klíče pomocí zadaného porovnávače.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Seskupí prvky sekvence podle zadané funkce selektoru klíčů a pomocí zadané funkce promítne elementy pro každou skupinu.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Seskupí prvky sekvence podle funkce selektoru klíčů. Klíče se porovnávají pomocí porovnávače a prvky každé skupiny se promítají pomocí zadané funkce.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)	Seskupí prvky sekvence podle zadané funkce selektoru klíčů a vytvoří výslednou hodnotu z každé skupiny a jejího klíče.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)	Seskupí prvky sekvence podle zadané funkce selektoru klíčů a vytvoří výslednou hodnotu z každé skupiny a jejího klíče. Klíče se porovnávají pomocí zadaného porovnávače.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)	Seskupí prvky sekvence podle zadané funkce selektoru klíčů a vytvoří výslednou hodnotu z každé skupiny a jejího klíče. Prvky každé skupiny jsou projektovány pomocí zadané funkce.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)	Seskupí prvky sekvence podle zadané funkce selektoru klíčů a vytvoří výslednou hodnotu z každé skupiny a jejího klíče. Hodnoty klíčů se porovnávají pomocí zadaného porovnávače a prvky každé skupiny se promítají pomocí zadané funkce.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>)	Koreluje prvky dvou sekvencí na základě rovnosti klíčů a seskupuje výsledky. Výchozí porovnávače rovnosti se používá k porovnání klíčů.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)	Koreluje prvky dvou sekvencí na základě rovnosti klíčů a seskupuje výsledky. Zadaný parametr IEqualityComparer<T> se používá k porovnání klíčů.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Vytvoří průnik sady dvou sekvencí pomocí výchozího porovnávače rovnosti pro porovnání hodnot.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Vytvoří množinu průniku dvou sekvencí pomocí zadaného IEqualityComparer<T> pro porovnání hodnot.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Vytvoří množinu průniku dvou sekvencí podle zadané funkce selektoru klíčů.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Vytvoří množinu průniku dvou sekvencí podle zadané funkce selektoru klíčů.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)	Koreluje prvky dvou sekvencí na základě odpovídajících klíčů. Výchozí porovnávače rovnosti se používá k porovnání klíčů.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)	Koreluje prvky dvou sekvencí na základě odpovídajících klíčů. Zadaný parametr IEqualityComparer<T> se používá k porovnání klíčů.
Last<TSource>(IEnumerable<TSource>)	Vrátí poslední prvek sekvence.
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Vrátí poslední prvek sekvence, která splňuje zadanou podmínku.
LastOrDefault<TSource>(IEnumerable<TSource>)	Vrátí poslední prvek sekvence nebo výchozí hodnotu, pokud sekvence neobsahuje žádné prvky.
LastOrDefault<TSource>(IEnumerable<TSource>, TSource)	Vrátí poslední prvek sekvence nebo zadanou výchozí hodnotu, pokud sekvence neobsahuje žádné prvky.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Vrátí poslední prvek sekvence, která splňuje podmínku nebo výchozí hodnotu, pokud není nalezen žádný takový prvek.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Vrátí poslední prvek sekvence, která splňuje podmínku, nebo zadanou výchozí hodnotu, pokud není nalezen žádný takový prvek.
LongCount<TSource>(IEnumerable<TSource>)	Vrátí hodnotu Int64 , která představuje celkový počet prvků v sekvenci.
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Vrátí hodnotu Int64 , která představuje, kolik prvků v sekvenci splňuje podmínku.
Max<TSource>(IEnumerable<TSource>)	Vrátí maximální hodnotu v obecné sekvenci.
Max<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Vrátí maximální hodnotu v obecné sekvenci.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Decimal hodnotu.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Double hodnotu.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Int32 hodnotu.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Int64 hodnotu.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu s možnou Decimal hodnotou null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu s možnou Double hodnotou null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu s možnou Int32 hodnotou null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu s možnou Int64 hodnotou null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu s možnou Single hodnotou null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Single hodnotu.
Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Vyvolá transformační funkci na každý prvek obecné sekvence a vrátí maximální výslednou hodnotu.
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Vrátí maximální hodnotu v obecné sekvenci podle zadané funkce selektoru klíčů.
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Vrátí maximální hodnotu v obecné sekvenci podle zadané funkce selektoru klíčů a porovnávače klíčů.
Min<TSource>(IEnumerable<TSource>)	Vrátí minimální hodnotu v obecné sekvenci.
Min<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Vrátí minimální hodnotu v obecné sekvenci.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Vyvolá transformační funkci na každý prvek sekvence a vrátí minimální Decimal hodnotu.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Vyvolá transformační funkci na každý prvek sekvence a vrátí minimální Double hodnotu.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Vyvolá transformační funkci na každý prvek sekvence a vrátí minimální Int32 hodnotu.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Vyvolá transformační funkci na každý prvek sekvence a vrátí minimální Int64 hodnotu.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu s možnou Decimal hodnotou null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu s možnou Double hodnotou null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu s možnou Int32 hodnotou null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu s možnou Int64 hodnotou null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu s možnou Single hodnotou null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Vyvolá transformační funkci na každý prvek sekvence a vrátí minimální Single hodnotu.
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Vyvolá transformační funkci pro každý prvek obecné sekvence a vrátí minimální výslednou hodnotu.
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Vrátí minimální hodnotu v obecné sekvenci podle zadané funkce selektoru klíčů.
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Vrátí minimální hodnotu v obecné sekvenci podle zadané funkce selektoru klíčů a porovnávače klíčů.
OfType<TResult>(IEnumerable)	Filtruje prvky objektu IEnumerable na základě zadaného typu.
Order<T>(IEnumerable<T>)	Seřadí prvky sekvence ve vzestupném pořadí.
Order<T>(IEnumerable<T>, IComparer<T>)	Seřadí prvky sekvence ve vzestupném pořadí.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Seřadí prvky sekvence ve vzestupném pořadí podle klíče.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Seřadí prvky sekvence ve vzestupném pořadí pomocí zadaného porovnávače.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Seřadí prvky sekvence v sestupném pořadí podle klíče.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Seřadí prvky sekvence v sestupném pořadí pomocí zadaného porovnávače.
OrderDescending<T>(IEnumerable<T>)	Seřadí prvky sekvence v sestupném pořadí.
OrderDescending<T>(IEnumerable<T>, IComparer<T>)	Seřadí prvky sekvence v sestupném pořadí.
Prepend<TSource>(IEnumerable<TSource>, TSource)	Přidá hodnotu na začátek sekvence.
Reverse<TSource>(IEnumerable<TSource>)	Invertuje pořadí prvků v sekvenci.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Promítá každý prvek sekvence do nového formuláře.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)	Projektuje každý prvek sekvence do nové podoby začleněním indexu elementu.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)	Promítá každý prvek sekvence do objektu IEnumerable<T> a výsledné sekvence zploštědí do jedné sekvence.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)	Každý prvek sekvence se promítá do objektu IEnumerable<T>a výsledné sekvence zploštědí do jedné sekvence. Index každého zdrojového prvku se používá v projektované podobě tohoto elementu.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Promítne každý prvek sekvence na IEnumerable<T>, zploštědí výsledné sekvence do jedné sekvence a vyvolá funkci selektoru výsledků pro každý prvek v této sekvenci.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Promítne každý prvek sekvence na IEnumerable<T>, zploštědí výsledné sekvence do jedné sekvence a vyvolá funkci selektoru výsledků pro každý prvek v této sekvenci. Index každého zdrojového prvku se používá v přechodné projektované podobě tohoto prvku.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Určuje, zda jsou dvě sekvence rovny porovnáním prvků pomocí výchozího porovnávače rovnosti pro jejich typ.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Určuje, zda jsou dvě sekvence rovny porovnáním jejich prvků pomocí zadaného IEqualityComparer<T>objektu .
Single<TSource>(IEnumerable<TSource>)	Vrátí jediný prvek sekvence a vyvolá výjimku, pokud v sekvenci není právě jeden prvek.
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Vrátí jediný prvek sekvence, která splňuje zadanou podmínku, a vyvolá výjimku, pokud existuje více než jeden takový prvek.
SingleOrDefault<TSource>(IEnumerable<TSource>)	Vrátí jediný prvek sekvence, nebo výchozí hodnotu, pokud sekvence je prázdná; tato metoda vyvolá výjimku, pokud je v sekvenci více než jeden prvek.
SingleOrDefault<TSource>(IEnumerable<TSource>, TSource)	Vrátí jediný prvek sekvence, nebo zadaná výchozí hodnota, pokud sekvence je prázdná; tato metoda vyvolá výjimku, pokud je v sekvenci více než jeden prvek.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Vrátí jediný prvek sekvence, která splňuje zadanou podmínku nebo výchozí hodnotu, pokud žádný takový prvek neexistuje; Tato metoda vyvolá výjimku, pokud více než jeden prvek splňuje podmínku.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Vrátí jediný prvek sekvence, která splňuje zadanou podmínku, nebo zadanou výchozí hodnotu, pokud neexistuje žádný takový prvek; Tato metoda vyvolá výjimku, pokud více než jeden prvek splňuje podmínku.
Skip<TSource>(IEnumerable<TSource>, Int32)	Obchází zadaný počet prvků v sekvenci a pak vrátí zbývající prvky.
SkipLast<TSource>(IEnumerable<TSource>, Int32)	Vrátí novou výčtovou kolekci, která obsahuje elementy z source , přičemž poslední count prvky zdrojové kolekce jsou vynechány.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Obchází elementy v sekvenci, pokud je zadaná podmínka pravdivá, a pak vrátí zbývající prvky.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Obchází elementy v sekvenci, pokud je zadaná podmínka pravdivá, a pak vrátí zbývající prvky. Index elementu se používá v logice funkce predikátu.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Vypočítá součet posloupnosti Decimal hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Vypočítá součet posloupnosti Double hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Vypočítá součet posloupnosti Int32 hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Vypočítá součet posloupnosti Int64 hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Vypočítá součet posloupnosti hodnot s možnou Decimal hodnotou null, které jsou získány vyvoláním transformační funkce pro každý prvek vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Vypočítá součet posloupnosti hodnot s možnou Double hodnotou null, které jsou získány vyvoláním transformační funkce pro každý prvek vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Vypočítá součet posloupnosti hodnot s možnou Int32 hodnotou null, které jsou získány vyvoláním transformační funkce pro každý prvek vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Vypočítá součet posloupnosti hodnot s možnou Int64 hodnotou null, které jsou získány vyvoláním transformační funkce pro každý prvek vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Vypočítá součet posloupnosti hodnot s možnou Single hodnotou null, které jsou získány vyvoláním transformační funkce pro každý prvek vstupní sekvence.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Vypočítá součet posloupnosti Single hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence.
Take<TSource>(IEnumerable<TSource>, Int32)	Vrátí zadaný počet souvislých prvků od začátku sekvence.
Take<TSource>(IEnumerable<TSource>, Range)	Vrátí zadanou oblast souvislých prvků ze sekvence.
TakeLast<TSource>(IEnumerable<TSource>, Int32)	Vrátí novou výčtovou kolekci, která obsahuje poslední count elementy z source.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Vrátí prvky ze sekvence, pokud je zadaná podmínka pravdivá.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Vrátí prvky ze sekvence, pokud je zadaná podmínka pravdivá. Index elementu se používá v logice predikátové funkce.
ToArray<TSource>(IEnumerable<TSource>)	Vytvoří pole z objektu IEnumerable<T>.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Dictionary<TKey,TValue> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Dictionary<TKey,TValue> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů a porovnávače klíčů.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Dictionary<TKey,TValue> Vytvoří z objektu IEnumerable<T> podle zadaného selektoru klíčů a funkcí selektoru prvků.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Dictionary<TKey,TValue> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů, porovnávače a funkce selektoru prvků.
ToHashSet<TSource>(IEnumerable<TSource>)	Vytvoří z HashSet<T> objektu IEnumerable<T>.
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	HashSet<T> Vytvoří z objektu IEnumerable<T> pomocí comparer příkazu k porovnání klíčů.
ToList<TSource>(IEnumerable<TSource>)	Vytvoří z List<T> objektu IEnumerable<T>.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Lookup<TKey,TElement> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Lookup<TKey,TElement> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů a porovnávače klíčů.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Lookup<TKey,TElement> Vytvoří z objektu IEnumerable<T> podle zadaného selektoru klíčů a funkcí selektoru prvků.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Lookup<TKey,TElement> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů, porovnávače a funkce selektoru prvků.
TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32)	Pokusí se určit počet prvků v sekvenci bez vynucení výčtu.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Vytvoří sadu sjednocení dvou sekvencí pomocí výchozího porovnávače rovnosti.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Vytvoří sjednocení sady dvou sekvencí pomocí zadané IEqualityComparer<T>.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>)	Vytvoří sjednocení sady dvou sekvencí podle zadané funkce selektoru klíčů.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Vytvoří sjednocení sady dvou sekvencí podle zadané funkce selektoru klíčů.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Filtruje posloupnost hodnot na základě predikátu.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Filtruje posloupnost hodnot na základě predikátu. Index každého prvku se používá v logice predikátové funkce.
Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)	Vytvoří posloupnost řazených kolekcí členů s prvky ze dvou zadaných sekvencí.
Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)	Vytvoří sekvenci řazených kolekcí členů s prvky ze tří zadaných sekvencí.
Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)	Použije zadanou funkci na odpovídající prvky dvou sekvencí a vytvoří sekvenci výsledků.
AsParallel(IEnumerable)	Umožňuje paralelizaci dotazu.
AsParallel<TSource>(IEnumerable<TSource>)	Umožňuje paralelizaci dotazu.
AsQueryable(IEnumerable)	Převede objekt na IEnumerableIQueryable.
AsQueryable<TElement>(IEnumerable<TElement>)	Převede obecný IEnumerable<T> na obecný IQueryable<T>.
AsMemory<T>(ArraySegment<T>)	Vytvoří novou oblast paměti nad částí cílového segmentu pole.
AsMemory<T>(ArraySegment<T>, Int32)	Vytvoří novou oblast paměti nad částí cílového segmentu pole počínaje zadanou pozicí na konci segmentu.
AsMemory<T>(ArraySegment<T>, Int32, Int32)	Vytvoří novou oblast paměti nad částí cílového segmentu pole začínající na zadané pozici se zadanou délkou.
AsSpan<T>(ArraySegment<T>)	Vytvoří nový rozsah přes cílový segment pole.
AsSpan<T>(ArraySegment<T>, Index)	Vytvoří nové rozpětí nad částí cílového segmentu pole počínaje zadaným indexem a končící na konci segmentu.
AsSpan<T>(ArraySegment<T>, Int32)	Vytvoří nové rozpětí nad částí cílového segmentu pole ze zadané pozice na konec segmentu.
AsSpan<T>(ArraySegment<T>, Int32, Int32)	Vytvoří nové rozpětí nad částí cílového segmentu pole ze zadané pozice pro zadanou délku.
AsSpan<T>(ArraySegment<T>, Range)	Vytvoří nové rozpětí nad částí cílového segmentu pole pomocí počátečního a koncového indexu rozsahu.
Ancestors<T>(IEnumerable<T>)	Vrátí kolekci prvků, která obsahuje nadřazené součásti všech uzlů ve zdrojové kolekci.
Ancestors<T>(IEnumerable<T>, XName)	Vrátí filtrovanou kolekci prvků, která obsahuje nadřazené součásti všech uzlů ve zdrojové kolekci. V kolekci jsou zahrnuty pouze prvky, které mají odpovídající XName hodnoty.
DescendantNodes<T>(IEnumerable<T>)	Vrátí kolekci následnických uzlů každého dokumentu a elementu ve zdrojové kolekci.
Descendants<T>(IEnumerable<T>)	Vrátí kolekci prvků, která obsahuje následné prvky každého prvku a dokumentu ve zdrojové kolekci.
Descendants<T>(IEnumerable<T>, XName)	Vrátí filtrovanou kolekci prvků, která obsahuje následné prvky každého prvku a dokumentu ve zdrojové kolekci. V kolekci jsou zahrnuty pouze prvky, které mají odpovídající XName hodnoty.
Elements<T>(IEnumerable<T>)	Vrátí kolekci podřízených prvků každého prvku a dokumentu ve zdrojové kolekci.
Elements<T>(IEnumerable<T>, XName)	Vrátí filtrovanou kolekci podřízených prvků každého prvku a dokumentu ve zdrojové kolekci. V kolekci jsou zahrnuty pouze prvky, které mají odpovídající XName hodnoty.
InDocumentOrder<T>(IEnumerable<T>)	Vrátí kolekci uzlů, která obsahuje všechny uzly ve zdrojové kolekci seřazené podle pořadí dokumentů.
Nodes<T>(IEnumerable<T>)	Vrátí kolekci podřízených uzlů každého dokumentu a elementu ve zdrojové kolekci.
Remove<T>(IEnumerable<T>)	Odebere všechny uzly ve zdrojové kolekci z nadřazeného uzlu.

Viz také

• Array