Stack<T> Osztály

Definíció

Névtér:

System.Collections.Generic

Szerelvények:

netstandard.dll, System.Collections.dll

Forrás:

Stack.cs

Az azonos típusú példányok utolsó előtti (LIFO) változóméretét jelöli.

generic <typename T>
public ref class Stack : System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IReadOnlyCollection<T>, System::Collections::ICollection

public class Stack<T> : System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection

type Stack<'T> = class
    interface seq<'T>
    interface IEnumerable
    interface IReadOnlyCollection<'T>
    interface ICollection

Public Class Stack(Of T)
Implements ICollection, IEnumerable(Of T), IReadOnlyCollection(Of T)

Típusparaméterek

T

Megadja a verem elemeinek típusát.

Öröklődés

Object

Stack<T>

Megvalósítás

IEnumerable<T> IReadOnlyCollection<T> ICollection IEnumerable

Példák

Az alábbi példakód az általános osztály számos metódusát Stack<T> mutatja be. A példakód egy alapértelmezett kapacitású sztringkészletet hoz létre, és a Push metódus használatával öt sztringet küld a verembe. A verem elemei enumerálva vannak, ami nem változtatja meg a verem állapotát. A Pop metódus az első sztringet a veremből való leugratására használja. A Peek metódus a verem következő elemének megtekintésére szolgál, majd a Pop metódust használja a rendszer a kiugratáshoz.

A ToArray metódus egy tömb létrehozására és a veremelemek másolására szolgál, majd a rendszer átadja a tömböt az Stack<T> azt használó IEnumerable<T>konstruktornak, létrehozva a verem másolatát az elemek sorrendjének megfordításával. A másolat elemei megjelennek.

A rendszer létrehoz egy tömböt, amely kétszer akkora, mint a verem, és a CopyTo metódus a tömb közepétől kezdődő tömbelemek másolására szolgál. A Stack<T> konstruktor ismét a verem egy másolatának létrehozására szolgál az elemek sorrendjének megfordítása mellett, így a három null elem a végén található.

A Contains metódus azt mutatja, hogy a "négy" sztring a verem első példányában található, majd a Clear metódus törli a másolatot, a Count tulajdonság pedig azt mutatja, hogy a verem üres.

using System;
using System.Collections.Generic;

class Example
{
    public static void Main()
    {
        Stack<string> numbers = new Stack<string>();
        numbers.Push("one");
        numbers.Push("two");
        numbers.Push("three");
        numbers.Push("four");
        numbers.Push("five");

        // A stack can be enumerated without disturbing its contents.
        foreach( string number in numbers )
        {
            Console.WriteLine(number);
        }

        Console.WriteLine("\nPopping '{0}'", numbers.Pop());
        Console.WriteLine("Peek at next item to destack: {0}",
            numbers.Peek());
        Console.WriteLine("Popping '{0}'", numbers.Pop());

        // Create a copy of the stack, using the ToArray method and the
        // constructor that accepts an IEnumerable<T>.
        Stack<string> stack2 = new Stack<string>(numbers.ToArray());

        Console.WriteLine("\nContents of the first copy:");
        foreach( string number in stack2 )
        {
            Console.WriteLine(number);
        }

        // Create an array twice the size of the stack and copy the
        // elements of the stack, starting at the middle of the
        // array.
        string[] array2 = new string[numbers.Count * 2];
        numbers.CopyTo(array2, numbers.Count);

        // Create a second stack, using the constructor that accepts an
        // IEnumerable(Of T).
        Stack<string> stack3 = new Stack<string>(array2);

        Console.WriteLine("\nContents of the second copy, with duplicates and nulls:");
        foreach( string number in stack3 )
        {
            Console.WriteLine(number);
        }

        Console.WriteLine("\nstack2.Contains(\"four\") = {0}",
            stack2.Contains("four"));

        Console.WriteLine("\nstack2.Clear()");
        stack2.Clear();
        Console.WriteLine("\nstack2.Count = {0}", stack2.Count);
    }
}

/* This code example produces the following output:

five
four
three
two
one

Popping 'five'
Peek at next item to destack: four
Popping 'four'

Contents of the first copy:
one
two
three

Contents of the second copy, with duplicates and nulls:
one
two
three




stack2.Contains("four") = False

stack2.Clear()

stack2.Count = 0
 */

open System
open System.Collections.Generic

let numbers = Stack()
numbers.Push "one"
numbers.Push "two"
numbers.Push "three"
numbers.Push "four"
numbers.Push "five"

// A stack can be enumerated without disturbing its contents.
for number in numbers do
    printfn $"{number}"

printfn $"\nPopping '{numbers.Pop()}'"
printfn $"Peek at next item to destack: {numbers.Peek()}"
numbers.Peek() |> ignore
printfn $"Popping '{numbers.Pop()}'"

// Create a copy of the stack, using the ToArray method and the
// constructor that accepts an IEnumerable<T>.
let stack2 = numbers.ToArray() |> Stack

printfn "\nContents of the first copy:"

for number in stack2 do
    printfn $"{number}"

// Create an array twice the size of the stack and copy the
// elements of the stack, starting at the middle of the
// array.
let array2 = numbers.Count * 2 |> Array.zeroCreate
numbers.CopyTo(array2, numbers.Count)

// Create a second stack, using the constructor that accepts an
// IEnumerable(Of T).
let stack3 = Stack array2

