ICollection<T> Rozhraní

Definice

Definuje metody pro manipulaci s obecnými kolekcemi.Defines methods to manipulate generic collections.

generic <typename T>
public interface class ICollection : System::Collections::Generic::IEnumerable<T>
public interface ICollection<T> : System.Collections.Generic.IEnumerable<T>
type ICollection<'T> = interface
    interface seq<'T>
    interface IEnumerable
Public Interface ICollection(Of T)
Implements IEnumerable(Of T)

Parametry typu

T

Typ elementů v kolekci.The type of the elements in the collection.

Odvozené
Implementuje

Příklady

Následující příklad implementuje ICollection<T> rozhraní pro vytvoření kolekce vlastních Box objektů s názvem BoxCollection .The following example implements the ICollection<T> interface to create a collection of custom Box objects named BoxCollection. Každá Box má vlastnosti Height, Length a Width, které slouží k definování rovnosti.Each Box has height, length, and width properties, which are used to define equality. Rovnost lze definovat, protože všechny dimenze jsou stejné nebo jsou svazky stejné.Equality can be defined as all dimensions being the same or the volume being the same. BoxTřída implementuje IEquatable<T> rozhraní pro definování výchozí rovnosti jako dimenzí.The Box class implements the IEquatable<T> interface to define the default equality as the dimensions being the same.

BoxCollectionTřída implementuje Contains metodu pro použití výchozí rovnosti k určení, zda Box je v kolekci.The BoxCollection class implements the Contains method to use the default equality to determine whether a Box is in the collection. Tato metoda je používána metodou, Add aby každá Box přidaná do kolekce měla jedinečnou sadu dimenzí.This method is used by the Add method so that each Box added to the collection has a unique set of dimensions. BoxCollectionTřída také poskytuje přetížení Contains metody, která přebírá zadaný EqualityComparer<T> objekt, například BoxSameDimensions a BoxSameVol třídy v příkladu.The BoxCollection class also provides an overload of the Contains method that takes a specified EqualityComparer<T> object, such as BoxSameDimensions and BoxSameVol classes in the example.

Tento příklad také implementuje IEnumerator<T> rozhraní pro BoxCollection třídu tak, aby bylo možné kolekci vyčíslit.This example also implements an IEnumerator<T> interface for the BoxCollection class so that the collection can be enumerated.

using System;
using System.Collections;
using System.Collections.Generic;

class Program
{

    static void Main(string[] args)
    {

        BoxCollection bxList = new BoxCollection();

        bxList.Add(new Box(10, 4, 6));
        bxList.Add(new Box(4, 6, 10));
        bxList.Add(new Box(6, 10, 4));
        bxList.Add(new Box(12, 8, 10));

        // Same dimensions. Cannot be added:
        bxList.Add(new Box(10, 4, 6));

        // Test the Remove method.
        Display(bxList);
        Console.WriteLine("Removing 6x10x4");
        bxList.Remove(new Box(6, 10, 4));
        Display(bxList);

        // Test the Contains method.
        Box BoxCheck = new Box(8, 12, 10);
        Console.WriteLine("Contains {0}x{1}x{2} by dimensions: {3}",
            BoxCheck.Height.ToString(), BoxCheck.Length.ToString(),
            BoxCheck.Width.ToString(), bxList.Contains(BoxCheck).ToString());

        // Test the Contains method overload with a specified equality comparer.
        Console.WriteLine("Contains {0}x{1}x{2} by volume: {3}",
            BoxCheck.Height.ToString(), BoxCheck.Length.ToString(),
            BoxCheck.Width.ToString(), bxList.Contains(BoxCheck,
            new BoxSameVol()).ToString());
    }
    public static void Display(BoxCollection bxList)
    {
        Console.WriteLine("\nHeight\tLength\tWidth\tHash Code");
        foreach (Box bx in bxList)
        {
            Console.WriteLine("{0}\t{1}\t{2}\t{3}",
                bx.Height.ToString(), bx.Length.ToString(),
                bx.Width.ToString(), bx.GetHashCode().ToString());
        }

        // Results by manipulating the enumerator directly:

        //IEnumerator enumerator = bxList.GetEnumerator();
        //Console.WriteLine("\nHeight\tLength\tWidth\tHash Code");
        //while (enumerator.MoveNext())
        //{
        //    Box b = (Box)enumerator.Current;
        //    Console.WriteLine("{0}\t{1}\t{2}\t{3}",
        //    b.Height.ToString(), b.Length.ToString(),
        //    b.Width.ToString(), b.GetHashCode().ToString());
        //}

        Console.WriteLine();
    }

}

public class Box : IEquatable<Box>
{

    public Box(int h, int l, int w)
    {
        this.Height = h;
        this.Length = l;
        this.Width = w;
    }
    public int Height { get; set; }
    public int Length { get; set; }
    public int Width { get; set; }

    // Defines equality using the
    // BoxSameDimensions equality comparer.
    public bool Equals(Box other)
    {
        if (new BoxSameDimensions().Equals(this, other))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public override bool Equals(object obj)
    {
        return base.Equals(obj);
    }

    public override int GetHashCode()
    {
        return base.GetHashCode();
    }
}

public class BoxCollection : ICollection<Box>
{
    // The generic enumerator obtained from IEnumerator<Box>
    // by GetEnumerator can also be used with the non-generic IEnumerator.
    // To avoid a naming conflict, the non-generic IEnumerable method
    // is explicitly implemented.

    public IEnumerator<Box> GetEnumerator()
    {
        return new BoxEnumerator(this);
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return new BoxEnumerator(this);
    }

    // The inner collection to store objects.
    private List<Box> innerCol;

    public BoxCollection()
    {
        innerCol = new List<Box>();
    }

    // Adds an index to the collection.
    public Box this[int index]
    {
        get { return (Box)innerCol[index]; }
        set { innerCol[index] = value; }
    }

    // Determines if an item is in the collection
    // by using the BoxSameDimensions equality comparer.
    public bool Contains(Box item)
    {
        bool found = false;

        foreach (Box bx in innerCol)
        {
            // Equality defined by the Box
            // class's implmentation of IEquatable<T>.
            if (bx.Equals(item))
            {
                found = true;
            }
        }

        return found;
    }

