Tento článek byl přeložený strojově. Pokud chcete zobrazit článek v angličtině, zaškrtněte políčko Angličtina. Anglickou verzi článku můžete také zobrazit v místním okně přesunutím ukazatele myši nad text.
Překlad
Angličtina

Rozhraní IEnumerable<T>

.NET Framework (current version)
 
System_CAPS_notePoznámka

The .NET API Reference documentation has a new home. Visit the .NET API Browser on docs.microsoft.com to see the new experience.

Poskytuje enumerátor, který podporuje jednoduchou iterace nad kolekcí zadaného typu.

K procházení zdrojového kódu rozhraní .NET Framework pro tento typ, naleznete v části Reference Source.

Obor názvů:   System.Collections.Generic
Sestavení:  mscorlib (v mscorlib.dll)

public interface IEnumerable<out T> : IEnumerable

Parametry typu

outT

Typ objektů pro vytvoření výčtu.

NázevPopis
System_CAPS_pubmethodGetEnumerator()

Vrátí enumerátor, který iteruje kolekci.

NázevPopis
System_CAPS_pubmethodAggregate<TSource>(Func<TSource, TSource, TSource>)

Přetížené Se vztahuje akumulátorová funkce přes sekvenci.(Definoval Enumerable.)

System_CAPS_pubmethodAggregate<TSource, TAccumulate>(TAccumulate, Func<TAccumulate, TSource, TAccumulate>)

Přetížené Se vztahuje akumulátorová funkce přes sekvenci. Zadaná počáteční hodnota se používá jako akumulátorová počáteční hodnota.(Definoval Enumerable.)

System_CAPS_pubmethodAggregate<TSource, TAccumulate, TResult>(TAccumulate, Func<TAccumulate, TSource, TAccumulate>, Func<TAccumulate, TResult>)

Přetížené Se vztahuje akumulátorová funkce přes sekvenci. Zadaný počáteční hodnota se používá jako hodnota počáteční akumulátorová a zadaná funkce se používá pro výběr výslednou hodnotu.(Definoval Enumerable.)

System_CAPS_pubmethodAll<TSource>(Func<TSource, Boolean>)

Určuje, zda všechny prvky pořadí splňují podmínku.(Definoval Enumerable.)

System_CAPS_pubmethodAncestors<T>()

Přetížené Vrátí kolekci elementů obsahující předchůdce každý uzel ve zdrojové kolekci.(Definoval Extensions.)

System_CAPS_pubmethodAncestors<T>(XName)

Přetížené Vrátí filtrované kolekci elementů obsahující předchůdce každý uzel ve zdrojové kolekci. Pouze elementy, které mají odpovídající XName jsou zahrnuty v kolekci.(Definoval Extensions.)

System_CAPS_pubmethodAny<TSource>()

Přetížené Určuje, zda obsahuje posloupnost žádné prvky.(Definoval Enumerable.)

System_CAPS_pubmethodAny<TSource>(Func<TSource, Boolean>)

Přetížené Určuje, zda některý z prvků v sekvenci splňuje podmínku.(Definoval Enumerable.)

System_CAPS_pubmethodAppend<TSource>(TSource)

Připojí hodnotu na konec pořadí.(Definoval Enumerable.)

System_CAPS_pubmethodAsEnumerable<TSource>()

Vrátí vstup zadaný jako IEnumerable<T>.(Definoval Enumerable.)

System_CAPS_pubmethodAsParallel<TSource>()

Přetížené Umožňuje paralelního zpracování dotazu.(Definoval ParallelEnumerable.)

System_CAPS_pubmethodAsQueryable<TElement>()

Přetížené Převede obecný IEnumerable<T> s obecným IQueryable<T>.(Definoval Queryable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Decimal>)

Přetížené Vypočítá průměrnou hodnotu posloupnost Decimal hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Double>)

Přetížené Vypočítá průměrnou hodnotu posloupnost Double hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Int32>)

Přetížené Vypočítá průměrnou hodnotu posloupnost Int32 hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Int64>)

Přetížené Vypočítá průměrnou hodnotu posloupnost Int64 hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Nullable<Decimal>>)

Přetížené Vypočítá průměrnou hodnotu posloupnost s povolenou hodnotou Null Decimal hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Nullable<Double>>)

Přetížené Vypočítá průměrnou hodnotu posloupnost s povolenou hodnotou Null Double hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Nullable<Int32>>)

Přetížené Vypočítá průměrnou hodnotu posloupnost s povolenou hodnotou Null Int32 hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Nullable<Int64>>)