printfn "\nContents of the second copy, with duplicates and nulls:"

for number in stack3 do
    printfn $"{number}"

printfn
    $"""
stack2.Contains "four" = {stack2.Contains "four"}"""

printfn "\nstack2.Clear()"
stack2.Clear()
printfn $"\nstack2.Count = {stack2.Count}"

// This code example produces the following output:
//       five
//       four
//       three
//       two
//       one
//
//       Popping 'five'
//       Peek at next item to destack: four
//       Popping 'four'
//
//       Contents of the first copy:
//       one
//       two
//       three
//
//       Contents of the second copy, with duplicates and nulls:
//       one
//       two
//       three
//
//       stack2.Contains("four") = False
//
//       stack2.Clear()
//
//       stack2.Count = 0

Imports System.Collections.Generic

Module Example

    Sub Main

        Dim numbers As New Stack(Of String)
        numbers.Push("one")
        numbers.Push("two")
        numbers.Push("three")
        numbers.Push("four")
        numbers.Push("five")

        ' A stack can be enumerated without disturbing its contents.
        For Each number As String In numbers
            Console.WriteLine(number)
        Next

        Console.WriteLine(vbLf & "Popping '{0}'", numbers.Pop())
        Console.WriteLine("Peek at next item to pop: {0}", _
            numbers.Peek())    
        Console.WriteLine("Popping '{0}'", numbers.Pop())

        ' Create another stack, using the ToArray method and the
        ' constructor that accepts an IEnumerable(Of T). Note that
        ' the order of items on the new stack is reversed.
        Dim stack2 As New Stack(Of String)(numbers.ToArray())

        Console.WriteLine(vbLf & "Contents of the first copy:")
        For Each number As String In stack2
            Console.WriteLine(number)
        Next
        
        ' Create an array twice the size of the stack, compensating
        ' for the fact that Visual Basic allocates an extra array 
        ' element. Copy the elements of the stack, starting at the
        ' middle of the array. 
        Dim array2((numbers.Count * 2) - 1) As String
        numbers.CopyTo(array2, numbers.Count)
        
        ' Create a second stack, using the constructor that accepts an
        ' IEnumerable(Of T). The elements are reversed, with the null
        ' elements appearing at the end of the stack when enumerated.
        Dim stack3 As New Stack(Of String)(array2)

        Console.WriteLine(vbLf & _
            "Contents of the second copy, with duplicates and nulls:")
        For Each number As String In stack3
            Console.WriteLine(number)
        Next

        Console.WriteLine(vbLf & "stack2.Contains(""four"") = {0}", _
            stack2.Contains("four"))

        Console.WriteLine(vbLf & "stack2.Clear()")
        stack2.Clear()
        Console.WriteLine(vbLf & "stack2.Count = {0}", _
            stack2.Count)
    End Sub
End Module

' This code example produces the following output:
'
'five
'four
'three
'two
'one
'
'Popping 'five'
'Peek at next item to pop: four
'Popping 'four'
'
'Contents of the first copy:
'one
'two
'three
'
'Contents of the second copy, with duplicates and nulls:
'one
'two
'three
'
'
'
'
'stack2.Contains("four") = False
'
'stack2.Clear()
'
'stack2.Count = 0

Megjegyzések

Stack<T> tömbként van implementálva.

A halmok és üzenetsorok akkor hasznosak, ha ideiglenes tárolásra van szüksége az információkhoz; vagyis amikor érdemes lehet elvetni egy elemet az érték beolvasása után. Akkor használja Queue<T> , ha az adatokat a gyűjteményben tárolt sorrendben kell elérnie. Használja System.Collections.Generic.Stack<T> , ha fordított sorrendben kell hozzáférnie az információkhoz.

Akkor használja a és System.Collections.Concurrent.ConcurrentStack<T> a System.Collections.Concurrent.ConcurrentQueue<T> típusokat, ha egyszerre több szálból kell hozzáférnie a gyűjteményhez.

Gyakran használják a változó állapotok megőrzését System.Collections.Generic.Stack<T> más eljárások hívásai során.

Három fő művelet hajtható végre egy System.Collections.Generic.Stack<T> és annak elemein:

• Push beszúr egy elemet a Stack<T>lap tetejére.

• Pop eltávolít egy elemet a . Stack<T>tetejéről.

• Peek egy olyan elemet ad vissza, amely a felső részen Stack<T> található, de nem távolítja el a Stack<T>.

Egy adott elem kapacitása Stack<T> a visszatartható elemek Stack<T> száma. Az elemek hozzáadásakor Stack<T>a kapacitás a belső tömb újraelosztásával automatikusan növekszik a szükséges módon. A kapacitás a hívással TrimExcesscsökkenthető.

Ha Count kisebb, mint a verem kapacitása, Push az O(1) művelet. Ha a kapacitást növelni kell az új elem elhelyezéséhez, Push O(n) művelet lesz, ahol n van Count. Pop O(1) művelet.

Stack<T> null érvényes értékként fogadja el a referenciatípusokat, és lehetővé teszi az ismétlődő elemek használatát.

Konstruktorok

Name	Description
Stack<T>()	Inicializálja az Stack<T> üres osztály új példányát, és az alapértelmezett kezdeti kapacitással rendelkezik.
Stack<T>(IEnumerable<T>)	Inicializálja az osztály új példányát, amely a Stack<T> megadott gyűjteményből másolt elemeket tartalmaz, és elegendő kapacitással rendelkezik a másolt elemek számának kielégítéséhez.
Stack<T>(Int32)	Inicializálja az Stack<T> osztály új példányát, amely üres, és a megadott kezdeti kapacitással vagy az alapértelmezett kezdeti kapacitással rendelkezik, attól függően, hogy melyik a nagyobb.