    // Determines if an item is in the
    // collection by using a specified equality comparer.
    public bool Contains(Box item, EqualityComparer<Box> comp)
    {
        bool found = false;

        foreach (Box bx in innerCol)
        {
            if (comp.Equals(bx, item))
            {
                found = true;
            }
        }

        return found;
    }

    // Adds an item if it is not already in the collection
    // as determined by calling the Contains method.
    public void Add(Box item)
    {

        if (!Contains(item))
        {
            innerCol.Add(item);
        }
        else
        {
            Console.WriteLine("A box with {0}x{1}x{2} dimensions was already added to the collection.",
                item.Height.ToString(), item.Length.ToString(), item.Width.ToString());
        }
    }

    public void Clear()
    {
        innerCol.Clear();
    }

    public void CopyTo(Box[] array, int arrayIndex)
    {
        if (array == null)
           throw new ArgumentNullException("The array cannot be null.");
        if (arrayIndex < 0)
           throw new ArgumentOutOfRangeException("The starting array index cannot be negative.");
        if (Count > array.Length - arrayIndex + 1)
           throw new ArgumentException("The destination array has fewer elements than the collection.");

        for (int i = 0; i < innerCol.Count; i++) {
            array[i + arrayIndex] = innerCol[i];
        }
    }

    public int Count
    {
        get
        {
            return innerCol.Count;
        }
    }

    public bool IsReadOnly
    {
        get { return false; }
    }

    public bool Remove(Box item)
    {
        bool result = false;

        // Iterate the inner collection to
        // find the box to be removed.
        for (int i = 0; i < innerCol.Count; i++)
        {

            Box curBox = (Box)innerCol[i];

            if (new BoxSameDimensions().Equals(curBox, item))
            {
                innerCol.RemoveAt(i);
                result = true;
                break;
            }
        }
        return result;
    }
}


// Defines the enumerator for the Boxes collection.
// (Some prefer this class nested in the collection class.)
public class BoxEnumerator : IEnumerator<Box>
{
    private BoxCollection _collection;
    private int curIndex;
    private Box curBox;

    public BoxEnumerator(BoxCollection collection)
    {
        _collection = collection;
        curIndex = -1;
        curBox = default(Box);
    }

    public bool MoveNext()
    {
        //Avoids going beyond the end of the collection.
        if (++curIndex >= _collection.Count)
        {
            return false;
        }
        else
        {
            // Set current box to next item in collection.
            curBox = _collection[curIndex];
        }
        return true;
    }

    public void Reset() { curIndex = -1; }

    void IDisposable.Dispose() { }

    public Box Current
    {
        get { return curBox; }
    }

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

// Defines two boxes as equal if they have the same dimensions.
public class BoxSameDimensions : EqualityComparer<Box>
{

    public override bool Equals(Box b1, Box b2)
    {
        if (b1.Height == b2.Height && b1.Length == b2.Length
                            && b1.Width == b2.Width)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public override int GetHashCode(Box bx)
    {
        int hCode = bx.Height ^ bx.Length ^ bx.Width;
        return hCode.GetHashCode();
    }
}

// Defines two boxes as equal if they have the same volume.
public class BoxSameVol : EqualityComparer<Box>
{

    public override bool Equals(Box b1, Box b2)
    {
        if ((b1.Height * b1.Length * b1.Width) ==
                (b2.Height * b2.Length * b2.Width))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public override int GetHashCode(Box bx)
    {
        int hCode = bx.Height ^ bx.Length ^ bx.Width;
        Console.WriteLine("HC: {0}", hCode.GetHashCode());
        return hCode.GetHashCode();
    }
}


/*
This code example displays the following output:
================================================

A box with 10x4x6 dimensions was already added to the collection.

Height  Length  Width   Hash Code
10      4       6       46104728
4       6       10      12289376
6       10      4       43495525
12      8       10      55915408

Removing 6x10x4

Height  Length  Width   Hash Code
10      4       6       46104728
4       6       10      12289376
12      8       10      55915408

Contains 8x12x10 by dimensions: False
Contains 8x12x10 by volume: True
 */
Imports System.Collections
Imports System.Collections.Generic

Class Program
    Public Shared Sub Main(ByVal args() As String)

        Dim bxList As BoxCollection = New BoxCollection()

        bxList.Add(New Box(10, 4, 6))
        bxList.Add(New Box(4, 6, 10))
        bxList.Add(New Box(6, 10, 4))
        bxList.Add(New Box(12, 8, 10))

        ' Same dimensions. Cannot be added:
        bxList.Add(New Box(10, 4, 6))

        ' Test the Remove method.
        Display(bxList)
        Console.WriteLine("Removing 6x10x4")
        bxList.Remove(New Box(6, 10, 4))
        Display(bxList)

        ' Test the Contains method
        Dim BoxCheck As Box = New Box(8, 12, 10)
        Console.WriteLine("Contains {0}x{1}x{2} by dimensions: {3}", BoxCheck.Height.ToString(),
            BoxCheck.Length.ToString(), BoxCheck.Width.ToString(), bxList.Contains(BoxCheck).ToString())

        ' Test the Contains method overload with a specified equality comparer.
        Console.WriteLine("Contains {0}x{1}x{2} by volume: {3}", BoxCheck.Height.ToString(),
            BoxCheck.Length.ToString(), BoxCheck.Width.ToString(),
            bxList.Contains(BoxCheck, New BoxSameVol()).ToString())

    End Sub

    Public Shared Sub Display(ByVal bxList As BoxCollection)
        Console.WriteLine(vbLf & "Height" & vbTab & "Length" & vbTab & "Width" & vbTab & "Hash Code")
        For Each bx As Box In bxList
            Console.WriteLine("{0}" & vbTab & "{1}" & vbTab & "{2}" & vbTab & "{3}", bx.Height.ToString(), bx.Length.ToString(), bx.Width.ToString(), bx.GetHashCode().ToString())
        Next
        Console.WriteLine()
    End Sub
End Class

Public Class Box : Implements IEquatable(Of Box)
    Public Sub New(ByVal h As Integer, ByVal l As Integer, ByVal w As Integer)
        Me.Height = h
        Me.Length = l
        Me.Width = w
    End Sub