Přetížené Vypočítá průměrnou hodnotu posloupnost s povolenou hodnotou Null Int64 hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Nullable<Single>>)

Přetížené Vypočítá průměrnou hodnotu posloupnost s povolenou hodnotou Null Single hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodAverage<TSource>(Func<TSource, Single>)

Přetížené Vypočítá průměrnou hodnotu posloupnost Single hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodCast<TResult>()

Přetypování prvky IEnumerable do zadaného typu.(Definoval Enumerable.)

System_CAPS_pubmethodConcat<TSource>(IEnumerable<TSource>)

Zřetězí dvě sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodContains<TSource>(TSource)

Přetížené Určuje, zda sekvenci obsahuje zadaný element pomocí výchozí porovnávací metody rovnosti.(Definoval Enumerable.)

System_CAPS_pubmethodContains<TSource>(TSource, IEqualityComparer<TSource>)

Přetížené Určuje, zda obsahuje posloupnost zadaný element s použitím zadaného IEqualityComparer<T>.(Definoval Enumerable.)

System_CAPS_pubmethodCopyToDataTable<T>()

Přetížené Vrátí DataTable kopie, který obsahuje DataRow objekty daný vstup IEnumerable<T> objekt kde obecný parametr T je DataRow.(Definoval DataTableExtensions.)

System_CAPS_pubmethodCopyToDataTable<T>(DataTable, LoadOption)

Přetížené Kopie DataRow objekty k zadanému DataTable, daný vstup IEnumerable<T> objekt kde obecný parametr T je DataRow.(Definoval DataTableExtensions.)

System_CAPS_pubmethodCopyToDataTable<T>(DataTable, LoadOption, FillErrorEventHandler)

Přetížené Kopie DataRow objekty k zadanému DataTable, daný vstup IEnumerable<T> objekt kde obecný parametr T je DataRow.(Definoval DataTableExtensions.)

System_CAPS_pubmethodCount<TSource>()

Přetížené Vrátí počet prvků v sekvenci.(Definoval Enumerable.)

System_CAPS_pubmethodCount<TSource>(Func<TSource, Boolean>)

Přetížené Vrací číslo představující počet prvků v zadané pořadí splňují podmínku.(Definoval Enumerable.)

System_CAPS_pubmethodDefaultIfEmpty<TSource>()

Přetížené Pokud sekvence je prázdný, vrátí prvky zadané pořadí nebo výchozí hodnotu parametru typu v kolekci singleton.(Definoval Enumerable.)

System_CAPS_pubmethodDefaultIfEmpty<TSource>(TSource)

Přetížené Pokud sekvence je prázdný, vrátí prvky zadané pořadí nebo zadaná hodnota v kolekci singleton.(Definoval Enumerable.)

System_CAPS_pubmethodDescendantNodes<T>()

Vrátí kolekci potomků uzly každý dokument a element ve zdrojové kolekci.(Definoval Extensions.)

System_CAPS_pubmethodDescendants<T>()

Přetížené Vrátí kolekci elementů obsahující následné prvky každý element a dokumentu ve zdrojové kolekci.(Definoval Extensions.)

System_CAPS_pubmethodDescendants<T>(XName)

Přetížené Vrátí filtrované kolekci elementů obsahující následné prvky každý element a dokumentu ve zdrojové kolekci. Pouze elementy, které mají odpovídající XName jsou zahrnuty v kolekci.(Definoval Extensions.)

System_CAPS_pubmethodDistinct<TSource>()

Přetížené Vrátí rozdílné prvky ze sekvence pomocí výchozí porovnávací metody rovnosti pro porovnání hodnot.(Definoval Enumerable.)

System_CAPS_pubmethodDistinct<TSource>(IEqualityComparer<TSource>)

Přetížené Vrátí rozdílné prvky ze sekvence s použitím zadaného IEqualityComparer<T> pro porovnání hodnot.(Definoval Enumerable.)

System_CAPS_pubmethodElementAt<TSource>(Int32)

Vrátí prvek na zadaném indexu v pořadí.(Definoval Enumerable.)

System_CAPS_pubmethodElementAtOrDefault<TSource>(Int32)

Vrátí prvek na zadaný index v sekvenci nebo výchozí hodnotu, pokud index je mimo rozsah.(Definoval Enumerable.)

System_CAPS_pubmethodElements<T>()

Přetížené Vrátí kolekci z podřízených prvků každý element a dokumentu ve zdrojové kolekci.(Definoval Extensions.)

System_CAPS_pubmethodElements<T>(XName)