Tulajdonságok

Name	Description
Capacity	Lekéri a belső adatstruktúra által tartható elemek teljes számát átméretezés nélkül.
Count	Lekéri a .Stack<T>

Metódusok

Name	Description
Clear()	Eltávolítja az összes objektumot a Stack<T>.
Contains(T)	Meghatározza, hogy egy elem szerepel-e a Stack<T>.
CopyTo(T[], Int32)	A másolatot Stack<T> egy meglévő egydimenziósra Arraymásolja a megadott tömbindextől kezdve.
EnsureCapacity(Int32)	Biztosítja, hogy a stack kapacitása legalább a megadott capacitylegyen. Ha a jelenlegi kapacitás kisebb, mint capacity, akkor a kapacitás legalább a megadott capacityértékre nő .
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
GetEnumerator()	Enumerátort ad vissza a Stack<T>.
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
Peek()	Az objektumot a felső részen Stack<T> adja vissza anélkül, hogy eltávolítaná.
Pop()	Eltávolítja és visszaadja az objektumot a Stack<T>felső részen.
Push(T)	Objektum beszúrása a lap tetején Stack<T>.
ToArray()	Átmásolja a Stack<T> tömböt egy új tömbbe.
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)
TrimExcess()	A kapacitást a jelenlegi kapacitás 90 százalékánál kisebb elemek Stack<T>tényleges számára állítja be.
TrimExcess(Int32)	Egy objektum kapacitását Stack<T> megadott számú bejegyzésre állítja be.
TryPeek(T)	Olyan értéket ad vissza, amely jelzi, hogy van-e objektum a Stack<T>tetején, és ha van ilyen, másolja a result paraméterbe. Az objektum nem lesz eltávolítva a Stack<T>.
TryPop(T)	Olyan értéket ad vissza, amely jelzi, hogy van-e objektum a Stack<T>tetején, és ha van ilyen, átmásolja a result paraméterbe, és eltávolítja a Stack<T>paraméterből.

Explicit interfész-implementációk

Name	Description
ICollection.CopyTo(Array, Int32)	Az elemeket ICollection egy adott indextől kezdve másolja Arrayegy adott Array indexbe.
ICollection.IsSynchronized	Beolvas egy értéket, amely jelzi, hogy a ICollection hozzáférés szinkronizálva van-e (a szál biztonságos).
ICollection.SyncRoot	Lekéri az objektumot, amely a hozzáférés szinkronizálására használható.ICollection
IEnumerable.GetEnumerator()	Egy gyűjteményen keresztül iteráló enumerátort ad vissza.
IEnumerable<T>.GetEnumerator()	Egy enumerátort ad vissza, amely a gyűjteményen keresztül iterál.

Bővítő metódusok