    Private _Height As Integer
    Public Property Height() As Integer
        Get
            Return _Height
        End Get
        Set(ByVal value As Integer)
            _Height = value
        End Set
    End Property

    Private _Length As Integer
    Public Property Length() As Integer
        Get
            Return _Length
        End Get
        Set(ByVal value As Integer)
            _Length = value
        End Set
    End Property

    Private _Width As Integer
    Public Property Width() As Integer
        Get
            Return _Width
        End Get
        Set(ByVal value As Integer)
            _Width = value
        End Set
    End Property

    Public Overloads Function Equals(ByVal other As Box) As Boolean Implements IEquatable(Of Box).Equals
        Dim BoxSameDim = New BoxSameDimensions()
        If BoxSameDim.Equals(Me, other) Then
            Return True
        Else
            Return False
        End If
    End Function

    Public Overrides Function Equals(ByVal obj As Object) As Boolean
        Return MyBase.Equals(obj)
    End Function

    Public Overrides Function GetHashCode() As Integer
        Return MyBase.GetHashCode()
    End Function
End Class

Public Class BoxCollection : Implements ICollection(Of Box)
    ' The generic enumerator obtained from IEnumerator<Box> by GetEnumerator can also
    ' be used with the non-generic IEnumerator. To avoid a naming conflict, 
    ' the non-generic IEnumerable method is explicitly implemented.

    Public Function GetEnumerator() As IEnumerator(Of Box) _
        Implements IEnumerable(Of Box).GetEnumerator

        Return New BoxEnumerator(Me)
    End Function

    Private Function GetEnumerator1() As IEnumerator _
        Implements IEnumerable.GetEnumerator

        Return Me.GetEnumerator()
    End Function

    ' The inner collection to store objects.
    Private innerCol As List(Of Box)

    Public Sub New()
        innerCol = New List(Of Box)
    End Sub

    ' Adds an index to the collection.
    Default Public Property Item(ByVal index As Integer) As Box
        Get
            'If index <> -1 Then
            Return CType(innerCol(index), Box)
            'End If
            'Return Nothing
        End Get
        Set(ByVal Value As Box)
            innerCol(index) = Value
        End Set
    End Property

    ' Determines if an item is in the collection
    ' by using the BoxSameDimensions equality comparer.
    Public Function Contains(ByVal item As Box) As Boolean _
            Implements ICollection(Of Box).Contains
        Dim found As Boolean = False

        Dim bx As Box
        For Each bx In innerCol
            If New BoxSameDimensions().Equals(bx, item) Then
                found = True
            End If
        Next

        Return found
    End Function

    ' Determines if an item is in the 
    ' collection by using a specified equality comparer.
    Public Function Contains(ByVal item As Box, _
        ByVal comp As EqualityComparer(Of Box)) As Boolean
        Dim found As Boolean = False

        Dim bx As Box
        For Each bx In innerCol
            If comp.Equals(bx, item) Then
                found = True
            End If
        Next

        Return found
    End Function

    ' Adds an item if it is not already in the collection
    ' as determined by calling the Contains method.
    Public Sub Add(ByVal item As Box) _
        Implements ICollection(Of Box).Add

        If Not Me.Contains(item) Then
            innerCol.Add(item)
        Else
            Console.WriteLine("A box with {0}x{1}x{2} dimensions was already added to the collection.",
                item.Height.ToString(), item.Length.ToString(), item.Width.ToString())
        End If
    End Sub

    Public Sub Clear() Implements ICollection(Of Box).Clear
        innerCol.Clear()
    End Sub

    Public Sub CopyTo(array As Box(), arrayIndex As Integer) _
            Implements ICollection(Of Box).CopyTo
        If array Is Nothing Then
           Throw New ArgumentNullException("The array cannot be null.")
        Else If arrayIndex < 0 Then
           Throw New ArgumentOutOfRangeException("The starting array index cannot be negative.")
        Else If Count > array.Length - arrayIndex + 1 Then
           Throw New ArgumentException("The destination array has fewer elements than the collection.")
        End If
        
        For i As Integer = 0 To innerCol.Count - 1
            array(i + arrayIndex) = innerCol(i)
        Next
    End Sub

    Public ReadOnly Property Count() As Integer _
            Implements ICollection(Of Box).Count
        Get
            Return innerCol.Count
        End Get
    End Property

    Public ReadOnly Property IsReadOnly() As Boolean _
           Implements ICollection(Of Box).IsReadOnly
        Get
            Return False
        End Get
    End Property

    Public Function Remove(ByVal item As Box) As Boolean _
            Implements ICollection(Of Box).Remove
        Dim result As Boolean = False

        ' Iterate the inner collection to 
        ' find the box to be removed.

        Dim i As Integer
        For i = 0 To innerCol.Count - 1

            Dim curBox As Box = CType(innerCol(i), Box)

            If New BoxSameDimensions().Equals(curBox, item) Then
                innerCol.RemoveAt(i)
                result = True
                Exit For
            End If
        Next
        Return result
    End Function
End Class

' Defines the enumerator for the Boxes collection.
' (Some prefer this class nested in the collection class.)
Public Class BoxEnumerator
    Implements IEnumerator(Of Box)
    Private _collection As BoxCollection
    Private curIndex As Integer
    Private curBox As Box


    Public Sub New(ByVal collection As BoxCollection)
        MyBase.New()
        _collection = collection
        curIndex = -1
        curBox = Nothing

    End Sub

    Private Property Box As Box
    Public Function MoveNext() As Boolean _
        Implements IEnumerator(Of Box).MoveNext
        curIndex = curIndex + 1
        If curIndex = _collection.Count Then
            ' Avoids going beyond the end of the collection.
            Return False
        Else
            'Set current box to next item in collection.
            curBox = _collection(curIndex)
        End If
        Return True
    End Function

    Public Sub Reset() _
        Implements IEnumerator(Of Box).Reset
        curIndex = -1
    End Sub

    Public Sub Dispose() _
        Implements IEnumerator(Of Box).Dispose

    End Sub