Přetížené Vrátí kolekci filtrované z podřízených prvků každý element a dokumentu ve zdrojové kolekci. Pouze elementy, které mají odpovídající XName jsou zahrnuty v kolekci.(Definoval Extensions.)

System_CAPS_pubmethodExcept<TSource>(IEnumerable<TSource>)

Přetížené Vytvoří sadu rozdíl dvou sekvencí pomocí výchozí porovnávací metody rovnosti pro porovnání hodnot.(Definoval Enumerable.)

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

Přetížené Vytvoří sadu rozdíl dvou sekvencí pomocí zadané IEqualityComparer<T> pro porovnání hodnot.(Definoval Enumerable.)

System_CAPS_pubmethodFirst<TSource>()

Přetížené Vrátí první prvek sekvenci.(Definoval Enumerable.)

System_CAPS_pubmethodFirst<TSource>(Func<TSource, Boolean>)

Přetížené Vrátí první prvek v pořadí, které splňuje zadanou podmínku.(Definoval Enumerable.)

System_CAPS_pubmethodFirstOrDefault<TSource>()

Přetížené Vrátí první prvek sekvence nebo výchozí hodnotu, pokud sekvence neobsahuje žádné elementy.(Definoval Enumerable.)

System_CAPS_pubmethodFirstOrDefault<TSource>(Func<TSource, Boolean>)

Přetížené Vrátí první prvek pořadí, které splňuje podmínky nebo výchozí hodnotu, pokud je nalezen žádný takový prvek.(Definoval Enumerable.)

System_CAPS_pubmethodGroupBy<TSource, TKey>(Func<TSource, TKey>)

Přetížené Elementy pořadí podle zadané selektoru klíče funkce skupin.(Definoval Enumerable.)

System_CAPS_pubmethodGroupBy<TSource, TKey>(Func<TSource, TKey>, IEqualityComparer<TKey>)

Přetížené Skupiny prvků pořadí podle funkce zadané selektoru klíče a porovná klíče pomocí zadaná porovnávací.(Definoval Enumerable.)

System_CAPS_pubmethodGroupBy<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>)

Přetížené Prvky pořadí podle projektů elementy pro každou skupinu s použitím zadané funkce a funkce selektoru zadané klíče skupiny.(Definoval Enumerable.)

System_CAPS_pubmethodGroupBy<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>)

Přetížené Skupiny prvků pořadí podle funkce selektoru klíče. Klíče jsou porovnány pomocí porovnávací metodu a každá skupina prvky jsou předpokládané pomocí zadané funkce.(Definoval Enumerable.)

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

Přetížené Skupiny prvků pořadí podle zadané selektoru klíče funkce a vytvoří výsledek hodnotu z každé skupiny a klíče.(Definoval Enumerable.)

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

Přetížené Skupiny prvků pořadí podle zadané selektoru klíče funkce a vytvoří výsledek hodnotu z každé skupiny a klíče. Klíče jsou porovnány s použitím zadané porovnávací metody.(Definoval Enumerable.)

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

Přetížené Skupiny prvků pořadí podle zadané selektoru klíče funkce a vytvoří výsledek hodnotu z každé skupiny a klíče. S použitím zadané funkce jsou promítat prvky každé skupiny.(Definoval Enumerable.)

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

Přetížené Skupiny prvků pořadí podle zadané selektoru klíče funkce a vytvoří výsledek hodnotu z každé skupiny a klíče. Hodnoty klíče jsou porovnány pomocí zadaná porovnávací a prvky každé skupiny jsou předpokládané pomocí zadanou funkci.(Definoval Enumerable.)

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

Přetížené Popisuje vztahy mezi rozhraním prvky dvou sekvencí založené na rovnosti klíče a výsledky jsou seskupeny. Výchozí porovnávací metody rovnosti se používá k porovnání klíčů.(Definoval Enumerable.)

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

Přetížené Popisuje vztahy mezi rozhraním elementy podle klíče rovnosti dvou sekvencí a výsledky jsou seskupeny. Zadané IEqualityComparer<T> se používá k porovnání klíčů.(Definoval Enumerable.)

System_CAPS_pubmethodInDocumentOrder<T>()

Vrátí kolekci uzlů, který obsahuje všechny uzly ve zdrojové kolekci seřazeny v pořadí dokumentů.(Definoval Extensions.)

System_CAPS_pubmethodIntersect<TSource>(IEnumerable<TSource>)

Přetížené Vytvoří sadu průnik dvou sekvencí pomocí výchozí procedury rovnosti Pokud chcete porovnat hodnoty.(Definoval Enumerable.)

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