Name	Description
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)	Egy akkumulátorfüggvényt alkalmaz egy sorozatra. A rendszer a megadott magértéket használja a kezdeti gyűjtőértékként, a megadott függvény pedig az eredményérték kiválasztásához.
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)	Egy akkumulátorfüggvényt alkalmaz egy sorozatra. A rendszer a megadott magértéket használja a kezdeti gyűjtőértékként.
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)	Egy akkumulátorfüggvényt alkalmaz egy sorozatra.
AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey,TAccumulate>, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>)	Egy akkumulátorfüggvényt alkalmaz egy sorozatra, és az eredményeket kulcs szerint csoportosítja.
AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>)	Egy akkumulátorfüggvényt alkalmaz egy sorozatra, és az eredményeket kulcs szerint csoportosítja.
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Meghatározza, hogy egy sorozat összes eleme megfelel-e egy feltételnek.
Ancestors<T>(IEnumerable<T>, XName)	Szűrt elemgyűjteményt ad vissza, amely a forrásgyűjtemény minden csomópontjának elődeit tartalmazza. A gyűjtemény csak az egyező XName elemeket tartalmazza.
Ancestors<T>(IEnumerable<T>)	Olyan elemek gyűjteményét adja vissza, amelyek a forrásgyűjtemény minden csomópontjának elődeit tartalmazzák.
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Meghatározza, hogy a sorozat bármely eleme megfelel-e egy feltételnek.
Any<TSource>(IEnumerable<TSource>)	Meghatározza, hogy a sorozat tartalmaz-e elemeket.
Append<TSource>(IEnumerable<TSource>, TSource)	Hozzáfűz egy értéket a sorozat végéhez.
AsEnumerable<TSource>(IEnumerable<TSource>)	A beírt értéket adja eredményül IEnumerable<T>.
AsParallel(IEnumerable)	Lehetővé teszi a lekérdezés párhuzamosítását.
AsParallel<TSource>(IEnumerable<TSource>)	Lehetővé teszi a lekérdezés párhuzamosítását.
AsQueryable(IEnumerable)	Átalakítja az egyiket IEnumerableIQueryable.
AsQueryable<TElement>(IEnumerable<TElement>)	Általánossá alakít át egy általánost IEnumerable<T>IQueryable<T>.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Kiszámítja az értékek sorozatának átlagát Decimal , amelyet egy átalakítási függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Kiszámítja az értékek sorozatának átlagát Double , amelyet egy átalakítási függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Kiszámítja az értékek sorozatának átlagát Int32 , amelyet egy átalakítási függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Kiszámítja az értékek sorozatának átlagát Int64 , amelyet egy átalakítási függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Kiszámítja a null értékű Decimal értékek sorozatának átlagát, amelyet egy transzformációs függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Kiszámítja a null értékű Double értékek sorozatának átlagát, amelyet egy transzformációs függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Kiszámítja a null értékű Int32 értékek sorozatának átlagát, amelyet egy transzformációs függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Kiszámítja a null értékű Int64 értékek sorozatának átlagát, amelyet egy transzformációs függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Kiszámítja a null értékű Single értékek sorozatának átlagát, amelyet egy transzformációs függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Kiszámítja az értékek sorozatának átlagát Single , amelyet egy átalakítási függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Cast<TResult>(IEnumerable)	Egy elem elemeit IEnumerable a megadott típusra veti.
Chunk<TSource>(IEnumerable<TSource>, Int32)	A sorozat elemeit legfeljebb sizemérettömbökre osztja.
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Összefűz két sorozatot.
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)	Meghatározza, hogy egy szekvencia egy megadott elemet tartalmaz-e egy megadott IEqualityComparer<T>elem használatával.
Contains<TSource>(IEnumerable<TSource>, TSource)	Meghatározza, hogy egy sorozat tartalmaz-e egy adott elemet az alapértelmezett egyenlőség-összehasonlító használatával.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)	Objektumok másolása DataRow a megadott DataTableértékre egy olyan bemeneti IEnumerable<T> objektum alapján, amelyben az általános paraméter T szerepel DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)	Objektumok másolása DataRow a megadott DataTableértékre egy olyan bemeneti IEnumerable<T> objektum alapján, amelyben az általános paraméter T szerepel DataRow.
CopyToDataTable<T>(IEnumerable<T>)	Olyan értéket ad DataTable vissza, amely az DataRow objektumok másolatait tartalmazza, egy olyan bemeneti IEnumerable<T> objektumot ad vissza, amelyben az általános paraméter T szerepel DataRow.
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Egy számot ad vissza, amely azt jelzi, hogy a megadott sorozat hány eleme felel meg egy feltételnek.
Count<TSource>(IEnumerable<TSource>)	A sorozat elemeinek számát adja vissza.
CountBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	A forrásütemezés elemeinek számát adja vissza kulcs szerint csoportosítva.
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)	A megadott sorozat elemeit vagy a megadott értéket adja vissza egy önálló gyűjteményben, ha a sorozat üres.
DefaultIfEmpty<TSource>(IEnumerable<TSource>)	A megadott sorozat elemeit vagy a típusparaméter alapértelmezett értékét adja vissza egy adott gyűjteményben, ha a sorozat üres.
DescendantNodes<T>(IEnumerable<T>)	A forrásgyűjtemény minden dokumentumának és elemének leszármazott csomópontjainak gyűjteményét adja vissza.
Descendants<T>(IEnumerable<T>, XName)	A forrásgyűjtemény minden elemének és dokumentumának leszármazott elemeit tartalmazó szűrt elemgyűjteményt ad vissza. A gyűjtemény csak az egyező XName elemeket tartalmazza.
Descendants<T>(IEnumerable<T>)	Olyan elemek gyűjteményét adja vissza, amelyek a forrásgyűjtemény minden elemének és dokumentumának leszármazott elemeit tartalmazzák.
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Különböző elemeket ad vissza egy sorozatból egy megadott IEqualityComparer<T> érték összehasonlítása gombra kattintva.
Distinct<TSource>(IEnumerable<TSource>)	Az értékek összehasonlításához az alapértelmezett egyenlőség-összehasonlítóval különböző elemeket ad vissza egy sorozatból.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Különböző elemeket ad vissza egy sorozatból egy adott kulcsválasztó függvény szerint, és egy megadott összehasonlító használatával összehasonlítja a kulcsokat.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Különböző elemeket ad vissza egy sorozatból egy adott kulcsválasztó függvény szerint.
ElementAt<TSource>(IEnumerable<TSource>, Index)	Egy adott index elemet ad vissza egy sorozatban.
ElementAt<TSource>(IEnumerable<TSource>, Int32)	Egy adott index elemet ad vissza egy sorozatban.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index)	Egy adott index elemet ad vissza egy sorozatban, vagy egy alapértelmezett értéket, ha az index túllépi a tartományt.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)	Egy adott index elemet ad vissza egy sorozatban, vagy egy alapértelmezett értéket, ha az index túllépi a tartományt.
Elements<T>(IEnumerable<T>, XName)	A forrásgyűjtemény minden elemének és dokumentumának gyermekelemeinek szűrt gyűjteményét adja vissza. A gyűjtemény csak az egyező XName elemeket tartalmazza.
Elements<T>(IEnumerable<T>)	A forrásgyűjteményben lévő összes elem és dokumentum gyermekelemeinek gyűjteményét adja vissza.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Két sorozat halmazkülönbségét állítja elő a megadott IEqualityComparer<T> értékek összehasonlításához.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Két sorozat halmazkülönbségét állítja elő az alapértelmezett egyenlőség-összehasonlítóval az értékek összehasonlításához.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Két szekvencia halmazkülönbségét állítja elő egy megadott kulcsválasztó függvény szerint.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Két szekvencia halmazkülönbségét állítja elő egy megadott kulcsválasztó függvény szerint.
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Egy adott feltételnek megfelelő sorozat első elemét adja vissza.
First<TSource>(IEnumerable<TSource>)	Egy sorozat első elemét adja vissza.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	A sorrend első olyan elemét adja vissza, amely megfelel egy feltételnek, vagy egy megadott alapértelmezett értéket, ha nem található ilyen elem.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	A sorozat első olyan elemét adja vissza, amely megfelel egy feltételnek vagy egy alapértelmezett értéknek, ha nem található ilyen elem.
FirstOrDefault<TSource>(IEnumerable<TSource>, TSource)	Egy sorozat első elemét adja vissza, vagy egy megadott alapértelmezett értéket, ha a sorozat nem tartalmaz elemeket.
FirstOrDefault<TSource>(IEnumerable<TSource>)	Egy sorozat első elemét adja vissza, vagy egy alapértelmezett értéket, ha a sorozat nem tartalmaz elemeket.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)	Csoportosítja a szekvencia elemeit egy megadott kulcsválasztó függvény szerint, és létrehoz egy eredményértéket az egyes csoportokból és kulcsából. A fő értékeket egy megadott összehasonlító használatával hasonlítjuk össze, és az egyes csoportok elemeit egy megadott függvény használatával vetjük ki.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)	Csoportosítja a szekvencia elemeit egy megadott kulcsválasztó függvény szerint, és létrehoz egy eredményértéket az egyes csoportokból és kulcsából. Az egyes csoportok elemei egy adott függvény használatával lesznek kivetítve.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	A szekvencia elemeit egy kulcsválasztó függvény szerint csoportosítja. A kulcsok összehasonlításához összehasonlítót kell használni, és az egyes csoportok elemeit egy megadott függvény használatával vetjük előre.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	A szekvencia elemeit egy megadott kulcsválasztó függvény szerint csoportosítja, és az egyes csoportok elemeit egy megadott függvény használatával kivetíti.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)	Csoportosítja a szekvencia elemeit egy megadott kulcsválasztó függvény szerint, és létrehoz egy eredményértéket az egyes csoportokból és kulcsából. A kulcsok összehasonlítása egy megadott összehasonlító használatával történik.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)	Csoportosítja a szekvencia elemeit egy megadott kulcsválasztó függvény szerint, és létrehoz egy eredményértéket az egyes csoportokból és kulcsából.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Egy sorozat elemeit egy megadott kulcsválasztó függvény szerint csoportosítja, és egy megadott összehasonlító használatával összehasonlítja a kulcsokat.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	A szekvencia elemeit egy megadott kulcsválasztó függvény szerint csoportosítja.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)	Két sorozat elemeit korrelálja a kulcsegyenlőség alapján, és csoportosítja az eredményeket. A megadott IEqualityComparer<T> érték a kulcsok összehasonlítására szolgál.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>)	Két sorozat elemeit korrelálja a kulcsok egyenlősége alapján, és csoportosítja az eredményeket. Az alapértelmezett egyenlőség-összehasonlító a kulcsok összehasonlítására szolgál.
Index<TSource>(IEnumerable<TSource>)	Egy számbavételt ad vissza, amely belefoglalja az elem indexét egy rekordba.
InDocumentOrder<T>(IEnumerable<T>)	Olyan csomópontgyűjteményt ad vissza, amely a forrásgyűjtemény összes csomópontját tartalmazza, dokumentum sorrendben rendezve.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Két sorozat metszéspontját állítja elő a megadott IEqualityComparer<T> értékek összehasonlításához.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Két sorozat metszéspontját állítja elő az alapértelmezett egyenlőség-összehasonlítóval az értékek összehasonlításához.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Két sorozat metszéspontját állítja elő egy megadott kulcsválasztó függvény szerint.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Két sorozat metszéspontját állítja elő egy megadott kulcsválasztó függvény szerint.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)	Két sorozat elemeit korrelálja egyező kulcsok alapján. A megadott IEqualityComparer<T> érték a kulcsok összehasonlítására szolgál.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)	Két sorozat elemeit korrelálja egyező kulcsok alapján. Az alapértelmezett egyenlőség-összehasonlító a kulcsok összehasonlítására szolgál.
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Egy adott feltételnek megfelelő sorozat utolsó elemét adja vissza.
Last<TSource>(IEnumerable<TSource>)	Egy sorozat utolsó elemét adja vissza.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Egy feltételnek megfelelő sorozat utolsó elemét adja vissza, vagy egy megadott alapértelmezett értéket, ha nem található ilyen elem.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Egy olyan sorozat utolsó elemét adja vissza, amely megfelel egy feltételnek vagy egy alapértelmezett értéknek, ha nem található ilyen elem.
LastOrDefault<TSource>(IEnumerable<TSource>, TSource)	Egy sorozat utolsó elemét adja vissza, vagy egy megadott alapértelmezett értéket, ha a sorozat nem tartalmaz elemeket.
LastOrDefault<TSource>(IEnumerable<TSource>)	Egy sorozat utolsó elemét adja vissza, vagy egy alapértelmezett értéket, ha a sorozat nem tartalmaz elemeket.
LeftJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)	Két sorozat elemeit korrelálja egyező kulcsok alapján. A megadott IEqualityComparer<T> érték a kulcsok összehasonlítására szolgál.
LeftJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)	Két sorozat elemeit korrelálja egyező kulcsok alapján. Az alapértelmezett egyenlőség-összehasonlító a kulcsok összehasonlítására szolgál.
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Olyan értéket Int64 ad vissza, amely azt jelzi, hogy egy sorozat hány eleme felel meg egy feltételnek.
LongCount<TSource>(IEnumerable<TSource>)	Olyan értéket Int64 ad vissza, amely egy sorozat elemeinek teljes számát jelöli.
Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Meghív egy átalakítási függvényt egy általános sorozat minden elemére, és visszaadja az eredményül kapott maximális értéket.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és visszaadja a maximális Decimal értéket.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és visszaadja a maximális Double értéket.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és visszaadja a maximális Int32 értéket.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és visszaadja a maximális Int64 értéket.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és visszaadja a maximális null értékű Decimal értéket.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és visszaadja a maximális null értékű Double értéket.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és visszaadja a maximális null értékű Int32 értéket.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és visszaadja a maximális null értékű Int64 értéket.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és visszaadja a maximális null értékű Single értéket.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és visszaadja a maximális Single értéket.
Max<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Egy általános sorozat maximális értékét adja vissza.
Max<TSource>(IEnumerable<TSource>)	Egy általános sorozat maximális értékét adja vissza.
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Egy általános sorozat maximális értékét adja vissza egy megadott kulcsválasztó függvény és kulcs-összehasonlító szerint.
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Egy általános sorozat maximális értékét adja vissza egy megadott kulcsválasztó függvénynek megfelelően.
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Meghív egy átalakítási függvényt egy általános sorozat minden elemére, és visszaadja az eredményül kapott minimális értéket.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és visszaadja a minimális Decimal értéket.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és visszaadja a minimális Double értéket.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és visszaadja a minimális Int32 értéket.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és visszaadja a minimális Int64 értéket.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és a minimális null értékű Decimal értéket adja vissza.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és a minimális null értékű Double értéket adja vissza.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és a minimális null értékű Int32 értéket adja vissza.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és a minimális null értékű Int64 értéket adja vissza.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és a minimális null értékű Single értéket adja vissza.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Meghív egy átalakítási függvényt egy sorozat minden elemére, és visszaadja a minimális Single értéket.
Min<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Egy általános sorozat minimális értékét adja vissza.
Min<TSource>(IEnumerable<TSource>)	Egy általános sorozat minimális értékét adja vissza.
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Egy általános sorozat minimális értékét adja vissza egy megadott kulcsválasztó függvény és kulcs-összehasonlító szerint.
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Egy általános sorozat minimális értékét adja vissza egy megadott kulcsválasztó függvénynek megfelelően.
Nodes<T>(IEnumerable<T>)	A forrásgyűjtemény minden dokumentumának és elemének gyermekcsomópontjait adja vissza.
OfType<TResult>(IEnumerable)	Egy adott típus alapján szűri IEnumerable egy adott elem elemeit.
Order<T>(IEnumerable<T>, IComparer<T>)	Növekvő sorrendbe rendezi a sorozat elemeit.
Order<T>(IEnumerable<T>)	Növekvő sorrendbe rendezi a sorozat elemeit.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Egy sorozat elemeit növekvő sorrendbe rendezi egy megadott összehasonlító használatával.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Egy sorozat elemeit növekvő sorrendbe rendezi egy kulcs alapján.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Egy sorozat elemeit csökkenő sorrendbe rendezi egy megadott összehasonlító használatával.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	A sorozat elemeit egy kulcs alapján csökkenő sorrendbe rendezi.
OrderDescending<T>(IEnumerable<T>, IComparer<T>)	A sorozat elemeit csökkenő sorrendbe rendezi.
OrderDescending<T>(IEnumerable<T>)	A sorozat elemeit csökkenő sorrendbe rendezi.
Prepend<TSource>(IEnumerable<TSource>, TSource)	Értéket ad hozzá a sorozat elejéhez.
Remove<T>(IEnumerable<T>)	Eltávolítja a forrásgyűjtemény összes csomópontját a szülőcsomópontról.
Reverse<TSource>(IEnumerable<TSource>)	Megfordítja az elemek sorrendjét egy sorrendben.
RightJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)	Két sorozat elemeit korrelálja egyező kulcsok alapján. A megadott IEqualityComparer<T> érték a kulcsok összehasonlítására szolgál.
RightJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)	Két sorozat elemeit korrelálja egyező kulcsok alapján. Az alapértelmezett egyenlőség-összehasonlító a kulcsok összehasonlítására szolgál.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)	Az elem indexének beépítésével a sorozat minden elemét új formába alakítja.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	A sorozat egyes elemeit új űrlapra alakítja.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Egy sorozat egyes elemeit egy-egy IEnumerable<T>sorozatra kivetíti, az eredményül kapott sorozatokat egy sorozatba alakítja, és meghív egy eredményválasztó függvényt az egyes elemeken.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Egy sorozat egyes elemeit egy-egy IEnumerable<T>sorozatra kivetíti, az eredményül kapott sorozatokat egy sorozatba alakítja, és meghív egy eredményválasztó függvényt az egyes elemeken. Az egyes forráselemek indexét az elem köztes, előre jelzett formájában használja a rendszer.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)	Egy sorozat egyes elemeit egy-egy IEnumerable<T> sorozatra alakítja, és az eredményül kapott sorozatokat egy sorozatba simítja.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)	A sorozat egyes elemeit egy IEnumerable<T>- és egybesimítja, és az eredményül kapott sorozatokat egy sorozattá alakítja. Az egyes forráselemek indexét az elem előre jelzett formájában használja a rendszer.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Meghatározza, hogy két sorozat egyenlő-e, ha az elemeket egy megadott IEqualityComparer<T>használatával hasonlítja össze.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Meghatározza, hogy két sorozat egyenlő-e azzal, hogy összehasonlítja az elemeket az alapértelmezett egyenlőség-összehasonlító használatával a típusukhoz.
Shuffle<TSource>(IEnumerable<TSource>)	A sorozat elemeinek sorrendje össze van fonva.
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Egy adott feltételnek megfelelő sorozat egyetlen elemét adja vissza, és kivételt eredményez, ha több ilyen elem is létezik.
Single<TSource>(IEnumerable<TSource>)	Egy sorozat egyetlen elemét adja vissza, és kivételt ad vissza, ha nincs pontosan egy elem a sorozatban.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	A szekvencia egyetlen olyan elemét adja vissza, amely megfelel egy megadott feltételnek, vagy egy megadott alapértelmezett értéket, ha nincs ilyen elem; ez a metódus kivételt eredményez, ha több elem is megfelel a feltételnek.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Egy sorozat egyetlen olyan elemét adja vissza, amely megfelel egy megadott feltételnek vagy egy alapértelmezett értéknek, ha nincs ilyen elem; ez a metódus kivételt eredményez, ha több elem is megfelel a feltételnek.
SingleOrDefault<TSource>(IEnumerable<TSource>, TSource)	Egy sorozat egyetlen elemét adja vissza, vagy egy megadott alapértelmezett értéket, ha a sorozat üres; ez a metódus kivételt eredményez, ha a sorrendben több elem is szerepel.
SingleOrDefault<TSource>(IEnumerable<TSource>)	Egy sorozat egyetlen elemét adja vissza, vagy egy alapértelmezett értéket, ha a sorozat üres; ez a metódus kivételt eredményez, ha a sorrendben több elem is szerepel.
Skip<TSource>(IEnumerable<TSource>, Int32)	Adott számú elemet ad át egy sorozatban, majd visszaadja a fennmaradó elemeket.
SkipLast<TSource>(IEnumerable<TSource>, Int32)	Egy új, számbavételre alkalmas gyűjteményt ad vissza, amely a forrásgyűjtemény utolsó source elemeiből kihagyott count elemeket tartalmazza.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	A sorozat elemeit addig adja át, amíg egy megadott feltétel igaz, majd visszaadja a fennmaradó elemeket.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	A sorozat elemeit addig adja át, amíg egy megadott feltétel igaz, majd visszaadja a fennmaradó elemeket. Az elem indexe a predikátumfüggvény logikájában használatos.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Kiszámítja az értékek sorozatának Decimal összegét, amelyet egy átalakítási függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Kiszámítja az értékek sorozatának Double összegét, amelyet egy átalakítási függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Kiszámítja az értékek sorozatának Int32 összegét, amelyet egy átalakítási függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Kiszámítja az értékek sorozatának Int64 összegét, amelyet egy átalakítási függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Kiszámítja azoknak a null értékű Decimal értékeknek az összegét, amelyeket egy átalakító függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Kiszámítja azoknak a null értékű Double értékeknek az összegét, amelyeket egy átalakító függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Kiszámítja azoknak a null értékű Int32 értékeknek az összegét, amelyeket egy átalakító függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Kiszámítja azoknak a null értékű Int64 értékeknek az összegét, amelyeket egy átalakító függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Kiszámítja azoknak a null értékű Single értékeknek az összegét, amelyeket egy átalakító függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Kiszámítja az értékek sorozatának Single összegét, amelyet egy átalakítási függvény meghívásával kapunk a bemeneti sorozat egyes elemeire.
Take<TSource>(IEnumerable<TSource>, Int32)	Megadott számú összefüggő elemet ad vissza a sorozat kezdetétől kezdve.
Take<TSource>(IEnumerable<TSource>, Range)	Egy sorozat egy adott összefüggő elemtartományát adja vissza.
TakeLast<TSource>(IEnumerable<TSource>, Int32)	Egy új, számbavételre alkalmas gyűjteményt ad vissza, amely az utolsó count elemeket sourcetartalmazza.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Egy sorozat elemeit adja vissza mindaddig, amíg egy megadott feltétel igaz.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Egy sorozat elemeit adja vissza mindaddig, amíg egy megadott feltétel igaz. Az elem indexe a predikátumfüggvény logikájában használatos.
ToArray<TSource>(IEnumerable<TSource>)	Tömböt hoz létre egy IEnumerable<T>.
ToAsyncEnumerable<TSource>(IEnumerable<TSource>)	Átalakítja az egyiket IEnumerable<T>IAsyncEnumerable<T>.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Létrehoz egy Dictionary<TKey,TValue>IEnumerable<T> adott kulcsválasztó függvény, egy összehasonlító és egy elemválasztó függvény alapján.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Létrehoz egy Dictionary<TKey,TValue>IEnumerable<T> megadott kulcsválasztó és elemválasztó függvény alapján.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Létrehoz egy Dictionary<TKey,TValue>IEnumerable<T> adott kulcsválasztó függvényt és kulcs-összehasonlítót.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Egy megadott kulcsválasztó függvény alapján hoz létre egy Dictionary<TKey,TValue>IEnumerable<T> értéket.
ToFrozenDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Létrehoz egy FrozenDictionary<TKey,TValue>IEnumerable<T> megadott kulcsválasztó és elemválasztó függvény alapján.
ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Létrehoz egy FrozenDictionary<TKey,TValue> megadott kulcsválasztó függvényt IEnumerable<T> .
ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>)	Létrehoz egy FrozenSet<T> értéket a megadott értékekkel.
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Létrehoz egy HashSet<T> olyan eszközt, IEnumerable<T> amely a comparer kulcsok összehasonlítására használható.
ToHashSet<TSource>(IEnumerable<TSource>)	Létrehoz egy HashSet<T>IEnumerable<T>.
ToImmutableArray<TSource>(IEnumerable<TSource>)	Módosíthatatlan tömböt hoz létre a megadott gyűjteményből.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)	Számba és átalakít egy sorozatot, és a megadott kulcs- és érték-összehasonlítók használatával módosíthatatlan szótárt hoz létre a tartalmából.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)	Számba és átalakít egy sorozatot, és a megadott kulcs-összehasonlító használatával módosíthatatlan szótárt hoz létre a tartalmából.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Számbavétele és átalakítása egy sorozat, és létrehoz egy nem módosítható szótár a tartalmát.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Egy szekvencia valamilyen átalakításán alapuló nem módosítható szótárt hoz létre.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Egy nem módosítható szótárat hoz létre egy meglévő elemgyűjteményből, amely egy átalakítási függvényt alkalmaz a forráskulcsokra.
ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Számba veszi a sorozatot, módosíthatatlan kivonatkészletet hoz létre a tartalmából, és a megadott egyenlőség-összehasonlítót használja a készlettípushoz.
ToImmutableHashSet<TSource>(IEnumerable<TSource>)	Számba ad egy sorozatot, és a tartalma nem módosítható kivonatkészletet hoz létre.
ToImmutableList<TSource>(IEnumerable<TSource>)	Számba ad egy sorozatot, és megváltoztathatatlan listát hoz létre annak tartalmáról.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)	Számba és átalakít egy sorozatot, és a megadott kulcs- és érték-összehasonlítók használatával módosíthatatlan rendezési szótárt hoz létre a tartalmaiból.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)	Számbavesz és átalakít egy sorozatot, és a megadott kulcs-összehasonlító használatával módosíthatatlan rendezési szótárt hoz létre a tartalmaiból.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Számbavétele és átalakítása egy sorozat, és létrehoz egy nem módosítható rendezett szótár a tartalmát.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Számba veszi a sorozatot, megváltoztathatatlan rendezési halmazt hoz létre, és a megadott összehasonlítót használja.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>)	Számba ad egy sorozatot, és megváltoztathatatlan rendezésű halmazt hoz létre annak tartalmából.
ToList<TSource>(IEnumerable<TSource>)	Létrehoz egy List<T>IEnumerable<T>.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Létrehoz egy Lookup<TKey,TElement>IEnumerable<T> adott kulcsválasztó függvény, egy összehasonlító és egy elemválasztó függvény alapján.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Létrehoz egy Lookup<TKey,TElement>IEnumerable<T> megadott kulcsválasztó és elemválasztó függvény alapján.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Létrehoz egy Lookup<TKey,TElement>IEnumerable<T> adott kulcsválasztó függvényt és kulcs-összehasonlítót.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Egy megadott kulcsválasztó függvény alapján hoz létre egy Lookup<TKey,TElement>IEnumerable<T> értéket.
TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32)	Megkísérli meghatározni a sorozat elemeinek számát enumerálás kényszerítése nélkül.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Két sorozat halmazának egyesítését állítja elő egy megadott IEqualityComparer<T>paranccsel.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Két sorozat egyesítését állítja elő az alapértelmezett egyenlőség-összehasonlító használatával.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Két szekvencia halmazegyesítését állítja elő egy megadott kulcsválasztó függvény szerint.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>)	Két szekvencia halmazegyesítését állítja elő egy megadott kulcsválasztó függvény szerint.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Egy predikátum alapján szűri az értékek sorozatát.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Egy predikátum alapján szűri az értékek sorozatát. Az egyes elemek indexét a predikátumfüggvény logikája használja.
Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)	Egy megadott függvényt alkalmaz a két sorozat megfelelő elemeire, és az eredmények sorozatát eredményezi.
Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)	A három megadott sorozat elemeit tartalmazó vonássorozatot hoz létre.
Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)	A két megadott sorozat elemeit tartalmazó vonássorozatot hoz létre.

Szálbiztonság

A nyilvános statikus (Shared Visual Basic) ilyen típusú tagjai szálbiztosak. A példánytagok nem garantáltan szálbiztosak.

A Stack<T> egyszerre több olvasót is támogathat, ha a gyűjtemény nem módosul. Ennek ellenére a gyűjteményen keresztüli számbavétel alapvetően nem szálbiztos eljárás. Az enumerálás során a szálbiztonság érdekében zárolhatja a gyűjteményt a teljes enumerálás során. Ahhoz, hogy a gyűjtemény több szálon keresztül is elérhető legyen olvasáshoz és íráshoz, saját szinkronizálást kell implementálnia.

Lásd még

• Iterátorok (C#)
• Iterators (Visual Basic)