    Public ReadOnly Property Current() As Box _
        Implements IEnumerator(Of Box).Current

        Get
            If curBox Is Nothing Then
                Throw New InvalidOperationException()
            End If

            Return curBox
        End Get
    End Property

    Private ReadOnly Property Current1() As Object _
        Implements IEnumerator.Current

        Get
            Return Me.Current
        End Get
    End Property
End Class

' Defines two boxes as equal if they have the same dimensions.
Public Class BoxSameDimensions
    Inherits EqualityComparer(Of Box)

    Public Overrides Function Equals(ByVal b1 As Box, ByVal b2 As Box) As Boolean
        If b1.Height = b2.Height And b1.Length = b2.Length And b1.Width = b2.Width Then
            Return True
        Else
            Return False
        End If
    End Function

    Public Overrides Function GetHashCode(ByVal bx As Box) As Integer
        Dim hCode As Integer = bx.Height ^ bx.Length ^ bx.Width
        Return hCode.GetHashCode()
    End Function
End Class

' Defines two boxes as equal if they have the same volume.
Public Class BoxSameVol
    Inherits EqualityComparer(Of Box)

    Public Overrides Function Equals(ByVal b1 As Box, ByVal b2 As Box) As Boolean
        If (b1.Height * b1.Length * b1.Width) _
            = (b2.Height * b2.Length * b2.Width) Then
            Return True
        Else
            Return False
        End If
    End Function

    Public Overrides Function GetHashCode(ByVal bx As Box) As Integer
        Dim hCode As Integer = bx.Height ^ bx.Length ^ bx.Width
        Console.WriteLine("HC: {0}", hCode.GetHashCode())
        Return hCode.GetHashCode()
    End Function
End Class


'  This code example displays the following output:
'  ================================================
'
'  A box with 10x4x6 dimensions was already added to the collection.
'
'  Height  Length  Width   Hash Code
'  10      4       6       46104728
'  4       6       10      12289376
'  6       10      4       43495525
'  12      8       10      55915408
'
'  Removing 6x10x4
'
'  Height  Length  Width   Hash Code
'  10      4       6       46104728
'  4       6       10      12289376
'  12      8       10      55915408
'
'  Contains 8x12x10 by dimensions: False
'  Contains 8x12x10 by volume: True
'

Poznámky

ICollection<T>Rozhraní je základní rozhraní tříd v System.Collections.Generic oboru názvů.The ICollection<T> interface is the base interface for classes in the System.Collections.Generic namespace.

ICollection<T>Rozhraní rozšiřuje IEnumerable<T> IDictionary<TKey,TValue> a IList<T> jsou specializovaná rozhraní, která rozšiřují ICollection<T> .The ICollection<T> interface extends IEnumerable<T>; IDictionary<TKey,TValue> and IList<T> are more specialized interfaces that extend ICollection<T>. IDictionary<TKey,TValue>Implementace je kolekce párů klíč/hodnota, jako je Dictionary<TKey,TValue> Třída.A IDictionary<TKey,TValue> implementation is a collection of key/value pairs, like the Dictionary<TKey,TValue> class. IList<T>Implementace je kolekce hodnot a její členové jsou k dispozici pomocí indexu, jako je List<T> Třída.A IList<T> implementation is a collection of values, and its members can be accessed by index, like the List<T> class.

Pokud IDictionary<TKey,TValue> rozhraní ani IList<T> rozhraní nesplňuje požadavky požadované kolekce, odvozuje novou třídu kolekce z ICollection<T> rozhraní místo toho, aby byla větší flexibilita.If neither the IDictionary<TKey,TValue> interface nor the IList<T> interface meet the requirements of the required collection, derive the new collection class from the ICollection<T> interface instead for more flexibility.

Vlastnosti

Count

Získá počet elementů obsažených v objektu ICollection<T>.Gets the number of elements contained in the ICollection<T>.

IsReadOnly

Získá hodnotu, která určuje, zda je ICollection<T> určena jen pro čtení.Gets a value indicating whether the ICollection<T> is read-only.

Metody

Add(T)

Přidá položku do ICollection<T> .Adds an item to the ICollection<T>.

Clear()

Odebere všechny položky z ICollection<T> .Removes all items from the ICollection<T>.

Contains(T)

Určuje, zda ICollection<T> obsahuje konkrétní hodnotu.Determines whether the ICollection<T> contains a specific value.

CopyTo(T[], Int32)

Zkopíruje prvky ICollection<T> do a Array počínaje konkrétním Array indexem.Copies the elements of the ICollection<T> to an Array, starting at a particular Array index.

GetEnumerator()

Vrací enumerátor procházející kolekci.Returns an enumerator that iterates through a collection.

(Zděděno od IEnumerable)
Remove(T)

Odebere první výskyt konkrétního objektu z ICollection<T> .Removes the first occurrence of a specific object from the ICollection<T>.

Metody rozšíření

ToImmutableArray<TSource>(IEnumerable<TSource>)

Vytvoří neměnné pole ze zadané kolekce.Creates an immutable array from the specified collection.

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

Sestaví neproměnlivý slovník z existující kolekce elementů a použije funkci transformace na zdrojové klíče.Constructs an immutable dictionary from an existing collection of elements, applying a transformation function to the source keys.

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

Vytvoří neproměnlivý slovník založený na určité transformaci sekvence.Constructs an immutable dictionary based on some transformation of a sequence.

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

Vytvoří výčet a transformuje sekvenci a vytvoří neproměnlivý slovník jeho obsahu.Enumerates and transforms a sequence, and produces an immutable dictionary of its contents.

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

Vytvoří výčet a transformuje sekvenci a vytvoří neproměnlivý slovník jeho obsahu pomocí zadaného klíčového porovnávání.Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key comparer.

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

Vytvoří výčet a transformuje sekvenci a vytvoří neproměnlivý slovník jeho obsahu pomocí zadaných porovnatelností klíčová a hodnotová.Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key and value comparers.

ToImmutableHashSet<TSource>(IEnumerable<TSource>)

Vytvoří výčet sekvencí a vytvoří neměnitelnou sadu hash jejího obsahu.Enumerates a sequence and produces an immutable hash set of its contents.

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

Vytvoří výčet sekvencí, vytvoří neměnitelnou sadu hodnot hash jejího obsahu a použije pro typ sady zadanou porovnávací metodu.Enumerates a sequence, produces an immutable hash set of its contents, and uses the specified equality comparer for the set type.

ToImmutableList<TSource>(IEnumerable<TSource>)

Vytvoří výčet sekvencí a vytvoří neměnný seznam jeho obsahu.Enumerates a sequence and produces an immutable list of its contents.

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

Vytvoří výčet a transformuje sekvenci a vytvoří neproměnlivý seřazený slovník jeho obsahu.Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents.

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 jeho obsahu pomocí zadaného klíčového porovnávání.Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key comparer.

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

Vytvoří výčet a transformuje sekvenci a vytvoří neproměnlivý seřazený slovník jeho obsahu pomocí zadaných porovnávače klíčová a hodnotová.Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key and value comparers.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>)

Vytvoří výčet sekvencí a vytvoří neproměnlivou seřazenou sadu jejího obsahu.Enumerates a sequence and produces an immutable sorted set of its contents.

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

Vytvoří výčet sekvencí, vytvoří neproměnlivou seřazenou sadu jejího obsahu a použije zadanou porovnávací metodu.Enumerates a sequence, produces an immutable sorted set of its contents, and uses the specified comparer.

CopyToDataTable<T>(IEnumerable<T>)

Vrátí DataTable , který obsahuje kopie DataRow objektů, a to tak, že předané vstupní IEnumerable<T> objekt, kde je obecný parametr T DataRow .Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

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

Zkopíruje DataRow objekty do zadaného s DataTable předaným vstupním IEnumerable<T> objektem, kde T je obecný parametr DataRow .Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

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

Zkopíruje DataRow objekty do zadaného s DataTable předaným vstupním IEnumerable<T> objektem, kde T je obecný parametr DataRow .Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

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

Aplikuje funkci Akumulovaná v rámci sekvence.Applies an accumulator function over a sequence.

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

Aplikuje funkci Akumulovaná v rámci sekvence.Applies an accumulator function over a sequence. Zadaná hodnota počáteční hodnoty se používá jako počáteční hodnota akumulátoru.The specified seed value is used as the initial accumulator value.

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

Aplikuje funkci Akumulovaná v rámci sekvence.Applies an accumulator function over a sequence. Zadaná hodnota počáteční hodnoty se používá jako počáteční hodnota akumulátoru a zadaná funkce slouží k výběru hodnoty výsledku.The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.

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

Určuje, zda všechny prvky sekvence splní podmínku.Determines whether all elements of a sequence satisfy a condition.

Any<TSource>(IEnumerable<TSource>)

Určuje, zda sekvence obsahuje nějaké prvky.Determines whether a sequence contains any elements.

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

Určuje, zda kterýkoli prvek sekvence splňuje podmínku.Determines whether any element of a sequence satisfies a condition.

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

Připojí hodnotu na konec sekvence.Appends a value to the end of the sequence.

AsEnumerable<TSource>(IEnumerable<TSource>)

Vrátí vstup zadaný jako IEnumerable<T> .Returns the input typed as IEnumerable<T>.

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

Vypočítá průměr sekvence Decimal hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

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

Vypočítá průměr sekvence Double hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

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

Vypočítá průměr sekvence Int32 hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.

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

Vypočítá průměr sekvence Int64 hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.

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

Vypočítá průměr sekvence hodnot s možnou hodnotou null Decimal , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

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

Vypočítá průměr sekvence hodnot s možnou hodnotou null Double , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

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

Vypočítá průměr sekvence hodnot s možnou hodnotou null Int32 , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.

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

Vypočítá průměr sekvence hodnot s možnou hodnotou null Int64 , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence.

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

Vypočítá průměr sekvence hodnot s možnou hodnotou null Single , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence.

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

Vypočítá průměr sekvence Single hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the average of a sequence of Single values that are obtained by invoking a transform function on each element of the input sequence.

Cast<TResult>(IEnumerable)

Přetypování prvky IEnumerable na zadaný typ.Casts the elements of an IEnumerable to the specified type.

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

Zřetězí dvě sekvence.Concatenates two sequences.

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

Určuje, zda sekvence obsahuje zadaný element pomocí výchozí porovnávače rovnosti.Determines whether a sequence contains a specified element by using the default equality comparer.

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

Určuje, zda sekvence obsahuje zadaný element pomocí zadaného prvku IEqualityComparer<T> .Determines whether a sequence contains a specified element by using a specified IEqualityComparer<T>.

Count<TSource>(IEnumerable<TSource>)

Vrátí počet prvků v sekvenci.Returns the number of elements in a sequence.

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

Vrátí číslo, které představuje, kolik prvků v zadané sekvenci vyhovuje podmínce.Returns a number that represents how many elements in the specified sequence satisfy a condition.

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

Vrátí prvky zadané sekvence nebo výchozí hodnotu parametru typu v kolekci singleton, pokud je sekvence prázdná.Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.

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

Vrátí prvky zadané sekvence nebo zadanou hodnotu v kolekci singleton, pokud je sekvence prázdná.Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.

Distinct<TSource>(IEnumerable<TSource>)

Vrátí odlišné prvky z sekvence pomocí výchozí porovnávací metody pro porovnání hodnot.Returns distinct elements from a sequence by using the default equality comparer to compare values.

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

Vrátí odlišné prvky z sekvence pomocí zadaného IEqualityComparer<T> pro porovnání hodnot.Returns distinct elements from a sequence by using a specified IEqualityComparer<T> to compare values.

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

Vrátí prvek v zadaném indexu v sekvenci.Returns the element at a specified index in a sequence.

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

Vrátí prvek v zadaném indexu v sekvenci nebo výchozí hodnotu, pokud je index mimo rozsah.Returns the element at a specified index in a sequence or a default value if the index is out of range.

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

Vytvoří množinový rozdíl dvou sekvencí pomocí výchozí porovnávací metody pro porovnání hodnot.Produces the set difference of two sequences by using the default equality comparer to compare values.

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

Vytvoří množinový rozdíl dvou sekvencí pomocí zadaného IEqualityComparer<T> pro porovnání hodnot.Produces the set difference of two sequences by using the specified IEqualityComparer<T> to compare values.

First<TSource>(IEnumerable<TSource>)

Vrátí první prvek sekvence.Returns the first element of a sequence.

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

Vrátí první prvek v sekvenci, která splňuje zadanou podmínku.Returns the first element in a sequence that satisfies a specified condition.

FirstOrDefault<TSource>(IEnumerable<TSource>)

Vrátí první prvek sekvence nebo výchozí hodnotu, pokud sekvence neobsahuje žádné prvky.Returns the first element of a sequence, or a default value if the sequence contains no elements.

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

Vrátí první prvek sekvence, který splňuje podmínku nebo výchozí hodnotu, pokud žádný takový prvek nebyl nalezen.Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.

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

Seskupí prvky sekvence podle zadané funkce selektoru klíče.Groups the elements of a sequence according to a specified key selector function.

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

Seskupí prvky sekvence podle zadané funkce selektoru klíče a porovná klíče s použitím zadané porovnávací metody.Groups the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.

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

Seskupí prvky sekvence podle zadané funkce selektoru klíče a projekty prvků pro každou skupinu pomocí zadané funkce.Groups the elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function.

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

Seskupí prvky pořadí podle funkce selektoru klíče.Groups the elements of a sequence according to a key selector function. Klíče jsou porovnány pomocí porovnávacího prvku a jednotlivé prvky skupiny jsou probíhají pomocí zadané funkce.The keys are compared by using a comparer and each group's elements are projected by using a specified function.

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

Seskupí prvky sekvence podle zadané funkce selektoru klíče a vytvoří výslednou hodnotu z každé skupiny a jejího klíče.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.

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

Seskupí prvky sekvence podle zadané funkce selektoru klíče a vytvoří výslednou hodnotu z každé skupiny a jejího klíče.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Klíče jsou porovnány pomocí zadané porovnávací metody.The keys are compared by using a specified comparer.

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íče a vytvoří výslednou hodnotu z každé skupiny a jejího klíče.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Prvky každé skupiny jsou probíhají pomocí zadané funkce.The elements of each group are projected by using a specified function.

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íče a vytvoří výslednou hodnotu z každé skupiny a jejího klíče.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Hodnoty klíčů jsou porovnány pomocí zadané porovnávací metody a prvky každé skupiny jsou probíhají pomocí zadané funkce.Key values are compared by using a specified comparer, and the elements of each group are projected by using a specified function.

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 skupin výsledků.Correlates the elements of two sequences based on equality of keys and groups the results. Výchozí porovnávání rovnosti se používá k porovnání klíčů.The default equality comparer is used to compare keys.

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 seskupí výsledky.Correlates the elements of two sequences based on key equality and groups the results. Zadaný IEqualityComparer<T> se používá k porovnání klíčů.A specified IEqualityComparer<T> is used to compare keys.

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

Vytvoří průniky sady dvou sekvencí pomocí výchozí porovnávače rovnosti pro porovnání hodnot.Produces the set intersection of two sequences by using the default equality comparer to compare values.

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

Vytvoří průnik dvou sekvencí sady pomocí zadaného IEqualityComparer<T> pro porovnání hodnot.Produces the set intersection of two sequences by using the specified IEqualityComparer<T> to compare values.

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

Koreluje prvky dvou sekvencí založených na porovnávacích klíčích.Correlates the elements of two sequences based on matching keys. Výchozí porovnávání rovnosti se používá k porovnání klíčů.The default equality comparer is used to compare keys.

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í založených na porovnávacích klíčích.Correlates the elements of two sequences based on matching keys. Zadaný IEqualityComparer<T> se používá k porovnání klíčů.A specified IEqualityComparer<T> is used to compare keys.

Last<TSource>(IEnumerable<TSource>)

Vrátí poslední prvek sekvence.Returns the last element of a sequence.

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

Vrátí poslední prvek sekvence, který splňuje zadanou podmínku.Returns the last element of a sequence that satisfies a specified condition.

LastOrDefault<TSource>(IEnumerable<TSource>)

Vrátí poslední prvek sekvence nebo výchozí hodnotu, pokud sekvence neobsahuje žádné prvky.Returns the last element of a sequence, or a default value if the sequence contains no elements.

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

Vrátí poslední prvek sekvence, který splňuje podmínku nebo výchozí hodnotu, pokud žádný takový prvek nebyl nalezen.Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.

LongCount<TSource>(IEnumerable<TSource>)

Vrátí hodnotu Int64 , která představuje celkový počet prvků v sekvenci.Returns an Int64 that represents the total number of elements in a sequence.

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

Vrátí hodnotu Int64 reprezentující, kolik prvků v sekvenci splní podmínku.Returns an Int64 that represents how many elements in a sequence satisfy a condition.

Max<TSource>(IEnumerable<TSource>)

Vrátí maximální hodnotu v obecné sekvenci.Returns the maximum value in a generic sequence.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Decimal hodnotu.Invokes a transform function on each element of a sequence and returns the maximum Decimal value.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Double hodnotu.Invokes a transform function on each element of a sequence and returns the maximum Double value.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Int32 hodnotu.Invokes a transform function on each element of a sequence and returns the maximum Int32 value.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Int64 hodnotu.Invokes a transform function on each element of a sequence and returns the maximum Int64 value.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Decimal hodnotu null.Invokes a transform function on each element of a sequence and returns the maximum nullable Decimal value.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Double hodnotu null.Invokes a transform function on each element of a sequence and returns the maximum nullable Double value.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Int32 hodnotu null.Invokes a transform function on each element of a sequence and returns the maximum nullable Int32 value.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Int64 hodnotu null.Invokes a transform function on each element of a sequence and returns the maximum nullable Int64 value.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Single hodnotu null.Invokes a transform function on each element of a sequence and returns the maximum nullable Single value.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Single hodnotu.Invokes a transform function on each element of a sequence and returns the maximum Single value.

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

Vyvolá funkci transformace u každého prvku obecné sekvence a vrátí maximální výslednou hodnotu.Invokes a transform function on each element of a generic sequence and returns the maximum resulting value.

Min<TSource>(IEnumerable<TSource>)

Vrátí minimální hodnotu v obecné sekvenci.Returns the minimum value in a generic sequence.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Decimal hodnotu.Invokes a transform function on each element of a sequence and returns the minimum Decimal value.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Double hodnotu.Invokes a transform function on each element of a sequence and returns the minimum Double value.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Int32 hodnotu.Invokes a transform function on each element of a sequence and returns the minimum Int32 value.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Int64 hodnotu.Invokes a transform function on each element of a sequence and returns the minimum Int64 value.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Decimal hodnotu null.Invokes a transform function on each element of a sequence and returns the minimum nullable Decimal value.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Double hodnotu null.Invokes a transform function on each element of a sequence and returns the minimum nullable Double value.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Int32 hodnotu null.Invokes a transform function on each element of a sequence and returns the minimum nullable Int32 value.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Int64 hodnotu null.Invokes a transform function on each element of a sequence and returns the minimum nullable Int64 value.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Single hodnotu null.Invokes a transform function on each element of a sequence and returns the minimum nullable Single value.

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

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Single hodnotu.Invokes a transform function on each element of a sequence and returns the minimum Single value.

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

Vyvolá funkci transformace u každého prvku obecné sekvence a vrátí minimální výslednou hodnotu.Invokes a transform function on each element of a generic sequence and returns the minimum resulting value.

OfType<TResult>(IEnumerable)

Filtruje prvky IEnumerable založené na zadaném typu.Filters the elements of an IEnumerable based on a specified type.

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

Seřadí prvky sekvence ve vzestupném pořadí podle klíče.Sorts the elements of a sequence in ascending order according to a key.

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

Seřadí prvky sekvence ve vzestupném pořadí pomocí zadané porovnávací metody.Sorts the elements of a sequence in ascending order by using a specified comparer.

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

Seřadí prvky sekvence v sestupném pořadí podle klíče.Sorts the elements of a sequence in descending order according to a key.

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

Seřadí prvky sekvence v sestupném pořadí pomocí zadané porovnávací metody.Sorts the elements of a sequence in descending order by using a specified comparer.

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

Přidá hodnotu na začátek sekvence.Adds a value to the beginning of the sequence.

Reverse<TSource>(IEnumerable<TSource>)

Obrátí pořadí prvků v sekvenci.Inverts the order of the elements in a sequence.

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

Projektuje každý prvek sekvence do nového formuláře.Projects each element of a sequence into a new form.

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

Projektuje každý prvek sekvence do nového formuláře zahrnutím indexu elementu.Projects each element of a sequence into a new form by incorporating the element's index.

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

Projekty jednotlivé prvky sekvence do IEnumerable<T> a sloučí výsledné sekvence do jedné sekvence.Projects each element of a sequence to an IEnumerable<T> and flattens the resulting sequences into one sequence.

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

Projekty jsou jednotlivé prvky sekvence IEnumerable<T> a jsou shrnuty ve výsledných sekvencích do jedné sekvence.Projects each element of a sequence to an IEnumerable<T>, and flattens the resulting sequences into one sequence. Index každého zdrojového elementu se používá v projektované podobě daného prvku.The index of each source element is used in the projected form of that element.

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

Projekty jednotlivé prvky sekvence na IEnumerable<T> , sloučí výsledné sekvence do jedné sekvence a vyvolá funkci selektor výsledku pro každý prvek v rámci.Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.

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

Projekty jednotlivé prvky sekvence na IEnumerable<T> , sloučí výsledné sekvence do jedné sekvence a vyvolá funkci selektor výsledku pro každý prvek v rámci.Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. Index jednotlivých zdrojových elementů se používá v mezilehlém projektovém formuláři tohoto prvku.The index of each source element is used in the intermediate projected form of that element.

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

Určuje, zda jsou dvě sekvence stejné, porovnáním prvků s použitím výchozí porovnávače rovnosti pro svůj typ.Determines whether two sequences are equal by comparing the elements by using the default equality comparer for their type.

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

Určuje, zda se dvě sekvence rovnají porovnáním jejich prvků pomocí zadaného parametru IEqualityComparer<T> .Determines whether two sequences are equal by comparing their elements by using a specified IEqualityComparer<T>.

Single<TSource>(IEnumerable<TSource>)

Vrátí jediný prvek sekvence a vyvolá výjimku, pokud v sekvenci není přesně jeden prvek.Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.

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.Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.

SingleOrDefault<TSource>(IEnumerable<TSource>)

Vrátí jediný prvek sekvence nebo výchozí hodnotu, pokud je sekvence prázdná. Tato metoda vyvolá výjimku, pokud je v sekvenci více než jeden prvek.Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.

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ínky.Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition.

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

Obchází zadaný počet prvků v sekvenci a vrátí zbývající prvky.Bypasses a specified number of elements in a sequence and then returns the remaining elements.

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

Vrátí novou vyčíslitelné kolekci, která obsahuje prvky z source s posledními count prvky zdrojové kolekce vynechány.Returns a new enumerable collection that contains the elements from source with the last count elements of the source collection omitted.

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

Vynechá prvky v sekvenci, pokud je zadaná podmínka pravdivá a vrátí zbývající prvky.Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.

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

Vynechá prvky v sekvenci, pokud je zadaná podmínka pravdivá a vrátí zbývající prvky.Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. Index elementu se používá v Logic funkce predikátu.The element's index is used in the logic of the predicate function.

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

Vypočítá součet sekvence Decimal hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

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

Vypočítá součet sekvence Double hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

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

Vypočítá součet sekvence Int32 hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.

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

Vypočítá součet sekvence Int64 hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.

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

Vypočítá součet posloupnosti hodnot s možnou hodnotou null Decimal , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

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

Vypočítá součet posloupnosti hodnot s možnou hodnotou null Double , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

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

Vypočítá součet posloupnosti hodnot s možnou hodnotou null Int32 , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.

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

Vypočítá součet posloupnosti hodnot s možnou hodnotou null Int64 , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence.

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

Vypočítá součet posloupnosti hodnot s možnou hodnotou null Single , které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence.

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

Vypočítá součet sekvence Single hodnot, které jsou získány vyvoláním funkce Transform na každý prvek vstupní sekvence.Computes the sum of the sequence of Single values that are obtained by invoking a transform function on each element of the input sequence.

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

Vrátí zadaný počet souvislých prvků od začátku sekvence.Returns a specified number of contiguous elements from the start of a sequence.

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

Vrátí novou vyčíslitelné kolekci, která obsahuje poslední count prvky z source .Returns a new enumerable collection that contains the last count elements from source.

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

Vrátí prvky z sekvence, pokud je zadaná podmínka pravdivá.Returns elements from a sequence as long as a specified condition is true.

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

Vrátí prvky z sekvence, pokud je zadaná podmínka pravdivá.Returns elements from a sequence as long as a specified condition is true. Index elementu se používá v Logic funkce predikátu.The element's index is used in the logic of the predicate function.

ToArray<TSource>(IEnumerable<TSource>)

Vytvoří pole z IEnumerable<T> .Creates an array from a IEnumerable<T>.

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

Vytvoří Dictionary<TKey,TValue> z IEnumerable<T> podle zadané funkce výběru klíče.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to a specified key selector function.

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

Vytvoří Dictionary<TKey,TValue> z v IEnumerable<T> závislosti na zadané funkci výběru klíče a porovnávací klávesu.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to a specified key selector function and key comparer.

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

Vytvoří Dictionary<TKey,TValue> z v IEnumerable<T> závislosti na zadaných funkcích selektoru klíče a voličů prvků.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to specified key selector and element selector functions.

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

Vytvoří Dictionary<TKey,TValue> z v IEnumerable<T> závislosti na zadané funkci výběru klíče, porovnávání a funkci selektor elementu.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to a specified key selector function, a comparer, and an element selector function.

ToHashSet<TSource>(IEnumerable<TSource>)

Vytvoří HashSet<T> z IEnumerable<T> .Creates a HashSet<T> from an IEnumerable<T>.

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

Vytvoří HashSet<T> z s IEnumerable<T> pomocí comparer k porovnání klíčů.Creates a HashSet<T> from an IEnumerable<T> using the comparer to compare keys.

ToList<TSource>(IEnumerable<TSource>)

Vytvoří List<T> z IEnumerable<T> .Creates a List<T> from an IEnumerable<T>.

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

Vytvoří Lookup<TKey,TElement> z IEnumerable<T> podle zadané funkce výběru klíče.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to a specified key selector function.

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

Vytvoří Lookup<TKey,TElement> z v IEnumerable<T> závislosti na zadané funkci výběru klíče a porovnávací klávesu.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to a specified key selector function and key comparer.

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

Vytvoří Lookup<TKey,TElement> z v IEnumerable<T> závislosti na zadaných funkcích selektoru klíče a voličů prvků.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to specified key selector and element selector functions.

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

Vytvoří Lookup<TKey,TElement> z IEnumerable<T> podle zadané funkce výběru klíče, porovnávací funkce a funkci selektor elementu.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to a specified key selector function, a comparer and an element selector function.

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

Vytvoří sjednocení dvou sekvencí pomocí výchozí porovnávače rovnosti.Produces the set union of two sequences by using the default equality comparer.

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

Vytvoří sjednocení ze dvou sekvencí pomocí zadaného typu IEqualityComparer<T> .Produces the set union of two sequences by using a specified IEqualityComparer<T>.

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

Filtruje sekvenci hodnot na základě predikátu.Filters a sequence of values based on a predicate.

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

Filtruje sekvenci hodnot na základě predikátu.Filters a sequence of values based on a predicate. Index každého elementu se používá v Logic funkce predikátu.Each element's index is used in the logic of the predicate function.

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

Vytvoří sekvenci řazených kolekcí členů s prvky ze dvou zadaných sekvencí.Produces a sequence of tuples with elements from the two specified sequences.

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ří tak sekvenci výsledků.Applies a specified function to the corresponding elements of two sequences, producing a sequence of the results.

AsParallel(IEnumerable)

Povoluje paralelní zpracování dotazu.Enables parallelization of a query.

AsParallel<TSource>(IEnumerable<TSource>)

Povoluje paralelní zpracování dotazu.Enables parallelization of a query.

AsQueryable(IEnumerable)

Převede IEnumerable na IQueryable .Converts an IEnumerable to an IQueryable.

AsQueryable<TElement>(IEnumerable<TElement>)

Převede obecný IEnumerable<T> na obecný IQueryable<T> .Converts a generic IEnumerable<T> to a generic IQueryable<T>.

Ancestors<T>(IEnumerable<T>)

Vrátí kolekci prvků, které obsahují předchůdce všech uzlů ve zdrojové kolekci.Returns a collection of elements that contains the ancestors of every node in the source collection.

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

Vrátí filtrovanou kolekci prvků, které obsahují předchůdce všech uzlů ve zdrojové kolekci.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Do kolekce jsou zahrnuty pouze prvky, které mají odpovídající spárování XName .Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Vrátí kolekci podřízených uzlů každého dokumentu a elementu ve zdrojové kolekci.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Vrátí kolekci prvků, které obsahují následníky každého prvku a dokumentu ve zdrojové kolekci.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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

Vrátí filtrovanou kolekci prvků, které obsahují následníky každého prvku a dokumentu ve zdrojové kolekci.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Do kolekce jsou zahrnuty pouze prvky, které mají odpovídající spárování XName .Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Vrátí kolekci podřízených prvků každého prvku a dokumentu ve zdrojové kolekci.Returns a collection of the child elements of every element and document in the source collection.

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

Vrátí filtrovanou kolekci podřízených prvků každého elementu a dokumentu ve zdrojové kolekci.Returns a filtered collection of the child elements of every element and document in the source collection. Do kolekce jsou zahrnuty pouze prvky, které mají odpovídající spárování XName .Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Vrátí kolekci uzlů, které obsahují všechny uzly ve zdrojové kolekci seřazené v pořadí dokumentů.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Vrátí kolekci podřízených uzlů každého dokumentu a elementu ve zdrojové kolekci.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Odebere všechny uzly ve zdrojové kolekci z nadřazeného uzlu.Removes every node in the source collection from its parent node.

Platí pro

Viz také