Přetížené Vytvoří sadu průnik dvou sekvencí pomocí zadaného IEqualityComparer<T> pro porovnání hodnot.(Definoval Enumerable.)

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

Přetížené Popisuje vztahy mezi rozhraním prvky dvou sekvencí podle odpovídající klíče. Výchozí porovnávací metody rovnosti se používá k porovnání klíčů.(Definoval Enumerable.)

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

Přetížené Popisuje vztahy mezi rozhraním prvky dvou sekvencí podle odpovídající klíče. Zadané IEqualityComparer<T> se používá k porovnání klíčů.(Definoval Enumerable.)

System_CAPS_pubmethodLast<TSource>()

Přetížené Vrátí poslední prvek sekvenci.(Definoval Enumerable.)

System_CAPS_pubmethodLast<TSource>(Func<TSource, Boolean>)

Přetížené Vrátí poslední prvek sekvenci, která splňuje zadanou podmínku.(Definoval Enumerable.)

System_CAPS_pubmethodLastOrDefault<TSource>()

Přetížené Vrátí poslední prvek sekvenci nebo výchozí hodnotu, pokud je pořadí neobsahuje žádné elementy.(Definoval Enumerable.)

System_CAPS_pubmethodLastOrDefault<TSource>(Func<TSource, Boolean>)

Přetížené Vrátí poslední prvek sekvenci, která splňuje podmínky nebo výchozí hodnotu, pokud je nalezen žádný takový prvek.(Definoval Enumerable.)

System_CAPS_pubmethodLongCount<TSource>()

Přetížené Vrátí Int64 která představuje celkový počet prvků v sekvenci.(Definoval Enumerable.)

System_CAPS_pubmethodLongCount<TSource>(Func<TSource, Boolean>)

Přetížené Vrátí Int64 představující počet prvků v sekvenci splňují podmínku.(Definoval Enumerable.)

System_CAPS_pubmethodMax<TSource>()

Přetížené Vrátí maximální hodnotu v obecné pořadí.(Definoval Enumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Decimal>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí maximální Decimal hodnota.(Definoval Enumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Double>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí maximální Double hodnota.(Definoval Enumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Int32>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí maximální Int32 hodnota.(Definoval Enumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Int64>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí maximální Int64 hodnota.(Definoval Enumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Nullable<Decimal>>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí maximální hodnotu Null Decimal hodnotu.(Definoval Enumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Nullable<Double>>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí maximální hodnotu Null Double hodnotu.(Definoval Enumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Nullable<Int32>>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí maximální hodnotu Null Int32 hodnotu.(Definoval Enumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Nullable<Int64>>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí maximální hodnotu Null Int64 hodnotu.(Definoval Enumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Nullable<Single>>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí maximální hodnotu Null Single hodnotu.(Definoval Enumerable.)

System_CAPS_pubmethodMax<TSource>(Func<TSource, Single>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí maximální Single hodnota.(Definoval Enumerable.)

System_CAPS_pubmethodMax<TSource, TResult>(Func<TSource, TResult>)

Přetížené Zavolá funkci transformace na každý prvek obecné pořadí a vrátí maximální výsledná hodnota.(Definoval Enumerable.)

System_CAPS_pubmethodMin<TSource>()

Přetížené Vrátí minimální hodnotu v obecné pořadí.(Definoval Enumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Decimal>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí minimální Decimal hodnotu.(Definoval Enumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Double>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí minimální Double hodnotu.(Definoval Enumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Int32>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí minimální Int32 hodnotu.(Definoval Enumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Int64>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí minimální Int64 hodnotu.(Definoval Enumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Nullable<Decimal>>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí minimální hodnotu Null Decimal hodnotu.(Definoval Enumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Nullable<Double>>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí minimální hodnotu Null Double hodnotu.(Definoval Enumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Nullable<Int32>>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí minimální hodnotu Null Int32 hodnotu.(Definoval Enumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Nullable<Int64>>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí minimální hodnotu Null Int64 hodnotu.(Definoval Enumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Nullable<Single>>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí minimální hodnotu Null Single hodnotu.(Definoval Enumerable.)

System_CAPS_pubmethodMin<TSource>(Func<TSource, Single>)

Přetížené Zavolá funkci transformace na každý prvek pořadí a vrátí minimální Single hodnotu.(Definoval Enumerable.)

System_CAPS_pubmethodMin<TSource, TResult>(Func<TSource, TResult>)

Přetížené Zavolá funkci transformace na každý prvek obecné pořadí a vrátí minimální výsledná hodnota.(Definoval Enumerable.)

System_CAPS_pubmethodNodes<T>()

Vrátí kolekci podřízených uzlů každý dokument a element ve zdrojové kolekci.(Definoval Extensions.)

System_CAPS_pubmethodOfType<TResult>()

Filtry prvky IEnumerable na základě zadaného typu.(Definoval Enumerable.)

System_CAPS_pubmethodOrderBy<TSource, TKey>(Func<TSource, TKey>)

Přetížené Seřadí prvky pořadí ve vzestupném pořadí podle klíče.(Definoval Enumerable.)

System_CAPS_pubmethodOrderBy<TSource, TKey>(Func<TSource, TKey>, IComparer<TKey>)

Přetížené Seřadí prvky pořadí ve vzestupném pořadí s použitím zadané porovnávací metody.(Definoval Enumerable.)

System_CAPS_pubmethodOrderByDescending<TSource, TKey>(Func<TSource, TKey>)

Přetížené Seřadí prvky pořadí v sestupném pořadí podle klíče.(Definoval Enumerable.)

System_CAPS_pubmethodOrderByDescending<TSource, TKey>(Func<TSource, TKey>, IComparer<TKey>)

Přetížené Seřadí prvky pořadí v sestupném pořadí pomocí zadaná porovnávací.(Definoval Enumerable.)

System_CAPS_pubmethodPrepend<TSource>(TSource)

Hodnota se přidá na začátek pořadí.(Definoval Enumerable.)

System_CAPS_pubmethodRemove<T>()

Přetížené Odebere všechny uzly ve zdrojové kolekci z jeho nadřazený uzel.(Definoval Extensions.)

System_CAPS_pubmethodReverse<TSource>()

Obrátí pořadí prvků v sekvenci.(Definoval Enumerable.)

System_CAPS_pubmethodSelect<TSource, TResult>(Func<TSource, TResult>)

Přetížené Projekty každý prvek pořadí do nového formuláře.(Definoval Enumerable.)

System_CAPS_pubmethodSelect<TSource, TResult>(Func<TSource, Int32, TResult>)

Přetížené Každý prvek pořadí do nového formuláře projekty začleněním index prvku.(Definoval Enumerable.)

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

Přetížené Každý prvek sekvenci pro projekty IEnumerable<T> a sloučí výsledné pořadí do jedné sekvence.(Definoval Enumerable.)

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

Přetížené Každý prvek sekvenci pro projekty IEnumerable<T>, a sloučí výsledné pořadí do jedné sekvence. Index každý prvek zdroje se používá v předpokládané podobě daného prvku.(Definoval Enumerable.)

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

Přetížené Každý prvek sekvenci pro projekty IEnumerable<T>, sloučí výsledné pořadí do jedné sekvence a vyvolá funkci selektor výsledek na každý prvek v něm.(Definoval Enumerable.)

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

Přetížené Každý prvek sekvenci pro projekty IEnumerable<T>, sloučí výsledné pořadí do jedné sekvence a vyvolá funkci selektor výsledek na každý prvek v něm. Index každý prvek zdroje se používá ve formuláři zprostředkující předpokládané daného prvku.(Definoval Enumerable.)

System_CAPS_pubmethodSequenceEqual<TSource>(IEnumerable<TSource>)

Přetížené Určuje, zda jsou dvě sekvence rovná porovnáním prvky pomocí výchozí porovnávací metody rovnosti pro jejich typu.(Definoval Enumerable.)

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

Přetížené Určuje, zda jsou dvě sekvence rovná porovnáním jejich prvky s použitím zadaného IEqualityComparer<T>.(Definoval Enumerable.)

System_CAPS_pubmethodSingle<TSource>()

Přetížené Vrátí jediným prvkem pořadí a vyvolá výjimku, pokud je přesně jeden element v pořadí.(Definoval Enumerable.)

System_CAPS_pubmethodSingle<TSource>(Func<TSource, Boolean>)

Přetížené Vrátí pouze prvek sekvenci, která splňuje zadanou podmínku a vyvolá výjimku, pokud existuje více než jeden takový prvek.(Definoval Enumerable.)

System_CAPS_pubmethodSingleOrDefault<TSource>()

Přetížené Vrátí jediným prvkem sekvence nebo výchozí hodnotu, pokud sekvence je prázdná. Tato metoda vyvolá výjimku, pokud existuje více než jeden prvek v pořadí.(Definoval Enumerable.)

System_CAPS_pubmethodSingleOrDefault<TSource>(Func<TSource, Boolean>)

Přetížené Vrátí jediným prvkem sekvenci, která splňuje zadanou podmínku nebo výchozí hodnotu, pokud žádný takový prvek neexistuje; Tato metoda vyvolá výjimku, pokud splňuje více než jeden element podmínku.(Definoval Enumerable.)

System_CAPS_pubmethodSkip<TSource>(Int32)

Obchází zadaný počet prvků v pořadí a vrátí zbývající prvky.(Definoval Enumerable.)

System_CAPS_pubmethodSkipWhile<TSource>(Func<TSource, Boolean>)

Přetížené Obchází prvky v pořadí, dokud je zadaná podmínka je splněna a vrátí zbývající prvky.(Definoval Enumerable.)

System_CAPS_pubmethodSkipWhile<TSource>(Func<TSource, Int32, Boolean>)

Přetížené Obchází prvky v pořadí, dokud je zadaná podmínka je splněna a vrátí zbývající prvky. Index prvku se používá v logiku funkce predikátu.(Definoval Enumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Decimal>)

Přetížené Vypočítá součet posloupnost Decimal hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Double>)

Přetížené Vypočítá součet posloupnost Double hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Int32>)

Přetížené Vypočítá součet posloupnost Int32 hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Int64>)

Přetížené Vypočítá součet posloupnost Int64 hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Nullable<Decimal>>)

Přetížené Vypočítá součet pořadí s povolenou hodnotou Null Decimal hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Nullable<Double>>)

Přetížené Vypočítá součet pořadí s povolenou hodnotou Null Double hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Nullable<Int32>>)

Přetížené Vypočítá součet pořadí s povolenou hodnotou Null Int32 hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Nullable<Int64>>)

Přetížené Vypočítá součet pořadí s povolenou hodnotou Null Int64 hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Nullable<Single>>)

Přetížené Vypočítá součet pořadí s povolenou hodnotou Null Single hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodSum<TSource>(Func<TSource, Single>)

Přetížené Vypočítá součet posloupnost Single hodnoty, které jsou získány vyvoláním funkce transformace na každý prvek vstupní sekvence.(Definoval Enumerable.)

System_CAPS_pubmethodTake<TSource>(Int32)

Vrátí zadaný počet souvislých prvků od začátku sekvenci.(Definoval Enumerable.)

System_CAPS_pubmethodTakeWhile<TSource>(Func<TSource, Boolean>)

Přetížené Vrátí elementy ze sekvence tak dlouho, dokud je zadaná podmínka splněna.(Definoval Enumerable.)

System_CAPS_pubmethodTakeWhile<TSource>(Func<TSource, Int32, Boolean>)

Přetížené Vrátí elementy ze sekvence tak dlouho, dokud je zadaná podmínka splněna. Index prvku se používá v logiku funkce predikátu.(Definoval Enumerable.)

System_CAPS_pubmethodToArray<TSource>()

Vytvoří pole z IEnumerable<T>.(Definoval Enumerable.)

System_CAPS_pubmethodToDictionary<TSource, TKey>(Func<TSource, TKey>)

Přetížené Vytvoří Dictionary<TKey, TValue> z IEnumerable<T> podle zadané selektoru klíče funkce.(Definoval Enumerable.)

System_CAPS_pubmethodToDictionary<TSource, TKey>(Func<TSource, TKey>, IEqualityComparer<TKey>)

Přetížené Vytvoří Dictionary<TKey, TValue> z IEnumerable<T> podle zadané selektoru klíče funkce a klíč porovnávání.(Definoval Enumerable.)

System_CAPS_pubmethodToDictionary<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>)

Přetížené Vytvoří Dictionary<TKey, TValue> z IEnumerable<T> podle zadané selektoru klíče a element selector funkce.(Definoval Enumerable.)

System_CAPS_pubmethodToDictionary<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>)

Přetížené Vytvoří Dictionary<TKey, TValue> z IEnumerable<T> podle zadané selektoru klíče funkce, porovnávací metodu a funkce element selector.(Definoval Enumerable.)

System_CAPS_pubmethodToHashSet<TSource>()

Přetížené Vytvoří HashSet<T> z IEnumerable<T>.(Definoval Enumerable.)

System_CAPS_pubmethodToHashSet<TSource>(IEqualityComparer<TSource>)

Přetížené Vytvoří HashSet<T> z IEnumerable<T> pomocí comparer k porovnání klíčů(Definoval Enumerable.)

System_CAPS_pubmethodToList<TSource>()

Vytvoří List<T> z IEnumerable<T>.(Definoval Enumerable.)

System_CAPS_pubmethodToLookup<TSource, TKey>(Func<TSource, TKey>)

Přetížené Vytvoří Lookup<TKey, TElement> z IEnumerable<T> podle zadané selektoru klíče funkce.(Definoval Enumerable.)

System_CAPS_pubmethodToLookup<TSource, TKey>(Func<TSource, TKey>, IEqualityComparer<TKey>)

Přetížené Vytvoří Lookup<TKey, TElement> z IEnumerable<T> podle zadané selektoru klíče funkce a klíč porovnávání.(Definoval Enumerable.)

System_CAPS_pubmethodToLookup<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>)

Přetížené Vytvoří Lookup<TKey, TElement> z IEnumerable<T> podle zadané selektoru klíče a element selector funkce.(Definoval Enumerable.)

System_CAPS_pubmethodToLookup<TSource, TKey, TElement>(Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>)

Přetížené Vytvoří Lookup<TKey, TElement> z IEnumerable<T> podle zadané selektoru klíče funkce, porovnávací metodu a funkce element selector.(Definoval Enumerable.)

System_CAPS_pubmethodUnion<TSource>(IEnumerable<TSource>)

Přetížené Vytvoří sadu sjednocení dvou sekvencí pomocí výchozí porovnávací metody rovnosti.(Definoval Enumerable.)

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

Přetížené Vytvoří sadu sjednocení dvou sekvencí pomocí zadané IEqualityComparer<T>.(Definoval Enumerable.)

System_CAPS_pubmethodWhere<TSource>(Func<TSource, Boolean>)

Přetížené Filtruje pořadí hodnot na základě v predikátu.(Definoval Enumerable.)

System_CAPS_pubmethodWhere<TSource>(Func<TSource, Int32, Boolean>)

Přetížené Filtruje pořadí hodnot na základě v predikátu. Každý prvek index se používá v logiku funkce predikátu.(Definoval Enumerable.)

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

Zadaná funkce se vztahuje na odpovídající elementy dvě pořadí, vytváření posloupnost výsledky.(Definoval Enumerable.)

System_CAPS_notePoznámka

Chcete-li zobrazit zdrojový kód rozhraní .NET Framework pro tento typ, naleznete v části Reference Source. Můžete procházet zdrojový kód online, stahování odkazu pro zobrazení offline a krokovat zdroje (včetně oprav a aktualizací) během ladění. see instructions.

IEnumerable<T> je základní rozhraní pro kolekce v System.Collections.Generic obor názvů, jako List<T>, Dictionary<TKey, TValue>, a Stack<T> a jiné obecné kolekce, jako ObservableCollection<T> a ConcurrentStack<T>. Kolekce, které implementují IEnumerable<T> může být přezkoumána pomocí foreach příkaz. Neobecné verzi tohoto rozhraní, naleznete v části System.Collections.IEnumerable.

Neobecné verzi tohoto rozhraní, naleznete v části System.Collections.IEnumerable.

IEnumerable<T> obsahuje jedinou metodu, kterou musí implementovat při implementaci tohoto rozhraní. GetEnumerator, která vrátí IEnumerator<T> objektu. Vrácený IEnumerator<T> poskytuje schopnost iterovat v kolekci podle vystavení Current vlastnost.

Poznámky pro implementátory:

IEnumerable<T> je zahrnuté pro parity s neobecných kolekcí; implementace IEnumerable<T> umožňuje obecných kolekcí mají být předány metodě, která očekává IEnumerable objektu.

Následující příklad ukazuje, jak implementovat IEnumerable<T> rozhraní a jak používat tuto implementaci k vytvoření dotazu LINQ. Při implementaci IEnumerable<T>, je nutné implementovat IEnumerator<T> nebo jenom v C#, můžete použít yield (Referenční dokumentace jazyka C#) klíčové slovo. Implementace IEnumerator<T> také vyžaduje IDisposable mají být implementována, který se zobrazí v tomto příkladu.

using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

public class App
{
    // Excercise the Iterator and show that it's more
    // performant.
    public static void Main()
    {
        TestStreamReaderEnumerable();
        Console.WriteLine("---");
        TestReadingFile();
    }

    public static void TestStreamReaderEnumerable()
	{
		// Check the memory before the iterator is used.
		long memoryBefore = GC.GetTotalMemory(true);
      IEnumerable<String> stringsFound;
		// Open a file with the StreamReaderEnumerable and check for a string.
      try {
         stringsFound =
               from line in new StreamReaderEnumerable(@"c:\temp\tempFile.txt")
               where line.Contains("string to search for")
               select line;
         Console.WriteLine("Found: " + stringsFound.Count());
      }
      catch (FileNotFoundException) {
         Console.WriteLine(@"This example requires a file named C:\temp\tempFile.txt.");
         return;
      }

		// Check the memory after the iterator and output it to the console.
		long memoryAfter = GC.GetTotalMemory(false);
		Console.WriteLine("Memory Used With Iterator = \t"
            + string.Format(((memoryAfter - memoryBefore) / 1000).ToString(), "n") + "kb");
	}

    public static void TestReadingFile()
	{
		long memoryBefore = GC.GetTotalMemory(true);
      StreamReader sr;
      try {
         sr = File.OpenText("c:\\temp\\tempFile.txt");
      }
      catch (FileNotFoundException) {
         Console.WriteLine(@"This example requires a file named C:\temp\tempFile.txt.");
         return;
      }

        // Add the file contents to a generic list of strings.
		List<string> fileContents = new List<string>();
		while (!sr.EndOfStream) {
			fileContents.Add(sr.ReadLine());
		}

		// Check for the string.
		var stringsFound = 
            from line in fileContents
            where line.Contains("string to search for")
            select line;

        sr.Close();
        Console.WriteLine("Found: " + stringsFound.Count());

		// Check the memory after when the iterator is not used, and output it to the console.
		long memoryAfter = GC.GetTotalMemory(false);
		Console.WriteLine("Memory Used Without Iterator = \t" + 
            string.Format(((memoryAfter - memoryBefore) / 1000).ToString(), "n") + "kb");
	}
}

// A custom class that implements IEnumerable(T). When you implement IEnumerable(T), 
// you must also implement IEnumerable and IEnumerator(T).
public class StreamReaderEnumerable : IEnumerable<string>
{
    private string _filePath;
    public StreamReaderEnumerable(string filePath)
    {
        _filePath = filePath;
    }

    // Must implement GetEnumerator, which returns a new StreamReaderEnumerator.
    public IEnumerator<string> GetEnumerator()
    {
        return new StreamReaderEnumerator(_filePath);
    }

    // Must also implement IEnumerable.GetEnumerator, but implement as a private method.
    private IEnumerator GetEnumerator1()
    {
        return this.GetEnumerator();
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator1();
    }
}

// When you implement IEnumerable(T), you must also implement IEnumerator(T), 
// which will walk through the contents of the file one line at a time.
// Implementing IEnumerator(T) requires that you implement IEnumerator and IDisposable.
public class StreamReaderEnumerator : IEnumerator<string>
{
    private StreamReader _sr;
    public StreamReaderEnumerator(string filePath)
    {
        _sr = new StreamReader(filePath);
    }

    private string _current;
    // Implement the IEnumerator(T).Current publicly, but implement 
    // IEnumerator.Current, which is also required, privately.
    public string Current
    {

        get
        {
            if (_sr == null || _current == null)
            {
                throw new InvalidOperationException();
            }

            return _current;
        }
    }

    private object Current1
    {

        get { return this.Current; }
    }

    object IEnumerator.Current
    {
        get { return Current1; }
    }

    // Implement MoveNext and Reset, which are required by IEnumerator.
    public bool MoveNext()
    {
        _current = _sr.ReadLine();
        if (_current == null)
            return false;
        return true;
    }

    public void Reset()
    {
        _sr.DiscardBufferedData();
        _sr.BaseStream.Seek(0, SeekOrigin.Begin);
        _current = null;
    }

    // Implement IDisposable, which is also implemented by IEnumerator(T).
    private bool disposedValue = false;
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposedValue)
        {
            if (disposing)
            {
                // Dispose of managed resources.
            }
            _current = null;
            if (_sr != null) {
               _sr.Close();
               _sr.Dispose();
            }
        }

        this.disposedValue = true;
    }

     ~StreamReaderEnumerator()
    {
        Dispose(false);
    }
}
// This example displays output similar to the following:
//       Found: 2
//       Memory Used With Iterator =     33kb
//       ---
//       Found: 2
//       Memory Used Without Iterator =  206kb

For another C# example that demonstrates how to implement the T:System.Collections.Generic.IEnumerable`1 interface, see the Generics Samplehttp://code.msdn.microsoft.com/Generics-Sample-C-9b41a192/sourcecode?fileId=46476&pathId=1364935593. This sample uses the yield keyword instead of implementing T:System.Collections.Generic.IEnumerator`1.

Univerzální platforma Windows
K dispozici od 8
.NET Framework
K dispozici od 2.0
Přenosná knihovna tříd
Podporováno v: přenosné platformy .NET
Silverlight
K dispozici od 2.0
Windows Phone Silverlight
K dispozici od 7.0
Windows Phone
K dispozici od 8.1
Zpět na začátek
Zobrazit: